private static void ExportDataSet(ExportContext context, DataSet dataSet, JsonWriter writer)
{
Debug.Assert(context != null);
Debug.Assert(dataSet != null);
Debug.Assert(writer != null);
writer.WriteStartObject();
foreach (DataTable table in dataSet.Tables)
{
writer.WriteMember(table.TableName);
//
// If there is an exporter (perhaps an override) for the
// DataTable in effect then use it. Otherwise our
// DataTableExporter.
//
IExporter tableExporter = context.FindExporter(table.GetType());
if (tableExporter != null)
tableExporter.Export(context, table, writer);
else
DataTableExporter.ExportTable(context, table, writer);
}
writer.WriteEndObject();
}
protected override void ExportValue(ExportContext context, object value, JsonWriter writer)
{
Debug.Assert(context != null);
Debug.Assert(value != null);
Debug.Assert(writer != null);
if (_properties.Count == 0)
{
writer.WriteString(value.ToString());
}
else
{
writer.WriteStartObject();
foreach (PropertyDescriptor property in _properties)
{
object propertyValue = property.GetValue(value);
if (!JsonNull.LogicallyEquals(propertyValue))
{
writer.WriteMember(property.Name);
context.Export(propertyValue, writer);
}
}
writer.WriteEndObject();
}
}
protected override void FormatOther(object o, JsonWriter writer)
{
if (writer == null)
throw new ArgumentNullException("writer");
if (JNull.LogicallyEquals(o))
{
FormatNull(o, writer);
return;
}
writer.WriteStartObject();
if (_properties == null)
_properties = TypeDescriptor.GetProperties(o);
foreach (PropertyDescriptor property in _properties)
{
// TODO: Allow someone to indicate via an attribute (e.g. JsonIgnore) that a property should be excluded.
object value = property.GetValue(o);
if (!JNull.LogicallyEquals(value))
{
writer.WriteMember(property.Name);
writer.WriteValue(value);
}
}
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)
{
IEntityKeyMember entityKeyMember = DynamicWrapper.CreateWrapper<IEntityKeyMember>(value);
Type keyType = (entityKeyMember.Value != null) ? entityKeyMember.Value.GetType() : null;
writer.WriteStartObject();
writer.WritePropertyName("Key");
writer.WriteValue(entityKeyMember.Key);
writer.WritePropertyName("Type");
writer.WriteValue((keyType != null) ? keyType.FullName : null);
writer.WritePropertyName("Value");
if (keyType != null)
{
string valueJson;
if (JsonSerializerInternalWriter.TryConvertToString(entityKeyMember.Value, keyType, out valueJson))
writer.WriteValue(valueJson);
else
writer.WriteValue(entityKeyMember.Value);
}
else
{
writer.WriteNull();
}
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;
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();
}
/// <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;
IEntityKeyMember entityKeyMember = DynamicWrapper.CreateWrapper<IEntityKeyMember>(value);
Type keyType = (entityKeyMember.Value != null) ? entityKeyMember.Value.GetType() : null;
writer.WriteStartObject();
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(KeyPropertyName) : KeyPropertyName);
writer.WriteValue(entityKeyMember.Key);
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(TypePropertyName) : TypePropertyName);
writer.WriteValue((keyType != null) ? keyType.FullName : null);
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(ValuePropertyName) : ValuePropertyName);
if (keyType != null)
{
string valueJson;
if (JsonSerializerInternalWriter.TryConvertToString(entityKeyMember.Value, keyType, out valueJson))
writer.WriteValue(valueJson);
else
writer.WriteValue(entityKeyMember.Value);
}
else
{
writer.WriteNull();
}
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)
{
EnsureReflectionObject(value.GetType());
DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver;
string keyName = (string)_reflectionObject.GetValue(value, KeyPropertyName);
object keyValue = _reflectionObject.GetValue(value, ValuePropertyName);
Type keyValueType = (keyValue != null) ? keyValue.GetType() : null;
writer.WriteStartObject();
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(KeyPropertyName) : KeyPropertyName);
writer.WriteValue(keyName);
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(TypePropertyName) : TypePropertyName);
writer.WriteValue((keyValueType != null) ? keyValueType.FullName : null);
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(ValuePropertyName) : ValuePropertyName);
if (keyValueType != null)
{
string valueJson;
if (JsonSerializerInternalWriter.TryConvertToString(keyValue, keyValueType, out valueJson))
writer.WriteValue(valueJson);
else
writer.WriteValue(keyValue);
}
else
{
writer.WriteNull();
}
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");
}
}
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.WriteStartObject();
ExportMembers(context, (ExpandoObject) value, writer);
writer.WriteEndObject();
}
private void WriteJson(JsonWriter writer, Regex regex)
{
writer.WriteStartObject();
writer.WritePropertyName("Pattern");
writer.WriteValue(regex.ToString());
writer.WritePropertyName("Options");
writer.WriteValue(regex.Options);
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>
public override void WriteJson(JsonWriter writer, object value)
{
XmlNode node = value as XmlNode;
if (node == null)
throw new ArgumentException("Value must be an XmlNode", "value");
writer.WriteStartObject();
SerializeNode(writer, node, true);
writer.WriteEndObject();
}
internal static void FormatTable(DataTable table, JsonWriter writer)
{
Debug.Assert(table != null);
Debug.Assert(writer != null);
writer.WriteStartObject();
writer.WriteMember("rows");
writer.WriteValue(table.Rows);
writer.WriteEndObject();
}
private static void FormatDataSet(DataSet dataSet, JsonWriter writer)
{
writer.WriteStartObject();
foreach (DataTable table in dataSet.Tables)
{
writer.WriteMember(table.TableName);
DataTableFormatter.FormatTable(table, writer);
}
writer.WriteEndObject();
}
private static void FormatRowView(DataRowView rowView, JsonWriter writer)
{
writer.WriteStartObject();
foreach (DataColumn column in rowView.DataView.Table.Columns)
{
writer.WriteMember(column.ColumnName);
writer.WriteValue(rowView[column.Ordinal]);
}
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)
{
Type t = value.GetType();
PropertyInfo keyProperty = t.GetProperty("Key");
PropertyInfo valueProperty = t.GetProperty("Value");
writer.WriteStartObject();
writer.WritePropertyName("Key");
serializer.Serialize(writer, ReflectionUtils.GetMemberValue(keyProperty, value));
writer.WritePropertyName("Value");
serializer.Serialize(writer, ReflectionUtils.GetMemberValue(valueProperty, value));
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)
{
ReflectionObject reflectionObject = ReflectionObjectPerType.Get(value.GetType());
DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver;
writer.WriteStartObject();
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(KeyName) : KeyName);
serializer.Serialize(writer, reflectionObject.GetValue(value, KeyName), reflectionObject.GetType(KeyName));
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(ValueName) : ValueName);
serializer.Serialize(writer, reflectionObject.GetValue(value, ValueName), reflectionObject.GetType(ValueName));
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:
{
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");
}
}
protected override void ExportValue(object value, JsonWriter writer)
{
writer.WriteStartObject();
IDictionary dictionary = (IDictionary) value;
foreach (DictionaryEntry entry in dictionary)
{
writer.WriteMember(entry.Key.ToString());
writer.WriteValue(entry.Value);
}
writer.WriteEndObject();
}
private void SerializePrimitive(JsonWriter writer, object value, JsonPrimitiveContract contract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerProperty) {
if (contract.UnderlyingType == typeof(byte[])) {
bool includeTypeDetails = ShouldWriteType(TypeNameHandling.Objects, contract, member, containerContract, containerProperty);
if (includeTypeDetails) {
writer.WriteStartObject();
WriteTypeProperty(writer, contract.CreatedType);
writer.WritePropertyName(JsonTypeReflector.ValuePropertyName);
writer.WriteValue(value);
writer.WriteEndObject();
return;
}
}
writer.WriteValue(value);
}
private static void ExportDataSet(DataSet dataSet, JsonWriter writer)
{
Debug.Assert(dataSet != null);
Debug.Assert(writer != null);
writer.WriteStartObject();
foreach (DataTable table in dataSet.Tables)
{
writer.WriteMember(table.TableName);
DataTableExporter.ExportTable(table, writer);
}
writer.WriteEndObject();
}
internal static void FormatDataRow(DataRow row, JsonWriter writer)
{
Debug.Assert(row != null);
Debug.Assert(writer != null);
writer.WriteStartObject();
foreach (DataColumn column in row.Table.Columns)
{
writer.WriteMember(column.ColumnName);
writer.WriteValue(row[column]);
}
writer.WriteEndObject();
}
internal static void ExportRecord(ExportContext context, ICustomTypeDescriptor record, JsonWriter writer)
{
Debug.Assert(context != null);
Debug.Assert(record != null);
Debug.Assert(writer != null);
writer.WriteStartObject();
foreach (PropertyDescriptor property in record.GetProperties())
{
writer.WriteMember(property.Name);
context.Export(property.GetValue(record), writer);
}
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)
{
Type t = value.GetType();
PropertyInfo keyProperty = t.GetProperty(KeyName);
PropertyInfo valueProperty = t.GetProperty(ValueName);
DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver;
writer.WriteStartObject();
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(KeyName) : KeyName);
serializer.Serialize(writer, ReflectionUtils.GetMemberValue(keyProperty, value));
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(ValueName) : ValueName);
serializer.Serialize(writer, ReflectionUtils.GetMemberValue(valueProperty, value));
writer.WriteEndObject();
}
internal static void ExportRow(ExportContext context, DataRow row, JsonWriter writer)
{
Debug.Assert(context != null);
Debug.Assert(row != null);
Debug.Assert(writer != null);
writer.WriteStartObject();
foreach (DataColumn column in row.Table.Columns)
{
writer.WriteMember(column.ColumnName);
context.Export(row[column], writer);
}
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)
{
DataSet dataSet = (DataSet)value;
DataTableConverter converter = new DataTableConverter();
writer.WriteStartObject();
foreach (DataTable table in dataSet.Tables)
{
writer.WritePropertyName(table.TableName);
converter.WriteJson(writer, table, serializer);
}
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)
{
DataSet dataSet = (DataSet)value;
DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver;
DataTableConverter converter = new DataTableConverter();
writer.WriteStartObject();
foreach (DataTable table in dataSet.Tables)
{
writer.WritePropertyName((resolver != null) ? resolver.ResolvePropertyName(table.TableName) : table.TableName);
converter.WriteJson(writer, table, serializer);
}
writer.WriteEndObject();
}
protected override void ExportValue(ExportContext context, object value, JsonWriter writer)
{
Debug.Assert(context != null);
Debug.Assert(value != null);
Debug.Assert(writer != null);
writer.WriteStartObject();
IDictionary dictionary = (IDictionary) value;
foreach (DictionaryEntry entry in DictionaryHelper.GetEntries(dictionary))
{
writer.WriteMember(entry.Key.ToString());
context.Export(entry.Value, writer);
}
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)
{
DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver;
Type t = value.GetType();
object result = FSharpUtils.GetUnionFields(null, value, t, null);
object info = FSharpUtils.GetUnionCaseInfo(result);
object fields = FSharpUtils.GetUnionCaseFields(result);
object caseName = FSharpUtils.GetUnionCaseInfoName(info);
writer.WriteStartObject();
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(CasePropertyName) : CasePropertyName);
writer.WriteValue((string)caseName);
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(FieldsPropertyName) : FieldsPropertyName);
serializer.Serialize(writer, fields);
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)
{
ReflectionObject reflectionObject = ReflectionObjectPerType.Get(value.GetType());
DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver;
writer.WriteStartObject();
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(Name) : Name);
serializer.Serialize(writer, reflectionObject.GetValue(value, Name), reflectionObject.GetType(Name));
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(isStaticName) : isStaticName);
serializer.Serialize(writer, reflectionObject.GetValue(value, isStaticName), reflectionObject.GetType(isStaticName));
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(layerName) : layerName);
serializer.Serialize(writer, reflectionObject.GetValue(value, layerName), reflectionObject.GetType(layerName));
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(tagName) : tagName);
serializer.Serialize(writer, reflectionObject.GetValue(value, tagName), reflectionObject.GetType(tagName));
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(flagsName) : flagsName);
serializer.Serialize(writer, reflectionObject.GetValue(value, flagsName), reflectionObject.GetType(flagsName));
writer.WriteEndObject();
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var indexSettings = (IndexSettings)value;
writer.WriteStartObject();
writer.WritePropertyName("settings");
writer.WriteStartObject();
writer.WritePropertyName("index");
writer.WriteStartObject();
// allready in indexSetting.Setting
/*
* if (indexSettings.NumberOfReplicas.HasValue)
* {
* writer.WritePropertyName("number_of_shards");
* writer.WriteValue(indexSettings.NumberOfShards);
* }
* if (indexSettings.NumberOfShards.HasValue)
* {
* writer.WritePropertyName("number_of_replicas");
* writer.WriteValue(indexSettings.NumberOfReplicas);
* }
*/
if (indexSettings.Settings.HasAny())
{
foreach (var kv in indexSettings.Settings)
{
writer.WritePropertyName(kv.Key);
writer.WriteValue(kv.Value);
}
}
if (
indexSettings.Analysis.Analyzers.Count > 0 ||
indexSettings.Analysis.TokenFilters.Count > 0 ||
indexSettings.Analysis.Tokenizers.Count > 0 ||
indexSettings.Analysis.CharFilters.Count > 0
)
{
writer.WritePropertyName("analysis");
writer.WriteStartObject();
if (indexSettings.Analysis.Analyzers.Count > 0)
{
writer.WritePropertyName("analyzer");
serializer.Serialize(writer, indexSettings.Analysis.Analyzers);
}
if (indexSettings.Analysis.TokenFilters.Count > 0)
{
writer.WritePropertyName("filter");
serializer.Serialize(writer, indexSettings.Analysis.TokenFilters);
}
if (indexSettings.Analysis.Tokenizers.Count > 0)
{
writer.WritePropertyName("tokenizer");
serializer.Serialize(writer, indexSettings.Analysis.Tokenizers);
}
if (indexSettings.Analysis.CharFilters.Count > 0)
{
writer.WritePropertyName("char_filter");
serializer.Serialize(writer, indexSettings.Analysis.CharFilters);
}
writer.WriteEndObject();
}
writer.WriteEndObject();
if (indexSettings.Similarity != null)
{
writer.WritePropertyName("similarity");
writer.WriteStartObject();
if (!string.IsNullOrEmpty(indexSettings.Similarity.BaseSimilarity))
{
writer.WritePropertyName("base");
writer.WriteStartObject();
writer.WritePropertyName("type");
writer.WriteValue(indexSettings.Similarity.BaseSimilarity);
writer.WriteEndObject();
}
if (indexSettings.Similarity.CustomSimilarities != null)
{
foreach (var customSimilarity in indexSettings.Similarity.CustomSimilarities)
{
writer.WritePropertyName(customSimilarity.Name);
writer.WriteStartObject();
writer.WritePropertyName("type");
writer.WriteValue(customSimilarity.Type);
if (customSimilarity.SimilarityParameters.HasAny())
{
foreach (var kv in customSimilarity.SimilarityParameters)
{
writer.WritePropertyName(kv.Key);
writer.WriteValue(kv.Value);
}
}
writer.WriteEndObject();
}
}
writer.WriteEndObject();
}
writer.WriteEndObject();
if (indexSettings.Mappings.Count > 0)
{
writer.WritePropertyName("mappings");
serializer.Serialize(writer, indexSettings.Mappings.ToDictionary(m => m.Name));
}
if (indexSettings.Warmers.Count > 0)
{
writer.WritePropertyName("warmers");
serializer.Serialize(writer, indexSettings.Warmers);
}
writer.WriteEndObject();
}
/// <summary>
/// Serializes the object to JSON.
/// </summary>
/// <param name="writer">The <see cref="T: Newtonsoft.Json.JsonWriter" /> to write to.</param>
/// <param name="obj">The object to serialize to JSON.</param>
internal static void Serialize(JsonWriter writer, RepairTaskHistory obj)
{
// Required properties are always serialized, optional properties are serialized when not null.
writer.WriteStartObject();
if (obj.CreatedUtcTimestamp != null)
{
writer.WriteProperty(obj.CreatedUtcTimestamp, "CreatedUtcTimestamp", JsonWriterExtensions.WriteDateTimeValue);
}
if (obj.ClaimedUtcTimestamp != null)
{
writer.WriteProperty(obj.ClaimedUtcTimestamp, "ClaimedUtcTimestamp", JsonWriterExtensions.WriteDateTimeValue);
}
if (obj.PreparingUtcTimestamp != null)
{
writer.WriteProperty(obj.PreparingUtcTimestamp, "PreparingUtcTimestamp", JsonWriterExtensions.WriteDateTimeValue);
}
if (obj.ApprovedUtcTimestamp != null)
{
writer.WriteProperty(obj.ApprovedUtcTimestamp, "ApprovedUtcTimestamp", JsonWriterExtensions.WriteDateTimeValue);
}
if (obj.ExecutingUtcTimestamp != null)
{
writer.WriteProperty(obj.ExecutingUtcTimestamp, "ExecutingUtcTimestamp", JsonWriterExtensions.WriteDateTimeValue);
}
if (obj.RestoringUtcTimestamp != null)
{
writer.WriteProperty(obj.RestoringUtcTimestamp, "RestoringUtcTimestamp", JsonWriterExtensions.WriteDateTimeValue);
}
if (obj.CompletedUtcTimestamp != null)
{
writer.WriteProperty(obj.CompletedUtcTimestamp, "CompletedUtcTimestamp", JsonWriterExtensions.WriteDateTimeValue);
}
if (obj.PreparingHealthCheckStartUtcTimestamp != null)
{
writer.WriteProperty(obj.PreparingHealthCheckStartUtcTimestamp, "PreparingHealthCheckStartUtcTimestamp", JsonWriterExtensions.WriteDateTimeValue);
}
if (obj.PreparingHealthCheckEndUtcTimestamp != null)
{
writer.WriteProperty(obj.PreparingHealthCheckEndUtcTimestamp, "PreparingHealthCheckEndUtcTimestamp", JsonWriterExtensions.WriteDateTimeValue);
}
if (obj.RestoringHealthCheckStartUtcTimestamp != null)
{
writer.WriteProperty(obj.RestoringHealthCheckStartUtcTimestamp, "RestoringHealthCheckStartUtcTimestamp", JsonWriterExtensions.WriteDateTimeValue);
}
if (obj.RestoringHealthCheckEndUtcTimestamp != null)
{
writer.WriteProperty(obj.RestoringHealthCheckEndUtcTimestamp, "RestoringHealthCheckEndUtcTimestamp", JsonWriterExtensions.WriteDateTimeValue);
}
writer.WriteEndObject();
}
/// <summary>
/// Serializes the object to JSON.
/// </summary>
/// <param name="writer">The <see cref="T: Newtonsoft.Json.JsonWriter" /> to write to.</param>
/// <param name="obj">The object to serialize to JSON.</param>
internal static void Serialize(JsonWriter writer, NodeInfo obj)
{
// Required properties are always serialized, optional properties are serialized when not null.
writer.WriteStartObject();
writer.WriteProperty(obj.NodeStatus, "NodeStatus", NodeStatusConverter.Serialize);
writer.WriteProperty(obj.HealthState, "HealthState", HealthStateConverter.Serialize);
if (obj.Name != null)
{
writer.WriteProperty(obj.Name, "Name", NodeNameConverter.Serialize);
}
if (obj.IpAddressOrFQDN != null)
{
writer.WriteProperty(obj.IpAddressOrFQDN, "IpAddressOrFQDN", JsonWriterExtensions.WriteStringValue);
}
if (obj.Type != null)
{
writer.WriteProperty(obj.Type, "Type", JsonWriterExtensions.WriteStringValue);
}
if (obj.CodeVersion != null)
{
writer.WriteProperty(obj.CodeVersion, "CodeVersion", JsonWriterExtensions.WriteStringValue);
}
if (obj.ConfigVersion != null)
{
writer.WriteProperty(obj.ConfigVersion, "ConfigVersion", JsonWriterExtensions.WriteStringValue);
}
if (obj.NodeUpTimeInSeconds != null)
{
writer.WriteProperty(obj.NodeUpTimeInSeconds, "NodeUpTimeInSeconds", JsonWriterExtensions.WriteStringValue);
}
if (obj.IsSeedNode != null)
{
writer.WriteProperty(obj.IsSeedNode, "IsSeedNode", JsonWriterExtensions.WriteBoolValue);
}
if (obj.UpgradeDomain != null)
{
writer.WriteProperty(obj.UpgradeDomain, "UpgradeDomain", JsonWriterExtensions.WriteStringValue);
}
if (obj.FaultDomain != null)
{
writer.WriteProperty(obj.FaultDomain, "FaultDomain", JsonWriterExtensions.WriteStringValue);
}
if (obj.Id != null)
{
writer.WriteProperty(obj.Id, "Id", NodeIdConverter.Serialize);
}
if (obj.InstanceId != null)
{
writer.WriteProperty(obj.InstanceId, "InstanceId", JsonWriterExtensions.WriteStringValue);
}
if (obj.NodeDeactivationInfo != null)
{
writer.WriteProperty(obj.NodeDeactivationInfo, "NodeDeactivationInfo", NodeDeactivationInfoConverter.Serialize);
}
if (obj.IsStopped != null)
{
writer.WriteProperty(obj.IsStopped, "IsStopped", JsonWriterExtensions.WriteBoolValue);
}
if (obj.NodeDownTimeInSeconds != null)
{
writer.WriteProperty(obj.NodeDownTimeInSeconds, "NodeDownTimeInSeconds", JsonWriterExtensions.WriteStringValue);
}
if (obj.NodeUpAt != null)
{
writer.WriteProperty(obj.NodeUpAt, "NodeUpAt", JsonWriterExtensions.WriteDateTimeValue);
}
if (obj.NodeDownAt != null)
{
writer.WriteProperty(obj.NodeDownAt, "NodeDownAt", JsonWriterExtensions.WriteDateTimeValue);
}
writer.WriteEndObject();
}
private void WriteDicomAttribute
(
DicomAttributeCollection ds,
DicomAttribute element,
JsonWriter writer
)
{
DicomVr dicomVr = element.Tag.VR;
writer.WritePropertyName(element.Tag.HexString, false);
//writer.WritePropertyName(element.Tag.Group.ToString("D4") + element.Tag.Element.ToString("D4"), false);
writer.WriteStartObject();
writer.WritePropertyName("temp");
writer.WriteValue(element.Tag.VariableName);
writer.WritePropertyName("vr");
writer.WriteValue(element.Tag.VR.Name);
//VR should at least support a switch!
if (dicomVr.Name == DicomVr.SQvr.Name)
{
ConvertSequence(element, writer);
}
else if (dicomVr.Equals(DicomVr.PNvr))
{
writer.WritePropertyName(JsonConstants.ValueField);
writer.WriteStartArray();
writer.WriteStartObject();
writer.WritePropertyName(JsonConstants.Alphabetic);
writer.WriteValue(element.ToString().TrimEnd()); //TODO: not sure if PN need to be trimmed
writer.WriteEndObject();
writer.WriteEndArray();
}
else if (dicomVr.Equals(DicomVr.OBvr) || dicomVr.Equals(DicomVr.ODvr) ||
dicomVr.Equals(DicomVr.OFvr) || dicomVr.Equals(DicomVr.OWvr) ||
dicomVr.Equals(DicomVr.UNvr)) //TODO inline bulk
{
if (element.Tag.TagValue == DicomTags.PixelData)
{
}
else
{
byte[] data = (byte[])element.Values;
WriteStringValue(writer, System.Convert.ToBase64String(data));
}
}
//else if ( dicomVr.Equals (DicomVr.PNvr) ) //TODO bulk reference
//{
//}
else
{
ConvertValue(element, writer);
}
if (element.Tag.IsPrivate)
{
//TODO:
//writer.WriteAttributeString ("privateCreator", ds[DicomTags.privatecreatro. ) ;
}
writer.WriteEndObject( );
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
IGeometry geom = value as IGeometry;
if (geom == null)
{
return;
}
writer.WriteStartObject();
GeoJsonObjectType geomType = ToGeoJsonObject(geom);
writer.WritePropertyName("type");
writer.WriteValue(Enum.GetName(typeof(GeoJsonObjectType), geomType));
switch (geomType)
{
case GeoJsonObjectType.Point:
serializer.Serialize(writer, geom.Coordinate);
break;
case GeoJsonObjectType.LineString:
case GeoJsonObjectType.MultiPoint:
serializer.Serialize(writer, geom.Coordinates);
break;
case GeoJsonObjectType.Polygon:
IPolygon poly = geom as IPolygon;
Debug.Assert(poly != null);
serializer.Serialize(writer, PolygonCoordiantes(poly));
break;
case GeoJsonObjectType.MultiPolygon:
IMultiPolygon mpoly = geom as IMultiPolygon;
Debug.Assert(mpoly != null);
List <List <Coordinate[]> > list = new List <List <Coordinate[]> >();
foreach (IPolygon mempoly in mpoly.Geometries)
{
list.Add(PolygonCoordiantes(mempoly));
}
serializer.Serialize(writer, list);
break;
case GeoJsonObjectType.GeometryCollection:
IGeometryCollection gc = geom as IGeometryCollection;
Debug.Assert(gc != null);
serializer.Serialize(writer, gc.Geometries);
break;
default:
List <Coordinate[]> coordinates = new List <Coordinate[]>();
foreach (IGeometry geometry in ((IGeometryCollection)geom).Geometries)
{
coordinates.Add(geometry.Coordinates);
}
serializer.Serialize(writer, coordinates);
break;
}
writer.WriteEndObject();
}
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();
writer.WriteValue(Matrix.M11); writer.WriteValue(Matrix.M21); writer.WriteValue(Matrix.M31); writer.WriteValue(Matrix.M41);
writer.WriteValue(Matrix.M12); writer.WriteValue(Matrix.M22); writer.WriteValue(Matrix.M32); writer.WriteValue(Matrix.M42);
writer.WriteValue(Matrix.M13); writer.WriteValue(Matrix.M23); writer.WriteValue(Matrix.M33); writer.WriteValue(Matrix.M43);
writer.WriteValue(Matrix.M14); writer.WriteValue(Matrix.M24); writer.WriteValue(Matrix.M34); writer.WriteValue(Matrix.M44);
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 static void CloseStyleSpecificKey(JsonWriter writer)
{
writer.WriteEndObject();
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var filter = (BinanceSymbolFilter)value;
writer.WriteStartObject();
writer.WritePropertyName("filterType");
writer.WriteValue(JsonConvert.SerializeObject(filter.FilterType, new SymbolFilterTypeConverter(false)));
switch (filter.FilterType)
{
case SymbolFilterType.LotSize:
var lotSizeFilter = (BinanceSymbolLotSizeFilter)filter;
writer.WritePropertyName("maxQty");
writer.WriteValue(lotSizeFilter.MaxQuantity);
writer.WritePropertyName("minQty");
writer.WriteValue(lotSizeFilter.MinQuantity);
writer.WritePropertyName("stepSize");
writer.WriteValue(lotSizeFilter.StepSize);
break;
case SymbolFilterType.MarketLotSize:
var marketLotSizeFilter = (BinanceSymbolMarketLotSizeFilter)filter;
writer.WritePropertyName("maxQty");
writer.WriteValue(marketLotSizeFilter.MaxQuantity);
writer.WritePropertyName("minQty");
writer.WriteValue(marketLotSizeFilter.MinQuantity);
writer.WritePropertyName("stepSize");
writer.WriteValue(marketLotSizeFilter.StepSize);
break;
case SymbolFilterType.MinNotional:
var minNotionalFilter = (BinanceSymbolMinNotionalFilter)filter;
writer.WritePropertyName("minNotional");
writer.WriteValue(minNotionalFilter.MinNotional);
writer.WritePropertyName("applyToMarket");
writer.WriteValue(minNotionalFilter.ApplyToMarketOrders);
writer.WritePropertyName("avgPriceMins");
writer.WriteValue(minNotionalFilter.AveragePriceMinutes);
break;
case SymbolFilterType.Price:
var priceFilter = (BinanceSymbolPriceFilter)filter;
writer.WritePropertyName("maxPrice");
writer.WriteValue(priceFilter.MaxPrice);
writer.WritePropertyName("minPrice");
writer.WriteValue(priceFilter.MinPrice);
writer.WritePropertyName("tickSize");
writer.WriteValue(priceFilter.TickSize);
break;
case SymbolFilterType.MaxNumberAlgorithmicOrders:
var algoFilter = (BinanceSymbolMaxAlgorithmicOrdersFilter)filter;
writer.WritePropertyName("maxNumAlgoOrders");
writer.WriteValue(algoFilter.MaxNumberAlgorithmicOrders);
break;
case SymbolFilterType.MaxNumberOrders:
var orderFilter = (BinanceSymbolMaxOrdersFilter)filter;
writer.WritePropertyName("maxNumOrders");
writer.WriteValue(orderFilter.MaxNumberOrders);
break;
case SymbolFilterType.IcebergParts:
var icebergPartsFilter = (BinanceSymbolIcebergPartsFilter)filter;
writer.WritePropertyName("limit");
writer.WriteValue(icebergPartsFilter.Limit);
break;
case SymbolFilterType.PricePercent:
var pricePercentFilter = (BinanceSymbolPercentPriceFilter)filter;
writer.WritePropertyName("multiplierUp");
writer.WriteValue(pricePercentFilter.MultiplierUp);
writer.WritePropertyName("multiplierDown");
writer.WriteValue(pricePercentFilter.MultiplierDown);
writer.WritePropertyName("avgPriceMins");
writer.WriteValue(pricePercentFilter.AveragePriceMinutes);
break;
default:
Debug.WriteLine("Can't write symbol filter of type: " + filter.FilterType);
break;
}
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.EarthWaterMassData).
///
/// </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 EarthWaterMassDataSet;
// 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(",");
// Velocity East
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_VELEAST);
writer.WriteValue(data.VelocityEast);
// Velocity North
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_VELNORTH);
writer.WriteValue(data.VelocityNorth);
// Velocity Vertical
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_VELVERTICAL);
writer.WriteValue(data.VelocityVertical);
// Velocity Error
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_VELQ);
writer.WriteValue(data.VelocityQ);
// Water Mass Depth Layer
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_WATERMASSDEPTHLAYER);
writer.WriteValue(data.WaterMassDepthLayer);
// Water Mass Depth Layer Far
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_WM_LAYER_FAR);
writer.WriteValue(data.BtRefLayerFar);
// Water Mass Depth Layer Min
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_WM_LAYER_MIN);
writer.WriteValue(data.BtRefLayerMin);
// Water Mass Depth Layer Near
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_WM_LAYER_NEAR);
writer.WriteValue(data.BtRefLayerNear);
// Water Mass Depth Layer Correlation Beam 0
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_WM_CORR_0);
writer.WriteValue(data.BtRefLayerCorrBeam0);
// Water Mass Depth Layer Correlation Beam 1
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_WM_CORR_1);
writer.WriteValue(data.BtRefLayerCorrBeam1);
// Water Mass Depth Layer Correlation Beam 2
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_WM_CORR_2);
writer.WriteValue(data.BtRefLayerCorrBeam2);
// Water Mass Depth Layer Correlation Beam 3
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_WM_CORR_3);
writer.WriteValue(data.BtRefLayerCorrBeam3);
// Water Mass Depth Layer Echo Intensity Beam 0
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_WM_ECHO_0);
writer.WriteValue(data.BtRefLayerEchoIntensityBeam0);
// Water Mass Depth Layer Echo Intensity Beam 1
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_WM_ECHO_1);
writer.WriteValue(data.BtRefLayerEchoIntensityBeam1);
// Water Mass Depth Layer Echo Intensity Beam 2
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_WM_ECHO_2);
writer.WriteValue(data.BtRefLayerEchoIntensityBeam2);
// Water Mass Depth Layer Echo Intensity Beam 3
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_WM_ECHO_3);
writer.WriteValue(data.BtRefLayerEchoIntensityBeam3);
// Water Mass Depth Layer Percent Good Beam 0
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_WM_PG_0);
writer.WriteValue(data.BtRefLayerPercentGoodBeam0);
// Water Mass Depth Layer Percent Good Beam 1
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_WM_PG_1);
writer.WriteValue(data.BtRefLayerPercentGoodBeam1);
// Water Mass Depth Layer Percent Good Beam 2
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_WM_PG_2);
writer.WriteValue(data.BtRefLayerPercentGoodBeam2);
// Water Mass Depth Layer Percent Good Beam 3
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_WM_PG_3);
writer.WriteValue(data.BtRefLayerPercentGoodBeam3);
// End the object
writer.WriteEndObject();
}
/// <summary>
/// Serializes the specified DDAttributesCollection and writes the Json document to a Json writer
/// </summary>
/// <param name="ac">the attributes collection to serialize</param>
/// <param name="writer">Json writer used to write the Json document.</param>
public static void Serialize(this DDAttributesCollection ac, JsonWriter writer)
{
writer.WriteStartObject();
JsonSerialize(ac, 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;
// 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(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);
}
private void SerializeObject(JsonWriter writer, object value, JsonObjectContract contract, JsonProperty member, JsonContainerContract collectionContract, JsonProperty containerProperty)
{
OnSerializing(writer, contract, value);
_serializeStack.Add(value);
WriteObjectStart(writer, value, contract, member, collectionContract, containerProperty);
int initialDepth = writer.Top;
for (int index = 0; index < contract.Properties.Count; index++)
{
JsonProperty property = contract.Properties[index];
try
{
object memberValue;
JsonContract memberContract;
if (!CalculatePropertyValues(writer, value, contract, member, property, out memberContract, out memberValue))
{
continue;
}
property.WritePropertyName(writer);
SerializeValue(writer, memberValue, memberContract, property, contract, member);
}
catch (Exception ex)
{
if (IsErrorHandled(value, contract, property.PropertyName, null, writer.ContainerPath, ex))
{
HandleError(writer, initialDepth);
}
else
{
throw;
}
}
}
if (contract.ExtensionDataGetter != null)
{
IEnumerable <KeyValuePair <object, object> > extensionData = contract.ExtensionDataGetter(value);
if (extensionData != null)
{
foreach (KeyValuePair <object, object> e in extensionData)
{
JsonContract keyContract = GetContractSafe(e.Key);
JsonContract valueContract = GetContractSafe(e.Value);
bool escape;
string propertyName = GetPropertyName(writer, e.Key, keyContract, out escape);
if (ShouldWriteReference(e.Value, null, valueContract, contract, member))
{
writer.WritePropertyName(propertyName);
WriteReference(writer, e.Value);
}
else
{
if (!CheckForCircularReference(writer, e.Value, null, valueContract, contract, member))
{
continue;
}
writer.WritePropertyName(propertyName);
SerializeValue(writer, e.Value, valueContract, null, contract, member);
}
}
}
}
writer.WriteEndObject();
_serializeStack.RemoveAt(_serializeStack.Count - 1);
OnSerialized(writer, contract, value);
}
/// <summary>
/// Se utiliza para crear el Json para el listado público. No se mostrarán Objetivos sin Acciones, ni Acciones no visibles
/// </summary>
/// <param name="writer"></param>
/// <param name="value"></param>
/// <param name="serializer"></param>
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var name = value as OBJETIVO;
//Si no tiene acciones no lo escribimos
if (name.ACCION.Where(a => a.VISIBLE && !String.IsNullOrEmpty(a.INSTRUMENTOS_ACT)).ToList().Count > 0)
{
writer.WriteStartObject();
writer.WritePropertyName("Objetivo estratégico".ToString(), true);
serializer.Serialize(writer, name.OBJETIVO_ESTRATEGICO);
writer.WritePropertyName("Instrumentos y actividades");
if ((name.ACCION != null) && (name.ACCION.Count > 0))
{
writer.WriteStartArray();
foreach (ACCION acc in name.ACCION)
{
if (acc.VISIBLE && !String.IsNullOrEmpty(acc.INSTRUMENTOS_ACT))
{
writer.WriteStartObject();
writer.WritePropertyName("Instrumentos y actividades", true);
serializer.Serialize(writer, acc.INSTRUMENTOS_ACT);
writer.WritePropertyName("Órgano responsable", true);
serializer.Serialize(writer, acc.ORGANO_RESPONSABLE);
writer.WritePropertyName("RRHH", true);
serializer.Serialize(writer, acc.RECURSOS_HUMANOS);
writer.WritePropertyName("Coste económico", true);
serializer.Serialize(writer, acc.COSTE_ECONOMICO);
writer.WritePropertyName("Otros medios", true);
if (String.IsNullOrEmpty(acc.MEDIOS_OTROS))
{
serializer.Serialize(writer, "-");
}
else
{
serializer.Serialize(writer, acc.MEDIOS_OTROS);
}
writer.WritePropertyName("Temporalidad", true);
serializer.Serialize(writer, acc.TEMPORALIDAD);
writer.WritePropertyName("Seguimiento", true);
serializer.Serialize(writer, acc.SEGUIMIENTO);
//writer.WritePropertyName("Estado seguimiento", true);
//if (acc.ESTADOS_SEGUIMIENTO != null)
// serializer.Serialize(writer, acc.ESTADOS_SEGUIMIENTO.DESCRIPCION);
//else
// serializer.Serialize(writer, "");
writer.WritePropertyName("Porcentaje avance", true);
if (acc.PORCENTAJE_AVANCE != null)
{
serializer.Serialize(writer, acc.PORCENTAJE_AVANCE);
}
else
{
serializer.Serialize(writer, "");
}
writer.WriteEndObject();
}
}
writer.WriteEndArray();
}
else
{
serializer.Serialize(writer, "");
}
writer.WriteEndObject();
}
}
private static void WriteAcls(JsonWriter writer, List <Claim> allowed, List <Claim> denied, List <ResetRequest> reset)
{
var map = new Dictionary <SidTypeKey, ClaimGroup>();
allowed.For(x =>
{
ClaimGroup group;
var key = new SidTypeKey {
Sid = x.Sid, Type = x.ClaimType
};
if (map.TryGetValue(key, out group) == false)
{
group = new ClaimGroup {
Sid = x.Sid, Type = x.ClaimType
}
}
;
group.Allowed.Add(x.AccessType);
});
denied.For(x =>
{
ClaimGroup group;
var key = new SidTypeKey {
Sid = x.Sid, Type = x.ClaimType
};
if (map.TryGetValue(key, out group) == false)
{
group = new ClaimGroup {
Sid = x.Sid, Type = x.ClaimType
}
}
;
group.Denied.Add(x.AccessType);
});
reset.For(x =>
{
ClaimGroup group;
var key = new SidTypeKey {
Sid = x.Sid, Type = x.Type
};
if (map.TryGetValue(key, out group) == false)
{
group = new ClaimGroup {
Sid = x.Sid, Type = x.Type
}
}
;
group.Reset.Add(x.Access);
});
writer.WriteStartArray();
map.Values.For(x =>
{
writer.WriteStartObject();
writer.WriteProperty("sid", x.Sid);
writer.WriteProperty("type", x.Type.ToString().ToLower());
if (x.Allowed.Count > 0)
{
writer.WriteArray("allow", x.Allowed.Select(y => y.ToString().ToLower()));
}
if (x.Denied.Count > 0)
{
writer.WriteArray("deny", x.Denied.Select(y => y.ToString().ToLower()));
}
if (x.Reset.Count > 0)
{
writer.WriteArray("dontcare", x.Reset.Select(y => y.ToString().ToLower()));
}
writer.WriteEndObject();
});
writer.WriteEndArray();
}
public void Serialize(ref JsonWriter writer, TDictionary value, IJsonFormatterResolver formatterResolver)
{
if (value == null)
{
writer.WriteNull();
return;
}
var mutator = formatterResolver.GetConnectionSettings().DefaultFieldNameInferrer;
var keyFormatter = formatterResolver.GetFormatterWithVerify <TKey>() as IObjectPropertyNameFormatter <TKey>;
var valueFormatter = formatterResolver.GetFormatterWithVerify <TValue>();
writer.WriteBeginObject();
var e = GetSourceEnumerator(value);
try
{
if (keyFormatter != null)
{
if (e.MoveNext())
{
var item = e.Current;
var innerWriter = new JsonWriter();
keyFormatter.SerializeToPropertyName(ref innerWriter, item.Key, formatterResolver);
writer.WriteString(mutator(innerWriter.ToString()));
writer.WriteNameSeparator();
valueFormatter.Serialize(ref writer, item.Value, formatterResolver);
}
else
{
goto END;
}
while (e.MoveNext())
{
writer.WriteValueSeparator();
var item = e.Current;
var innerWriter = new JsonWriter();
keyFormatter.SerializeToPropertyName(ref innerWriter, item.Key, formatterResolver);
writer.WriteString(mutator(innerWriter.ToString()));
writer.WriteNameSeparator();
valueFormatter.Serialize(ref writer, item.Value, formatterResolver);
}
}
else
{
if (e.MoveNext())
{
var item = e.Current;
writer.WriteString(mutator(item.Key.ToString()));
writer.WriteNameSeparator();
valueFormatter.Serialize(ref writer, item.Value, formatterResolver);
}
else
{
goto END;
}
while (e.MoveNext())
{
writer.WriteValueSeparator();
var item = e.Current;
writer.WriteString(mutator(item.Key.ToString()));
writer.WriteNameSeparator();
valueFormatter.Serialize(ref writer, item.Value, formatterResolver);
}
}
}
finally
{
e.Dispose();
}
END:
writer.WriteEndObject();
}
public override void WriteEndObject()
{
_textWriter.WriteEndObject();
_innerWriter.WriteEndObject();
base.WriteEndObject();
}
public void Serialize(ref JsonWriter writer, IShapeQuery value, IJsonFormatterResolver formatterResolver)
{
var fieldName = value.Field;
if (fieldName == null)
{
writer.WriteNull();
return;
}
var settings = formatterResolver.GetConnectionSettings();
var field = settings.Inferrer.Field(fieldName);
if (field.IsNullOrEmpty())
{
writer.WriteNull();
return;
}
writer.WriteBeginObject();
var name = value.Name;
var boost = value.Boost;
var ignoreUnmapped = value.IgnoreUnmapped;
if (!name.IsNullOrEmpty())
{
writer.WritePropertyName("_name");
writer.WriteString(name);
writer.WriteValueSeparator();
}
if (boost != null)
{
writer.WritePropertyName("boost");
writer.WriteDouble(boost.Value);
writer.WriteValueSeparator();
}
if (ignoreUnmapped != null)
{
writer.WritePropertyName("ignore_unmapped");
writer.WriteBoolean(ignoreUnmapped.Value);
writer.WriteValueSeparator();
}
writer.WritePropertyName(field);
writer.WriteBeginObject();
var written = false;
if (value.Shape != null)
{
writer.WritePropertyName("shape");
var shapeFormatter = formatterResolver.GetFormatter <IGeoShape>();
shapeFormatter.Serialize(ref writer, value.Shape, formatterResolver);
written = true;
}
else if (value.IndexedShape != null)
{
writer.WritePropertyName("indexed_shape");
var fieldLookupFormatter = formatterResolver.GetFormatter <IFieldLookup>();
fieldLookupFormatter.Serialize(ref writer, value.IndexedShape, formatterResolver);
written = true;
}
if (value.Relation.HasValue)
{
if (written)
{
writer.WriteValueSeparator();
}
writer.WritePropertyName("relation");
formatterResolver.GetFormatter <ShapeRelation>()
.Serialize(ref writer, value.Relation.Value, formatterResolver);
}
writer.WriteEndObject();
writer.WriteEndObject();
}
public override void WriteJson(JsonWriter writer)
{
writer.WriteStartObject();
writer.WriteProperty("name", Name);
writer.WriteEndObject();
}
public void Serialize(ref JsonWriter writer, ValueTuple <T1> value, IJsonFormatterResolver formatterResolver)
{
writer.WriteRaw(cache[0]);
formatterResolver.GetFormatterWithVerify <T1>().Serialize(ref writer, value.Item1, formatterResolver);
writer.WriteEndObject();
}
/// <summary>
/// Serializes the object to JSON.
/// </summary>
/// <param name="writer">The <see cref="T: Newtonsoft.Json.JsonWriter" /> to write to.</param>
/// <param name="obj">The object to serialize to JSON.</param>
internal static void Serialize(JsonWriter writer, StatefulServiceUpdateDescription obj)
{
// Required properties are always serialized, optional properties are serialized when not null.
writer.WriteStartObject();
writer.WriteProperty(obj.ServiceKind.ToString(), "ServiceKind", JsonWriterExtensions.WriteStringValue);
writer.WriteProperty(obj.DefaultMoveCost, "DefaultMoveCost", MoveCostConverter.Serialize);
if (obj.Flags != null)
{
writer.WriteProperty(obj.Flags, "Flags", JsonWriterExtensions.WriteStringValue);
}
if (obj.PlacementConstraints != null)
{
writer.WriteProperty(obj.PlacementConstraints, "PlacementConstraints", JsonWriterExtensions.WriteStringValue);
}
if (obj.CorrelationScheme != null)
{
writer.WriteEnumerableProperty(obj.CorrelationScheme, "CorrelationScheme", ServiceCorrelationDescriptionConverter.Serialize);
}
if (obj.LoadMetrics != null)
{
writer.WriteEnumerableProperty(obj.LoadMetrics, "LoadMetrics", ServiceLoadMetricDescriptionConverter.Serialize);
}
if (obj.ServicePlacementPolicies != null)
{
writer.WriteEnumerableProperty(obj.ServicePlacementPolicies, "ServicePlacementPolicies", ServicePlacementPolicyDescriptionConverter.Serialize);
}
if (obj.ScalingPolicies != null)
{
writer.WriteEnumerableProperty(obj.ScalingPolicies, "ScalingPolicies", ScalingPolicyDescriptionConverter.Serialize);
}
if (obj.TargetReplicaSetSize != null)
{
writer.WriteProperty(obj.TargetReplicaSetSize, "TargetReplicaSetSize", JsonWriterExtensions.WriteIntValue);
}
if (obj.MinReplicaSetSize != null)
{
writer.WriteProperty(obj.MinReplicaSetSize, "MinReplicaSetSize", JsonWriterExtensions.WriteIntValue);
}
if (obj.ReplicaRestartWaitDurationSeconds != null)
{
writer.WriteProperty(obj.ReplicaRestartWaitDurationSeconds, "ReplicaRestartWaitDurationSeconds", JsonWriterExtensions.WriteStringValue);
}
if (obj.QuorumLossWaitDurationSeconds != null)
{
writer.WriteProperty(obj.QuorumLossWaitDurationSeconds, "QuorumLossWaitDurationSeconds", JsonWriterExtensions.WriteStringValue);
}
if (obj.StandByReplicaKeepDurationSeconds != null)
{
writer.WriteProperty(obj.StandByReplicaKeepDurationSeconds, "StandByReplicaKeepDurationSeconds", JsonWriterExtensions.WriteStringValue);
}
writer.WriteEndObject();
}
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();
if (ArrayTypeFormat.IsPrimitiveType)
{
writer.WritePropertyName("type");
writer.WriteValue(ArrayTypeFormat.Type.ToString().ToLower());
if (!string.IsNullOrWhiteSpace(ArrayTypeFormat.Format))
{
writer.WritePropertyName("format");
writer.WriteValue(ArrayTypeFormat.Format);
}
}
else
{
writer.WritePropertyName("$ref");
writer.WriteValue(string.Format("#/definitions/{0}", Ref));
}
writer.WriteEndObject();
}
}
else if (!string.IsNullOrWhiteSpace(Ref))
{
writer.WritePropertyName("$ref");
writer.WriteValue(string.Format("#/definitions/{0}", Ref));
}
}
public new void AsJson(JsonWriter writer, string baseUrl)
{
writer.WriteStartObject();
base.AsJson(writer, baseUrl);
writer.WritePropertyName("title");
writer.WriteValue(Title);
if (SchoolYearAcademicSession != null)
{
writer.WritePropertyName("schoolYear");
SchoolYearAcademicSession.AsJsonReference(writer, baseUrl);
}
if (!String.IsNullOrEmpty(CourseCode))
{
writer.WritePropertyName("courseCode");
writer.WriteValue(CourseCode);
}
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("subjectCodes");
writer.WriteStartArray();
foreach (var subjectCode in SubjectCodes)
{
writer.WriteValue(subjectCode);
}
writer.WriteEndArray();
}
if (Resources != null && Resources.Length > 0)
{
writer.WritePropertyName("resources");
writer.WriteStartArray();
foreach (var resource in Resources)
{
writer.WriteStartObject();
writer.WritePropertyName("href");
writer.WriteValue(baseUrl + "/resources/" + resource);
writer.WritePropertyName("sourceId");
writer.WriteValue(resource);
writer.WritePropertyName("type");
writer.WriteValue("resource");
writer.WriteEndObject();
}
writer.WriteEndArray();
}
if (Org != null)
{
writer.WritePropertyName("org");
Org.AsJsonReference(writer, baseUrl);
}
writer.WriteEndObject();
writer.Flush();
}
public new void AsJson(JsonWriter writer, string baseUrl)
{
writer.WriteStartObject();
base.AsJson(writer, baseUrl);
writer.WritePropertyName("username");
writer.WriteValue(Username);
if (UserIds != null && UserIds.Length > 0)
{
writer.WritePropertyName("userIds");
writer.WriteStartArray();
foreach (var userId in UserIds)
{
userId.AsJson(writer, baseUrl);
}
writer.WriteEndArray();
}
writer.WritePropertyName("enabledUser");
writer.WriteValue(EnabledUser.ToString());
writer.WritePropertyName("givenName");
writer.WriteValue(GivenName);
writer.WritePropertyName("familyName");
writer.WriteValue(FamilyName);
if (!String.IsNullOrEmpty(MiddleName))
{
writer.WritePropertyName("middleName");
writer.WriteValue(MiddleName);
}
writer.WritePropertyName("role");
writer.WriteValue(Enum.GetName(typeof(Vocabulary.RoleType), Role));
if (!String.IsNullOrEmpty(Identifier))
{
writer.WritePropertyName("identifier");
writer.WriteValue(Identifier);
}
if (!String.IsNullOrEmpty(Email))
{
writer.WritePropertyName("email");
writer.WriteValue(Email);
}
if (!String.IsNullOrEmpty(SMS))
{
writer.WritePropertyName("sms");
writer.WriteValue(SMS);
}
if (!String.IsNullOrEmpty(Phone))
{
writer.WritePropertyName("phone");
writer.WriteValue(Phone);
}
if (UserAgents.Count > 0)
{
writer.WritePropertyName("agents");
writer.WriteStartArray();
UserAgents.ForEach(ua => ua.Agent.AsJsonReference(writer, baseUrl));
writer.WriteEndArray();
}
writer.WritePropertyName("orgs");
writer.WriteStartArray();
UserOrgs.ForEach(uo => uo.Org.AsJsonReference(writer, baseUrl));
writer.WriteEndArray();
if (Grades != null && Grades.Length > 0)
{
writer.WritePropertyName("grades");
writer.WriteStartArray();
foreach (var grade in Grades)
{
writer.WriteValue(grade);
}
writer.WriteEndArray();
}
if (!String.IsNullOrEmpty(Password))
{
writer.WritePropertyName("password");
writer.WriteValue(Password);
}
writer.WriteEndObject();
writer.Flush();
}
internal static void WriteVariant(this JsonWriter stream, object value)
{
var type = value?.GetType();
stream.WriteStartObject();
stream.WritePropertyName("Type");
stream.WriteVariantType(type);
stream.WritePropertyName("Value");
var variantType = ToVariantType(type);
// ReSharper disable PossibleNullReferenceException
switch (variantType)
{
case VariantType.Null:
case VariantType.ManagedObject:
case VariantType.Void:
stream.WriteStartObject();
stream.WriteEndObject();
break;
case VariantType.Bool:
stream.WriteValue((bool)value);
break;
case VariantType.Int16:
stream.WriteValue((short)value);
break;
case VariantType.Uint16:
stream.WriteValue((ushort)value);
break;
case VariantType.Int:
stream.WriteValue((int)value);
break;
case VariantType.Uint:
stream.WriteValue((uint)value);
break;
case VariantType.Int64:
stream.WriteValue((long)value);
break;
case VariantType.Uint64:
stream.WriteValue((ulong)value);
break;
case VariantType.Float:
stream.WriteValue((float)value);
break;
case VariantType.Double:
stream.WriteValue((double)value);
break;
case VariantType.Pointer:
stream.WriteValue((ulong)(IntPtr)value);
break;
case VariantType.String:
stream.WriteValue((string)value);
break;
case VariantType.Object:
stream.WriteValue(((FlaxEngine.Object)value).ID);
break;
case VariantType.Asset:
stream.WriteValue(((Asset)value).ID);
break;
case VariantType.Blob:
stream.WriteValue(Convert.ToBase64String((byte[])value));
break;
case VariantType.Enum:
stream.WriteValue(Convert.ToUInt64(value));
break;
case VariantType.Vector2:
{
var asVector2 = (Vector2)value;
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asVector2.X);
stream.WritePropertyName("Y");
stream.WriteValue(asVector2.Y);
stream.WriteEndObject();
break;
}
case VariantType.Vector3:
{
var asVector3 = (Vector3)value;
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asVector3.X);
stream.WritePropertyName("Y");
stream.WriteValue(asVector3.Y);
stream.WritePropertyName("Z");
stream.WriteValue(asVector3.Z);
stream.WriteEndObject();
break;
}
case VariantType.Vector4:
{
var asVector4 = (Vector4)value;
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asVector4.X);
stream.WritePropertyName("Y");
stream.WriteValue(asVector4.Y);
stream.WritePropertyName("Z");
stream.WriteValue(asVector4.Z);
stream.WritePropertyName("W");
stream.WriteValue(asVector4.W);
stream.WriteEndObject();
break;
}
case VariantType.Int2:
{
var asInt2 = (Int2)value;
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asInt2.X);
stream.WritePropertyName("Y");
stream.WriteValue(asInt2.Y);
stream.WriteEndObject();
break;
}
case VariantType.Int3:
{
var asInt3 = (Int3)value;
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asInt3.X);
stream.WritePropertyName("Y");
stream.WriteValue(asInt3.Y);
stream.WritePropertyName("Z");
stream.WriteValue(asInt3.Z);
stream.WriteEndObject();
break;
}
case VariantType.Int4:
{
var asInt4 = (Int4)value;
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asInt4.X);
stream.WritePropertyName("Y");
stream.WriteValue(asInt4.Y);
stream.WritePropertyName("Z");
stream.WriteValue(asInt4.Z);
stream.WritePropertyName("W");
stream.WriteValue(asInt4.W);
stream.WriteEndObject();
break;
}
case VariantType.Color:
{
var asColor = (Color)value;
stream.WriteStartObject();
stream.WritePropertyName("R");
stream.WriteValue(asColor.R);
stream.WritePropertyName("G");
stream.WriteValue(asColor.G);
stream.WritePropertyName("B");
stream.WriteValue(asColor.B);
stream.WritePropertyName("A");
stream.WriteValue(asColor.A);
stream.WriteEndObject();
break;
}
case VariantType.Guid:
stream.WriteValue((Guid)value);
break;
case VariantType.BoundingBox:
{
var asBoundingBox = (BoundingBox)value;
stream.WriteStartObject();
stream.WritePropertyName("Minimum");
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asBoundingBox.Minimum.X);
stream.WritePropertyName("Y");
stream.WriteValue(asBoundingBox.Minimum.Y);
stream.WritePropertyName("Z");
stream.WriteValue(asBoundingBox.Minimum.Z);
stream.WriteEndObject();
stream.WritePropertyName("Maximum");
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asBoundingBox.Maximum.X);
stream.WritePropertyName("Y");
stream.WriteValue(asBoundingBox.Maximum.Y);
stream.WritePropertyName("Z");
stream.WriteValue(asBoundingBox.Maximum.Z);
stream.WriteEndObject();
stream.WriteEndObject();
break;
}
case VariantType.BoundingSphere:
{
var asBoundingSphere = (BoundingSphere)value;
stream.WriteStartObject();
stream.WritePropertyName("Center");
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asBoundingSphere.Center.X);
stream.WritePropertyName("Y");
stream.WriteValue(asBoundingSphere.Center.Y);
stream.WritePropertyName("Z");
stream.WriteValue(asBoundingSphere.Center.Z);
stream.WriteEndObject();
stream.WritePropertyName("Radius");
stream.WriteValue(asBoundingSphere.Radius);
stream.WriteEndObject();
break;
}
case VariantType.Quaternion:
{
var asQuaternion = (Quaternion)value;
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asQuaternion.X);
stream.WritePropertyName("Y");
stream.WriteValue(asQuaternion.Y);
stream.WritePropertyName("Z");
stream.WriteValue(asQuaternion.Z);
stream.WritePropertyName("W");
stream.WriteValue(asQuaternion.W);
stream.WriteEndObject();
break;
}
case VariantType.Transform:
{
var asTransform = (Transform)value;
stream.WriteStartObject();
stream.WritePropertyName("Translation");
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asTransform.Translation.X);
stream.WritePropertyName("Y");
stream.WriteValue(asTransform.Translation.Y);
stream.WritePropertyName("Z");
stream.WriteValue(asTransform.Translation.Z);
stream.WriteEndObject();
stream.WritePropertyName("Orientation");
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asTransform.Orientation.X);
stream.WritePropertyName("Y");
stream.WriteValue(asTransform.Orientation.Y);
stream.WritePropertyName("Z");
stream.WriteValue(asTransform.Orientation.Z);
stream.WritePropertyName("W");
stream.WriteValue(asTransform.Orientation.W);
stream.WriteEndObject();
stream.WritePropertyName("Scale");
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asTransform.Scale.X);
stream.WritePropertyName("Y");
stream.WriteValue(asTransform.Scale.Y);
stream.WritePropertyName("Z");
stream.WriteValue(asTransform.Scale.Z);
stream.WriteEndObject();
stream.WriteEndObject();
break;
}
case VariantType.Rectangle:
{
var asRectangle = (Rectangle)value;
stream.WriteStartObject();
stream.WritePropertyName("Location");
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asRectangle.Location.X);
stream.WritePropertyName("Y");
stream.WriteValue(asRectangle.Location.Y);
stream.WriteEndObject();
stream.WritePropertyName("Size");
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asRectangle.Size.X);
stream.WritePropertyName("Y");
stream.WriteValue(asRectangle.Size.Y);
stream.WriteEndObject();
stream.WriteEndObject();
break;
}
case VariantType.Ray:
{
var asRay = (Ray)value;
stream.WriteStartObject();
stream.WritePropertyName("Position");
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asRay.Position.X);
stream.WritePropertyName("Y");
stream.WriteValue(asRay.Position.Y);
stream.WritePropertyName("Z");
stream.WriteValue(asRay.Position.Z);
stream.WriteEndObject();
stream.WritePropertyName("Direction");
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asRay.Direction.X);
stream.WritePropertyName("Y");
stream.WriteValue(asRay.Direction.Y);
stream.WritePropertyName("Z");
stream.WriteValue(asRay.Direction.Z);
stream.WriteEndObject();
stream.WriteEndObject();
break;
}
case VariantType.Matrix:
{
var asMatrix = (Matrix)value;
stream.WriteStartObject();
stream.WritePropertyName("M11");
stream.WriteValue(asMatrix.M11);
stream.WritePropertyName("M12");
stream.WriteValue(asMatrix.M12);
stream.WritePropertyName("M13");
stream.WriteValue(asMatrix.M13);
stream.WritePropertyName("M14");
stream.WriteValue(asMatrix.M14);
stream.WritePropertyName("M21");
stream.WriteValue(asMatrix.M21);
stream.WritePropertyName("M22");
stream.WriteValue(asMatrix.M22);
stream.WritePropertyName("M23");
stream.WriteValue(asMatrix.M23);
stream.WritePropertyName("M24");
stream.WriteValue(asMatrix.M24);
stream.WritePropertyName("M31");
stream.WriteValue(asMatrix.M31);
stream.WritePropertyName("M32");
stream.WriteValue(asMatrix.M32);
stream.WritePropertyName("M33");
stream.WriteValue(asMatrix.M33);
stream.WritePropertyName("M34");
stream.WriteValue(asMatrix.M34);
stream.WritePropertyName("M41");
stream.WriteValue(asMatrix.M41);
stream.WritePropertyName("M42");
stream.WriteValue(asMatrix.M42);
stream.WritePropertyName("M43");
stream.WriteValue(asMatrix.M43);
stream.WritePropertyName("M44");
stream.WriteValue(asMatrix.M44);
stream.WriteEndObject();
break;
}
case VariantType.Array:
{
stream.WriteStartArray();
foreach (var e in (object[])value)
{
stream.WriteVariant(e);
}
stream.WriteEndArray();
break;
}
case VariantType.Dictionary:
{
stream.WriteStartArray();
foreach (var e in (Dictionary <object, object>)value)
{
stream.WritePropertyName("Key");
stream.WriteVariant(e.Key);
stream.WritePropertyName("Value");
stream.WriteVariant(e.Value);
}
stream.WriteEndArray();
break;
}
case VariantType.Typename:
if (value is Type)
{
stream.WriteValue(((Type)value).FullName);
}
else if (value is ScriptType)
{
stream.WriteValue(((ScriptType)value).TypeName);
}
break;
default: throw new NotImplementedException($"TODO: serialize {variantType} to Json");
}
// ReSharper restore PossibleNullReferenceException
stream.WriteEndObject();
}
private void WriteEndObject()
{
_writer.WriteEndObject();
DecreaseDepth();
}
public void Serialize(ref JsonWriter writer, IPercentilesAggregation value, IJsonFormatterResolver formatterResolver)
{
if (value == null)
{
writer.WriteNull();
return;
}
writer.WriteBeginObject();
var propertyWritten = false;
if (value.Meta != null && value.Meta.Any())
{
writer.WritePropertyName("meta");
var formatter = formatterResolver.GetFormatter <IDictionary <string, object> >();
formatter.Serialize(ref writer, value.Meta, formatterResolver);
propertyWritten = true;
}
if (value.Field != null)
{
if (propertyWritten)
{
writer.WriteValueSeparator();
}
var settings = formatterResolver.GetConnectionSettings();
writer.WritePropertyName("field");
writer.WriteString(settings.Inferrer.Field(value.Field));
propertyWritten = true;
}
if (value.Script != null)
{
if (propertyWritten)
{
writer.WriteValueSeparator();
}
writer.WritePropertyName("script");
var formatter = formatterResolver.GetFormatter <IScript>();
formatter.Serialize(ref writer, value.Script, formatterResolver);
propertyWritten = true;
}
if (value.Method != null)
{
if (propertyWritten)
{
writer.WriteValueSeparator();
}
switch (value.Method)
{
case ITDigestMethod tdigest:
{
writer.WritePropertyName("tdigest");
writer.WriteBeginObject();
if (tdigest.Compression.HasValue)
{
writer.WritePropertyName("compression");
writer.WriteDouble(tdigest.Compression.Value);
}
writer.WriteEndObject();
break;
}
case IHDRHistogramMethod hdr:
{
writer.WritePropertyName("hdr");
writer.WriteBeginObject();
if (hdr.NumberOfSignificantValueDigits.HasValue)
{
writer.WritePropertyName("number_of_significant_value_digits");
writer.WriteInt32(hdr.NumberOfSignificantValueDigits.Value);
}
writer.WriteEndObject();
break;
}
}
propertyWritten = true;
}
if (value.Missing.HasValue)
{
if (propertyWritten)
{
writer.WriteValueSeparator();
}
writer.WritePropertyName("missing");
writer.WriteDouble(value.Missing.Value);
propertyWritten = true;
}
if (value.Percents != null)
{
if (propertyWritten)
{
writer.WriteValueSeparator();
}
writer.WritePropertyName("percents");
var formatter = formatterResolver.GetFormatter <IEnumerable <double> >();
formatter.Serialize(ref writer, value.Percents, formatterResolver);
propertyWritten = true;
}
if (value.Keyed.HasValue)
{
if (propertyWritten)
{
writer.WriteValueSeparator();
}
writer.WritePropertyName("keyed");
writer.WriteBoolean(value.Keyed.Value);
propertyWritten = true;
}
if (!string.IsNullOrEmpty(value.Format))
{
if (propertyWritten)
{
writer.WriteValueSeparator();
}
writer.WritePropertyName("format");
writer.WriteString(value.Format);
}
writer.WriteEndObject();
}
private void SerializeDynamic(JsonWriter writer, IDynamicMetaObjectProvider value, JsonDynamicContract contract, JsonProperty member, JsonContainerContract collectionContract, JsonProperty containerProperty)
{
OnSerializing(writer, contract, value);
_serializeStack.Add(value);
WriteObjectStart(writer, value, contract, member, collectionContract, containerProperty);
int initialDepth = writer.Top;
for (int index = 0; index < contract.Properties.Count; index++)
{
JsonProperty property = contract.Properties[index];
// only write non-dynamic properties that have an explicit attribute
if (property.HasMemberAttribute)
{
try
{
object memberValue;
JsonContract memberContract;
if (!CalculatePropertyValues(writer, value, contract, member, property, out memberContract, out memberValue))
{
continue;
}
property.WritePropertyName(writer);
SerializeValue(writer, memberValue, memberContract, property, contract, member);
}
catch (Exception ex)
{
if (IsErrorHandled(value, contract, property.PropertyName, null, writer.ContainerPath, ex))
{
HandleError(writer, initialDepth);
}
else
{
throw;
}
}
}
}
foreach (string memberName in value.GetDynamicMemberNames())
{
object memberValue;
if (contract.TryGetMember(value, memberName, out memberValue))
{
try
{
JsonContract valueContract = GetContractSafe(memberValue);
if (!ShouldWriteDynamicProperty(memberValue))
{
continue;
}
if (CheckForCircularReference(writer, memberValue, null, valueContract, contract, member))
{
string resolvedPropertyName = (contract.PropertyNameResolver != null)
? contract.PropertyNameResolver(memberName)
: memberName;
writer.WritePropertyName(resolvedPropertyName);
SerializeValue(writer, memberValue, valueContract, null, contract, member);
}
}
catch (Exception ex)
{
if (IsErrorHandled(value, contract, memberName, null, writer.ContainerPath, ex))
{
HandleError(writer, initialDepth);
}
else
{
throw;
}
}
}
}
writer.WriteEndObject();
_serializeStack.RemoveAt(_serializeStack.Count - 1);
OnSerialized(writer, contract, value);
}
/// <summary>
/// Se utiliza para crear el Json para el listado público. No se mostrarán Objetivos sin Acciones, ni Acciones no visibles
/// </summary>
/// <param name="writer"></param>
/// <param name="value"></param>
/// <param name="serializer"></param>
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var name = value as OBJETIVO;
//Si no tiene acciones no lo escribimos
if (name.ACCION.Where(a => a.VISIBLE && !String.IsNullOrEmpty(a.INSTRUMENTOS_ACT)).ToList().Count > 0)
{
writer.WriteStartObject();
writer.WritePropertyName("ID");
serializer.Serialize(writer, name.CONTENIDO_ID.ToString());
writer.WritePropertyName("Obj".ToString(), true);
serializer.Serialize(writer, name.OBJETIVO_ESTRATEGICO);
writer.WritePropertyName("Porc".ToString(), true);
if (name.PORCENTAJE_AVANCE_CALCULADO != null)
{
serializer.Serialize(writer, name.PORCENTAJE_AVANCE_CALCULADO);
}
else
{
serializer.Serialize(writer, 0);
}
writer.WritePropertyName("AC");
if ((name.ACCION != null) && (name.ACCION.Count > 0))
{
writer.WriteStartArray();
foreach (ACCION acc in name.ACCION)
{
if (acc.VISIBLE && !String.IsNullOrEmpty(acc.INSTRUMENTOS_ACT))
{
writer.WriteStartObject();
writer.WritePropertyName("Ins", true);
serializer.Serialize(writer, acc.INSTRUMENTOS_ACT);
writer.WritePropertyName("Org", true);
serializer.Serialize(writer, acc.ORGANO_RESPONSABLE);
writer.WritePropertyName("RH", true);
serializer.Serialize(writer, acc.RECURSOS_HUMANOS);
writer.WritePropertyName("CE", true);
serializer.Serialize(writer, acc.COSTE_ECONOMICO);
writer.WritePropertyName("OM", true);
if (String.IsNullOrEmpty(acc.MEDIOS_OTROS))
{
serializer.Serialize(writer, "-");
}
else
{
serializer.Serialize(writer, acc.MEDIOS_OTROS);
}
writer.WritePropertyName("Tem", true);
serializer.Serialize(writer, acc.TEMPORALIDAD);
writer.WritePropertyName("Seg", true);
serializer.Serialize(writer, acc.SEGUIMIENTO);
writer.WritePropertyName("IS", true);
serializer.Serialize(writer, acc.PORCENTAJE_AVANCE);
writer.WriteEndObject();
}
}
writer.WriteEndArray();
}
else
{
serializer.Serialize(writer, "");
}
writer.WriteEndObject();
}
}
private void SerializeDictionary(JsonWriter writer, IDictionary values, JsonDictionaryContract contract, JsonProperty member, JsonContainerContract collectionContract, JsonProperty containerProperty)
{
IWrappedDictionary wrappedDictionary = values as IWrappedDictionary;
object underlyingDictionary = wrappedDictionary != null ? wrappedDictionary.UnderlyingDictionary : values;
OnSerializing(writer, contract, underlyingDictionary);
_serializeStack.Add(underlyingDictionary);
WriteObjectStart(writer, underlyingDictionary, contract, member, collectionContract, containerProperty);
if (contract.ItemContract == null)
{
contract.ItemContract = Serializer._contractResolver.ResolveContract(contract.DictionaryValueType ?? typeof(object));
}
if (contract.KeyContract == null)
{
contract.KeyContract = Serializer._contractResolver.ResolveContract(contract.DictionaryKeyType ?? typeof(object));
}
int initialDepth = writer.Top;
foreach (DictionaryEntry entry in values)
{
bool escape;
string propertyName = GetPropertyName(writer, entry.Key, contract.KeyContract, out escape);
propertyName = (contract.DictionaryKeyResolver != null)
? contract.DictionaryKeyResolver(propertyName)
: propertyName;
try
{
object value = entry.Value;
JsonContract valueContract = contract.FinalItemContract ?? GetContractSafe(value);
if (ShouldWriteReference(value, null, valueContract, contract, member))
{
writer.WritePropertyName(propertyName, escape);
WriteReference(writer, value);
}
else
{
if (!CheckForCircularReference(writer, value, null, valueContract, contract, member))
{
continue;
}
writer.WritePropertyName(propertyName, escape);
SerializeValue(writer, value, valueContract, null, contract, member);
}
}
catch (Exception ex)
{
if (IsErrorHandled(underlyingDictionary, contract, propertyName, null, writer.ContainerPath, ex))
{
HandleError(writer, initialDepth);
}
else
{
throw;
}
}
}
writer.WriteEndObject();
_serializeStack.RemoveAt(_serializeStack.Count - 1);
OnSerialized(writer, contract, underlyingDictionary);
}
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");
}
}
