/// <summary>
///
/// </summary>
/// <param name="writer"></param>
public override void WriteJson(JsonWriter writer)
{
using (new JsonObject(writer, RedmineKeys.USER))
{
writer.WriteProperty(RedmineKeys.LOGIN, Login);
writer.WriteProperty(RedmineKeys.FIRST_NAME, FirstName);
writer.WriteProperty(RedmineKeys.LAST_NAME, LastName);
writer.WriteProperty(RedmineKeys.MAIL, Email);
if (!string.IsNullOrEmpty(MailNotification))
{
writer.WriteProperty(RedmineKeys.MAIL_NOTIFICATION, MailNotification);
}
if (!string.IsNullOrEmpty(Password))
{
writer.WriteProperty(RedmineKeys.PASSWORD, Password);
}
if (AuthenticationModeId.HasValue)
{
writer.WriteValueOrEmpty(RedmineKeys.AUTH_SOURCE_ID, AuthenticationModeId);
}
writer.WriteBoolean(RedmineKeys.MUST_CHANGE_PASSWORD, MustChangePassword);
writer.WriteProperty(RedmineKeys.STATUS, ((int)Status).ToString(CultureInfo.InvariantCulture));
if (CustomFields != null)
{
writer.WriteArray(RedmineKeys.CUSTOM_FIELDS, CustomFields);
}
}
}
protected override void ExportValue(ExportContext context, object value, JsonWriter writer)
{
Debug.Assert(context != null);
Debug.Assert(value != null);
Debug.Assert(writer != null);
writer.WriteBoolean((bool)value);
}
/// <summary>
///
/// </summary>
/// <param name="writer"></param>
public override void WriteJson(JsonWriter writer)
{
if (Values == null)
{
return;
}
var itemsCount = Values.Count;
writer.WriteStartObject();
writer.WriteProperty(RedmineKeys.ID, Id);
writer.WriteProperty(RedmineKeys.NAME, Name);
if (itemsCount > 1)
{
writer.WritePropertyName(RedmineKeys.VALUE);
writer.WriteStartArray();
foreach (var cfv in Values)
{
writer.WriteValue(cfv.Info);
}
writer.WriteEndArray();
writer.WriteBoolean(RedmineKeys.MULTIPLE, Multiple);
}
else
{
writer.WriteProperty(RedmineKeys.VALUE, itemsCount > 0 ? Values[0].Info : null);
}
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.WriteBoolean((bool) value);
}
private static void WriteDatum(JsonWriter writer, Spec.Datum datum)
{
switch (datum.type)
{
case Spec.Datum.DatumType.R_BOOL:
writer.WriteBoolean(datum.r_bool);
break;
case Spec.Datum.DatumType.R_JSON:
throw new NotSupportedException();
case Spec.Datum.DatumType.R_NULL:
writer.WriteNull();
break;
case Spec.Datum.DatumType.R_NUM:
writer.WriteNumber(datum.r_num);
break;
case Spec.Datum.DatumType.R_STR:
writer.WriteString(datum.r_str);
break;
case Spec.Datum.DatumType.R_ARRAY:
{
var newterm = new Term()
{
type = Term.TermType.MAKE_ARRAY
};
newterm.args.AddRange(datum.r_array.Select(ap => new Term()
{
type = Term.TermType.DATUM,
datum = ap,
}));
WriteTerm(writer, newterm);
}
break;
case Spec.Datum.DatumType.R_OBJECT:
{
var newterm = new Term()
{
type = Term.TermType.MAKE_OBJ
};
newterm.optargs.AddRange(datum.r_object.Select(ap => new Term.AssocPair()
{
key = ap.key,
val = new Term()
{
type = Term.TermType.DATUM,
datum = ap.val
}
}));
WriteTerm(writer, newterm);
}
break;
}
}
public void Serialize(ref JsonWriter writer, TEnum value, IJsonFormatterResolver formatterResolver)
{
if (value is null)
{
writer.WriteNull();
return;
}
if (typeof(TValue) == typeof(bool))
{
writer.WriteBoolean((bool)(object)value.Value);
}
else if (typeof(TValue) == typeof(byte))
{
writer.WriteByte((byte)(object)value.Value);
}
else if (typeof(TValue) == typeof(sbyte))
{
writer.WriteSByte((sbyte)(object)value.Value);
}
else if (typeof(TValue) == typeof(short))
{
writer.WriteInt16((short)(object)value.Value);
}
else if (typeof(TValue) == typeof(ushort))
{
writer.WriteUInt16((ushort)(object)value.Value);
}
else if (typeof(TValue) == typeof(int))
{
writer.WriteInt32((int)(object)value.Value);
}
else if (typeof(TValue) == typeof(uint))
{
writer.WriteUInt32((uint)(object)value.Value);
}
else if (typeof(TValue) == typeof(long))
{
writer.WriteInt64((long)(object)value.Value);
}
else if (typeof(TValue) == typeof(ulong))
{
writer.WriteUInt64((ulong)(object)value.Value);
}
else if (typeof(TValue) == typeof(float))
{
writer.WriteSingle((float)(object)value.Value);
}
else if (typeof(TValue) == typeof(double))
{
writer.WriteDouble((double)(object)value.Value);
}
else
{
throw new ArgumentOutOfRangeException(typeof(TValue).ToString(), $"{typeof(TValue).Name} is not supported.");
}
}
public override void SerializePrimitive <T>(ref T val)
{
switch (val)
{
case bool v:
jsonWriter.WriteBoolean(v);
break;
case int v:
jsonWriter.WriteInt32(v);
break;
case uint v:
jsonWriter.WriteUInt32(v);
break;
case float v:
jsonWriter.WriteSingle(v);
break;
case double v:
jsonWriter.WriteDouble(v);
break;
case long v:
jsonWriter.WriteInt64(v);
break;
case ulong v:
jsonWriter.WriteUInt64(v);
break;
case short v:
jsonWriter.WriteInt16(v);
break;
case ushort v:
jsonWriter.WriteUInt16(v);
break;
case char v:
jsonWriter.WriteUInt16(v);
break;
case sbyte v:
jsonWriter.WriteSByte(v);
break;
case byte v:
jsonWriter.WriteByte(v);
break;
case decimal v:
//jsonWriter.WriteNumberValue(v);
break;
}
}
/// <summary>
///
/// </summary>
/// <param name="writer"></param>
public override void WriteJson(JsonWriter writer)
{
using (new JsonObject(writer, RedmineKeys.ISSUE))
{
writer.WriteProperty(RedmineKeys.SUBJECT, Subject);
writer.WriteProperty(RedmineKeys.DESCRIPTION, Description);
writer.WriteProperty(RedmineKeys.NOTES, Notes);
if (Id != 0)
{
writer.WriteBoolean(RedmineKeys.PRIVATE_NOTES, PrivateNotes);
}
writer.WriteBoolean(RedmineKeys.IS_PRIVATE, IsPrivate);
writer.WriteIdIfNotNull(RedmineKeys.PROJECT_ID, Project);
writer.WriteIdIfNotNull(RedmineKeys.PRIORITY_ID, Priority);
writer.WriteIdIfNotNull(RedmineKeys.STATUS_ID, Status);
writer.WriteIdIfNotNull(RedmineKeys.CATEGORY_ID, Category);
writer.WriteIdIfNotNull(RedmineKeys.TRACKER_ID, Tracker);
writer.WriteIdIfNotNull(RedmineKeys.ASSIGNED_TO_ID, AssignedTo);
writer.WriteIdIfNotNull(RedmineKeys.FIXED_VERSION_ID, FixedVersion);
writer.WriteValueOrEmpty(RedmineKeys.ESTIMATED_HOURS, EstimatedHours);
writer.WriteIdOrEmpty(RedmineKeys.PARENT_ISSUE_ID, ParentIssue);
writer.WriteDateOrEmpty(RedmineKeys.START_DATE, StartDate);
writer.WriteDateOrEmpty(RedmineKeys.DUE_DATE, DueDate);
writer.WriteDateOrEmpty(RedmineKeys.UPDATED_ON, UpdatedOn);
if (DoneRatio != null)
{
writer.WriteProperty(RedmineKeys.DONE_RATIO, DoneRatio.Value.ToString(CultureInfo.InvariantCulture));
}
if (SpentHours != null)
{
writer.WriteProperty(RedmineKeys.SPENT_HOURS, SpentHours.Value.ToString(CultureInfo.InvariantCulture));
}
writer.WriteArray(RedmineKeys.UPLOADS, Uploads);
writer.WriteArray(RedmineKeys.CUSTOM_FIELDS, CustomFields);
writer.WriteRepeatableElement(RedmineKeys.WATCHER_USER_IDS, (IEnumerable <IValue>)Watchers);
}
}
public void BoolTest(bool target)
{
var writer = new JsonWriter();
writer.WriteBoolean(target);
var reader = SameAsReference(target, writer.GetBuffer());
reader.ReadBoolean().Is(target);
}
public void Serialize(ref JsonWriter writer, BoolSetting value, IJsonFormatterResolver formatterResolver)
{
if (!value.IsEnabled)
{
return;
}
writer.WritePropertyName(value.Name);
writer.WriteBoolean(value.TypedValue);
WriteSeparatorIfNotTheLast(ref writer, value);
}
public void Serialize(ref JsonWriter writer, bool?value, IJsonFormatterResolver formatterResolver)
{
if (value == null)
{
writer.WriteNull();
return;
}
writer.WriteBoolean(value.Value);
}
public void Serialize(JsonWriter writer, Boolean?value, IJsonFormatterResolver formatterResolver)
{
if (value == null)
{
writer.WriteNull();
}
else
{
writer.WriteBoolean(value.Value);
}
}
public void SerializeToPropertyName(ref JsonWriter writer, Boolean?value, IJsonFormatterResolver formatterResolver)
{
if (value == null)
{
writer.WriteNull(); return;
}
writer.WriteQuotation();
writer.WriteBoolean(value.Value);
writer.WriteQuotation();
}
public void Serialize(ref JsonWriter writer, bool value, IJsonFormatterResolver formatterResolver)
{
if (_writeAsString)
{
writer.WriteString(value ? "true" : "false");
}
else
{
writer.WriteBoolean(value);
}
}
public void PrimitiveWrapperUtf16()
{
var value = Fixture.Create <Boolean>();
var writer = new JsonWriter <char>();
writer.WriteBoolean(value);
var output = writer.ToString();
var reader = new JsonReader <char>(output);
var deserialized = reader.ReadBoolean();
Assert.Equal(value, deserialized);
}
/// <summary>
///
/// </summary>
/// <param name="writer"></param>
public override void WriteJson(JsonWriter writer)
{
using (new JsonObject(writer, RedmineKeys.PROJECT))
{
writer.WriteProperty(RedmineKeys.NAME, Name);
writer.WriteProperty(RedmineKeys.IDENTIFIER, Identifier);
writer.WriteIfNotDefaultOrNull(RedmineKeys.DESCRIPTION, Description);
writer.WriteIfNotDefaultOrNull(RedmineKeys.HOMEPAGE, HomePage);
writer.WriteBoolean(RedmineKeys.INHERIT_MEMBERS, InheritMembers);
writer.WriteBoolean(RedmineKeys.IS_PUBLIC, IsPublic);
writer.WriteIdIfNotNull(RedmineKeys.PARENT_ID, Parent);
writer.WriteRepeatableElement(RedmineKeys.TRACKER_IDS, (IEnumerable <IValue>)Trackers);
writer.WriteRepeatableElement(RedmineKeys.ENABLED_MODULE_NAMES, (IEnumerable <IValue>)EnabledModules);
if (Id == 0)
{
writer.WriteRepeatableElement(RedmineKeys.ISSUE_CUSTOM_FIELD_IDS, (IEnumerable <IValue>)CustomFields);
return;
}
writer.WriteArray(RedmineKeys.CUSTOM_FIELDS, CustomFields);
}
}
public void Serialize(ref JsonWriter writer, Boolean[] value, IJsonFormatterResolver formatterResolver)
{
if (value == null)
{
writer.WriteNull();
}
else
{
writer.WriteBeginArray();
if (value.Length != 0)
{
writer.WriteBoolean(value[0]);
}
for (int i = 1; i < value.Length; i++)
{
writer.WriteValueSeparator();
writer.WriteBoolean(value[i]);
}
writer.WriteEndArray();
}
}
private string WriteJson(string image, bool isDark, string color)
{
JsonWriter writer = new JsonWriter();
writer.WriteBeginObject();
writer.WritePropertyName("data");
writer.WriteString(image);
writer.WriteValueSeparator();
writer.WritePropertyName("isDark");
writer.WriteBoolean(isDark);
writer.WriteValueSeparator();
writer.WritePropertyName("color");
writer.WriteString(color);
writer.WriteEndObject();
return(writer.ToString());
}
public void Serialize(ref JsonWriter writer, Track track, IJsonFormatterResolver formatterResolver)
{
if (track == null)
{
writer.WriteNull();
return;
}
var dateTimeFormatter = formatterResolver.GetFormatter <DateTime>();
UnsafeMemory64.WriteRaw26(ref writer, this.stringByteKeys[0]);
dateTimeFormatter.Serialize(ref writer, track.AddedToLibraryDateTime, formatterResolver);
UnsafeMemory64.WriteRaw20(ref writer, this.stringByteKeys[1]);
formatterResolver.GetFormatter <TrackAlbumAssociation>().Serialize(ref writer, track.AlbumAssociation, formatterResolver);
UnsafeMemory64.WriteRaw9(ref writer, this.stringByteKeys[2]);
IJsonFormatterHelper.SerializeList(ref writer, track.Composers, formatterResolver);
UnsafeMemory64.WriteRaw12(ref writer, this.stringByteKeys[3]);
formatterResolver.GetFormatter <TimeSpan?>().Serialize(ref writer, track.Duration, formatterResolver);
UnsafeMemory64.WriteRaw17(ref writer, this.stringByteKeys[4]);
formatterResolver.GetFormatter <ulong?>().Serialize(ref writer, track.FileSizeBytes, formatterResolver);
UnsafeMemory64.WriteRaw11(ref writer, this.stringByteKeys[5]);
writer.WriteBoolean(track.IsLoved);
UnsafeMemory64.WriteRaw24(ref writer, this.stringByteKeys[6]);
formatterResolver.GetFormatter <DateTime?>().Serialize(ref writer, track.LastModifiedDateTime, formatterResolver);
UnsafeMemory64.WriteRaw12(ref writer, this.stringByteKeys[8]);
formatterResolver.GetFormatter <Uri>().Serialize(ref writer, track.Location, formatterResolver);
UnsafeMemory64.WriteRaw14(ref writer, this.stringByteKeys[9]);
IJsonFormatterHelper.SerializeList(ref writer, track.Performers, formatterResolver);
UnsafeMemory64.WriteRaw9(ref writer, this.stringByteKeys[10]);
writer.WriteString(track.Title);
UnsafeMemory64.WriteRaw8(ref writer, this.stringByteKeys[11]);
formatterResolver.GetFormatter <uint?>().Serialize(ref writer, track.Year, formatterResolver);
writer.WriteEndObject();
}
public void Serialize(ref JsonWriter writer, BitArray value, IJsonFormatterResolver formatterResolver)
{
if (value == null)
{
writer.WriteNull(); return;
}
writer.WriteBeginArray();
for (int i = 0; i < value.Length; i++)
{
if (i != 0)
{
writer.WriteValueSeparator();
}
writer.WriteBoolean(value[i]);
}
writer.WriteEndArray();
}
public void Serialize(ref JsonWriter writer, Union <bool, DynamicMapping> value, IJsonFormatterResolver formatterResolver)
{
if (value == null)
{
writer.WriteNull();
return;
}
switch (value.Tag)
{
case 0:
writer.WriteBoolean(value.Item1);
break;
case 1:
writer.WriteString(value.Item2.GetStringValue());
break;
}
}
private static void WriteContact()
{
using (JsonWriter writer = CreateJsonWriter(Console.Out))
{
writer.WriteStartObject(); // {
writer.WriteMember("Name"); // "Name" :
writer.WriteString("John Doe"); // "John Doe",
writer.WriteMember("PermissionToCall"); // "PermissionToCall" :
writer.WriteBoolean(true); // true,
writer.WriteMember("PhoneNumbers"); // "PhoneNumbers" :
writer.WriteStartArray(); // [
WritePhoneNumber(writer, // { "Location": "Home",
"Home", "555-555-1234"); // "Number": "555-555-1234" },
WritePhoneNumber(writer, // { "Location": "Work",
"Work", "555-555-9999 Ext. 123"); // "Number": "555-555-9999 Ext. 123" }
writer.WriteEndArray(); // ]
writer.WriteEndObject(); // }
}
}
public void SerializeToPropertyName(ref JsonWriter writer, Boolean value, IJsonFormatterResolver formatterResolver)
{
writer.WriteQuotation();
writer.WriteBoolean(value);
writer.WriteQuotation();
}
public void Serialize(ref JsonWriter writer, Boolean value, IJsonFormatterResolver formatterResolver)
{
writer.WriteBoolean(value);
}
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();
}
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();
}
/// <summary>
/// Removes indentation in JSON byte representation
/// </summary>
internal static void WriteUnindented(ref JsonReader reader, ref JsonWriter writer)
{
var token = reader.GetCurrentJsonToken();
switch (token)
{
case JsonToken.BeginObject:
{
writer.WriteBeginObject();
var c = 0;
while (reader.ReadIsInObject(ref c))
{
if (c != 1)
{
writer.WriteRaw((byte)',');
}
writer.WritePropertyName(reader.ReadPropertyName());
WriteUnindented(ref reader, ref writer);
}
writer.WriteEndObject();
}
break;
case JsonToken.BeginArray:
{
writer.WriteBeginArray();
var c = 0;
while (reader.ReadIsInArray(ref c))
{
if (c != 1)
{
writer.WriteRaw((byte)',');
}
WriteUnindented(ref reader, ref writer);
}
writer.WriteEndArray();
}
break;
case JsonToken.Number:
var segment = reader.ReadNumberSegment();
for (var i = 0; i < segment.Count; i++)
{
// segment.Array never null
// ReSharper disable once PossibleNullReferenceException
writer.WriteRawUnsafe(segment.Array[i + segment.Offset]);
}
break;
case JsonToken.String:
var s = reader.ReadString();
writer.WriteString(s);
break;
case JsonToken.True:
case JsonToken.False:
var b = reader.ReadBoolean();
writer.WriteBoolean(b);
break;
case JsonToken.Null:
reader.ReadIsNull();
writer.WriteNull();
break;
}
}
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 WriteBoolean(bool value)
{
Palette.Boolean.Apply();
inner.WriteBoolean(value);
}
public void Serialize(ref JsonWriter writer, Attachment value, IJsonFormatterResolver formatterResolver)
{
if (value == null)
{
writer.WriteNull();
return;
}
if (!value.ContainsMetadata)
{
writer.WriteString(value.Content);
}
else
{
writer.WriteBeginObject();
writer.WritePropertyName("content");
writer.WriteString(value.Content);
if (!string.IsNullOrEmpty(value.Author))
{
writer.WriteValueSeparator();
writer.WritePropertyName("author");
writer.WriteString(value.Author);
}
if (value.ContentLength.HasValue)
{
writer.WriteValueSeparator();
writer.WritePropertyName("content_length");
writer.WriteInt64(value.ContentLength.Value);
}
if (!string.IsNullOrEmpty(value.ContentType))
{
writer.WriteValueSeparator();
writer.WritePropertyName("content_type");
writer.WriteString(value.ContentType);
}
if (value.Date.HasValue)
{
writer.WriteValueSeparator();
writer.WritePropertyName("date");
formatterResolver.GetFormatter <DateTime?>().Serialize(ref writer, value.Date, formatterResolver);
}
if (value.DetectLanguage.HasValue)
{
writer.WriteValueSeparator();
writer.WritePropertyName("detect_language");
writer.WriteBoolean(value.DetectLanguage.Value);
}
if (value.IndexedCharacters.HasValue)
{
writer.WriteValueSeparator();
writer.WritePropertyName("indexed_chars");
writer.WriteInt64(value.IndexedCharacters.Value);
}
if (!string.IsNullOrEmpty(value.Keywords))
{
writer.WriteValueSeparator();
writer.WritePropertyName("keywords");
writer.WriteString(value.Keywords);
}
if (!string.IsNullOrEmpty(value.Language))
{
writer.WriteValueSeparator();
writer.WritePropertyName("language");
writer.WriteString(value.Language);
}
if (!string.IsNullOrEmpty(value.Name))
{
writer.WriteValueSeparator();
writer.WritePropertyName("name");
writer.WriteString(value.Name);
}
if (!string.IsNullOrEmpty(value.Title))
{
writer.WriteValueSeparator();
writer.WritePropertyName("title");
writer.WriteString(value.Title);
}
writer.WriteEndObject();
}
}
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 string
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);
}