public override void Write(object value, IJsonConsumer writer)
{
if (value == null)
{
writer.Null();
return;
}
var objConsumer = writer.Object();
foreach (var property in mPropList)
{
object propValue = property.Getter(value);
if (propValue == null)
{
if (!property.EmitNullValue)
{
continue;
}
}
else if (property.SuppressDefaultValue && Equals(propValue, property.DefaultValue))
{
continue;
}
objConsumer.PropertyName(property.Name);
property.Converter.Write(propValue, objConsumer);
}
objConsumer.Done();
}
public WritingConsumer(string typeName, string typeProperty, Type type, IJsonConsumer wrappedConsumer)
{
this.mTypeName = typeName;
this.mTypeProperty = typeProperty;
this.mType = type;
this.mWrappedConsumer = wrappedConsumer;
}
public override void Write(object value, IJsonConsumer writer)
{
if (!mEnumValueToString.TryGetValue(value, out string str))
{
throw new Exception($"Unrecognized enumeration value '{value}'. Valid values are {string.Join(", ", mStringToEnumValue.Keys)}.");
}
writer.String(str);
}
protected override void InternalWrite(DateTime value, IJsonConsumer writer)
{
StringBuilder sb = new StringBuilder(50);
if (value.Year < 10)
{
sb.Append("000");
}
else if (value.Year < 100)
{
sb.Append("00");
}
else if (value.Year < 1000)
{
sb.Append('0');
}
sb.Append(value.Year);
sb.Append('-');
Append2Chars(sb, value.Month);
sb.Append('-');
Append2Chars(sb, value.Day);
sb.Append('T');
Append2Chars(sb, value.Hour);
sb.Append(':');
Append2Chars(sb, value.Minute);
sb.Append(':');
Append2Chars(sb, value.Second);
if (value.Millisecond > 0)
{
sb.Append('.');
Append3Chars(sb, value.Millisecond);
}
if (value.Kind == DateTimeKind.Utc)
{
sb.Append('Z');
}
else if (value.Kind == DateTimeKind.Local)
{
TimeSpan offset = TimeZoneInfo.Local.GetUtcOffset(value);
if (offset >= TimeSpan.Zero)
{
sb.Append('+');
}
else
{
sb.Append('-');
offset = offset.Negate();
}
Append2Chars(sb, offset.Hours);
sb.Append(':');
Append2Chars(sb, offset.Minutes);
}
writer.String(sb.ToString());
}
/// <summary>
/// Writes data of the .NET object to the given <see cref="IJsonConsumer"/>
/// in order to convert it to a JSON string or to any other representation of
/// JSON data.
/// </summary>
/// <param name="value">The .NET object to write. The object type must match
/// the type of the converter.</param>
/// <param name="writer">The JSON consumer which will be used to write
/// the data to according to the contents of the given value.</param>
public sealed override void Write(object value, IJsonConsumer writer)
{
if (mNullable && value == null)
{
writer.Null();
return;
}
InternalWrite((T)value, writer);
}
/// <summary>
/// Writes this <see cref="JsonArray"/> to a <see cref="IJsonConsumer"/>.
/// This is also used internally by <see cref="JsonValue.ToModel(System.Type)"/> and
/// <see cref="JsonValue.ToModel{T}"/> in order to convert this generic object
/// model to a JSON string or another .NET object.
/// </summary>
/// <param name="consumer">The consumer.</param>
public override void Write(IJsonConsumer consumer)
{
IJsonArrayConsumer arrayConsumer = consumer.Array();
for (int i = 0; i < mList.Count; i++)
{
mList[i].Write(arrayConsumer);
}
arrayConsumer.Done();
}
public override void Write(object value, IJsonConsumer writer)
{
if (value == null)
{
writer.Null();
return;
}
valueTypeConverter.Write(value, writer);
}
public override void Write(object value, IJsonConsumer writer)
{
if (value == null)
{
writer.Null();
}
else
{
writer.String(System.Convert.ToBase64String((byte[])value, System.Base64FormattingOptions.None));
}
}
/// <summary>
/// Writes the string or null value to the <see cref="IJsonConsumer"/>.
/// </summary>
/// <param name="value">The string value or null.</param>
/// <param name="writer">The <see cref="IJsonConsumer"/></param>
public override void Write(object value, IJsonConsumer writer)
{
if (value == null)
{
writer.Null();
}
else
{
writer.String((string)value);
}
}
/// <summary>
/// Serializes the given object into the given consumer.
/// </summary>
/// <param name="model">The object to serialize. This may be null or a primitive.</param>
/// <param name="consumer">An instance of IJsonConsumer which receives all data from
/// the given object.</param>
public static void Write(object model, IJsonConsumer consumer)
{
if (model == null)
{
consumer.Null();
}
else
{
ConverterRegistry.Get(model.GetType()).Write(model, consumer);
}
}
protected override void InternalWrite(long value, IJsonConsumer writer)
{
if (value >= 0)
{
writer.Number((ulong)value);
}
else
{
writer.Number(value);
}
}
/// <summary>
/// Writes this <see cref="JsonObject"/> to a <see cref="IJsonConsumer"/>.
/// This is also used internally by <see cref="JsonValue.ToModel(System.Type)"/> and
/// <see cref="JsonValue.ToModel{T}"/> in order to convert this generic object
/// model to a JSON string or another .NET object.
/// </summary>
/// <param name="consumer">The consumer.</param>
public override void Write(IJsonConsumer consumer)
{
IJsonObjectConsumer obj = consumer.Object();
foreach (KeyValuePair <string, JsonValue> property in mPropertiesOrdered)
{
obj.PropertyName(property.Key);
property.Value.Write(obj);
}
obj.Done();
}
/// <summary>
/// Parses JSON read from the given text reader and pushes all
/// data into the given consumer.
/// </summary>
/// <param name="reader">The TextReader to read JSON from.</param>
/// <param name="consumer">The consumer which will be invoked for the
/// parsed fragments.</param>
public static void Parse(TextReader reader, IJsonConsumer consumer)
{
var tokenizer = new Tokenizer(reader);
tokenizer.MoveNext();
Parser.ParseValue(tokenizer, consumer);
if (tokenizer.CurrentToken.Type != Tokenizer.Token.None)
{
throw new ParserException($"Unexpected input data '{tokenizer.CurrentToken}' after end of JSON entity in line {tokenizer.CurrentToken.LineNo} at position {tokenizer.CurrentToken.Position}.", tokenizer.CurrentToken.LineNo, tokenizer.CurrentToken.Position);
}
}
public static void ParseValue(Tokenizer tokenizer, IJsonConsumer consumer)
{
if (tokenizer.CurrentToken.Type == Tokenizer.Token.None)
{
throw new ParserException($"Unexpected end of stream reached in line {tokenizer.CurrentToken.LineNo} at position {tokenizer.CurrentToken.Position}.", tokenizer.CurrentToken.LineNo, tokenizer.CurrentToken.Position);
}
if (tokenizer.CurrentToken.Type == Tokenizer.Token.CurlyOpen)
{
ParseObject(tokenizer, consumer.Object());
return;
}
if (tokenizer.CurrentToken.Type == Tokenizer.Token.SquaredOpen)
{
ParseArray(tokenizer, consumer.Array());
return;
}
if (tokenizer.CurrentToken.Type == Tokenizer.Token.String)
{
consumer.String(tokenizer.CurrentToken.StringValue);
}
else if (tokenizer.CurrentToken.Type == Tokenizer.Token.Boolean)
{
consumer.Boolean(tokenizer.CurrentToken.BooleanValue);
}
else if (tokenizer.CurrentToken.Type == Tokenizer.Token.NumberInteger)
{
consumer.Number(tokenizer.CurrentToken.IntegerValue);
}
else if (tokenizer.CurrentToken.Type == Tokenizer.Token.NumberUnsignedInteger)
{
consumer.Number(tokenizer.CurrentToken.UnsignedIntegerValue);
}
else if (tokenizer.CurrentToken.Type == Tokenizer.Token.NumberFloat)
{
consumer.Number(tokenizer.CurrentToken.FloatValue);
}
else if (tokenizer.CurrentToken.Type == Tokenizer.Token.Null)
{
consumer.Null();
}
else
{
throw new ParserException($"Expected value in line {tokenizer.CurrentToken.LineNo} at position {tokenizer.CurrentToken.Position}, but found '{tokenizer.CurrentToken}'.", tokenizer.CurrentToken.LineNo, tokenizer.CurrentToken.Position);
}
tokenizer.MoveNext(); // skip value literal
}
/// <summary>
/// Writes data of the .NET object to the given <see cref="IJsonConsumer"/>
/// in order to convert it to a JSON string or to any other representation of
/// JSON data. This implementation expects <paramref name="value"/> to implement
/// <see cref="IEnumerable"/> and creates a JSON array from it. The <paramref name="value"/>
/// may be null, though.
/// </summary>
/// <param name="value">The .NET object to write. It may be null or an instance of
/// <see cref="IEnumerable"/>.</param>
/// <param name="writer">The JSON consumer which will be used to write the array to.</param>
public override void Write(object value, IJsonConsumer writer)
{
if (value == null)
{
writer.Null();
return;
}
var arrayConsumer = writer.Array();
foreach (object item in (IEnumerable)value)
{
ElementConverter.Write(item, arrayConsumer);
}
arrayConsumer.Done();
}
public override void Write(object value, IJsonConsumer writer)
{
if (value == null)
{
writer.Null();
return;
}
IJsonObjectConsumer objectConsumer = writer.Object();
foreach (KeyValuePair <string, T> kvp in (Dictionary <string, T>)value)
{
objectConsumer.PropertyName(kvp.Key);
ElementConverter.Write(kvp.Value, objectConsumer);
}
objectConsumer.Done();
}
protected override void InternalWrite(double value, IJsonConsumer writer)
{
if (double.IsNaN(value))
{
writer.String(NAN);
}
else if (double.IsPositiveInfinity(value))
{
writer.String(POS_INFINITY);
}
else if (double.IsNegativeInfinity(value))
{
writer.String(NEG_INFINITY);
}
else
{
writer.Number(value);
}
}
/// <summary>
/// Writes data of the .NET object to the given <see cref="IJsonConsumer"/>
/// in order to convert it to a JSON string or to any other representation of
/// JSON data.
/// </summary>
/// <param name="value">The .NET object to write. Implementors may assume
/// that the type of the incoming value can be cast to the target type
/// of this converter, however, it may be null.</param>
/// <param name="writer">The JSON consumer which must be used to write
/// the data to according to the contents of the given value.</param>
public override void Write(object value, IJsonConsumer writer)
{
if (value == null)
{
writer.Null();
return;
}
Type type = value.GetType();
if (!mTypeNameResolver.TryGetTypeName(type, out string typeName) && type != mTypeNameResolver.DefaultType)
{
throw new Exception($"Type '{type}' is unknown.");
}
IConverter converter = GetConverterForType(type);
converter.Write(value, new WritingConsumer(typeName, mTypeProperty, type, writer));
}
protected override void InternalWrite(float value, IJsonConsumer writer)
{
if (float.IsNaN(value))
{
writer.String(DoubleConverter.NAN);
}
else if (float.IsPositiveInfinity(value))
{
writer.String(DoubleConverter.POS_INFINITY);
}
else if (float.IsNegativeInfinity(value))
{
writer.String(DoubleConverter.NEG_INFINITY);
}
else
{
writer.Number((double)value);
}
}
public override void Write(object value, IJsonConsumer writer)
{
if (value == null)
{
writer.Null();
}
else
{
Type type = value.GetType();
if (type == typeof(object)) // prevent recursion
{
writer.Object().Done();
}
else
{
IConverter converter = ConverterRegistry.Get(type);
converter.Write(value, writer);
}
}
}
public void Write(object value, IJsonConsumer writer)
{
writer.String(((int)value).ToString("X"));
}
/// <summary>
/// Parses the given JSON and pushes all
/// data into the given consumer.
/// </summary>
/// <param name="json">The JSON to parse.</param>
/// <param name="consumer">The consumer which will be invoked for the
/// parsed fragments.</param>
public static void Parse(string json, IJsonConsumer consumer)
{
using (StringReader reader = new StringReader(json))
Parse(reader, consumer);
}
/// <summary>
/// Writes this <see cref="JsonValue"/> to a <see cref="IJsonConsumer"/>.
/// This is also used internally by <see cref="Write(TextWriter, bool)"/>,
/// <see cref="ToModel(Type)"/> and <see cref="ToModel{T}"/> in order to convert
/// this generic object model to a JSON string or another .NET object.
/// </summary>
/// <param name="consumer">The consumer.</param>
public abstract void Write(IJsonConsumer consumer);
protected override void InternalWrite(Guid value, IJsonConsumer writer)
{
writer.String(value.ToString());
}
/// <summary>
/// Writes this <see cref="JsonBoolean"/> to a <see cref="IJsonConsumer"/>.
/// This is also used internally by <see cref="JsonValue.ToModel(System.Type)"/> and
/// <see cref="JsonValue.ToModel{T}"/> in order to convert this generic object
/// model to a JSON string or another .NET object.
/// </summary>
/// <param name="consumer">The consumer.</param>
public override void Write(IJsonConsumer consumer)
{
consumer.Boolean(Value);
}
public override void Write(object value, IJsonConsumer writer)
{
((JsonValue)value).Write(writer);
}
/// <summary> /// Writes data of the .NET object to the given <see cref="IJsonConsumer"/> /// in order to convert it to a JSON string or to any other representation of /// JSON data. /// </summary> /// <param name="value">The .NET object to write. Implementors may assume /// that the type of the incoming value can be cast to the target type /// of this converter, however, it may be null.</param> /// <param name="writer">The JSON consumer which must be used to write /// the data to according to the contents of the given value.</param> public abstract void Write(object value, IJsonConsumer writer);
/// <summary> /// An internal Write method which needs to be implemented /// by deriving classes. The <paramref name="value"/> is non-nullable /// at this point. /// </summary> /// <param name="value">The value to write.</param> /// <param name="writer">The json consumer to write to.</param> protected abstract void InternalWrite(T value, IJsonConsumer writer);
/// <summary>
/// Writes null to a <see cref="IJsonConsumer"/>.
/// This is also used internally by <see cref="JsonValue.ToModel(System.Type)"/> and
/// <see cref="JsonValue.ToModel{T}"/> in order to convert this generic object
/// model to a JSON string or another .NET object.
/// </summary>
/// <param name="consumer">The consumer.</param>
public override void Write(IJsonConsumer consumer)
{
consumer.Null();
}
protected override void InternalWrite(uint value, IJsonConsumer writer)
{
writer.Number((ulong)value);
}
