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)
{
if (value == null)
{
writer.WriteNull();
return;
}
Enum e = (Enum)value;
string enumName = e.ToString("G");
if (char.IsNumber(enumName[0]) || enumName[0] == '-')
{
writer.WriteValue(value);
}
else
{
BidirectionalDictionary<string, string> map = GetEnumNameMap(e.GetType());
string resolvedEnumName;
map.TryGetByFirst(enumName, out resolvedEnumName);
resolvedEnumName = resolvedEnumName ?? enumName;
if (CamelCaseText)
resolvedEnumName = StringUtils.ToCamelCase(resolvedEnumName);
writer.WriteValue(resolvedEnumName);
}
}
public void WritesNull()
{
var sw = new StringWriter();
var writer = new JsonWriter(sw);
writer.WriteNull();
Assert.AreEqual("null", sw.ToString());
}
/// <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)
{
if (value == null)
{
writer.WriteNull();
return;
}
Enum e = (Enum)value;
string enumName = e.ToString("G");
if (char.IsNumber(enumName[0]) || enumName[0] == '-')
{
// enum value has no name so write number
writer.WriteValue(value);
}
else
{
Type enumType = e.GetType();
string finalName = EnumUtils.ToEnumName(enumType, enumName, CamelCaseText);
writer.WriteValue(finalName);
}
}
/// <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)
{
if (value == null)
{
writer.WriteNull();
return;
}
Enum e = (Enum)value;
string enumName = e.ToString("G");
if (char.IsNumber(enumName[0]) || enumName[0] == '-')
{
writer.WriteValue(value);
}
else
{
BidirectionalDictionary<string, string> map = GetEnumNameMap(e.GetType());
string resolvedEnumName;
map.TryGetByFirst(enumName, out resolvedEnumName);
resolvedEnumName = resolvedEnumName ?? enumName;
if (CamelCaseText)
{
string[] names = resolvedEnumName.Split(',').Select(item => StringUtils.ToCamelCase(item.Trim())).ToArray();
resolvedEnumName = string.Join(", ", names);
}
writer.WriteValue(resolvedEnumName);
}
}
/// <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)
{
if (value == null)
{
writer.WriteNull();
return;
}
Enum e = (Enum) value;
string enumName = e.ToString("G");
if (char.IsNumber(enumName[0]) || enumName[0] == '-')
{
// enum value didn't have an option against it
// fallback to writing number value
writer.WriteValue(value);
}
else
{
if (CamelCaseText)
enumName = StringUtils.ToCamelCase(enumName);
writer.WriteValue(enumName);
}
}
/// <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");
}
}
/// <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) {
if (writer == null) throw new ArgumentNullException("writer");
if (value == null) {
writer.WriteNull();
return;
}
var data = GetByteArray(value);
writer.WriteValue(data);
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
NameContainer nameContainer = value as NameContainer;
if (nameContainer != null)
writer.WriteValue(nameContainer.Value);
else
writer.WriteNull();
}
public virtual void Export(object value, JsonWriter writer)
{
if (writer == null)
throw new ArgumentNullException("writer");
if (value == null)
writer.WriteNull();
else
ExportValue(value, writer);
}
public override void Write(JsonWriter writer, object value)
{
if (value == null) writer.WriteNull();
else
{
var m = value as LinearRegressionModel;
base.Write(writer, m);
writer.WriteProperty(nameof(m.Theta), m.Theta);
}
}
// Token: 0x0600017F RID: 383
// RVA: 0x0002B420 File Offset: 0x00029620
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
if (value == null)
{
writer.WriteNull();
return;
}
byte[] byteArray = this.GetByteArray(value);
writer.WriteValue(byteArray);
}
private void SerializeValue(JsonWriter writer, object value, JsonConverter memberConverter)
{
JsonConverter converter = memberConverter;
if (value == null)
{
writer.WriteNull();
}
else if (converter != null
|| _serializer.HasClassConverter(value.GetType(), out converter)
|| _serializer.HasMatchingConverter(value.GetType(), out converter))
{
SerializeConvertable(writer, converter, value);
}
else if (JsonConvert.IsJsonPrimitive(value))
{
writer.WriteValue(value);
}
else if (value is JToken)
{
((JToken)value).WriteTo(writer, (_serializer.Converters != null) ? _serializer.Converters.ToArray() : null);
}
else if (value is JsonRaw)
{
writer.WriteRawValue(((JsonRaw)value).Content);
}
else
{
JsonContract contract = _serializer.ContractResolver.ResolveContract(value.GetType());
if (contract is JsonObjectContract)
{
SerializeObject(writer, value, (JsonObjectContract)contract);
}
else if (contract is JsonDictionaryContract)
{
SerializeDictionary(writer, (IDictionary)value, (JsonDictionaryContract)contract);
}
else if (contract is JsonArrayContract)
{
if (value is IList)
{
SerializeList(writer, (IList)value, (JsonArrayContract)contract);
}
else if (value is IEnumerable)
{
SerializeEnumerable(writer, (IEnumerable)value, (JsonArrayContract)contract);
}
else
{
throw new Exception("Cannot serialize '{0}' into a JSON array. Type does not implement IEnumerable.".FormatWith(CultureInfo.InvariantCulture, value.GetType()));
}
}
}
}
public override void Write(JsonWriter writer, object value)
{
if (value == null)
writer.WriteNull();
else
{
var t = value as Tree;
base.Write(writer, t);
writer.WriteProperty(nameof(t.Root), t.Root);
}
}
/// <summary>
/// Serializes a generic model object to the stream.
/// </summary>
/// <param name="writer">A JSON Writer.</param>
/// <param name="value"></param>
public override void Write(JsonWriter writer, object value)
{
if (value == null) writer.WriteNull();
else
{
var model = (numl.Supervised.Model)value;
writer.WriteProperty(nameof(model.Descriptor), model.Descriptor);
writer.WriteProperty(nameof(model.NormalizeFeatures), model.NormalizeFeatures);
writer.WriteProperty(nameof(model.FeatureNormalizer), model.FeatureNormalizer?.GetType().FullName);
writer.WriteProperty(nameof(model.FeatureProperties), model.FeatureProperties);
}
}
/// <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)
{
if (value == null)
{
writer.WriteNull();
return;
}
var data = GetByteArray(value);
writer.WriteValue(data);
}
// Token: 0x060001B5 RID: 437
// RVA: 0x00006EA4 File Offset: 0x000050A4
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
if (value == null)
{
writer.WriteNull();
return;
}
if (!(value is Version))
{
throw new JsonSerializationException("Expected Version object value");
}
writer.WriteValue(value.ToString());
}
public virtual void Export(ExportContext context, object value, JsonWriter writer)
{
if (context == null)
throw new ArgumentNullException("context");
if (writer == null)
throw new ArgumentNullException("writer");
if (JsonNull.LogicallyEquals(value))
writer.WriteNull();
else
ExportValue(context, value, writer);
}
/// <summary>
/// Serializes the given Summary object to the given stream.
/// </summary>
/// <param name="writer">A JSON Writer object.</param>
/// <param name="value">A Summary object.</param>
public override void Write(JsonWriter writer, object value)
{
if (value == null) writer.WriteNull();
else
{
var summary = (Summary)value;
writer.WriteProperty(nameof(Summary.Average), summary.Average);
writer.WriteProperty(nameof(Summary.Minimum), summary.Minimum);
writer.WriteProperty(nameof(Summary.Median), summary.Median);
writer.WriteProperty(nameof(Summary.Maximum), summary.Maximum);
writer.WriteProperty(nameof(Summary.StandardDeviation), summary.StandardDeviation);
}
}
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");
}
}
/// <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)
{
if (value == null)
{
writer.WriteNull();
return;
}
byte[] data = value as byte[];
if (data == null)
data = GetByteArray(value);
writer.WriteValue(Convert.ToBase64String(data));
}
/// <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)
{
if (value == null)
{
writer.WriteNull();
}
else if (value is Version)
{
writer.WriteValue(value.ToString());
}
else
{
throw new Exception("Expected Version object value");
}
}
/// <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)
{
if (value == null)
{
writer.WriteNull();
return;
}
Enum e = (Enum) value;
string enumName = e.ToString("G");
if (char.IsNumber(enumName[0]) || enumName[0] == '-')
writer.WriteValue(value);
else
writer.WriteValue(enumName);
}
/// <summary>
/// Writes the Neural Network object to the stream.
/// </summary>
/// <param name="writer">Stream to write to.</param>
/// <param name="value">Neural Network object to write.</param>
public override void Write(JsonWriter writer, object value)
{
if (value == null)
writer.WriteNull();
else
{
var network = (Network)value;
// write out nodes
writer.WriteArrayProperty("Nodes",
network.GetVertices().ToArray());
// write out all edges
writer.WriteArrayProperty("Edges",
network.GetEdges().ToArray());
}
}
/// <summary>
/// Serializes neural network model
/// </summary>
/// <param name="writer">JsonWriter</param>
/// <param name="value">Model to Serialize</param>
public override void Write(JsonWriter writer, object value)
{
if (value == null)
writer.WriteNull();
else
{
var model = (NeuralNetworkModel)value;
base.Write(writer, model);
// write out function
writer.WriteProperty(nameof(model.OutputFunction),
model.OutputFunction?.GetType().FullName);
// write out network
writer.WriteProperty(nameof(model.Network), model.Network);
}
}
public static void Export(object value, JsonWriter writer)
{
if (writer == null)
throw new ArgumentNullException("writer");
if (value == null)
{
writer.WriteNull();
return;
}
IJsonExporter exporter = TryGetExporter(value.GetType());
if (exporter != null)
exporter.Export(value, writer);
else
writer.WriteString(value.ToString());
}
protected override void FormatEnumerable(IEnumerable enumerable, JsonWriter writer)
{
if (writer == null)
throw new ArgumentNullException("writer");
if (JNull.LogicallyEquals(enumerable))
{
writer.WriteNull();
return;
}
NameValueCollection collection = enumerable as NameValueCollection;
if (collection != null)
FormatNameValueCollection(collection, writer);
else
base.FormatEnumerable(enumerable, writer);
}
public void Serialize(ref JsonWriter writer, TDictionary value, IJsonFormatterResolver formatterResolver)
{
if (value == null)
{
writer.WriteNull();
return;
}
else
{
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;
keyFormatter.SerializeToPropertyName(ref writer, item.Key, formatterResolver);
writer.WriteNameSeparator();
valueFormatter.Serialize(ref writer, item.Value, formatterResolver);
}
else
{
goto END;
}
while (e.MoveNext())
{
writer.WriteValueSeparator();
var item = e.Current;
keyFormatter.SerializeToPropertyName(ref writer, item.Key, formatterResolver);
writer.WriteNameSeparator();
valueFormatter.Serialize(ref writer, item.Value, formatterResolver);
}
}
else
{
if (e.MoveNext())
{
var item = e.Current;
writer.WriteString(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(item.Key.ToString());
writer.WriteNameSeparator();
valueFormatter.Serialize(ref writer, item.Value, formatterResolver);
}
}
}
finally
{
e.Dispose();
}
END:
writer.WriteEndObject();
}
}
private void SerializeNode(JsonWriter writer, IXmlNode node, XmlNamespaceManager manager, bool writePropertyName)
{
switch (node.NodeType)
{
case XmlNodeType.Document:
case XmlNodeType.DocumentFragment:
SerializeGroupedNodes(writer, node, manager, writePropertyName);
break;
case XmlNodeType.Element:
if (IsArray(node) && node.ChildNodes.All(n => n.LocalName == node.LocalName) && node.ChildNodes.Count > 0)
{
SerializeGroupedNodes(writer, node, manager, false);
}
else
{
foreach (IXmlNode attribute in node.Attributes)
{
if (attribute.NamespaceURI == "http://www.w3.org/2000/xmlns/")
{
string prefix = (attribute.LocalName != "xmlns")
? attribute.LocalName
: string.Empty;
manager.AddNamespace(prefix, attribute.Value);
}
}
if (writePropertyName)
{
writer.WritePropertyName(GetPropertyName(node, manager));
}
if (ValueAttributes(node.Attributes).Count() == 0 && node.ChildNodes.Count == 1 &&
node.ChildNodes[0].NodeType == XmlNodeType.Text)
{
// write elements with a single text child as a name value pair
writer.WriteValue(node.ChildNodes[0].Value);
}
else if (node.ChildNodes.Count == 0 && CollectionUtils.IsNullOrEmpty(node.Attributes))
{
// empty element
writer.WriteNull();
}
else
{
writer.WriteStartObject();
for (int i = 0; i < node.Attributes.Count; i++)
{
SerializeNode(writer, node.Attributes[i], manager, true);
}
SerializeGroupedNodes(writer, node, manager, true);
writer.WriteEndObject();
}
}
break;
case XmlNodeType.Comment:
if (writePropertyName)
{
writer.WriteComment(node.Value);
}
break;
case XmlNodeType.Attribute:
case XmlNodeType.Text:
case XmlNodeType.CDATA:
case XmlNodeType.ProcessingInstruction:
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
if (node.NamespaceURI == "http://www.w3.org/2000/xmlns/" && node.Value == JsonNamespaceUri)
{
return;
}
if (node.NamespaceURI == JsonNamespaceUri)
{
if (node.LocalName == "Array")
{
return;
}
}
if (writePropertyName)
{
writer.WritePropertyName(GetPropertyName(node, manager));
}
writer.WriteValue(node.Value);
break;
case XmlNodeType.XmlDeclaration:
IXmlDeclaration declaration = (IXmlDeclaration)node;
writer.WritePropertyName(GetPropertyName(node, manager));
writer.WriteStartObject();
if (!string.IsNullOrEmpty(declaration.Version))
{
writer.WritePropertyName("@version");
writer.WriteValue(declaration.Version);
}
if (!string.IsNullOrEmpty(declaration.Encoding))
{
writer.WritePropertyName("@encoding");
writer.WriteValue(declaration.Encoding);
}
if (!string.IsNullOrEmpty(declaration.Standalone))
{
writer.WritePropertyName("@standalone");
writer.WriteValue(declaration.Standalone);
}
writer.WriteEndObject();
break;
default:
throw new JsonSerializationException("Unexpected XmlNodeType when serializing nodes: " + node.NodeType);
}
}
public void Serialize(ref JsonWriter writer, IAnalyzer value, IJsonFormatterResolver formatterResolver)
{
if (value == null)
{
writer.WriteNull();
return;
}
switch (value.Type)
{
case "stop":
Serialize <IStopAnalyzer>(ref writer, value, formatterResolver);
break;
case "standard":
Serialize <IStandardAnalyzer>(ref writer, value, formatterResolver);
break;
case "snowball":
Serialize <ISnowballAnalyzer>(ref writer, value, formatterResolver);
break;
case "pattern":
Serialize <IPatternAnalyzer>(ref writer, value, formatterResolver);
break;
case "keyword":
Serialize <IKeywordAnalyzer>(ref writer, value, formatterResolver);
break;
case "whitespace":
Serialize <IWhitespaceAnalyzer>(ref writer, value, formatterResolver);
break;
case "simple":
Serialize <ISimpleAnalyzer>(ref writer, value, formatterResolver);
break;
case "fingerprint":
Serialize <IFingerprintAnalyzer>(ref writer, value, formatterResolver);
break;
case "kuromoji":
Serialize <IKuromojiAnalyzer>(ref writer, value, formatterResolver);
break;
case "nori":
Serialize <INoriAnalyzer>(ref writer, value, formatterResolver);
break;
case "icu_analyzer":
Serialize <IIcuAnalyzer>(ref writer, value, formatterResolver);
break;
case "custom":
Serialize <ICustomAnalyzer>(ref writer, value, formatterResolver);
break;
default:
Serialize <ILanguageAnalyzer>(ref writer, value, formatterResolver);
break;
}
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializerWriter internalWriter)
{
if (value == null)
{
writer.WriteNull();
return;
}
var m = (Matrix4x4)value;
writer.WriteStartObject();
writer.WritePropertyName("m00");
writer.WriteValue(m.m00);
writer.WritePropertyName("m01");
writer.WriteValue(m.m01);
writer.WritePropertyName("m02");
writer.WriteValue(m.m02);
writer.WritePropertyName("m03");
writer.WriteValue(m.m03);
writer.WritePropertyName("m10");
writer.WriteValue(m.m10);
writer.WritePropertyName("m11");
writer.WriteValue(m.m11);
writer.WritePropertyName("m12");
writer.WriteValue(m.m12);
writer.WritePropertyName("m13");
writer.WriteValue(m.m13);
writer.WritePropertyName("m20");
writer.WriteValue(m.m20);
writer.WritePropertyName("m21");
writer.WriteValue(m.m21);
writer.WritePropertyName("m22");
writer.WriteValue(m.m22);
writer.WritePropertyName("m23");
writer.WriteValue(m.m23);
writer.WritePropertyName("m30");
writer.WriteValue(m.m30);
writer.WritePropertyName("m31");
writer.WriteValue(m.m31);
writer.WritePropertyName("m32");
writer.WriteValue(m.m32);
writer.WritePropertyName("m33");
writer.WriteValue(m.m33);
writer.WriteEnd();
}
public override void WriteTo(JsonWriter writer, params JsonConverter[] converters)
{
switch (_valueType)
{
case JTokenType.Comment:
writer.WriteComment(_value.ToString());
return;
case JTokenType.Raw:
writer.WriteRawValue((_value != null) ? _value.ToString() : null);
return;
case JTokenType.Null:
writer.WriteNull();
return;
case JTokenType.Undefined:
writer.WriteUndefined();
return;
}
JsonConverter matchingConverter;
if (_value != null && (matchingConverter = JsonSerializer.GetMatchingConverter(converters, _value.GetType())) != null)
{
matchingConverter.WriteJson(writer, _value, new JsonSerializer());
return;
}
switch (_valueType)
{
case JTokenType.Integer:
writer.WriteValue(Convert.ToInt64(_value, CultureInfo.InvariantCulture));
break;
case JTokenType.Float:
writer.WriteValue(Convert.ToDouble(_value, CultureInfo.InvariantCulture));
break;
case JTokenType.String:
writer.WriteValue((_value != null) ? _value.ToString() : null);
break;
case JTokenType.Boolean:
writer.WriteValue(Convert.ToBoolean(_value, CultureInfo.InvariantCulture));
break;
case JTokenType.Date:
if (_value is DateTimeOffset)
{
writer.WriteValue((DateTimeOffset)_value);
}
else
{
writer.WriteValue(Convert.ToDateTime(_value, CultureInfo.InvariantCulture));
}
break;
case JTokenType.Bytes:
writer.WriteValue((byte[])_value);
break;
case JTokenType.Guid:
case JTokenType.Uri:
case JTokenType.TimeSpan:
writer.WriteValue((_value != null) ? _value.ToString() : null);
break;
default:
throw MiscellaneousUtils.CreateArgumentOutOfRangeException("TokenType", _valueType, "Unexpected token type.");
}
}
public void Serialize(ref JsonWriter writer, TDictionary value, IJsonFormatterResolver formatterResolver)
{
var enumerable = (IEnumerable <KeyValuePair <TKey, TValue> >)value;
if (enumerable == null)
{
writer.WriteNull();
return;
}
var settings = formatterResolver.GetConnectionSettings();
var seenEntries = new Dictionary <string, TValue>(value.Count());
foreach (var entry in enumerable)
{
if (SkipValue(entry)) // TODO: pass _connectionSettingsValues and configure Null Handling on this
{
continue;
}
string key;
if (_keyIsString)
{
key = entry.Key?.ToString();
}
else if (settings == null)
{
key = Convert.ToString(entry.Key, CultureInfo.InvariantCulture);
}
else if (_keyIsField)
{
var fieldName = entry.Key as Field;
key = settings.Inferrer.Field(fieldName);
}
else if (_keyIsPropertyName)
{
var propertyName = entry.Key as PropertyName;
if (propertyName?.Property != null && settings.PropertyMappings.TryGetValue(propertyName.Property, out var mapping) &&
mapping.Ignore)
{
continue;
}
key = settings.Inferrer.PropertyName(propertyName);
}
else if (_keyIsIndexName)
{
var indexName = entry.Key as IndexName;
key = settings.Inferrer.IndexName(indexName);
}
else if (_keyIsRelationName)
{
var typeName = entry.Key as RelationName;
key = settings.Inferrer.RelationName(typeName);
}
else
{
key = Convert.ToString(entry.Key, CultureInfo.InvariantCulture);
}
if (key != null)
{
seenEntries[key] = entry.Value;
}
}
var formatter = formatterResolver.GetFormatter <Dictionary <string, TValue> >();
formatter.Serialize(ref writer, seenEntries, formatterResolver);
}
public void Serialize(ref JsonWriter writer, T value, IJsonFormatterResolver formatterResolver)
{
writer.WriteNull();
}
public static void WriteJson(JsonWriter writer, object value, JsonSerializer serializer,
Func <Type, bool> shouldConvertDictionary,
Action <JsonWriter, object, JsonSerializer> recurse,
Func <IProvideSerialization, double> orderSerializationAttrs)
{
if (value is IReferenceable)
{
var id = (value as IReferenceable).id;
WriteId(id);
//writer.WriteValue(id);
return;
}
if (value is IReferences)
{
writer.WriteStartArray();
Guid[] ids = (value as IReferences).ids
.Select(
id =>
{
WriteId(id);
//writer.WriteValue(id);
return(id);
})
.ToArray();
writer.WriteEndArray();
return;
}
if (value is IReferenceableOptional)
{
var id = (value as IReferenceableOptional).id;
WriteId(id);
//writer.WriteValue(id);
return;
}
if (!value.TryGetType(out Type valueType))
{
writer.WriteNull();
return;
}
if (valueType.IsSubClassOfGeneric(typeof(IDictionary <,>)))
{
writer.WriteStartObject();
foreach (var kvpObj in value.DictionaryKeyValuePairs())
{
var keyValue = kvpObj.Key;
var propertyName = (keyValue is IReferenceable) ?
(keyValue as IReferenceable).id.ToString()
:
keyValue.ToString();
writer.WritePropertyName(propertyName);
var valueValue = kvpObj.Value;
var valueValueType = valueType.GenericTypeArguments.Last();
if (shouldConvertDictionary(valueValueType))
{
recurse(writer, valueValue, serializer);
continue;
}
writer.WriteValue(valueValue);
}
writer.WriteEndObject();
return;
}
if (value is Type)
{
var typeValue = (value as Type);
var serializationAttrs = typeValue
.GetAttributesInterface <IProvideSerialization>();
if (serializationAttrs.Any())
{
var serializationAttr = serializationAttrs
.OrderByDescending(orderSerializationAttrs)
.First();
writer.WriteValue(serializationAttr.ContentType);
return;
}
var stringType = typeValue.GetClrString();
writer.WriteValue(stringType);
return;
}
if (valueType.IsEnum)
{
var stringValue = Enum.GetName(valueType, value);
writer.WriteValue(stringValue);
return;
}
serializer.Serialize(writer, value);
void WriteId(Guid?idMaybe)
{
if (!idMaybe.HasValue)
{
writer.WriteValue((string)null);
return;
}
var id = idMaybe.Value;
writer.WriteValue(id);
}
}
/// <summary>
/// Writes this token to a <see cref="JsonWriter"/>.
/// </summary>
/// <param name="writer">A <see cref="JsonWriter"/> into which this method will write.</param>
/// <param name="converters">A collection of <see cref="JsonConverter"/> which will be used when writing the token.</param>
public override void WriteTo(JsonWriter writer, params JsonConverter[] converters)
{
if (converters != null && converters.Length > 0 && _value != null)
{
JsonConverter matchingConverter = JsonSerializer.GetMatchingConverter(converters, _value.GetType());
if (matchingConverter != null)
{
matchingConverter.WriteJson(writer, _value, new JsonSerializer());
return;
}
}
switch (_valueType)
{
case JTokenType.Comment:
writer.WriteComment((_value != null) ? _value.ToString() : null);
return;
case JTokenType.Raw:
writer.WriteRawValue((_value != null) ? _value.ToString() : null);
return;
case JTokenType.Null:
writer.WriteNull();
return;
case JTokenType.Undefined:
writer.WriteUndefined();
return;
case JTokenType.Integer:
writer.WriteValue(Convert.ToInt64(_value, CultureInfo.InvariantCulture));
return;
case JTokenType.Float:
if (_value is decimal)
{
writer.WriteValue((decimal)_value);
}
else if (_value is double)
{
writer.WriteValue((double)_value);
}
else if (_value is float)
{
writer.WriteValue((float)_value);
}
else
{
writer.WriteValue(Convert.ToDouble(_value, CultureInfo.InvariantCulture));
}
return;
case JTokenType.String:
writer.WriteValue((_value != null) ? _value.ToString() : null);
return;
case JTokenType.Boolean:
writer.WriteValue(Convert.ToBoolean(_value, CultureInfo.InvariantCulture));
return;
case JTokenType.Date:
#if !PocketPC && !NET20
if (_value is DateTimeOffset)
{
writer.WriteValue((DateTimeOffset)_value);
}
else
#endif
writer.WriteValue(Convert.ToDateTime(_value, CultureInfo.InvariantCulture));
return;
case JTokenType.Bytes:
writer.WriteValue((byte[])_value);
return;
case JTokenType.Guid:
case JTokenType.Uri:
case JTokenType.TimeSpan:
writer.WriteValue((_value != null) ? _value.ToString() : null);
return;
}
throw MiscellaneousUtils.CreateArgumentOutOfRangeException("TokenType", _valueType, "Unexpected token type.");
}
public override unsafe void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
// Also serves as a null check.
if (!(value is Stream stream))
{
writer.WriteNull();
return;
}
if (!stream.CanRead)
{
throw new InvalidDataException("The stream is not readable.");
}
StringBuilder base64Builder;
if (!stream.CanSeek)
{
// If the stream isn't seekable all we can do is start reading from it.
base64Builder = new StringBuilder(HEADER);
}
else
{
// Check if it's an empty attachment.
if (stream.Length == 0)
{
writer.WriteValue(HEADER);
return;
}
// Check if the user didn't rewind the stream.
if (stream.Position == stream.Length)
{
throw new InvalidDataException("The stream's position is the same as its length. Did you forget to rewind it?");
}
// Check if the stream is a memory stream and the underlying buffer is retrievable,
// so we can skip the reading as all of the memory is already allocated anyways.
if (stream is MemoryStream memoryStream && memoryStream.TryGetBuffer(out var memoryStreamBuffer))
{
var base64 = string.Concat(HEADER, Convert.ToBase64String(memoryStreamBuffer.AsSpan()));
writer.WriteValue(base64);
return;
}
// If the stream is seekable we can use its length and position to roughly calculate its base64 length.
base64Builder = new StringBuilder(HEADER, (int)((stream.Length - stream.Position) * 1.37f) + HEADER.Length);
}
// TODO: Do something about both not fully downloaded http streams
// and buffer underflowing.
// Allocate a 3 bytes span buffer for reading data from the stream
// and a 4 chars span buffer for the base64 encoded bytes.
Span <byte> byteSpan = stackalloc byte[3];
Span <char> charSpan = stackalloc char[4];
int bytesRead;
while ((bytesRead = stream.Read(byteSpan)) != 0)
{
if (!Convert.TryToBase64Chars(byteSpan.Slice(0, bytesRead), charSpan, out var charsWritten))
{
throw new InvalidDataException("The stream could not be converted to base64.");
}
base64Builder.Append(charSpan.Slice(0, charsWritten));
}
writer.WriteValue(base64Builder.ToString());
}
/// <summary>
/// Writes this token to a <see cref="JsonWriter"/>.
/// </summary>
/// <param name="writer">A <see cref="JsonWriter"/> into which this method will write.</param>
/// <param name="converters">A collection of <see cref="JsonConverter"/> which will be used when writing the token.</param>
public override void WriteTo(JsonWriter writer, params JsonConverter[] converters)
{
if (converters != null && converters.Length > 0 && _value != null)
{
JsonConverter matchingConverter = JsonSerializer.GetMatchingConverter(converters, _value.GetType());
if (matchingConverter != null && matchingConverter.CanWrite)
{
matchingConverter.WriteJson(writer, _value, JsonSerializer.CreateDefault());
return;
}
}
switch (_valueType)
{
case JTokenType.Comment:
writer.WriteComment((_value != null) ? _value.ToString() : null);
return;
case JTokenType.Raw:
writer.WriteRawValue((_value != null) ? _value.ToString() : null);
return;
case JTokenType.Null:
writer.WriteNull();
return;
case JTokenType.Undefined:
writer.WriteUndefined();
return;
case JTokenType.Integer:
if (_value is int)
{
writer.WriteValue((int)_value);
}
else if (_value is long)
{
writer.WriteValue((long)_value);
}
else if (_value is ulong)
{
writer.WriteValue((ulong)_value);
}
#if !(NET20 || NET35 || PORTABLE40 || PORTABLE) || NETSTANDARD1_1
else if (_value is BigInteger)
{
writer.WriteValue((BigInteger)_value);
}
#endif
else
{
writer.WriteValue(Convert.ToInt64(_value, CultureInfo.InvariantCulture));
}
return;
case JTokenType.Float:
if (_value is decimal)
{
writer.WriteValue((decimal)_value);
}
else if (_value is double)
{
writer.WriteValue((double)_value);
}
else if (_value is float)
{
writer.WriteValue((float)_value);
}
else
{
writer.WriteValue(Convert.ToDouble(_value, CultureInfo.InvariantCulture));
}
return;
case JTokenType.String:
writer.WriteValue((_value != null) ? _value.ToString() : null);
return;
case JTokenType.Boolean:
writer.WriteValue(Convert.ToBoolean(_value, CultureInfo.InvariantCulture));
return;
case JTokenType.Date:
#if !NET20
if (_value is DateTimeOffset)
{
writer.WriteValue((DateTimeOffset)_value);
}
else
#endif
{
writer.WriteValue(Convert.ToDateTime(_value, CultureInfo.InvariantCulture));
}
return;
case JTokenType.Bytes:
writer.WriteValue((byte[])_value);
return;
case JTokenType.Guid:
writer.WriteValue((_value != null) ? (Guid?)_value : null);
return;
case JTokenType.TimeSpan:
writer.WriteValue((_value != null) ? (TimeSpan?)_value : null);
return;
case JTokenType.Uri:
writer.WriteValue((Uri)_value);
return;
}
throw MiscellaneousUtils.CreateArgumentOutOfRangeException("TokenType", _valueType, "Unexpected token type.");
}
public void Serialize(ref JsonWriter writer, object value, IJsonFormatterResolver formatterResolver)
{
if (value == null)
{
writer.WriteNull(); return;
}
var type = value.GetType();
if (type == typeof(object))
{
// serialize to empty object
writer.WriteBeginObject();
writer.WriteEndObject();
return;
}
KeyValuePair <object, Tuple <SerializeMethod, bool> > formatterAndDelegate;
if (!serializers.TryGetValue(type, out formatterAndDelegate))
{
lock (serializers)
{
if (!serializers.TryGetValue(type, out formatterAndDelegate))
{
object formatter = null;
foreach (var innerResolver in innerResolvers)
{
formatter = innerResolver.GetFormatterDynamic(type);
if (formatter != null)
{
break;
}
}
if (formatter == null)
{
throw new FormatterNotRegisteredException(type.FullName + " is not registered in this resolver. resolvers:" + string.Join(", ", innerResolvers.Select(x => x.GetType().Name).ToArray()));
}
var t = type;
{
var dm = new DynamicMethod("Serialize", null, new[] { typeof(object), typeof(JsonWriter).MakeByRefType(), typeof(object), typeof(IJsonFormatterResolver) }, type.Module, true);
var il = dm.GetILGenerator();
// delegate void SerializeMethod(object dynamicFormatter, ref JsonWriter writer, object value, IJsonFormatterResolver formatterResolver);
il.EmitLdarg(0);
il.Emit(OpCodes.Castclass, typeof(IJsonFormatter <>).MakeGenericType(t));
il.EmitLdarg(1);
il.EmitLdarg(2);
il.EmitUnboxOrCast(t);
il.EmitLdarg(3);
il.EmitCall(Resolvers.Internal.DynamicObjectTypeBuilder.EmitInfo.Serialize(t));
il.Emit(OpCodes.Ret);
var writeTypeName = BuiltinResolver.HasFormatter(type);
formatterAndDelegate = new KeyValuePair <object, Tuple <SerializeMethod, bool> >(formatter, Tuple.Create((SerializeMethod)dm.CreateDelegate(typeof(SerializeMethod)), writeTypeName));
}
serializers.TryAdd(t, formatterAndDelegate);
}
}
}
if (formatterAndDelegate.Value.Item2)
{
writer.WriteBeginObject();
writer.WritePropertyName("$type");
var typeName = SubtractFullNameRegex.Replace(type.AssemblyQualifiedName, "");
writer.WriteString(typeName);
writer.WriteValueSeparator();
writer.WritePropertyName("$value");
}
formatterAndDelegate.Value.Item1(formatterAndDelegate.Key, ref writer, value, formatterResolver);
if (formatterAndDelegate.Value.Item2)
{
writer.WriteEndObject();
}
}
public void Serialize(ref JsonWriter writer, ILifecycleActions value, IJsonFormatterResolver formatterResolver)
{
if (value == null)
{
writer.WriteNull();
return;
}
writer.WriteBeginObject();
var count = 0;
foreach (var action in value)
{
if (count > 0)
{
writer.WriteValueSeparator();
}
writer.WritePropertyName(action.Key);
switch (action.Key)
{
case "allocate":
Serialize <IAllocateLifecycleAction>(ref writer, action.Value, formatterResolver);
break;
case "delete":
Serialize <IDeleteLifecycleAction>(ref writer, action.Value, formatterResolver);
break;
case "forcemerge":
Serialize <IForceMergeLifecycleAction>(ref writer, action.Value, formatterResolver);
break;
case "freeze":
Serialize <IFreezeLifecycleAction>(ref writer, action.Value, formatterResolver);
break;
case "readonly":
Serialize <IReadOnlyLifecycleAction>(ref writer, action.Value, formatterResolver);
break;
case "rollover":
Serialize <IRolloverLifecycleAction>(ref writer, action.Value, formatterResolver);
break;
case "set_priority":
Serialize <ISetPriorityLifecycleAction>(ref writer, action.Value, formatterResolver);
break;
case "shrink":
Serialize <IShrinkLifecycleAction>(ref writer, action.Value, formatterResolver);
break;
case "unfollow":
Serialize <IUnfollowLifecycleAction>(ref writer, action.Value, formatterResolver);
break;
case "wait_for_snapshot":
Serialize <IWaitForSnapshotLifecycleAction>(ref writer, action.Value, formatterResolver);
break;
default:
DynamicObjectResolver.ExcludeNullCamelCase.GetFormatter <ILifecycleAction>()
.Serialize(ref writer, action.Value, formatterResolver);
break;
}
count++;
}
writer.WriteEndObject();
}
public void Serialize(ref JsonWriter writer, IMovingAverageAggregation value, IJsonFormatterResolver formatterResolver)
{
if (value == null)
{
writer.WriteNull();
return;
}
writer.WriteBeginObject();
var propertyWritten = false;
if (value.BucketsPath != null)
{
writer.WritePropertyName("buckets_path");
var formatter = formatterResolver.GetFormatter <IBucketsPath>();
formatter.Serialize(ref writer, value.BucketsPath, formatterResolver);
propertyWritten = true;
}
if (value.GapPolicy != null)
{
if (propertyWritten)
{
writer.WriteValueSeparator();
}
writer.WritePropertyName("gap_policy");
writer.WriteString(value.GapPolicy.GetStringValue());
propertyWritten = true;
}
if (!value.Format.IsNullOrEmpty())
{
if (propertyWritten)
{
writer.WriteValueSeparator();
}
writer.WritePropertyName("format");
writer.WriteString(value.Format);
propertyWritten = true;
}
if (value.Window != null)
{
if (propertyWritten)
{
writer.WriteValueSeparator();
}
writer.WritePropertyName("window");
writer.WriteInt32(value.Window.Value);
propertyWritten = true;
}
if (value.Minimize != null)
{
if (propertyWritten)
{
writer.WriteValueSeparator();
}
writer.WritePropertyName("minimize");
writer.WriteBoolean(value.Minimize.Value);
propertyWritten = true;
}
if (value.Predict != null)
{
if (propertyWritten)
{
writer.WriteValueSeparator();
}
writer.WritePropertyName("predict");
writer.WriteInt32(value.Predict.Value);
propertyWritten = true;
}
if (value.Model != null)
{
if (propertyWritten)
{
writer.WriteValueSeparator();
}
writer.WritePropertyName("model");
writer.WriteString(value.Model.Name);
writer.WriteValueSeparator();
writer.WritePropertyName("settings");
switch (value.Model.Name)
{
case "ewma":
Serialize(ref writer, (IEwmaModel)value.Model, formatterResolver);
break;
case "linear":
Serialize(ref writer, (ILinearModel)value.Model, formatterResolver);
break;
case "simple":
Serialize(ref writer, (ISimpleModel)value.Model, formatterResolver);
break;
case "holt":
Serialize(ref writer, (IHoltLinearModel)value.Model, formatterResolver);
break;
case "holt_winters":
Serialize(ref writer, (IHoltWintersModel)value.Model, formatterResolver);
break;
default:
Serialize(ref writer, value.Model, formatterResolver);
break;
}
}
writer.WriteEndObject();
}
public override void WriteTo(JsonWriter writer, JsonConverterCollection converters)
{
switch (_valueType)
{
case JTokenType.Comment:
writer.WriteComment(_value.ToString());
return;
case JTokenType.Raw:
writer.WriteRawValue((_value != null) ? _value.ToString() : null);
return;
case JTokenType.Null:
writer.WriteNull();
return;
case JTokenType.Undefined:
writer.WriteUndefined();
return;
}
if (_value != null)
{
Type typeToFind = _value.GetType();
// If we are using the default converters we will try to avoid repeatedly check the same types as
// GetMatchingConverter is a costly call with a very low probability to hit (less than 1% in real scenarios).
JsonConverter matchingConverter = JsonConverterCache.GetMatchingConverter(converters, typeToFind);
if (matchingConverter != null)
{
matchingConverter.WriteJson(writer, _value, JsonExtensions.CreateDefaultJsonSerializer());
return;
}
}
switch (_valueType)
{
case JTokenType.Integer:
writer.WriteValue(Convert.ToInt64(_value, CultureInfo.InvariantCulture));
return;
case JTokenType.Float:
if (_value is decimal)
{
writer.WriteValue((decimal)_value);
return;
}
if (_value is float)
{
writer.WriteValue((float)_value);
return;
}
writer.WriteValue(Convert.ToDouble(_value, CultureInfo.InvariantCulture));
return;
case JTokenType.String:
writer.WriteValue((_value != null) ? _value.ToString() : null);
return;
case JTokenType.Boolean:
writer.WriteValue(Convert.ToBoolean(_value, CultureInfo.InvariantCulture));
return;
case JTokenType.Date:
#if !PocketPC && !NET20
if (_value is DateTimeOffset)
{
writer.WriteValue((DateTimeOffset)_value);
}
else
#endif
writer.WriteValue(Convert.ToDateTime(_value, CultureInfo.InvariantCulture));
return;
case JTokenType.Bytes:
writer.WriteValue((byte[])_value);
return;
case JTokenType.Guid:
case JTokenType.Uri:
case JTokenType.TimeSpan:
writer.WriteValue((_value != null) ? _value.ToString() : null);
return;
}
throw MiscellaneousUtils.CreateArgumentOutOfRangeException("TokenType", _valueType, "Unexpected token type.");
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
if (value == null)
{
writer.WriteNull();
return;
}
writer.WriteStartObject();
var oldPreserveReferencesHandling = serializer.PreserveReferencesHandling;
try
{
serializer.PreserveReferencesHandling = PreserveReferencesHandling.None;
foreach (var kvp in (Parameters)value)
{
writer.WritePropertyName(kvp.Key);
var v = kvp.Value;
if (v is DateTime dateTime)
{
if (dateTime.Kind == DateTimeKind.Unspecified)
{
dateTime = DateTime.SpecifyKind(dateTime, DateTimeKind.Local);
}
writer.WriteValue(dateTime.GetDefaultRavenFormat());
}
else if (v is DateTimeOffset dateTimeOffset)
{
writer.WriteValue(dateTimeOffset.UtcDateTime.GetDefaultRavenFormat(true));
}
else if (v is IEnumerable enumerable)
{
var oldTypeNameHandling = serializer.TypeNameHandling;
try
{
serializer.TypeNameHandling = Newtonsoft.Json.TypeNameHandling.None;
serializer.Serialize(writer, enumerable);
}
finally
{
serializer.TypeNameHandling = oldTypeNameHandling;
}
}
else if (IsRavenAssembly(v))
{
var oldNullValueHandling = serializer.NullValueHandling;
var oldDefaultValueHandling = serializer.DefaultValueHandling;
try
{
serializer.NullValueHandling = NullValueHandling.Ignore;
serializer.DefaultValueHandling = DefaultValueHandling.Ignore;
serializer.Serialize(writer, v);
}
finally
{
serializer.NullValueHandling = oldNullValueHandling;
serializer.DefaultValueHandling = oldDefaultValueHandling;
}
}
else
{
serializer.Serialize(writer, v);
}
}
}
finally
{
serializer.PreserveReferencesHandling = oldPreserveReferencesHandling;
}
writer.WriteEndObject();
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
writer.WriteNull();
}
public void Serialize(ref JsonWriter writer, IProperty value, IJsonFormatterResolver formatterResolver)
{
if (value == null)
{
writer.WriteNull();
return;
}
switch (value)
{
case ITextProperty textProperty:
Serialize(ref writer, textProperty, formatterResolver);
break;
case IKeywordProperty keywordProperty:
Serialize(ref writer, keywordProperty, formatterResolver);
break;
case INumberProperty numberProperty:
Serialize(ref writer, numberProperty, formatterResolver);
break;
case IDateProperty dateProperty:
Serialize(ref writer, dateProperty, formatterResolver);
break;
case IBooleanProperty booleanProperty:
Serialize(ref writer, booleanProperty, formatterResolver);
break;
case INestedProperty nestedProperty:
Serialize(ref writer, nestedProperty, formatterResolver);
break;
case IObjectProperty objectProperty:
Serialize(ref writer, objectProperty, formatterResolver);
break;
case ISearchAsYouTypeProperty searchAsYouTypeProperty:
Serialize(ref writer, searchAsYouTypeProperty, formatterResolver);
break;
case IDateNanosProperty dateNanosProperty:
Serialize(ref writer, dateNanosProperty, formatterResolver);
break;
case IBinaryProperty binaryProperty:
Serialize(ref writer, binaryProperty, formatterResolver);
break;
case IIpProperty ipProperty:
Serialize(ref writer, ipProperty, formatterResolver);
break;
case IGeoPointProperty geoPointProperty:
Serialize(ref writer, geoPointProperty, formatterResolver);
break;
case IGeoShapeProperty geoShapeProperty:
Serialize(ref writer, geoShapeProperty, formatterResolver);
break;
case IShapeProperty shapeProperty:
Serialize(ref writer, shapeProperty, formatterResolver);
break;
case ICompletionProperty completionProperty:
Serialize(ref writer, completionProperty, formatterResolver);
break;
case ITokenCountProperty tokenCountProperty:
Serialize(ref writer, tokenCountProperty, formatterResolver);
break;
case IMurmur3HashProperty murmur3HashProperty:
Serialize(ref writer, murmur3HashProperty, formatterResolver);
break;
case IPercolatorProperty percolatorProperty:
Serialize(ref writer, percolatorProperty, formatterResolver);
break;
case IDateRangeProperty dateRangeProperty:
Serialize(ref writer, dateRangeProperty, formatterResolver);
break;
case IDoubleRangeProperty doubleRangeProperty:
Serialize(ref writer, doubleRangeProperty, formatterResolver);
break;
case IFloatRangeProperty floatRangeProperty:
Serialize(ref writer, floatRangeProperty, formatterResolver);
break;
case IIntegerRangeProperty integerRangeProperty:
Serialize(ref writer, integerRangeProperty, formatterResolver);
break;
case ILongRangeProperty longRangeProperty:
Serialize(ref writer, longRangeProperty, formatterResolver);
break;
case IIpRangeProperty ipRangeProperty:
Serialize(ref writer, ipRangeProperty, formatterResolver);
break;
case IJoinProperty joinProperty:
Serialize(ref writer, joinProperty, formatterResolver);
break;
case IFieldAliasProperty fieldAliasProperty:
Serialize(ref writer, fieldAliasProperty, formatterResolver);
break;
case IRankFeatureProperty rankFeatureProperty:
Serialize(ref writer, rankFeatureProperty, formatterResolver);
break;
case IRankFeaturesProperty rankFeaturesProperty:
Serialize(ref writer, rankFeaturesProperty, formatterResolver);
break;
case IFlattenedProperty flattenedProperty:
Serialize(ref writer, flattenedProperty, formatterResolver);
break;
case IHistogramProperty histogramProperty:
Serialize(ref writer, histogramProperty, formatterResolver);
break;
case IGenericProperty genericProperty:
Serialize(ref writer, genericProperty, formatterResolver);
break;
default:
var formatter = formatterResolver.GetFormatter <object>();
formatter.Serialize(ref writer, value, formatterResolver);
break;
}
}
public void Serialize(ref JsonWriter writer, ITokenizer value, IJsonFormatterResolver formatterResolver)
{
if (value == null)
{
writer.WriteNull();
return;
}
switch (value.Type)
{
case "char_group":
Serialize <ICharGroupTokenizer>(ref writer, value, formatterResolver);
break;
case "edge_ngram":
Serialize <IEdgeNGramTokenizer>(ref writer, value, formatterResolver);
break;
case "ngram":
Serialize <INGramTokenizer>(ref writer, value, formatterResolver);
break;
case "path_hierarchy":
Serialize <IPathHierarchyTokenizer>(ref writer, value, formatterResolver);
break;
case "pattern":
Serialize <IPatternTokenizer>(ref writer, value, formatterResolver);
break;
case "standard":
Serialize <IStandardTokenizer>(ref writer, value, formatterResolver);
break;
case "uax_url_email":
Serialize <IUaxEmailUrlTokenizer>(ref writer, value, formatterResolver);
break;
case "whitespace":
Serialize <IWhitespaceTokenizer>(ref writer, value, formatterResolver);
break;
case "kuromoji_tokenizer":
Serialize <IKuromojiTokenizer>(ref writer, value, formatterResolver);
break;
case "icu_tokenizer":
Serialize <IIcuTokenizer>(ref writer, value, formatterResolver);
break;
case "nori_tokenizer":
Serialize <INoriTokenizer>(ref writer, value, formatterResolver);
break;
default:
// serialize user defined tokenizer
var formatter = formatterResolver.GetFormatter <object>();
formatter.Serialize(ref writer, value, formatterResolver);
break;
}
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
IGeometry geom = value as IGeometry;
if (geom == null)
{
writer.WriteNull();
return;
}
writer.WriteStartObject();
GeoJsonObjectType geomType = ToGeoJsonObject(geom);
writer.WritePropertyName("type");
writer.WriteValue(Enum.GetName(typeof(GeoJsonObjectType), geomType));
switch (geomType)
{
case GeoJsonObjectType.Point:
if (serializer.NullValueHandling == NullValueHandling.Include || geom.Coordinate != null)
{
writer.WritePropertyName("coordinates");
serializer.Serialize(writer, geom.Coordinate);
}
break;
case GeoJsonObjectType.LineString:
case GeoJsonObjectType.MultiPoint:
var linealCoords = geom.Coordinates;
if (serializer.NullValueHandling == NullValueHandling.Include || linealCoords != null)
{
writer.WritePropertyName("coordinates");
serializer.Serialize(writer, linealCoords);
}
break;
case GeoJsonObjectType.Polygon:
IPolygon poly = geom as IPolygon;
Debug.Assert(poly != null);
var polygonCoords = PolygonCoordinates(poly);
if (serializer.NullValueHandling == NullValueHandling.Include || polygonCoords != null)
{
writer.WritePropertyName("coordinates");
serializer.Serialize(writer, polygonCoords);
}
break;
case GeoJsonObjectType.MultiPolygon:
IMultiPolygon mpoly = geom as IMultiPolygon;
Debug.Assert(mpoly != null);
var list = new List <List <Coordinate[]> >();
foreach (IPolygon mempoly in mpoly.Geometries)
{
list.Add(PolygonCoordinates(mempoly));
}
if (serializer.NullValueHandling == NullValueHandling.Include || list.Count > 0)
{
writer.WritePropertyName("coordinates");
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);
}
if (serializer.NullValueHandling == NullValueHandling.Include || coordinates.Count > 0)
{
writer.WritePropertyName("coordinates");
serializer.Serialize(writer, coordinates);
}
break;
}
writer.WriteEndObject();
}
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();
}
public void JsonReaderToJsonWriter(JsonReader reader, JsonWriter writer)
{
do
{
//log.Info("reader.TokenType-->" + reader.TokenType);
switch (reader.TokenType)
{
case JsonToken.None:
break;
case JsonToken.StartObject:
writer.WriteStartObject();
break;
case JsonToken.StartArray:
writer.WriteStartArray();
break;
case JsonToken.PropertyName:
writer.WritePropertyName(reader.Value.ToString());
break;
case JsonToken.Comment:
writer.WriteComment((reader.Value != null) ? reader.Value.ToString() : null);
break;
//数字/字符/布尔型/GUID都转成string
case JsonToken.Integer:
case JsonToken.Float:
case JsonToken.String:
case JsonToken.Boolean:
case JsonToken.Bytes:
writer.WriteValue(reader.Value.ToString());
break;
case JsonToken.Null:
if (this.PropertyNullValueReplaceValue != null)
{
writer.WriteValue(this.PropertyNullValueReplaceValue);
}
else
{
writer.WriteNull();
}
break;
case JsonToken.Undefined:
writer.WriteUndefined();
break;
case JsonToken.EndObject:
writer.WriteEndObject();
break;
case JsonToken.EndArray:
writer.WriteEndArray();
break;
case JsonToken.EndConstructor:
writer.WriteEndConstructor();
break;
case JsonToken.Date:
if (reader.Value != null)
{
writer.WriteValue(((DateTime)reader.Value).ToString("yyyy-MM-dd HH:mm:ss"));
}
break;
case JsonToken.Raw:
writer.WriteRawValue((reader.Value != null) ? reader.Value.ToString() : null);
break;
}
} while (reader.Read());
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
if (value is JsonLoggerOutput)
{
var output = value as JsonLoggerOutput;
writer.WriteStartObject();
writer.WritePropertyName("successful");
writer.WriteValue(output.Succeeded);
writer.WritePropertyName("stats");
writer.WriteStartObject();
foreach (var time in output.StepTimes)
{
writer.WritePropertyName(time.Key);
writer.WriteValue(time.Value);
}
writer.WriteEndObject();
writer.WritePropertyName("messages");
writer.WriteStartArray();
foreach (var diagnostic in output.Diagnostics)
{
serializer.Serialize(writer, diagnostic);
}
writer.WriteEndArray();
writer.WriteEndObject();
}
else if (value is Diagnostic)
{
var diagnostic = value as Diagnostic;
writer.WriteStartObject();
writer.WritePropertyName("location");
if (diagnostic.Location != null)
{
writer.WriteStartObject();
writer.WritePropertyName("file");
writer.WriteValue(diagnostic.Location.FileName);
writer.WritePropertyName("StartLine");
writer.WriteValue(diagnostic.Location.StartLine);
writer.WritePropertyName("StartColumn");
writer.WriteValue(diagnostic.Location.StartColumn);
writer.WritePropertyName("EndLine");
writer.WriteValue(diagnostic.Location.EndLine);
writer.WritePropertyName("EndColumn");
writer.WriteValue(diagnostic.Location.EndColumn);
writer.WriteEndObject();
}
else
{
writer.WriteNull();
}
writer.WritePropertyName("code");
writer.WriteValue(diagnostic.Code);
writer.WritePropertyName("level");
writer.WriteValue(diagnostic.Level);
writer.WritePropertyName("message");
writer.WriteValue(diagnostic.Message);
writer.WriteEndObject();
}
else
{
throw new InvalidOperationException();
}
}
public override void WriteNull()
{
_textWriter.WriteNull();
_innerWriter.WriteNull();
base.WriteUndefined();
}
public void Serialize(ref JsonWriter writer, IGeoBoundingBoxQuery value, IJsonFormatterResolver formatterResolver)
{
if (value == null)
{
writer.WriteNull();
return;
}
var written = false;
writer.WriteBeginObject();
if (!value.Name.IsNullOrEmpty())
{
writer.WritePropertyName("_name");
writer.WriteString(value.Name);
written = true;
}
if (value.Boost != null)
{
if (written)
{
writer.WriteValueSeparator();
}
writer.WritePropertyName("boost");
writer.WriteDouble(value.Boost.Value);
written = true;
}
if (value.ValidationMethod != null)
{
if (written)
{
writer.WriteValueSeparator();
}
writer.WritePropertyName("validation_method");
formatterResolver.GetFormatter <GeoValidationMethod>()
.Serialize(ref writer, value.ValidationMethod.Value, formatterResolver);
written = true;
}
if (value.Type != null)
{
if (written)
{
writer.WriteValueSeparator();
}
writer.WritePropertyName("type");
formatterResolver.GetFormatter <GeoExecution>()
.Serialize(ref writer, value.Type.Value, formatterResolver);
written = true;
}
if (written)
{
writer.WriteValueSeparator();
}
var settings = formatterResolver.GetConnectionSettings();
writer.WritePropertyName(settings.Inferrer.Field(value.Field));
formatterResolver.GetFormatter <IBoundingBox>()
.Serialize(ref writer, value.BoundingBox, formatterResolver);
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 void Serialize(ref JsonWriter writer, IProperty value, IJsonFormatterResolver formatterResolver)
{
if (value == null)
{
writer.WriteNull();
return;
}
switch (value.Type)
{
case "text":
Serialize <ITextProperty>(ref writer, value, formatterResolver);
break;
case "keyword":
Serialize <IKeywordProperty>(ref writer, value, formatterResolver);
break;
case "float":
case "double":
case "byte":
case "short":
case "integer":
case "long":
case "scaled_float":
case "half_float":
Serialize <INumberProperty>(ref writer, value, formatterResolver);
break;
case "date":
Serialize <IDateProperty>(ref writer, value, formatterResolver);
break;
case "date_nanos":
Serialize <IDateNanosProperty>(ref writer, value, formatterResolver);
break;
case "boolean":
Serialize <IBooleanProperty>(ref writer, value, formatterResolver);
break;
case "binary":
Serialize <IBinaryProperty>(ref writer, value, formatterResolver);
break;
case "object":
Serialize <IObjectProperty>(ref writer, value, formatterResolver);
break;
case "nested":
Serialize <INestedProperty>(ref writer, value, formatterResolver);
break;
case "ip":
Serialize <IIpProperty>(ref writer, value, formatterResolver);
break;
case "geo_point":
Serialize <IGeoPointProperty>(ref writer, value, formatterResolver);
break;
case "geo_shape":
Serialize <IGeoShapeProperty>(ref writer, value, formatterResolver);
break;
case "completion":
Serialize <ICompletionProperty>(ref writer, value, formatterResolver);
break;
case "token_count":
Serialize <ITokenCountProperty>(ref writer, value, formatterResolver);
break;
case "murmur3":
Serialize <IMurmur3HashProperty>(ref writer, value, formatterResolver);
break;
case "percolator":
Serialize <IPercolatorProperty>(ref writer, value, formatterResolver);
break;
case "date_range":
Serialize <IDateRangeProperty>(ref writer, value, formatterResolver);
break;
case "double_range":
Serialize <IDoubleRangeProperty>(ref writer, value, formatterResolver);
break;
case "float_range":
Serialize <IFloatRangeProperty>(ref writer, value, formatterResolver);
break;
case "integer_range":
Serialize <IIntegerRangeProperty>(ref writer, value, formatterResolver);
break;
case "long_range":
Serialize <ILongRangeProperty>(ref writer, value, formatterResolver);
break;
case "ip_range":
Serialize <IIpRangeProperty>(ref writer, value, formatterResolver);
break;
case "join":
Serialize <IJoinProperty>(ref writer, value, formatterResolver);
break;
case "alias":
Serialize <IFieldAliasProperty>(ref writer, value, formatterResolver);
break;
case "rank_feature":
Serialize <IRankFeatureProperty>(ref writer, value, formatterResolver);
break;
case "rank_features":
Serialize <IRankFeaturesProperty>(ref writer, value, formatterResolver);
break;
default:
if (value is IGenericProperty genericProperty)
{
Serialize <IGenericProperty>(ref writer, genericProperty, formatterResolver);
}
else
{
var formatter = DynamicObjectResolver.ExcludeNullCamelCase.GetFormatter <IProperty>();
formatter.Serialize(ref writer, value, formatterResolver);
}
break;
}
}
public void Serialize(ref JsonWriter writer, IGeoShapeQuery 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 <GeoShapeRelation>()
.Serialize(ref writer, value.Relation.Value, formatterResolver);
}
writer.WriteEndObject();
writer.WriteEndObject();
}
private void SerializeValue(JsonWriter writer, object value, JsonContract valueContract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerProperty)
{
if (value == null)
{
writer.WriteNull();
return;
}
JsonConverter converter =
((member != null) ? member.Converter : null) ??
((containerProperty != null) ? containerProperty.ItemConverter : null) ??
((containerContract != null) ? containerContract.ItemConverter : null) ??
valueContract.Converter ??
Serializer.GetMatchingConverter(valueContract.UnderlyingType) ??
valueContract.InternalConverter;
if (converter != null && converter.CanWrite)
{
SerializeConvertable(writer, converter, value, valueContract, containerContract, containerProperty);
return;
}
switch (valueContract.ContractType)
{
case JsonContractType.Object:
SerializeObject(writer, value, (JsonObjectContract)valueContract, member, containerContract, containerProperty);
break;
case JsonContractType.Array:
JsonArrayContract arrayContract = (JsonArrayContract)valueContract;
if (!arrayContract.IsMultidimensionalArray)
{
SerializeList(writer, (IEnumerable)value, arrayContract, member, containerContract, containerProperty);
}
else
{
SerializeMultidimensionalArray(writer, (Array)value, arrayContract, member, containerContract, containerProperty);
}
break;
case JsonContractType.Primitive:
SerializePrimitive(writer, value, (JsonPrimitiveContract)valueContract, member, containerContract, containerProperty);
break;
case JsonContractType.String:
SerializeString(writer, value, (JsonStringContract)valueContract);
break;
case JsonContractType.Dictionary:
JsonDictionaryContract dictionaryContract = (JsonDictionaryContract)valueContract;
SerializeDictionary(writer, (value is IDictionary) ? (IDictionary)value : dictionaryContract.CreateWrapper(value), dictionaryContract, member, containerContract, containerProperty);
break;
#if !(NET35 || NET20 || PORTABLE40)
case JsonContractType.Dynamic:
SerializeDynamic(writer, (IDynamicMetaObjectProvider)value, (JsonDynamicContract)valueContract, member, containerContract, containerProperty);
break;
#endif
#if !(DOTNET || PORTABLE40 || PORTABLE)
case JsonContractType.Serializable:
SerializeISerializable(writer, (ISerializable)value, (JsonISerializableContract)valueContract, member, containerContract, containerProperty);
break;
#endif
case JsonContractType.Linq:
((JToken)value).WriteTo(writer, Serializer.Converters.ToArray());
break;
}
}
public void Serialize(ref JsonWriter writer, object value, IJsonFormatterResolver formatterResolver)
{
if (value == null)
{
writer.WriteNull();
return;
}
var t = value.GetType();
int key;
if (typeToJumpCode.TryGetValue(t, out key))
{
switch (key)
{
case 0: writer.WriteBoolean((bool)value); return;
case 1: CharFormatter.Default.Serialize(ref writer, (char)value, formatterResolver); return;
case 2: writer.WriteSByte((sbyte)value); return;
case 3: writer.WriteByte((byte)value); return;
case 4: writer.WriteInt16((Int16)value); return;
case 5: writer.WriteUInt16((UInt16)value); return;
case 6: writer.WriteInt32((int)value); return;
case 7: writer.WriteUInt32((UInt32)value); return;
case 8: writer.WriteInt64((long)value); return;
case 9: writer.WriteUInt64((UInt64)value); return;
case 10: writer.WriteSingle((float)value); return;
case 11: writer.WriteDouble((double)value); return;
case 12: ISO8601DateTimeFormatter.Default.Serialize(ref writer, (DateTime)value, formatterResolver); return;
case 13: writer.WriteString((string)value); return;
case 14: ByteArrayFormatter.Default.Serialize(ref writer, (byte[])value, formatterResolver); return;
default:
break;
}
}
if (t.IsEnum)
{
writer.WriteString(t.ToString()); // enum as stringq
return;
}
var dict = value as IDictionary; // check dictionary first
if (dict != null)
{
var count = 0;
writer.WriteBeginObject();
foreach (DictionaryEntry item in dict)
{
if (count++ != 0)
{
writer.WriteValueSeparator();
}
writer.WritePropertyName((string)item.Key);
Serialize(ref writer, item.Value, formatterResolver);
}
writer.WriteEndObject();
return;
}
var collection = value as ICollection;
if (collection != null)
{
var count = 0;
writer.WriteBeginArray();
foreach (var item in collection)
{
if (count++ != 0)
{
writer.WriteValueSeparator();
}
Serialize(ref writer, item, formatterResolver);
}
writer.WriteEndArray();
return;
}
throw new InvalidOperationException("Not supported primitive object resolver. type:" + t.Name);
}
