public void ValueFormatting() { StringBuilder sb = new StringBuilder(); StringWriter sw = new StringWriter(sb); using (JsonWriter jsonWriter = new JsonWriter(sw)) { jsonWriter.WriteStartArray(); jsonWriter.WriteValue('@'); jsonWriter.WriteValue("\r\n\t\f\b?{\\r\\n\"\'"); jsonWriter.WriteValue(true); jsonWriter.WriteValue(10); jsonWriter.WriteValue(10.99); jsonWriter.WriteValue(0.99); jsonWriter.WriteValue(0.000000000000000001d); jsonWriter.WriteValue(0.000000000000000001m); jsonWriter.WriteValue(null); jsonWriter.WriteValue("This is a string."); jsonWriter.WriteNull(); jsonWriter.WriteUndefined(); jsonWriter.WriteEndArray(); } const string expected = @"[""@"",""\r\n\t\f\b?{\\r\\n\""'"",true,10,10.99,0.99,1E-18,0.000000000000000001,,""This is a string."",null,undefined]"; string result = sb.ToString(); Console.WriteLine("ValueFormatting"); Console.WriteLine(result); Assert.AreEqual(expected, result); }
/// <summary> /// Writes the JSON representation of the object. /// </summary> /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param> /// <param name="value">The value.</param> /// <param name="serializer">The calling serializer.</param> public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { DataTable table = (DataTable)value; DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver; writer.WriteStartArray(); foreach (DataRow row in table.Rows) { writer.WriteStartObject(); foreach (DataColumn column in row.Table.Columns) { object columnValue = row[column]; if (serializer.NullValueHandling == NullValueHandling.Ignore && (columnValue == null || columnValue == DBNull.Value)) { continue; } writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(column.ColumnName) : column.ColumnName); serializer.Serialize(writer, columnValue); } writer.WriteEndObject(); } writer.WriteEndArray(); }
public void WritesEmptyArray() { var sw = new StringWriter(); var writer = new JsonWriter(sw); writer.WriteStartArray(); writer.WriteEnd(); Assert.AreEqual("[]", sw.ToString()); }
private void WriteJsonValue(JsonWriter writer, IJsonValue value) { switch (value.ValueType) { case JsonValueType.Array: { JsonArray a = value.GetArray(); writer.WriteStartArray(); for (int i = 0; i < a.Count; i++) { WriteJsonValue(writer, a[i]); } writer.WriteEndArray(); } break; case JsonValueType.Boolean: { writer.WriteValue(value.GetBoolean()); } break; case JsonValueType.Null: { writer.WriteNull(); } break; case JsonValueType.Number: { // JsonValue doesn't support integers // serialize whole numbers without a decimal point double d = value.GetNumber(); bool isInteger = (d % 1 == 0); if (isInteger && d <= long.MaxValue && d >= long.MinValue) writer.WriteValue(Convert.ToInt64(d)); else writer.WriteValue(d); } break; case JsonValueType.Object: { JsonObject o = value.GetObject(); writer.WriteStartObject(); foreach (KeyValuePair<string, IJsonValue> v in o) { writer.WritePropertyName(v.Key); WriteJsonValue(writer, v.Value); } writer.WriteEndObject(); } break; case JsonValueType.String: { writer.WriteValue(value.GetString()); } break; default: throw new ArgumentOutOfRangeException("ValueType"); } }
public void WritesSinglePropertyArray() { var sw = new StringWriter(); var writer = new JsonWriter(sw); writer.WriteStartArray(); writer.WriteValue(1); writer.WriteEnd(); Assert.AreEqual("[1]", sw.ToString()); }
protected override void ExportValue(ExportContext context, object value, JsonWriter writer) { if (context == null) throw new ArgumentNullException("context"); if (writer == null) throw new ArgumentNullException("writer"); writer.WriteStartArray(); _exporter(context, value, writer); writer.WriteEndArray(); }
protected override void ExportValue(object value, JsonWriter writer) { IEnumerable items = (IEnumerable) value; writer.WriteStartArray(); foreach (object item in items) writer.WriteValue(item); writer.WriteEndArray(); }
private void WriteJsonValue(JsonWriter writer, IJsonValue value) { switch (value.ValueType) { case JsonValueType.Array: { JsonArray a = value.GetArray(); writer.WriteStartArray(); for (int i = 0; i < a.Count; i++) { WriteJsonValue(writer, a[i]); } writer.WriteEndArray(); } break; case JsonValueType.Boolean: { writer.WriteValue(value.GetBoolean()); } break; case JsonValueType.Null: { writer.WriteNull(); } break; case JsonValueType.Number: { writer.WriteValue(value.GetNumber()); } break; case JsonValueType.Object: { JsonObject o = value.GetObject(); writer.WriteStartObject(); foreach (KeyValuePair<string, IJsonValue> v in o) { writer.WritePropertyName(v.Key); WriteJsonValue(writer, v.Value); } writer.WriteEndObject(); } break; case JsonValueType.String: { writer.WriteValue(value.GetString()); } break; default: throw new ArgumentOutOfRangeException("ValueType"); } }
internal static void FormatView(DataView view, JsonWriter writer) { Debug.Assert(view != null); Debug.Assert(writer != null); writer.WriteStartObject(); writer.WriteMember("columns"); writer.WriteStartArray(); foreach (DataColumn column in view.Table.Columns) writer.WriteValue(column.ColumnName); writer.WriteEndArray(); writer.WriteMember("rows"); writer.WriteStartArray(); foreach (DataRowView row in view) writer.WriteValue(row.Row.ItemArray); writer.WriteEndArray(); writer.WriteEndObject(); }
protected override void ExportValue(ExportContext context, object value, JsonWriter writer) { Debug.Assert(context != null); Debug.Assert(value != null); Debug.Assert(writer != null); IEnumerable items = (IEnumerable) value; writer.WriteStartArray(); foreach (object item in items) context.Export(item, writer); writer.WriteEndArray(); }
internal static void ExportView(ExportContext context, DataView view, JsonWriter writer) { Debug.Assert(context != null); Debug.Assert(view != null); Debug.Assert(writer != null); writer.WriteStartObject(); writer.WriteMember("columns"); writer.WriteStartArray(); foreach (DataColumn column in view.Table.Columns) context.Export(column.ColumnName, writer); writer.WriteEndArray(); writer.WriteMember("rows"); writer.WriteStartArray(); foreach (DataRowView row in view) context.Export(row.Row.ItemArray, writer); writer.WriteEndArray(); writer.WriteEndObject(); }
/// <summary> /// Writes the JSON representation of the object. /// </summary> /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param> /// <param name="value">The value.</param> /// <param name="serializer">The calling serializer.</param> public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { DataTable table = (DataTable)value; writer.WriteStartArray(); foreach (DataRow row in table.Rows) { writer.WriteStartObject(); foreach (DataColumn column in row.Table.Columns) { writer.WritePropertyName(column.ColumnName); serializer.Serialize(writer, row[column]); } writer.WriteEndObject(); } writer.WriteEndArray(); }
/// <summary> /// Writes the JSON representation of the object. /// </summary> /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param> /// <param name="value">The value.</param> /// <param name="serializer">The calling serializer.</param> public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { DataTable table = (DataTable)value; DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver; writer.WriteStartArray(); foreach (DataRow row in table.Rows) { writer.WriteStartObject(); foreach (DataColumn column in row.Table.Columns) { writer.WritePropertyName((resolver != null) ? resolver.ResolvePropertyName(column.ColumnName) : column.ColumnName); serializer.Serialize(writer, row[column]); } writer.WriteEndObject(); } writer.WriteEndArray(); }
public void WriteReadWrite() { StringBuilder sb = new StringBuilder(); StringWriter sw = new StringWriter(sb); using (JsonWriter jsonWriter = new JsonWriter(sw)) { jsonWriter.WriteStartArray(); jsonWriter.WriteValue(true); jsonWriter.WriteStartObject(); jsonWriter.WritePropertyName("integer"); jsonWriter.WriteValue(99); jsonWriter.WritePropertyName("string"); jsonWriter.WriteValue("how now brown cow?"); jsonWriter.WritePropertyName("array"); jsonWriter.WriteStartArray(); for (int i = 0; i < 5; i++) { jsonWriter.WriteValue(i); } jsonWriter.WriteStartObject(); jsonWriter.WritePropertyName("decimal"); jsonWriter.WriteValue(990.00990099m); jsonWriter.WriteEndObject(); jsonWriter.WriteValue(5); jsonWriter.WriteEndArray(); jsonWriter.WriteEndObject(); jsonWriter.WriteValue("This is a string."); jsonWriter.WriteNull(); jsonWriter.WriteNull(); jsonWriter.WriteEndArray(); } string json = sb.ToString(); JsonSerializer serializer = new JsonSerializer(); object jsonObject = serializer.Deserialize(new JsonReader(new StringReader(json))); sb = new StringBuilder(); sw = new StringWriter(sb); using (JsonWriter jsonWriter = new JsonWriter(sw)) { serializer.Serialize(sw, jsonObject); } Assert.AreEqual(json, sb.ToString()); }
/// <summary> /// Write transformalize rows as GeoJson to a stream /// </summary> /// <param name="rows">transformalize rows</param> public void Write(IEnumerable <IRow> rows) { if (Equals(_context.Process.Entities.First(), _context.Entity)) { _jw.WriteStartObject(); //root _jw.WritePropertyName("type"); _jw.WriteValue("FeatureCollection"); _jw.WritePropertyName("features"); _jw.WriteStartArray(); //features } foreach (var row in rows) { _jw.WriteStartObject(); //feature _jw.WritePropertyName("type"); _jw.WriteValue("Feature"); _jw.WritePropertyName("geometry"); _jw.WriteStartObject(); //geometry _jw.WritePropertyName("type"); _jw.WriteValue("Point"); _jw.WritePropertyName("coordinates"); _jw.WriteStartArray(); _jw.WriteValue(row[_longitudeField]); _jw.WriteValue(row[_latitudeField]); _jw.WriteEndArray(); _jw.WriteEndObject(); //geometry _jw.WritePropertyName("properties"); _jw.WriteStartObject(); //properties if (_hasDescription) { _jw.WritePropertyName("description"); _jw.WriteValue(row[_descriptionField]); } if (_hasBatchValue) { _jw.WritePropertyName("batch-value"); _jw.WriteValue(row[_batchField]); } if (_hasColor) { _jw.WritePropertyName("marker-color"); _jw.WriteValue(row[_colorField]); } if (_hasSymbol) { var symbol = row[_symbolField].ToString(); _jw.WritePropertyName("marker-symbol"); _jw.WriteValue(symbol); } foreach (var field in _properties) { var name = field.Label == string.Empty ? field.Alias : field.Label; _jw.WritePropertyName(name); _jw.WriteValue(row[field]); } _jw.WriteEndObject(); //properties _jw.WriteEndObject(); //feature } if (Equals(_context.Process.Entities.Last(), _context.Entity)) { _jw.WriteEndArray(); //features _jw.WriteEndObject(); //root } _jw.Flush(); }
public override void WriteJson( JsonWriter writer, object value, JsonSerializer serializer) { if (!(value is PatchSpec patchSpec)) { throw new ArgumentOutOfRangeException("nameof(value) should be of type PatchSpec."); } IReadOnlyList <PatchOperation> patchOperations = patchSpec.PatchOperations; writer.WriteStartObject(); patchSpec.RequestOptions.Match( (PatchItemRequestOptions patchRequestOptions) => { if (patchRequestOptions != null) { if (!String.IsNullOrWhiteSpace(patchRequestOptions.FilterPredicate)) { writer.WritePropertyName(PatchConstants.PatchSpecAttributes.Condition); writer.WriteValue(patchRequestOptions.FilterPredicate); } } }, (TransactionalBatchPatchItemRequestOptions transactionalBatchPatchRequestOptions) => { if (transactionalBatchPatchRequestOptions != null) { if (!String.IsNullOrWhiteSpace(transactionalBatchPatchRequestOptions.FilterPredicate)) { writer.WritePropertyName(PatchConstants.PatchSpecAttributes.Condition); writer.WriteValue(transactionalBatchPatchRequestOptions.FilterPredicate); } } }); writer.WritePropertyName(PatchConstants.PatchSpecAttributes.Operations); writer.WriteStartArray(); foreach (PatchOperation operation in patchOperations) { writer.WriteStartObject(); writer.WritePropertyName(PatchConstants.PropertyNames.OperationType); writer.WriteValue(operation.OperationType.ToEnumMemberString()); writer.WritePropertyName(PatchConstants.PropertyNames.Path); writer.WriteValue(operation.Path); if (operation.TrySerializeValueParameter(this.userSerializer, out Stream valueStream)) { string valueParam; using (valueStream) { using (StreamReader streamReader = new StreamReader(valueStream)) { valueParam = streamReader.ReadToEnd(); } } writer.WritePropertyName(PatchConstants.PropertyNames.Value); writer.WriteRawValue(valueParam); } writer.WriteEndObject(); } writer.WriteEndArray(); writer.WriteEndObject(); }
private void SerializeList(JsonWriter writer, IList values, JsonArrayContract contract) { contract.InvokeOnSerializing(values); SerializeStack.Add(values); bool isReference = contract.IsReference ?? HasFlag(_serializer.PreserveReferencesHandling, PreserveReferencesHandling.Arrays); bool includeTypeDetails = HasFlag(_serializer.TypeNameHandling, TypeNameHandling.Arrays); if (isReference || includeTypeDetails) { writer.WriteStartObject(); if (isReference) { writer.WritePropertyName(JsonTypeReflector.IdPropertyName); writer.WriteValue(_serializer.ReferenceResolver.GetReference(values)); } if (includeTypeDetails) { WriteTypeProperty(writer, values.GetType()); } writer.WritePropertyName(JsonTypeReflector.ArrayValuesPropertyName); } writer.WriteStartArray(); for (int i = 0; i < values.Count; i++) { object value = values[i]; if (ShouldWriteReference(value, null)) { WriteReference(writer, value); } else { if (!CheckForCircularReference(value, null)) continue; SerializeValue(writer, value, null); } } writer.WriteEndArray(); if (isReference) { writer.WriteEndObject(); } SerializeStack.RemoveAt(SerializeStack.Count - 1); contract.InvokeOnSerialized(values); }
public void Execute(IEnumerable <DataRow> rows, ISampler <DataRow> sampler, IEnumerable <ColumnMetadata> metadata, JsonWriter writer) { rows = rows ?? new List <DataRow>(); sampler.Build(rows); var sampled = sampler.GetResult(); writer.WriteStartObject(); writer.WritePropertyName("total-rows"); writer.WriteValue(rows.Count()); if (sampler.GetIsSampled()) { writer.WritePropertyName("sampled-rows"); writer.WriteValue(rows.Count() - sampler.GetExcludedRowCount()); } if (sampled.Count() > 0) { writer.WritePropertyName("table"); writer.WriteStartObject(); writer.WritePropertyName("columns"); writer.WriteStartArray(); var formatters = new List <IPresenter>(); var columns = sampled.ElementAt(0).Table.Columns; for (var i = 0; i < columns.Count; i++) { var meta = metadata.ElementAt(i); writer.WriteStartObject(); writer.WritePropertyName("position"); writer.WriteValue(columns[i].Ordinal); writer.WritePropertyName("name"); writer.WriteValue(columns[i].ColumnName); var cpFormatter = new ColumnPropertiesFormatter(); writer.WritePropertyName("role"); writer.WriteValue(cpFormatter.GetRoleText(meta.Role)); writer.WritePropertyName("type"); writer.WriteValue(cpFormatter.GetTypeText(meta.Type)); if (!Tolerance.IsNullOrNone(meta.Tolerance)) { writer.WritePropertyName("tolerance"); writer.WriteValue(cpFormatter.GetToleranceText(meta.Tolerance).Trim()); } if (meta.Rounding != null) { writer.WritePropertyName("rounding"); writer.WriteValue(cpFormatter.GetRoundingText(meta.Rounding)); } formatters.Add(new PresenterFactory().Instantiate(metadata.ElementAt(i).Type)); writer.WriteEndObject(); } writer.WriteEndArray(); //columns BuildRows(sampled, formatters, writer); writer.WriteEndObject(); //table } writer.WriteEndObject(); }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { var ws = (WorkspaceModel)value; bool isCustomNode = value is CustomNodeWorkspaceModel; writer.WriteStartObject(); writer.WritePropertyName("Uuid"); if (isCustomNode) { writer.WriteValue((ws as CustomNodeWorkspaceModel).CustomNodeId.ToString()); } else { writer.WriteValue(ws.Guid.ToString()); } // TODO: revisit IsCustomNode during DYN/DYF convergence writer.WritePropertyName("IsCustomNode"); writer.WriteValue(value is CustomNodeWorkspaceModel ? true : false); if (isCustomNode) { writer.WritePropertyName("Category"); writer.WriteValue(((CustomNodeWorkspaceModel)value).Category); } // Description writer.WritePropertyName("Description"); if (isCustomNode) { writer.WriteValue(((CustomNodeWorkspaceModel)ws).Description); } else { writer.WriteValue(ws.Description); } writer.WritePropertyName("Name"); writer.WriteValue(ws.Name); //element resolver writer.WritePropertyName("ElementResolver"); serializer.Serialize(writer, ws.ElementResolver); //inputs writer.WritePropertyName("Inputs"); //find nodes which are inputs and get their inputData if its not null. var inputNodeDatas = ws.Nodes.Where((node) => node.IsSetAsInput == true && node.InputData != null) .Select(inputNode => inputNode.InputData).ToList(); serializer.Serialize(writer, inputNodeDatas); //nodes writer.WritePropertyName("Nodes"); serializer.Serialize(writer, ws.Nodes); //connectors writer.WritePropertyName("Connectors"); serializer.Serialize(writer, ws.Connectors); // Dependencies writer.WritePropertyName("Dependencies"); writer.WriteStartArray(); var functions = ws.Nodes.Where(n => n is Function); if (functions.Any()) { var deps = functions.Cast <Function>().Select(f => f.Definition.FunctionId).Distinct(); foreach (var d in deps) { writer.WriteValue(d); } } writer.WriteEndArray(); if (engine != null) { // Bindings writer.WritePropertyName(Configurations.BindingsTag); writer.WriteStartArray(); // Selecting all nodes that are either a DSFunction, // a DSVarArgFunction or a CodeBlockNodeModel into a list. var nodeGuids = ws.Nodes.Where( n => n is DSFunction || n is DSVarArgFunction || n is CodeBlockNodeModel || n is Function) .Select(n => n.GUID); var nodeTraceDataList = engine.LiveRunnerRuntimeCore.RuntimeData.GetTraceDataForNodes(nodeGuids, this.engine.LiveRunnerRuntimeCore.DSExecutable); // serialize given node-data-list pairs into an Json. if (nodeTraceDataList.Any()) { foreach (var pair in nodeTraceDataList) { writer.WriteStartObject(); writer.WritePropertyName(Configurations.NodeIdAttribName); // Set the node ID attribute for this element. var nodeGuid = pair.Key.ToString(); writer.WriteValue(nodeGuid); writer.WritePropertyName(Configurations.BingdingTag); // D4R binding writer.WriteStartObject(); foreach (var data in pair.Value) { writer.WritePropertyName(data.ID); writer.WriteValue(data.Data); } writer.WriteEndObject(); writer.WriteEndObject(); } } writer.WriteEndArray(); writer.WriteEndObject(); } }
private void WriteJsonValue(JsonWriter writer, IJsonValue value) { switch (value.ValueType) { case JsonValueType.Array: { JsonArray a = value.GetArray(); writer.WriteStartArray(); for (int i = 0; i < a.Count; i++) { WriteJsonValue(writer, a[i]); } writer.WriteEndArray(); } break; case JsonValueType.Boolean: { writer.WriteValue(value.GetBoolean()); } break; case JsonValueType.Null: { writer.WriteNull(); } break; case JsonValueType.Number: { // JsonValue doesn't support integers // serialize whole numbers without a decimal point double d = value.GetNumber(); bool isInteger = (d % 1 == 0); if (isInteger && d <= long.MaxValue && d >= long.MinValue) { writer.WriteValue(Convert.ToInt64(d)); } else { writer.WriteValue(d); } } break; case JsonValueType.Object: { JsonObject o = value.GetObject(); writer.WriteStartObject(); foreach (KeyValuePair <string, IJsonValue> v in o) { writer.WritePropertyName(v.Key); WriteJsonValue(writer, v.Value); } writer.WriteEndObject(); } break; case JsonValueType.String: { writer.WriteValue(value.GetString()); } break; default: throw new ArgumentOutOfRangeException("ValueType"); } }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { SearchRequest request = (SearchRequest)value; if (request == null) { return; } writer.WriteStartObject(); writer.WritePropertyName("from"); writer.WriteValue(request.From); writer.WritePropertyName("size"); writer.WriteValue(request.Size); if (request.Filter != null) { writer.WritePropertyName("filtered"); writer.WriteStartObject(); writer.WritePropertyName("query"); serializer.Serialize(writer, request.Query); writer.WritePropertyName("filter"); serializer.Serialize(writer, request.Filter); writer.WriteEndObject(); } else { writer.WritePropertyName("query"); serializer.Serialize(writer, request.Query); } if (request.Fields != null && request.Fields.Count > 0) { writer.WritePropertyName("fields"); writer.WriteStartArray(); foreach (string field in request.Fields) { writer.WriteValue(field); } writer.WriteEndArray(); } if (request.SortFields != null && request.SortFields.Count > 0) { writer.WritePropertyName("sort"); writer.WriteStartArray(); foreach (SortField field in request.SortFields) { serializer.Serialize(writer, field); } writer.WriteEndArray(); } if (request.Facet != null) { writer.WritePropertyName("facets"); serializer.Serialize(writer, request.Facet); } writer.WritePropertyName("explain"); writer.WriteValue(request.Explain); writer.WritePropertyName("version"); writer.WriteValue(request.Version); writer.WriteEndObject(); }
public override void WriteStartArray() { _textWriter.WriteStartArray(); _innerWriter.WriteStartArray(); base.WriteStartArray(); }
private void SerializeList(JsonWriter writer, IWrappedCollection values, JsonArrayContract contract, JsonProperty member, JsonContainerContract collectionContract, JsonProperty containerProperty) { contract.InvokeOnSerializing(values.UnderlyingCollection, Serializer.Context); _serializeStack.Add(values.UnderlyingCollection); bool hasWrittenMetadataObject = WriteStartArray(writer, values, contract, member, collectionContract, containerProperty); writer.WriteStartArray(); int initialDepth = writer.Top; int index = 0; // note that an error in the IEnumerable won't be caught foreach (object value in values) { try { JsonContract valueContract = contract.FinalItemContract ?? GetContractSafe(value); if (ShouldWriteReference(value, null, valueContract, contract, member)) { WriteReference(writer, value); } else { if (CheckForCircularReference(writer, value, null, valueContract, contract, member)) { SerializeValue(writer, value, valueContract, null, contract, member); } } } catch (Exception ex) { if (IsErrorHandled(values.UnderlyingCollection, contract, index, writer.ContainerPath, ex)) { HandleError(writer, initialDepth); } else { throw; } } finally { index++; } } writer.WriteEndArray(); if (hasWrittenMetadataObject) { writer.WriteEndObject(); } _serializeStack.RemoveAt(_serializeStack.Count - 1); contract.InvokeOnSerialized(values.UnderlyingCollection, Serializer.Context); }
public void Serialize(JsonWriter writer) { writer.WritePropertyName(Title); writer.WriteStartObject(); if (!string.IsNullOrWhiteSpace(Description)) { writer.WritePropertyName("description"); writer.WriteValue(Description); } if (TypeFormat.Type == ParameterType.Object) { writer.WritePropertyName("$ref"); writer.WriteValue(string.Format("#/definitions/{0}", Ref)); } else { if (TypeFormat.Type != ParameterType.Unknown) { writer.WritePropertyName("type"); writer.WriteValue(TypeFormat.Type.ToString().ToLower()); if (!string.IsNullOrWhiteSpace(TypeFormat.Format)) { writer.WritePropertyName("format"); writer.WriteValue(TypeFormat.Format); } } if (TypeFormat.Type == ParameterType.Array && Items != null) { writer.WritePropertyName("items"); Items.Serialize(writer); } if (!string.IsNullOrWhiteSpace(Default)) { writer.WritePropertyName("default"); writer.WriteValue(Default); } if (Maximum != decimal.MaxValue) { writer.WritePropertyName("maximum"); writer.WriteValue(Maximum); writer.WritePropertyName("exclusiveMaximum"); writer.WriteValue(ExclusiveMaximum); } if (Minimum != decimal.MinValue) { writer.WritePropertyName("minimum"); writer.WriteValue(Minimum); writer.WritePropertyName("exclusiveMinimum"); writer.WriteValue(ExclusiveMinimum); } if (MaxLength != int.MaxValue) { writer.WritePropertyName("maxLength"); writer.WriteValue(MaxLength); } if (MinLength != int.MinValue) { writer.WritePropertyName("minLength"); writer.WriteValue(MinLength); } if (!string.IsNullOrWhiteSpace(Pattern)) { writer.WritePropertyName("pattern"); writer.WriteValue(Pattern); } if (MaxItems != int.MaxValue) { writer.WritePropertyName("maxItems"); writer.WriteValue(MaxItems); } if (MinItems != int.MinValue) { writer.WritePropertyName("minItems"); writer.WriteValue(MinItems); } writer.WritePropertyName("uniqueItems"); writer.WriteValue(UniqueItems); if (Enum != null && Enum.Any()) { writer.WritePropertyName("enum"); writer.WriteStartArray(); foreach (string e in Enum) { writer.WriteValue(e); } writer.WriteEndArray(); } if (MultipleOf != decimal.MinValue) { writer.WritePropertyName("multipleOf"); writer.WriteValue(MultipleOf); } } writer.WriteEndObject(); }
private void SerializeList(JsonWriter writer, IWrappedCollection values, JsonArrayContract contract, JsonProperty member, JsonContract collectionValueContract) { contract.InvokeOnSerializing(values.UnderlyingCollection, Serializer.Context); SerializeStack.Add(values.UnderlyingCollection); bool isReference = contract.IsReference ?? HasFlag(Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Arrays); bool includeTypeDetails = ShouldWriteType(TypeNameHandling.Arrays, contract, member, collectionValueContract); if (isReference || includeTypeDetails) { writer.WriteStartObject(); if (isReference) { writer.WritePropertyName(JsonTypeReflector.IdPropertyName); writer.WriteValue(Serializer.ReferenceResolver.GetReference(this, values.UnderlyingCollection)); } if (includeTypeDetails) { WriteTypeProperty(writer, values.UnderlyingCollection.GetType()); } writer.WritePropertyName(JsonTypeReflector.ArrayValuesPropertyName); } JsonContract childValuesContract = Serializer.ContractResolver.ResolveContract(contract.CollectionItemType ?? typeof(object)); writer.WriteStartArray(); int initialDepth = writer.Top; int index = 0; // note that an error in the IEnumerable won't be caught foreach (object value in values) { try { JsonContract valueContract = GetContractSafe(value); if (ShouldWriteReference(value, null, valueContract)) { WriteReference(writer, value); } else { if (CheckForCircularReference(value, null, contract)) { SerializeValue(writer, value, valueContract, null, childValuesContract); } } } catch (Exception ex) { if (IsErrorHandled(values.UnderlyingCollection, contract, index, ex)) { HandleError(writer, initialDepth); } else { throw; } } finally { index++; } } writer.WriteEndArray(); if (isReference || includeTypeDetails) { writer.WriteEndObject(); } SerializeStack.RemoveAt(SerializeStack.Count - 1); contract.InvokeOnSerialized(values.UnderlyingCollection, Serializer.Context); }
public void Serialize(JsonWriter writer) { if (TypeFormat.Type == ParameterType.Object) { // complex object if (!string.IsNullOrWhiteSpace(Description)) { writer.WritePropertyName("description"); writer.WriteValue(Description); } if (ParentSchema != null) { writer.WritePropertyName("allOf"); writer.WriteStartArray(); writer.WritePropertyName("$ref"); writer.WriteValue(string.Format("#/definitions/{0}", ParentSchema.Name)); writer.WriteStartObject(); } SerializeRequired(writer); SerializeExternalDocs(writer); SerializeProperties(writer); if (ParentSchema != null) { writer.WriteEndObject(); writer.WriteEndArray(); } } if (TypeFormat.Type != ParameterType.Unknown) { writer.WritePropertyName("type"); writer.WriteValue(TypeFormat.Type.ToString().ToLower()); if (!string.IsNullOrWhiteSpace(TypeFormat.Format)) { writer.WritePropertyName("format"); writer.WriteValue(TypeFormat.Format); } if (TypeFormat.Type == ParameterType.Array) { writer.WritePropertyName("items"); writer.WriteStartObject(); writer.WritePropertyName("$ref"); writer.WriteValue(string.Format("#/definitions/{0}", Ref)); writer.WriteEndObject(); } if (Enum != null && Enum.Any()) { writer.WritePropertyName("enum"); writer.WriteStartArray(); foreach (string e in Enum) { writer.WriteValue(e); } writer.WriteEndArray(); } } else if (!string.IsNullOrWhiteSpace(Ref)) { writer.WritePropertyName("$ref"); writer.WriteValue(string.Format("#/definitions/{0}", Ref)); } }
private void SerializeList(JsonWriter writer, IList values, JsonArrayContract contract, JsonProperty member, JsonContract collectionValueContract) { contract.InvokeOnSerializing(values, Serializer.Context); SerializeStack.Add(values); bool isReference = contract.IsReference ?? HasFlag(Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Arrays); bool includeTypeDetails = ShouldWriteType(TypeNameHandling.Arrays, contract, member, collectionValueContract); if (isReference || includeTypeDetails) { writer.WriteStartObject(); if (isReference) { writer.WritePropertyName(JsonTypeReflector.IdPropertyName); writer.WriteValue(Serializer.ReferenceResolver.GetReference(values)); } if (includeTypeDetails) { WriteTypeProperty(writer, values.GetType()); } writer.WritePropertyName(JsonTypeReflector.ArrayValuesPropertyName); } JsonContract childValuesContract = Serializer.ContractResolver.ResolveContract(contract.CollectionItemType ?? typeof(object)); writer.WriteStartArray(); int initialDepth = writer.Top; for (int i = 0; i < values.Count; i++) { try { object value = values[i]; JsonContract valueContract = GetContractSafe(value); if (ShouldWriteReference(value, null, valueContract)) { WriteReference(writer, value); } else { if (!CheckForCircularReference(value, null, contract)) continue; SerializeValue(writer, value, valueContract, null, childValuesContract); } } catch (Exception ex) { if (IsErrorHandled(values, contract, i, ex)) HandleError(writer, initialDepth); else throw; } } writer.WriteEndArray(); if (isReference || includeTypeDetails) { writer.WriteEndObject(); } SerializeStack.RemoveAt(SerializeStack.Count - 1); contract.InvokeOnSerialized(values, Serializer.Context); }
private void SerializeList(JsonWriter writer, IEnumerable values, JsonArrayContract contract, JsonProperty member, JsonContainerContract collectionContract, JsonProperty containerProperty) { IWrappedCollection wrappedCollection = values as IWrappedCollection; object underlyingList = wrappedCollection != null ? wrappedCollection.UnderlyingCollection : values; OnSerializing(writer, contract, underlyingList); _serializeStack.Add(underlyingList); bool hasWrittenMetadataObject = WriteStartArray(writer, underlyingList, contract, member, collectionContract, containerProperty); writer.WriteStartArray(); int initialDepth = writer.Top; int index = 0; IEnumerator enumerator; try { enumerator = values.GetEnumerator(); } catch (Exception e) { throw new InvalidOperationException("Could not get enumerator for property: " + member, e); } using (enumerator as IDisposable) { while (true) { try { if (enumerator.MoveNext() == false) { break; } } catch (Exception e) { throw new InvalidOperationException("Could not move to next value for property: " + member, e); } object value; try { value = enumerator.Current; } catch (Exception e) { throw new InvalidOperationException("Could not get current value for property: " + member, e); } try { JsonContract valueContract = contract.FinalItemContract ?? GetContractSafe(value); if (ShouldWriteReference(value, null, valueContract, contract, member)) { WriteReference(writer, value); } else { if (CheckForCircularReference(writer, value, null, valueContract, contract, member)) { SerializeValue(writer, value, valueContract, null, contract, member); } } } catch (Exception ex) { if (IsErrorHandled(underlyingList, contract, index, null, writer.ContainerPath, ex)) { HandleError(writer, initialDepth); } else { throw; } } finally { index++; } } } writer.WriteEndArray(); if (hasWrittenMetadataObject) { writer.WriteEndObject(); } _serializeStack.RemoveAt(_serializeStack.Count - 1); OnSerialized(writer, contract, underlyingList); }
public new void AsJson(JsonWriter writer, string baseUrl) { writer.WriteStartObject(); base.AsJson(writer, baseUrl); writer.WritePropertyName("title"); writer.WriteValue(Title); if (!String.IsNullOrEmpty(IMSClassCode)) { writer.WritePropertyName("classCode"); writer.WriteValue(IMSClassCode); } writer.WritePropertyName("classType"); writer.WriteValue(Enum.GetName(typeof(Vocabulary.IMSClassType), IMSClassType)); if (!String.IsNullOrEmpty(Location)) { writer.WritePropertyName("location"); writer.WriteValue(Location); } if (Grades != null && Grades.Length > 0) { writer.WritePropertyName("grades"); writer.WriteStartArray(); foreach (var grade in Grades) { writer.WriteValue(grade); } writer.WriteEndArray(); } if (Subjects != null && Subjects.Length > 0) { writer.WritePropertyName("subjects"); writer.WriteStartArray(); foreach (var subject in Subjects) { writer.WriteValue(subject); } writer.WriteEndArray(); } writer.WritePropertyName("course"); Course.AsJsonReference(writer, baseUrl); writer.WritePropertyName("resources"); writer.WriteStartArray(); if (Course.Resources != null) { foreach (var resource in Course.Resources) { writer.WriteValue(resource); } } if (Resources != null) { foreach (var resource in Resources) { writer.WriteValue(resource); } } writer.WriteEndArray(); writer.WritePropertyName("school"); School.AsJsonReference(writer, baseUrl); writer.WritePropertyName("terms"); writer.WriteStartArray(); IMSClassAcademicSessions.ForEach(join => join.AcademicSession.AsJsonReference(writer, baseUrl)); writer.WriteEndArray(); if (SubjectCodes != null && SubjectCodes.Length > 0) { writer.WritePropertyName("subjectCodes"); writer.WriteStartArray(); foreach (var subjectCode in SubjectCodes) { writer.WriteValue(subjectCode); } writer.WriteEndArray(); } if (Periods != null && Periods.Length > 0) { writer.WritePropertyName("periods"); writer.WriteStartArray(); foreach (var period in Periods) { writer.WriteValue(period); } writer.WriteEndArray(); } writer.WriteEndObject(); writer.Flush(); }
private void WriteToken(JSchema context, JsonWriter writer, JToken token, bool isDefinitions = false) { if (token is JObject) { JObject o = (JObject)token; JSchemaAnnotation schemaAnnotation = o.Annotation <JSchemaAnnotation>(); if (schemaAnnotation != null) { ReferenceOrWriteSchema(context, schemaAnnotation.Schema, null, isDefinitions); } else { writer.WriteStartObject(); foreach (JProperty property in o.Properties()) { writer.WritePropertyName(property.Name); JToken value = property.Value; if (value != null) { WriteToken(context, writer, value, isDefinitions); } else { writer.WriteNull(); } } writer.WriteEndObject(); } } else if (token is JArray) { JArray a = (JArray)token; writer.WriteStartArray(); for (int i = 0; i < a.Count; i++) { WriteToken(context, writer, a[i]); } writer.WriteEndArray(); } else if (token is JConstructor) { JConstructor c = (JConstructor)token; writer.WriteStartConstructor(c.Name); foreach (JToken t in c.Children()) { WriteToken(context, writer, t); } writer.WriteEndConstructor(); } else if (token is JValue) { token.WriteTo(writer); } }
private void SerializeGroupedNodes(JsonWriter writer, XmlNode node) { // group nodes together by name Dictionary<string, List<XmlNode>> nodesGroupedByName = new Dictionary<string, List<XmlNode>>(); for (int i = 0; i < node.ChildNodes.Count; i++) { XmlNode childNode = node.ChildNodes[i]; string nodeName = GetPropertyName(childNode); List<XmlNode> nodes; if (!nodesGroupedByName.TryGetValue(nodeName, out nodes)) { nodes = new List<XmlNode>(); nodesGroupedByName.Add(nodeName, nodes); } nodes.Add(childNode); } // loop through grouped nodes. write single name instances as normal, // write multiple names together in an array foreach (KeyValuePair<string, List<XmlNode>> nodeNameGroup in nodesGroupedByName) { List<XmlNode> groupedNodes = nodeNameGroup.Value; bool writeArray; if (groupedNodes.Count == 1) { XmlNode singleNode = groupedNodes[0]; XmlAttribute jsonArrayAttribute = (singleNode.Attributes != null) ? singleNode.Attributes["Array", JsonNamespaceUri] : null; if (jsonArrayAttribute != null) writeArray = XmlConvert.ToBoolean(jsonArrayAttribute.Value); else writeArray = false; } else { writeArray = true; } if (!writeArray) { SerializeNode(writer, groupedNodes[0], true); } else { string elementNames = nodeNameGroup.Key; writer.WritePropertyName(nodeNameGroup.Key); writer.WriteStartArray(); for (int i = 0; i < groupedNodes.Count; i++) { SerializeNode(writer, groupedNodes[i], false); } writer.WriteEndArray(); } } }
private void WriteSchemaObjectInternal(JSchema schema) { _writer.WriteStartObject(); if (schema == _rootSchema) { Uri resolvedVersionUri = (_version != SchemaVersion.Unset) ? SchemaVersionHelpers.MapSchemaVersion(_version) : schema.SchemaVersion; WritePropertyIfNotNull(_writer, Constants.PropertyNames.Schema, resolvedVersionUri); } if (EnsureVersion(SchemaVersion.Draft6)) { WritePropertyIfNotNull(_writer, Constants.PropertyNames.Id, schema.Id); } else { WritePropertyIfNotNull(_writer, Constants.PropertyNames.IdDraft4, schema.Id); } WritePropertyIfNotNull(_writer, Constants.PropertyNames.Title, schema.Title); WritePropertyIfNotNull(_writer, Constants.PropertyNames.Description, schema.Description); if (schema._extensionData != null) { foreach (KeyValuePair <string, JToken> extensionDataPair in schema._extensionData) { bool isDefinitions = schema == _rootSchema && string.Equals(extensionDataPair.Key, Constants.PropertyNames.Definitions); _writer.WritePropertyName(extensionDataPair.Key); WriteToken(schema, _writer, extensionDataPair.Value, isDefinitions); } } if (schema.Type != null) { WriteType(Constants.PropertyNames.Type, _writer, schema.Type.Value); } if (schema.Default != null) { _writer.WritePropertyName(Constants.PropertyNames.Default); schema.Default.WriteTo(_writer); } if (!schema.AllowAdditionalProperties) { _writer.WritePropertyName(Constants.PropertyNames.AdditionalProperties); _writer.WriteValue(schema.AllowAdditionalProperties); } else { if (schema.AdditionalProperties != null) { ReferenceOrWriteSchema(schema, schema.AdditionalProperties, Constants.PropertyNames.AdditionalProperties); } } if (!schema.AllowAdditionalItems) { _writer.WritePropertyName(Constants.PropertyNames.AdditionalItems); _writer.WriteValue(schema.AllowAdditionalItems); } else { if (schema.AdditionalItems != null) { ReferenceOrWriteSchema(schema, schema.AdditionalItems, Constants.PropertyNames.AdditionalItems); } } WriteSchemaDictionaryIfNotNull(schema, _writer, Constants.PropertyNames.Properties, schema._properties); WriteRequired(schema); WriteSchemaDictionaryIfNotNull(schema, _writer, Constants.PropertyNames.PatternProperties, schema._patternProperties); WriteItems(schema); WritePropertyIfNotDefault(_writer, Constants.PropertyNames.UniqueItems, schema.UniqueItems); if (EnsureVersion(SchemaVersion.Draft6)) { WritePropertyIfNotNull(_writer, schema.ExclusiveMinimum ? Constants.PropertyNames.ExclusiveMinimum : Constants.PropertyNames.Minimum, schema.Minimum); WritePropertyIfNotNull(_writer, schema.ExclusiveMaximum ? Constants.PropertyNames.ExclusiveMaximum : Constants.PropertyNames.Maximum, schema.Maximum); } else { WritePropertyIfNotNull(_writer, Constants.PropertyNames.Minimum, schema.Minimum); WritePropertyIfNotNull(_writer, Constants.PropertyNames.Maximum, schema.Maximum); WritePropertyIfNotDefault(_writer, Constants.PropertyNames.ExclusiveMinimum, schema.ExclusiveMinimum); WritePropertyIfNotDefault(_writer, Constants.PropertyNames.ExclusiveMaximum, schema.ExclusiveMaximum); } WritePropertyIfNotNull(_writer, Constants.PropertyNames.MinimumLength, schema.MinimumLength); WritePropertyIfNotNull(_writer, Constants.PropertyNames.MaximumLength, schema.MaximumLength); WritePropertyIfNotNull(_writer, Constants.PropertyNames.MinimumItems, schema.MinimumItems); WritePropertyIfNotNull(_writer, Constants.PropertyNames.MaximumItems, schema.MaximumItems); WritePropertyIfNotNull(_writer, Constants.PropertyNames.MinimumProperties, schema.MinimumProperties); WritePropertyIfNotNull(_writer, Constants.PropertyNames.MaximumProperties, schema.MaximumProperties); WritePropertyIfNotNull(_writer, Constants.PropertyNames.MultipleOf, schema.MultipleOf); WritePropertyIfNotNull(_writer, Constants.PropertyNames.Pattern, schema.Pattern); WritePropertyIfNotNull(_writer, Constants.PropertyNames.Format, schema.Format); if (!schema._enum.IsNullOrEmpty()) { _writer.WritePropertyName(Constants.PropertyNames.Enum); _writer.WriteStartArray(); foreach (JToken token in schema._enum) { token.WriteTo(_writer); } _writer.WriteEndArray(); } if (EnsureVersion(SchemaVersion.Draft6)) { if (schema.Const != null) { _writer.WritePropertyName(Constants.PropertyNames.Const); schema.Const.WriteTo(_writer); } WriteSchema(schema, schema.PropertyNames, Constants.PropertyNames.PropertyNamesSchema); WriteSchema(schema, schema.Contains, Constants.PropertyNames.Contains); } WriteSchemas(schema, schema._allOf, Constants.PropertyNames.AllOf); WriteSchemas(schema, schema._anyOf, Constants.PropertyNames.AnyOf); WriteSchemas(schema, schema._oneOf, Constants.PropertyNames.OneOf); WriteSchema(schema, schema.Not, Constants.PropertyNames.Not); _writer.WriteEndObject(); }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { BoolQuery boolQuery = (BoolQuery)value; if (boolQuery == null) { return; } /* * { * "bool" : { * "must" : [{}], * "must_not" : [{}], * "should" : [], * "minimum_should_match" : mini, * "boost" : boostvalue * } * } */ writer.WriteStartObject(); writer.WritePropertyName("bool"); writer.WriteStartObject(); if (boolQuery.MustQuery != null && boolQuery.MustQuery.Count > 0) { writer.WritePropertyName("must"); writer.WriteStartArray(); foreach (IQuery query in boolQuery.MustQuery) { serializer.Serialize(writer, query); } writer.WriteEndArray(); } if (boolQuery.MustNotQuery != null && boolQuery.MustNotQuery.Count > 0) { writer.WritePropertyName("must_not"); writer.WriteStartArray(); foreach (IQuery query in boolQuery.MustNotQuery) { serializer.Serialize(writer, query); } writer.WriteEndArray(); } if (boolQuery.ShouldQuery != null && boolQuery.ShouldQuery.Count > 0) { writer.WritePropertyName("should"); writer.WriteStartArray(); foreach (IQuery query in boolQuery.ShouldQuery) { serializer.Serialize(writer, query); } writer.WriteEndArray(); } if (Math.Abs(boolQuery.Boost - Constants.DF_Boost) > 0) { writer.WritePropertyName("boost"); writer.WriteValue(boolQuery.Boost); } writer.WriteEndObject(); writer.WriteEndObject(); }
public override void Serialize(JsonWriter writer) { writer.WriteStartObject(); writer.WritePropertyName("attributes"); writer.WriteStartObject(); foreach (var attribute in Attributes) { writer.WritePropertyName(attribute.Key); writer.WriteValue(attribute.Value.Id); } writer.WriteEndObject(); if (Indices != null) { writer.WritePropertyName("indices"); writer.WriteValue(Indices.Id); } if (Material != null) { writer.WritePropertyName("material"); writer.WriteValue(Material.Id); } if (Mode != DrawMode.Triangles) { writer.WritePropertyName("mode"); writer.WriteValue((int)Mode); } if (Targets != null && Targets.Count > 0) { writer.WritePropertyName("targets"); writer.WriteStartArray(); foreach (var target in Targets) { writer.WriteStartObject(); foreach (var attribute in target) { writer.WritePropertyName(attribute.Key); writer.WriteValue(attribute.Value.Id); } writer.WriteEndObject(); } writer.WriteEndArray(); } // GLTF does not support morph target names, serialize in extras for now // https://github.com/KhronosGroup/glTF/issues/1036 if (TargetNames != null && TargetNames.Count > 0) { writer.WritePropertyName("extras"); writer.WriteStartObject(); writer.WritePropertyName("targetNames"); writer.WriteStartArray(); foreach (var targetName in TargetNames) { writer.WriteValue(targetName); } writer.WriteEndArray(); writer.WriteEndObject(); } base.Serialize(writer); writer.WriteEndObject(); }
public void StringEscaping() { StringBuilder sb = new StringBuilder(); StringWriter sw = new StringWriter(sb); using (JsonWriter jsonWriter = new JsonWriter(sw)) { jsonWriter.WriteStartArray(); jsonWriter.WriteValue(@"""These pretzels are making me thirsty!"""); jsonWriter.WriteValue("Jeff's house was burninated."); jsonWriter.WriteValue(@"1. You don't talk about fight club. 2. You don't talk about fight club."); jsonWriter.WriteValue("35% of\t statistics\n are made\r up."); jsonWriter.WriteEndArray(); } string expected = @"[""\""These pretzels are making me thirsty!\"""",""Jeff's house was burninated."",""1. You don't talk about fight club.\r\n2. You don't talk about fight club."",""35% of\t statistics\n are made\r up.""]"; string result = sb.ToString(); Console.WriteLine("StringEscaping"); Console.WriteLine(result); Assert.AreEqual(expected, result); }
public override void Serialize(JsonWriter writer) { writer.WriteStartObject(); if (PbrMetallicRoughness != null) { writer.WritePropertyName("pbrMetallicRoughness"); PbrMetallicRoughness.Serialize(writer); } if (CommonConstant != null) { writer.WritePropertyName("commonConstant"); CommonConstant.Serialize(writer); } if (NormalTexture != null) { writer.WritePropertyName("normalTexture"); NormalTexture.Serialize(writer); } if (OcclusionTexture != null) { writer.WritePropertyName("occlusionTexture"); OcclusionTexture.Serialize(writer); } if (EmissiveTexture != null) { writer.WritePropertyName("emissiveTexture"); EmissiveTexture.Serialize(writer); } if (EmissiveFactor != Color.black) { writer.WritePropertyName("emissiveFactor"); writer.WriteStartArray(); writer.WriteValue(EmissiveFactor.r); writer.WriteValue(EmissiveFactor.g); writer.WriteValue(EmissiveFactor.b); writer.WriteEndArray(); } if (AlphaMode != AlphaMode.OPAQUE) { writer.WritePropertyName("alphaMode"); writer.WriteValue(AlphaMode.ToString()); } if (AlphaCutoff != 0.5) { writer.WritePropertyName("alphaCutoff"); writer.WriteValue(AlphaCutoff); } if (DoubleSided) { writer.WritePropertyName("doubleSided"); writer.WriteValue(true); } base.Serialize(writer); writer.WriteEndObject(); }
private void SerializeList(JsonWriter writer, IEnumerable values, JsonArrayContract contract, JsonProperty member, JsonContainerContract collectionContract, JsonProperty containerProperty) { IWrappedCollection wrappedCollection = values as IWrappedCollection; object underlyingList = wrappedCollection != null ? wrappedCollection.UnderlyingCollection : values; OnSerializing(writer, contract, underlyingList); _serializeStack.Add(underlyingList); bool hasWrittenMetadataObject = WriteStartArray(writer, underlyingList, contract, member, collectionContract, containerProperty); writer.WriteStartArray(); int initialDepth = writer.Top; int index = 0; IEnumerator enumerator; try { enumerator = values.GetEnumerator(); } catch (Exception e) { throw new InvalidOperationException("Could not get enumerator for property: " + member, e); } using (enumerator as IDisposable) { while (true) { try { if (enumerator.MoveNext() == false) break; } catch (Exception e) { throw new InvalidOperationException("Could not move to next value for property: " + member, e); } object value; try { value = enumerator.Current; } catch (Exception e) { throw new InvalidOperationException("Could not get current value for property: " + member, e); } try { JsonContract valueContract = contract.FinalItemContract ?? GetContractSafe(value); if (ShouldWriteReference(value, null, valueContract, contract, member)) { WriteReference(writer, value); } else { if (CheckForCircularReference(writer, value, null, valueContract, contract, member)) { SerializeValue(writer, value, valueContract, null, contract, member); } } } catch (Exception ex) { if (IsErrorHandled(underlyingList, contract, index, null, writer.ContainerPath, ex)) HandleError(writer, initialDepth); else throw; } finally { index++; } } } writer.WriteEndArray(); if (hasWrittenMetadataObject) writer.WriteEndObject(); _serializeStack.RemoveAt(_serializeStack.Count - 1); OnSerialized(writer, contract, underlyingList); }
public override void WriteTo(JsonWriter writer) { writer.WriteStartArray(); foreach (JToken token in Children()) { token.WriteTo(writer); } writer.WriteEndArray(); }
private void SerializeGroupedNodes(JsonWriter writer, XmlNode node) { // group nodes together by name Dictionary <string, List <XmlNode> > nodesGroupedByName = new Dictionary <string, List <XmlNode> >(); for (int i = 0; i < node.ChildNodes.Count; i++) { XmlNode childNode = node.ChildNodes[i]; string nodeName = GetPropertyName(childNode); List <XmlNode> nodes; if (!nodesGroupedByName.TryGetValue(nodeName, out nodes)) { nodes = new List <XmlNode>(); nodesGroupedByName.Add(nodeName, nodes); } nodes.Add(childNode); } // loop through grouped nodes. write single name instances as normal, // write multiple names together in an array foreach (KeyValuePair <string, List <XmlNode> > nodeNameGroup in nodesGroupedByName) { List <XmlNode> groupedNodes = nodeNameGroup.Value; bool writeArray; if (groupedNodes.Count == 1) { XmlNode singleNode = groupedNodes[0]; XmlAttribute jsonArrayAttribute = (singleNode.Attributes != null) ? singleNode.Attributes["Array", JsonNamespaceUri] : null; if (jsonArrayAttribute != null) { writeArray = XmlConvert.ToBoolean(jsonArrayAttribute.Value); } else { writeArray = false; } } else { writeArray = true; } if (!writeArray) { SerializeNode(writer, groupedNodes[0], true); } else { string elementNames = nodeNameGroup.Key; writer.WritePropertyName(nodeNameGroup.Key); writer.WriteStartArray(); for (int i = 0; i < groupedNodes.Count; i++) { SerializeNode(writer, groupedNodes[i], false); } writer.WriteEndArray(); } } }
private void SerializeList(JsonWriter writer, IWrappedCollection values, JsonArrayContract contract, JsonProperty member, JsonContainerContract collectionContract, JsonProperty containerProperty) { contract.InvokeOnSerializing(values.UnderlyingCollection, Serializer.Context); _serializeStack.Add(values.UnderlyingCollection); bool hasWrittenMetadataObject = WriteStartArray(writer, values.UnderlyingCollection, contract, member, collectionContract, containerProperty); writer.WriteStartArray(); int initialDepth = writer.Top; int index = 0; // note that an error in the IEnumerable won't be caught foreach (object value in values) { try { JsonContract valueContract = contract.FinalItemContract ?? GetContractSafe(value); if (ShouldWriteReference(value, null, valueContract, contract, member)) { WriteReference(writer, value); } else { if (CheckForCircularReference(writer, value, null, valueContract, contract, member)) { SerializeValue(writer, value, valueContract, null, contract, member); } } } catch (Exception ex) { if (IsErrorHandled(values.UnderlyingCollection, contract, index, writer.ContainerPath, ex)) HandleError(writer, initialDepth); else throw; } finally { index++; } } writer.WriteEndArray(); if (hasWrittenMetadataObject) writer.WriteEndObject(); _serializeStack.RemoveAt(_serializeStack.Count - 1); contract.InvokeOnSerialized(values.UnderlyingCollection, Serializer.Context); }
/// <summary> /// Write the JSON string. This will convert all the properties to a JSON string. /// This is done manaully to improve conversion time. The default serializer will check /// each property if it can convert. This will convert the properties automatically. This /// will double the speed. /// /// Newtonsoft.Json.JsonConvert.SerializeObject(ensemble.InstrumentVelocityData). /// /// </summary> /// <param name="writer">JSON Writer.</param> /// <param name="value">Object to write to JSON.</param> /// <param name="serializer">Serializer to convert the object.</param> public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { // Cast the object var data = value as InstrumentVelocityDataSet; // Start the object writer.Formatting = Formatting.None; // Make the text not indented, so not as human readable. This will save disk space writer.WriteStartObject(); // Start the JSON object // Write the base values writer.WriteRaw(data.ToJsonBaseStub()); writer.WriteRaw(","); // Write the float[,] array data // This will be an array of arrays // Each array element will contain an array with the 4 beam's value writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_INSTRUMENTVELOCITYDATA); writer.WriteStartArray(); for (int bin = 0; bin < data.NumElements; bin++) { // Write an array of float values for each beam's value writer.WriteStartArray(); for (int beam = 0; beam < data.ElementsMultiplier; beam++) { writer.WriteValue(data.InstrumentVelocityData[bin, beam]); } writer.WriteEndArray(); } writer.WriteEndArray(); // End the object writer.WriteEndObject(); }
private void WriteType(string propertyName, JsonWriter writer, JsonSchemaType type) { IList<JsonSchemaType> types; if (System.Enum.IsDefined(typeof(JsonSchemaType), type)) { types = new List<JsonSchemaType> { type }; } else { types = EnumUtils.GetFlagsValues(type).Where(v => v != JsonSchemaType.None).ToList(); } if (types.Count == 0) { return; } writer.WritePropertyName(propertyName); if (types.Count == 1) { writer.WriteValue(JsonSchemaBuilder.MapType(types[0])); return; } writer.WriteStartArray(); foreach (JsonSchemaType jsonSchemaType in types) { writer.WriteValue(JsonSchemaBuilder.MapType(jsonSchemaType)); } writer.WriteEndArray(); }
/// <summary> /// Writes the JSON representation of the object. /// </summary> /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param> /// <param name="value">The value.</param> /// <param name="serializer">The calling serializer.</param> public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver; Type unionType = UnionTypeLookupCache.Get(value.GetType()); Union union = UnionCache.Get(unionType); int tag = (int)union.TagReader.Invoke(value); UnionCase caseInfo = union.Cases.Single(c => c.Tag == tag); writer.WriteStartObject(); writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(CasePropertyName) : CasePropertyName); writer.WriteValue(caseInfo.Name); if (caseInfo.Fields != null && caseInfo.Fields.Length > 0) { object[] fields = (object[])caseInfo.FieldReader.Invoke(value); writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(FieldsPropertyName) : FieldsPropertyName); writer.WriteStartArray(); foreach (object field in fields) { serializer.Serialize(writer, field); } writer.WriteEndArray(); } writer.WriteEndObject(); }
/// <summary> /// Converts XML to JsonML array form. /// </summary> public static void EncodeArrayForm(XmlReader reader, JsonWriter writer) { if (reader == null) throw new ArgumentNullException("reader"); if (writer == null) throw new ArgumentNullException("writer"); if (reader.MoveToContent() != XmlNodeType.Element) throw new ArgumentException(null, "reader"); writer.WriteStartArray(); writer.WriteString(reader.Name); // // Write attributes // if (reader.MoveToFirstAttribute()) { writer.WriteStartObject(); do { writer.WriteMember(reader.Name); writer.WriteString(reader.Value); } while (reader.MoveToNextAttribute()); writer.WriteEndObject(); reader.MoveToElement(); } bool isEmpty = reader.IsEmptyElement; if (!isEmpty) { reader.Read(); // // Write child nodes (text, CDATA and element) // while (reader.NodeType != XmlNodeType.EndElement) { if (reader.NodeType == XmlNodeType.Text || reader.NodeType == XmlNodeType.CDATA) { writer.WriteString(reader.Value); reader.Read(); } else if (reader.NodeType == XmlNodeType.Element) { Encode(reader, writer); } else { reader.Read(); } } } writer.WriteEndArray(); reader.Read(); }
private void SerializeList(JsonWriter writer, IWrappedCollection values, JsonArrayContract contract, JsonProperty member, JsonContract collectionValueContract) { contract.InvokeOnSerializing(values.UnderlyingCollection, Serializer.Context); SerializeStack.Add(values.UnderlyingCollection); bool isReference = contract.IsReference ?? HasFlag(Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Arrays); bool includeTypeDetails = ShouldWriteType(TypeNameHandling.Arrays, contract, member, collectionValueContract); if (isReference || includeTypeDetails) { writer.WriteStartObject(); if (isReference) { writer.WritePropertyName(JsonTypeReflector.IdPropertyName); writer.WriteValue(Serializer.ReferenceResolver.GetReference(this, values.UnderlyingCollection)); } if (includeTypeDetails) { WriteTypeProperty(writer, values.UnderlyingCollection.GetType()); } writer.WritePropertyName(JsonTypeReflector.ArrayValuesPropertyName); } JsonContract childValuesContract = Serializer.ContractResolver.ResolveContract(contract.CollectionItemType ?? typeof(object)); writer.WriteStartArray(); int initialDepth = writer.Top; int index = 0; // note that an error in the IEnumerable won't be caught #if !(UNITY_IPHONE || UNITY_IOS) foreach (object value in values) { try { JsonContract valueContract = GetContractSafe(value); if (ShouldWriteReference(value, null, valueContract)) { WriteReference(writer, value); } else { if (CheckForCircularReference(value, null, contract)) { SerializeValue(writer, value, valueContract, null, childValuesContract); } } } catch (Exception ex) { if (IsErrorHandled(values.UnderlyingCollection, contract, index, ex)) HandleError(writer, initialDepth); else throw; } finally { index++; } } #else values.ForEach(value => { try { JsonContract valueContract = GetContractSafe(value); if (ShouldWriteReference(value, null, valueContract)) { WriteReference(writer, value); } else { if (CheckForCircularReference(value, null, contract)) { SerializeValue(writer, value, valueContract, null, childValuesContract); } } } catch (Exception ex) { if (IsErrorHandled(values.UnderlyingCollection, contract, index, ex)) HandleError(writer, initialDepth); else throw; } finally { index++; } }); #endif writer.WriteEndArray(); if (isReference || includeTypeDetails) { writer.WriteEndObject(); } SerializeStack.RemoveAt(SerializeStack.Count - 1); contract.InvokeOnSerialized(values.UnderlyingCollection, Serializer.Context); }
public override void Serialize(JsonWriter writer) { writer.WriteStartObject(); if (Camera != null) { writer.WritePropertyName("camera"); writer.WriteValue(Camera.Id); } if (Children != null && Children.Count > 0) { writer.WritePropertyName("children"); writer.WriteStartArray(); foreach (var child in Children) { writer.WriteValue(child.Id); } writer.WriteEndArray(); } if (Skin != null) { writer.WritePropertyName("skin"); writer.WriteValue(Skin.Id); } if (Matrix != Matrix4x4.identity) { writer.WritePropertyName("matrix"); writer.WriteStartArray(); for (var i = 0; i < 16; i++) { writer.WriteValue(Matrix[i]); } writer.WriteEndArray(); } if (Mesh != null) { writer.WritePropertyName("mesh"); writer.WriteValue(Mesh.Id); } if (Rotation != Quaternion.identity) { writer.WritePropertyName("rotation"); writer.WriteStartArray(); writer.WriteValue(Rotation.x); writer.WriteValue(Rotation.y); writer.WriteValue(Rotation.z); writer.WriteValue(Rotation.w); writer.WriteEndArray(); } if (Scale != Vector3.one) { writer.WritePropertyName("scale"); writer.WriteStartArray(); writer.WriteValue(Scale.x); writer.WriteValue(Scale.y); writer.WriteValue(Scale.z); writer.WriteEndArray(); } if (Translation != Vector3.zero) { writer.WritePropertyName("translation"); writer.WriteStartArray(); writer.WriteValue(Translation.x); writer.WriteValue(Translation.y); writer.WriteValue(Translation.z); writer.WriteEndArray(); } if (Weights != null && Weights.Count > 0) { writer.WritePropertyName("weights"); writer.WriteStartArray(); foreach (var weight in Weights) { writer.WriteValue(weight); } writer.WriteEndArray(); } base.Serialize(writer); writer.WriteEndObject(); }
private void SerializeList(JsonWriter writer, IList values, JsonArrayContract contract, JsonProperty member) { contract.InvokeOnSerializing(values, Serializer.Context); SerializeStack.Add(values); bool isReference = contract.IsReference ?? HasFlag(Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Arrays); bool includeTypeDetails = HasFlag(((member != null) ? member.TypeNameHandling : null) ?? Serializer.TypeNameHandling, TypeNameHandling.Arrays); if (isReference || includeTypeDetails) { writer.WriteStartObject(); if (isReference) { writer.WritePropertyName(JsonTypeReflector.IdPropertyName); writer.WriteValue(Serializer.ReferenceResolver.GetReference(values)); } if (includeTypeDetails) { WriteTypeProperty(writer, values.GetType()); } writer.WritePropertyName(JsonTypeReflector.ArrayValuesPropertyName); } writer.WriteStartArray(); int initialDepth = writer.Top; for (int i = 0; i < values.Count; i++) { try { object value = values[i]; JsonContract valueContract = GetContractSafe(value); if (ShouldWriteReference(value, null, valueContract)) { WriteReference(writer, value); } else { if (!CheckForCircularReference(value, null, contract)) { continue; } SerializeValue(writer, value, null, valueContract); } } catch (Exception ex) { if (IsErrorHandled(values, contract, i, ex)) { HandleError(writer, initialDepth); } else { throw; } } } writer.WriteEndArray(); if (isReference || includeTypeDetails) { writer.WriteEndObject(); } SerializeStack.RemoveAt(SerializeStack.Count - 1); contract.InvokeOnSerialized(values, Serializer.Context); }
public void WriteArrayStart() { _jsonWriter.WriteStartArray(); }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { if (value != null) { if (value.GetType() == typeof(Color)) { Color color = (Color)value; writer.WriteStartArray(); writer.WriteValue(color.r); writer.WriteValue(color.g); writer.WriteValue(color.b); writer.WriteValue(color.a); writer.WriteEndArray(); } else if (value.GetType() == typeof(Vector2)) { Vector2 v = (Vector2)value; writer.WriteStartArray(); writer.WriteValue(v.x); writer.WriteValue(v.y); writer.WriteEndArray(); } else if (value.GetType() == typeof(Vector3)) { Vector3 v = (Vector3)value; writer.WriteStartArray(); writer.WriteValue(v.x); writer.WriteValue(v.y); writer.WriteValue(v.z); writer.WriteEndArray(); } else if (value.GetType() == typeof(Vector4)) { Vector4 v = (Vector4)value; writer.WriteStartArray(); writer.WriteValue(v.x); writer.WriteValue(v.y); writer.WriteValue(v.z); writer.WriteValue(v.w); writer.WriteEndArray(); } else if (value.GetType() == typeof(Quaternion)) { Quaternion q = (Quaternion)value; writer.WriteStartArray(); writer.WriteValue(q.x); writer.WriteValue(q.y); writer.WriteValue(q.z); writer.WriteValue(q.w); writer.WriteEndArray(); } else if (value.GetType() == typeof(Matrix4x4)) { Matrix4x4 m = (Matrix4x4)value; writer.WriteStartArray(); for (int y = 0; y < 4; y++) { for (int x = 0; x < 4; x++) { writer.WriteValue(m[y, x]); } } writer.WriteEndArray(); } } }
private void InternalWrite(JsonWriter writer, string name, object value, JsonSerializer serializer) { JsonConverter converter; if (value == null) { if (serializer.NullValueHandling == NullValueHandling.Include) { writer.WriteNull(); } return; } Type valueType = value.GetType(); if (HasConverter(serializer, valueType, out converter)) { converter.WriteJson(writer, value, serializer); } else if (IsSimpleType(valueType)) { // Only re-write values if the flag is switched, and they have an obvious string representation if (!_client.Configuration.LogPersonalInformation && (value is string || value is Uri)) { if (_piiBlacklist.Contains(name)) { writer.WriteValue(GetHash(value.ToString())); } else { writer.WriteValue(GuidRegex.Replace(value.ToString(), GetHash)); } } else { writer.WriteValue(value); } } else if (value is IEnumerable) { if (_client.Configuration.LogFullResponse) { writer.WriteStartArray(); foreach (var o in (IEnumerable)value) { InternalWrite(writer, null, o, serializer); } writer.WriteEndArray(); } else { writer.WriteStartObject(); writer.WritePropertyName("Type"); writer.WriteValue(valueType.ToString()); writer.WritePropertyName("Count"); writer.WriteValue(((IEnumerable)value).Cast <object>().Count()); writer.WriteEndObject(); } } else { var properties = valueType.GetPublicProperties(); writer.WriteStartObject(); foreach (var prop in properties) { var propValue = prop.GetValue(value, null); if (propValue != null || serializer.NullValueHandling == NullValueHandling.Include) { writer.WritePropertyName(prop.Name); InternalWrite(writer, prop.Name, propValue, serializer); } } writer.WriteEndObject(); } }
/// <summary> /// WriteJson /// </summary> /// <param name="writer">json writer</param> /// <param name="value">object value</param> /// <param name="serializer">json serilaizer value</param> /// <returns>void</returns> public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { if (value.GetType().BaseType == Type.GetType("System.Array")) { writer.WriteStartArray(); foreach (var arr in value as Array) { serializer.Serialize(writer, arr); } writer.WriteEndArray(); return; } if (value.GetType().GetProperties().Count() > 0) { writer.WriteStartObject(); foreach (PropertyInfo propertyInfo in value.GetType().GetProperties()) { if (propertyInfo.CanRead && ((propertyInfo.PropertyType.IsArray && propertyInfo.PropertyType.GetElementType() == Type.GetType("System.Object")) || (propertyInfo.PropertyType == Type.GetType("System.Object")))) { object val = propertyInfo.GetValue(value, null); if (!(val == null && (serializer.NullValueHandling == NullValueHandling.Ignore))) { string propName = propertyInfo.Name + "Specified"; PropertyInfo specifiedProp = value.GetType().GetProperty(propName); if (specifiedProp != null && ((bool)specifiedProp.GetValue(value, null) == true)) { writer.WritePropertyName(val.GetType().Name); serializer.Serialize(writer, propertyInfo.GetValue(value, null)); } else if (specifiedProp == null) { System.Xml.Serialization.XmlChoiceIdentifierAttribute[] attrs = (System.Xml.Serialization.XmlChoiceIdentifierAttribute[])propertyInfo.GetCustomAttributes((new System.Xml.Serialization.XmlChoiceIdentifierAttribute()).GetType(), false); if (attrs.Count() > 0) { System.Xml.Serialization.XmlChoiceIdentifierAttribute attr = attrs[0]; PropertyInfo choiceNameProp = value.GetType().GetProperty(attr.MemberName); if (choiceNameProp.PropertyType.IsArray) { //AnyIntuitObjects var TypeofValue = choiceNameProp.GetValue(value, null); Array choiceNameArr = (TypeofValue as Array); Array valueArr = (propertyInfo.GetValue(value, null) as Array); for (int i = 0; i < choiceNameArr.Length; i++) { writer.WritePropertyName(choiceNameArr.GetValue(i).ToString()); serializer.Serialize(writer, valueArr.GetValue(i)); } } else { //AnyIntuitObject var TypeofValue = choiceNameProp.GetValue(value, null); writer.WritePropertyName(TypeofValue.ToString()); serializer.Serialize(writer, propertyInfo.GetValue(value, null)); } } else { Type valueType = null; if (val.GetType().IsArray) { if ((val as Array).Length > 0) { valueType = (val as Array).GetValue(0).GetType(); } } else { valueType = val.GetType(); } System.Xml.Serialization.XmlElementAttribute[] elementAttrs = (System.Xml.Serialization.XmlElementAttribute[])propertyInfo.GetCustomAttributes((new System.Xml.Serialization.XmlElementAttribute()).GetType(), false); foreach (System.Xml.Serialization.XmlElementAttribute attr in elementAttrs) { if (valueType.Name == attr.Type.Name) { writer.WritePropertyName(attr.ElementName); serializer.Serialize(writer, propertyInfo.GetValue(value, null)); } } } } } } else { if ((propertyInfo.GetValue(value, null) != null) && (serializer.NullValueHandling == NullValueHandling.Ignore)) { if (propertyInfo.GetCustomAttributes(false).Contains(new Newtonsoft.Json.JsonIgnoreAttribute()) != true) { if (propertyInfo.GetCustomAttributes(false).Contains(new System.Xml.Serialization.XmlTextAttribute()) && propertyInfo.Name == "Value") { writer.WritePropertyName("value"); writer.WriteValue(propertyInfo.GetValue(value, null).ToString()); } else { string propName = propertyInfo.Name + "Specified"; PropertyInfo specifiedProp = value.GetType().GetProperty(propName); if (specifiedProp != null && (bool)specifiedProp.GetValue(value, null) == true) { writer.WritePropertyName(propertyInfo.Name); serializer.Serialize(writer, propertyInfo.GetValue(value, null)); } else if (specifiedProp == null) { //check if this has choiceIdentifier put key name as its value else put name of property System.Xml.Serialization.XmlChoiceIdentifierAttribute[] choiceattrs = (System.Xml.Serialization.XmlChoiceIdentifierAttribute[])propertyInfo.GetCustomAttributes((new System.Xml.Serialization.XmlChoiceIdentifierAttribute()).GetType(), false); if (choiceattrs.Count() > 0) { foreach ( System.Xml.Serialization.XmlChoiceIdentifierAttribute choiceAttr in choiceattrs) { PropertyInfo choiceProp = value.GetType().GetProperty(choiceAttr.MemberName); writer.WritePropertyName(choiceProp.GetValue(value, null).ToString()); } } else { writer.WritePropertyName(propertyInfo.Name); } //check if its XmlArrayItem (NameValue) System.Xml.Serialization.XmlArrayItemAttribute[] arrayItemAttrs = (System.Xml.Serialization.XmlArrayItemAttribute[])propertyInfo.GetCustomAttributes((new System.Xml.Serialization.XmlArrayItemAttribute()).GetType(), false); if (arrayItemAttrs.Count() > 0) { writer.WriteStartObject(); //if XmlArrayitem has name else data type will be the name if (!string.IsNullOrEmpty(arrayItemAttrs[0].ElementName)) { writer.WritePropertyName(arrayItemAttrs[0].ElementName); } else { writer.WritePropertyName(propertyInfo.GetValue(value, null).GetType().GetElementType().Name); } serializer.Serialize(writer, propertyInfo.GetValue(value, null)); writer.WriteEndObject(); } else { serializer.Serialize(writer, propertyInfo.GetValue(value, null)); } } } } } } } writer.WriteEndObject(); } else { writer.WriteValue(value); } }
/// <summary> /// Write a well-known binary object to JSON. /// </summary> /// <param name="lebr"> /// The little-endian binary reader. /// </param> /// <param name="bebr"> /// The big-endian binary reader. /// </param> /// <param name="writer"> /// The writer. /// </param> /// <exception cref="ArgumentException"> /// Unexpected well-known binary. /// </exception> private static void WriteObject(BinaryReader lebr, BinaryReader bebr, JsonWriter writer) { writer.WriteStartObject(); writer.WritePropertyName("type"); var br = lebr.ReadByte() == 0 ? bebr : lebr; int gtype = br.ReadInt32(); string objTypeName; if (!WkbTypes.TryGetValue(gtype, out objTypeName)) { throw new ArgumentException( string.Format( "Unsupported type {0}. Supported types: {1}", gtype, string.Join(", ", WkbTypes.Select(kv => string.Format("({0}, {1}", kv.Key, kv.Value))))); } writer.WriteValue(objTypeName); if (gtype == GeometryCollectionWkb) { writer.WritePropertyName("geometries"); writer.WriteStartArray(); int count = br.ReadInt32(); for (int i = 0; i < count; ++i) { WriteObject(lebr, bebr, writer); } writer.WriteEndArray(); } else { writer.WritePropertyName("coordinates"); writer.WriteStartArray(); switch (gtype) { case PointWkb: writer.WriteValue(br.ReadDouble()); writer.WriteValue(br.ReadDouble()); break; case LineStringWkb: WriteLine(br, writer); break; case PolygonWkb: WritePolygon(br, writer); break; case MultiPointWkb: int pointCount = br.ReadInt32(); for (int i = 0; i < pointCount; ++i) { br = lebr.ReadByte() == 0 ? bebr : lebr; gtype = br.ReadInt32(); if (gtype != PointWkb) { throw new ArgumentException( string.Format("Expected a type of 1, got {0}", gtype), "lebr"); } writer.WriteStartArray(); writer.WriteValue(br.ReadDouble()); writer.WriteValue(br.ReadDouble()); writer.WriteEndArray(); } break; case MultiLineStringWkb: int lineCount = br.ReadInt32(); for (int i = 0; i < lineCount; ++i) { br = lebr.ReadByte() == 0 ? bebr : lebr; gtype = br.ReadInt32(); if (gtype != LineStringWkb) { throw new ArgumentException( string.Format("Expected a type of 2, got {0}", gtype), "lebr"); } writer.WriteStartArray(); WriteLine(br, writer); writer.WriteEndArray(); } break; case MultiPolygonWkb: int polygonCount = br.ReadInt32(); for (int i = 0; i < polygonCount; ++i) { br = lebr.ReadByte() == 0 ? bebr : lebr; gtype = br.ReadInt32(); if (gtype != PolygonWkb) { throw new ArgumentException( string.Format("Expected a type of 3, got {0}", gtype), "lebr"); } writer.WriteStartArray(); WritePolygon(br, writer); writer.WriteEndArray(); } break; default: throw new ArgumentException(string.Format("Unsupported geo-type {0}", gtype), "lebr"); } writer.WriteEndArray(); } writer.WriteEndObject(); }
private void SerializeGroupedNodes(JsonWriter writer, IXmlNode node, XmlNamespaceManager manager, bool writePropertyName) { // group nodes together by name Dictionary<string, List<IXmlNode>> nodesGroupedByName = new Dictionary<string, List<IXmlNode>>(); for (int i = 0; i < node.ChildNodes.Count; i++) { IXmlNode childNode = node.ChildNodes[i]; string nodeName = GetPropertyName(childNode, manager); List<IXmlNode> nodes; if (!nodesGroupedByName.TryGetValue(nodeName, out nodes)) { nodes = new List<IXmlNode>(); nodesGroupedByName.Add(nodeName, nodes); } nodes.Add(childNode); } // loop through grouped nodes. write single name instances as normal, // write multiple names together in an array foreach (KeyValuePair<string, List<IXmlNode>> nodeNameGroup in nodesGroupedByName) { List<IXmlNode> groupedNodes = nodeNameGroup.Value; bool writeArray; if (groupedNodes.Count == 1) { writeArray = IsArray(groupedNodes[0]); } else { writeArray = true; } if (!writeArray) { SerializeNode(writer, groupedNodes[0], manager, writePropertyName); } else { string elementNames = nodeNameGroup.Key; if (writePropertyName) writer.WritePropertyName(elementNames); writer.WriteStartArray(); for (int i = 0; i < groupedNodes.Count; i++) { SerializeNode(writer, groupedNodes[i], manager, false); } writer.WriteEndArray(); } } }
private void WriteStartArray() { _writer.WriteStartArray(); IncreaseDepth(); }
private void SerializeMultidimensionalArray(JsonWriter writer, Array values, JsonArrayContract contract, JsonProperty member, int initialDepth, int[] indices) { int dimension = indices.Length; int[] newIndices = new int[dimension + 1]; for (int i = 0; i < dimension; i++) { newIndices[i] = indices[i]; } writer.WriteStartArray(); for (int i = 0; i < values.GetLength(dimension); i++) { newIndices[dimension] = i; bool isTopLevel = (newIndices.Length == values.Rank); if (isTopLevel) { object value = values.GetValue(newIndices); try { JsonContract valueContract = contract.FinalItemContract ?? GetContractSafe(value); if (ShouldWriteReference(value, null, valueContract, contract, member)) { WriteReference(writer, value); } else { if (CheckForCircularReference(writer, value, null, valueContract, contract, member)) { SerializeValue(writer, value, valueContract, null, contract, member); } } } catch (Exception ex) { if (IsErrorHandled(values, contract, i, writer.ContainerPath, ex)) HandleError(writer, initialDepth + 1); else throw; } } else { SerializeMultidimensionalArray(writer, values, contract, member, initialDepth + 1, newIndices); } } writer.WriteEndArray(); }
public void WriteSchema(JsonSchema schema) { ValidationUtils.ArgumentNotNull(schema, "schema"); if (!_resolver.LoadedSchemas.Contains(schema)) { _resolver.LoadedSchemas.Add(schema); } _writer.WriteStartObject(); WritePropertyIfNotNull(_writer, JsonSchemaConstants.IdPropertyName, schema.Id); WritePropertyIfNotNull(_writer, JsonSchemaConstants.TitlePropertyName, schema.Title); WritePropertyIfNotNull(_writer, JsonSchemaConstants.DescriptionPropertyName, schema.Description); WritePropertyIfNotNull(_writer, JsonSchemaConstants.RequiredPropertyName, schema.Required); WritePropertyIfNotNull(_writer, JsonSchemaConstants.ReadOnlyPropertyName, schema.ReadOnly); WritePropertyIfNotNull(_writer, JsonSchemaConstants.HiddenPropertyName, schema.Hidden); WritePropertyIfNotNull(_writer, JsonSchemaConstants.TransientPropertyName, schema.Transient); if (schema.Type != null) { WriteType(JsonSchemaConstants.TypePropertyName, _writer, schema.Type.Value); } if (!schema.AllowAdditionalProperties) { _writer.WritePropertyName(JsonSchemaConstants.AdditionalPropertiesPropertyName); _writer.WriteValue(schema.AllowAdditionalProperties); } else { if (schema.AdditionalProperties != null) { _writer.WritePropertyName(JsonSchemaConstants.AdditionalPropertiesPropertyName); ReferenceOrWriteSchema(schema.AdditionalProperties); } } if (!schema.AllowAdditionalItems) { _writer.WritePropertyName(JsonSchemaConstants.AdditionalItemsPropertyName); _writer.WriteValue(schema.AllowAdditionalItems); } else { if (schema.AdditionalItems != null) { _writer.WritePropertyName(JsonSchemaConstants.AdditionalItemsPropertyName); ReferenceOrWriteSchema(schema.AdditionalItems); } } WriteSchemaDictionaryIfNotNull(_writer, JsonSchemaConstants.PropertiesPropertyName, schema.Properties); WriteSchemaDictionaryIfNotNull(_writer, JsonSchemaConstants.PatternPropertiesPropertyName, schema.PatternProperties); WriteItems(schema); WritePropertyIfNotNull(_writer, JsonSchemaConstants.MinimumPropertyName, schema.Minimum); WritePropertyIfNotNull(_writer, JsonSchemaConstants.MaximumPropertyName, schema.Maximum); WritePropertyIfNotNull(_writer, JsonSchemaConstants.ExclusiveMinimumPropertyName, schema.ExclusiveMinimum); WritePropertyIfNotNull(_writer, JsonSchemaConstants.ExclusiveMaximumPropertyName, schema.ExclusiveMaximum); WritePropertyIfNotNull(_writer, JsonSchemaConstants.MinimumLengthPropertyName, schema.MinimumLength); WritePropertyIfNotNull(_writer, JsonSchemaConstants.MaximumLengthPropertyName, schema.MaximumLength); WritePropertyIfNotNull(_writer, JsonSchemaConstants.MinimumItemsPropertyName, schema.MinimumItems); WritePropertyIfNotNull(_writer, JsonSchemaConstants.MaximumItemsPropertyName, schema.MaximumItems); WritePropertyIfNotNull(_writer, JsonSchemaConstants.DivisibleByPropertyName, schema.DivisibleBy); WritePropertyIfNotNull(_writer, JsonSchemaConstants.FormatPropertyName, schema.Format); WritePropertyIfNotNull(_writer, JsonSchemaConstants.PatternPropertyName, schema.Pattern); if (schema.Enum != null) { _writer.WritePropertyName(JsonSchemaConstants.EnumPropertyName); _writer.WriteStartArray(); foreach (JToken token in schema.Enum) { token.WriteTo(_writer); } _writer.WriteEndArray(); } if (schema.Default != null) { _writer.WritePropertyName(JsonSchemaConstants.DefaultPropertyName); schema.Default.WriteTo(_writer); } if (schema.Disallow != null) { WriteType(JsonSchemaConstants.DisallowPropertyName, _writer, schema.Disallow.Value); } if (schema.Extends != null && schema.Extends.Count > 0) { _writer.WritePropertyName(JsonSchemaConstants.ExtendsPropertyName); if (schema.Extends.Count == 1) { ReferenceOrWriteSchema(schema.Extends[0]); } else { _writer.WriteStartArray(); foreach (JsonSchema jsonSchema in schema.Extends) { ReferenceOrWriteSchema(jsonSchema); } _writer.WriteEndArray(); } } _writer.WriteEndObject(); }
/// <summary> /// Write the JSON string. This will convert all the properties to a JSON string. /// This is done manaully to improve conversion time. The default serializer will check /// each property if it can convert. This will convert the properties automatically. This /// will double the speed. /// /// Newtonsoft.Json.JsonConvert.SerializeObject(ensemble.BottomTrackData). /// /// </summary> /// <param name="writer">JSON Writer.</param> /// <param name="value">Object to write to JSON.</param> /// <param name="serializer">Serializer to convert the object.</param> public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { // Cast the object var data = value as BottomTrackDataSet; // Start the object writer.Formatting = Formatting.None; // Make the text not indented, so not as human readable. This will save disk space writer.WriteStartObject(); // Start the JSON object // Write the base values writer.WriteRaw(data.ToJsonBaseStub()); writer.WriteRaw(","); // FirstPingTime writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_FIRSTPINGTIME); writer.WriteValue(data.FirstPingTime); // LastPingTime writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_LASTPINGTIME); writer.WriteValue(data.LastPingTime); // Heading writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_HEADING); writer.WriteValue(data.Heading); // Pitch writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_PITCH); writer.WriteValue(data.Pitch); // Roll writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_ROLL); writer.WriteValue(data.Roll); // WaterTemp writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_WATERTEMP); writer.WriteValue(data.WaterTemp); // SystemTemp writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_SYSTEMP); writer.WriteValue(data.SystemTemp); // Salinity writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_SALINITY); writer.WriteValue(data.Salinity); // Pressure writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_PRESSURE); writer.WriteValue(data.Pressure); // TransducerDepth writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_TRANSDUCERDEPTH); writer.WriteValue(data.TransducerDepth); // SpeedOfSound writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_SPEEDOFSOUND); writer.WriteValue(data.SpeedOfSound); // Status Value writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_STATUS); writer.WriteValue(data.Status.Value); // NumBeams writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_NUMBEAMS); writer.WriteValue(data.NumBeams); // ActualPingCount writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_ACTUALPINGCOUNT); writer.WriteValue(data.ActualPingCount); // Range writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_RANGE); writer.WriteStartArray(); for (int beam = 0; beam < data.NumBeams; beam++) { writer.WriteValue(data.Range[beam]); } writer.WriteEndArray(); // SNR writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_SNR); writer.WriteStartArray(); for (int beam = 0; beam < data.NumBeams; beam++) { writer.WriteValue(data.SNR[beam]); } writer.WriteEndArray(); // Amplitude writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_AMPLITUDE); writer.WriteStartArray(); for (int beam = 0; beam < data.NumBeams; beam++) { writer.WriteValue(data.Amplitude[beam]); } writer.WriteEndArray(); // Correlation writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_CORRELATION); writer.WriteStartArray(); for (int beam = 0; beam < data.NumBeams; beam++) { writer.WriteValue(data.Correlation[beam]); } writer.WriteEndArray(); // Beam Velocity writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_BEAMVELOCITY); writer.WriteStartArray(); for (int beam = 0; beam < data.NumBeams; beam++) { writer.WriteValue(data.BeamVelocity[beam]); } writer.WriteEndArray(); // Good Beam Velocity writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_BEAMGOOD); writer.WriteStartArray(); for (int beam = 0; beam < data.NumBeams; beam++) { writer.WriteValue(data.BeamGood[beam]); } writer.WriteEndArray(); // Instrument Velocity writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_INSTRUMENTVELOCITY); writer.WriteStartArray(); for (int beam = 0; beam < data.NumBeams; beam++) { writer.WriteValue(data.InstrumentVelocity[beam]); } writer.WriteEndArray(); // Good Instrument Velocity writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_INSTRUMENTGOOD); writer.WriteStartArray(); for (int beam = 0; beam < data.NumBeams; beam++) { writer.WriteValue(data.InstrumentGood[beam]); } writer.WriteEndArray(); // Earth Velocity writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_EARTHVELOCITY); writer.WriteStartArray(); for (int beam = 0; beam < data.NumBeams; beam++) { writer.WriteValue(data.EarthVelocity[beam]); } writer.WriteEndArray(); // Good Earth Velocity writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_EARTHGOOD); writer.WriteStartArray(); for (int beam = 0; beam < data.NumBeams; beam++) { writer.WriteValue(data.EarthGood[beam]); } writer.WriteEndArray(); // End the object writer.WriteEndObject(); }
private static void WriteBoundAttribute(JsonWriter writer, BoundAttributeDescriptor boundAttribute, JsonSerializer serializer) { writer.WriteStartObject(); writer.WritePropertyName(nameof(BoundAttributeDescriptor.Kind)); writer.WriteValue(boundAttribute.Kind); writer.WritePropertyName(nameof(BoundAttributeDescriptor.Name)); writer.WriteValue(boundAttribute.Name); writer.WritePropertyName(nameof(BoundAttributeDescriptor.TypeName)); writer.WriteValue(boundAttribute.TypeName); if (boundAttribute.IsEnum) { writer.WritePropertyName(nameof(BoundAttributeDescriptor.IsEnum)); writer.WriteValue(boundAttribute.IsEnum); } if (boundAttribute.IndexerNamePrefix != null) { writer.WritePropertyName(nameof(BoundAttributeDescriptor.IndexerNamePrefix)); writer.WriteValue(boundAttribute.IndexerNamePrefix); } if (boundAttribute.IsEditorRequired) { writer.WritePropertyName(nameof(BoundAttributeDescriptor.IsEditorRequired)); writer.WriteValue(boundAttribute.IsEditorRequired); } if (boundAttribute.IndexerTypeName != null) { writer.WritePropertyName(nameof(BoundAttributeDescriptor.IndexerTypeName)); writer.WriteValue(boundAttribute.IndexerTypeName); } if (boundAttribute.Documentation != null) { writer.WritePropertyName(nameof(BoundAttributeDescriptor.Documentation)); writer.WriteValue(boundAttribute.Documentation); } if (boundAttribute.Diagnostics != null && boundAttribute.Diagnostics.Count > 0) { writer.WritePropertyName(nameof(BoundAttributeDescriptor.Diagnostics)); serializer.Serialize(writer, boundAttribute.Diagnostics); } writer.WritePropertyName(nameof(BoundAttributeDescriptor.Metadata)); WriteMetadata(writer, boundAttribute.Metadata); if (boundAttribute.BoundAttributeParameters != null && boundAttribute.BoundAttributeParameters.Count > 0) { writer.WritePropertyName(nameof(BoundAttributeDescriptor.BoundAttributeParameters)); writer.WriteStartArray(); foreach (var boundAttributeParameter in boundAttribute.BoundAttributeParameters) { WriteBoundAttributeParameter(writer, boundAttributeParameter, serializer); } writer.WriteEndArray(); } writer.WriteEndObject(); }
/// <summary> /// Converts XML to JsonML object form. /// </summary> public static void EncodeObjectForm(XmlReader reader, JsonWriter writer) { if (reader == null) throw new ArgumentNullException("reader"); if (writer == null) throw new ArgumentNullException("writer"); if (reader.MoveToContent() != XmlNodeType.Element) throw new ArgumentException(null, "reader"); writer.WriteStartObject(); writer.WriteMember("tagName"); writer.WriteString(reader.Name); // // Write attributes // if (reader.MoveToFirstAttribute()) { do { writer.WriteMember(reader.Name); writer.WriteString(reader.Value); } while (reader.MoveToNextAttribute()); reader.MoveToElement(); } bool isEmpty = reader.IsEmptyElement; if (!isEmpty) { reader.Read(); int childCount = 0; // // Write child nodes (text, CDATA and element) // XmlNodeType nodeType; while ((nodeType = reader.NodeType) != XmlNodeType.EndElement) { if (nodeType == XmlNodeType.Text || nodeType == XmlNodeType.CDATA || nodeType == XmlNodeType.Element) { if (childCount == 0) { writer.WriteMember("childNodes"); writer.WriteStartArray(); } if (nodeType == XmlNodeType.Text || nodeType == XmlNodeType.CDATA) { writer.WriteString(reader.Value); reader.Read(); } else if (nodeType == XmlNodeType.Element) { EncodeObjectForm(reader, writer); } childCount++; } else { reader.Read(); } } if (childCount > 0) writer.WriteEndArray(); } writer.WriteEndObject(); reader.Read(); }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { var tagHelper = (TagHelperDescriptor)value; writer.WriteStartObject(); writer.WritePropertyName(nameof(TagHelperDescriptor.Kind)); writer.WriteValue(tagHelper.Kind); writer.WritePropertyName(nameof(TagHelperDescriptor.Name)); writer.WriteValue(tagHelper.Name); writer.WritePropertyName(nameof(TagHelperDescriptor.AssemblyName)); writer.WriteValue(tagHelper.AssemblyName); if (tagHelper.Documentation != null) { writer.WritePropertyName(nameof(TagHelperDescriptor.Documentation)); writer.WriteValue(tagHelper.Documentation); } if (tagHelper.TagOutputHint != null) { writer.WritePropertyName(nameof(TagHelperDescriptor.TagOutputHint)); writer.WriteValue(tagHelper.TagOutputHint); } writer.WritePropertyName(nameof(TagHelperDescriptor.CaseSensitive)); writer.WriteValue(tagHelper.CaseSensitive); writer.WritePropertyName(nameof(TagHelperDescriptor.TagMatchingRules)); writer.WriteStartArray(); foreach (var ruleDescriptor in tagHelper.TagMatchingRules) { WriteTagMatchingRule(writer, ruleDescriptor, serializer); } writer.WriteEndArray(); if (tagHelper.BoundAttributes != null && tagHelper.BoundAttributes.Count > 0) { writer.WritePropertyName(nameof(TagHelperDescriptor.BoundAttributes)); writer.WriteStartArray(); foreach (var boundAttribute in tagHelper.BoundAttributes) { WriteBoundAttribute(writer, boundAttribute, serializer); } writer.WriteEndArray(); } if (tagHelper.AllowedChildTags != null && tagHelper.AllowedChildTags.Count > 0) { writer.WritePropertyName(nameof(TagHelperDescriptor.AllowedChildTags)); writer.WriteStartArray(); foreach (var allowedChildTag in tagHelper.AllowedChildTags) { WriteAllowedChildTags(writer, allowedChildTag, serializer); } writer.WriteEndArray(); } if (tagHelper.Diagnostics != null && tagHelper.Diagnostics.Count > 0) { writer.WritePropertyName(nameof(TagHelperDescriptor.Diagnostics)); serializer.Serialize(writer, tagHelper.Diagnostics); } writer.WritePropertyName(nameof(TagHelperDescriptor.Metadata)); WriteMetadata(writer, tagHelper.Metadata); writer.WriteEndObject(); }