public void ValueFormatting()
{
StringBuilder sb = new StringBuilder();
StringWriter sw = new StringWriter(sb);
using (JsonWriter jsonWriter = new JsonWriter(sw))
{
jsonWriter.WriteStartArray();
jsonWriter.WriteValue('@');
jsonWriter.WriteValue("\r\n\t\f\b?{\\r\\n\"\'");
jsonWriter.WriteValue(true);
jsonWriter.WriteValue(10);
jsonWriter.WriteValue(10.99);
jsonWriter.WriteValue(0.99);
jsonWriter.WriteValue(0.000000000000000001d);
jsonWriter.WriteValue(0.000000000000000001m);
jsonWriter.WriteValue(null);
jsonWriter.WriteValue("This is a string.");
jsonWriter.WriteNull();
jsonWriter.WriteUndefined();
jsonWriter.WriteEndArray();
}
const string expected = @"[""@"",""\r\n\t\f\b?{\\r\\n\""'"",true,10,10.99,0.99,1E-18,0.000000000000000001,,""This is a string."",null,undefined]";
string result = sb.ToString();
Console.WriteLine("ValueFormatting");
Console.WriteLine(result);
Assert.AreEqual(expected, result);
}
/// <summary>
/// Writes the JSON representation of the object.
/// </summary>
/// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
/// <param name="value">The value.</param>
/// <param name="serializer">The calling serializer.</param>
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
DataTable table = (DataTable)value;
DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver;
writer.WriteStartArray();
foreach (DataRow row in table.Rows)
{
writer.WriteStartObject();
foreach (DataColumn column in row.Table.Columns)
{
object columnValue = row[column];
if (serializer.NullValueHandling == NullValueHandling.Ignore && (columnValue == null || columnValue == DBNull.Value))
{
continue;
}
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(column.ColumnName) : column.ColumnName);
serializer.Serialize(writer, columnValue);
}
writer.WriteEndObject();
}
writer.WriteEndArray();
}
private void WriteJsonValue(JsonWriter writer, IJsonValue value)
{
switch (value.ValueType)
{
case JsonValueType.Array:
{
JsonArray a = value.GetArray();
writer.WriteStartArray();
for (int i = 0; i < a.Count; i++)
{
WriteJsonValue(writer, a[i]);
}
writer.WriteEndArray();
}
break;
case JsonValueType.Boolean:
{
writer.WriteValue(value.GetBoolean());
}
break;
case JsonValueType.Null:
{
writer.WriteNull();
}
break;
case JsonValueType.Number:
{
// JsonValue doesn't support integers
// serialize whole numbers without a decimal point
double d = value.GetNumber();
bool isInteger = (d % 1 == 0);
if (isInteger && d <= long.MaxValue && d >= long.MinValue)
writer.WriteValue(Convert.ToInt64(d));
else
writer.WriteValue(d);
}
break;
case JsonValueType.Object:
{
JsonObject o = value.GetObject();
writer.WriteStartObject();
foreach (KeyValuePair<string, IJsonValue> v in o)
{
writer.WritePropertyName(v.Key);
WriteJsonValue(writer, v.Value);
}
writer.WriteEndObject();
}
break;
case JsonValueType.String:
{
writer.WriteValue(value.GetString());
}
break;
default:
throw new ArgumentOutOfRangeException("ValueType");
}
}
protected override void ExportValue(ExportContext context, object value, JsonWriter writer)
{
if (context == null) throw new ArgumentNullException("context");
if (writer == null) throw new ArgumentNullException("writer");
writer.WriteStartArray();
_exporter(context, value, writer);
writer.WriteEndArray();
}
protected override void ExportValue(object value, JsonWriter writer)
{
IEnumerable items = (IEnumerable) value;
writer.WriteStartArray();
foreach (object item in items)
writer.WriteValue(item);
writer.WriteEndArray();
}
private void WriteJsonValue(JsonWriter writer, IJsonValue value)
{
switch (value.ValueType)
{
case JsonValueType.Array:
{
JsonArray a = value.GetArray();
writer.WriteStartArray();
for (int i = 0; i < a.Count; i++)
{
WriteJsonValue(writer, a[i]);
}
writer.WriteEndArray();
}
break;
case JsonValueType.Boolean:
{
writer.WriteValue(value.GetBoolean());
}
break;
case JsonValueType.Null:
{
writer.WriteNull();
}
break;
case JsonValueType.Number:
{
writer.WriteValue(value.GetNumber());
}
break;
case JsonValueType.Object:
{
JsonObject o = value.GetObject();
writer.WriteStartObject();
foreach (KeyValuePair<string, IJsonValue> v in o)
{
writer.WritePropertyName(v.Key);
WriteJsonValue(writer, v.Value);
}
writer.WriteEndObject();
}
break;
case JsonValueType.String:
{
writer.WriteValue(value.GetString());
}
break;
default:
throw new ArgumentOutOfRangeException("ValueType");
}
}
internal static void FormatView(DataView view, JsonWriter writer)
{
Debug.Assert(view != null);
Debug.Assert(writer != null);
writer.WriteStartObject();
writer.WriteMember("columns");
writer.WriteStartArray();
foreach (DataColumn column in view.Table.Columns)
writer.WriteValue(column.ColumnName);
writer.WriteEndArray();
writer.WriteMember("rows");
writer.WriteStartArray();
foreach (DataRowView row in view)
writer.WriteValue(row.Row.ItemArray);
writer.WriteEndArray();
writer.WriteEndObject();
}
protected override void ExportValue(ExportContext context, object value, JsonWriter writer)
{
Debug.Assert(context != null);
Debug.Assert(value != null);
Debug.Assert(writer != null);
IEnumerable items = (IEnumerable) value;
writer.WriteStartArray();
foreach (object item in items)
context.Export(item, writer);
writer.WriteEndArray();
}
internal static void ExportView(ExportContext context, DataView view, JsonWriter writer)
{
Debug.Assert(context != null);
Debug.Assert(view != null);
Debug.Assert(writer != null);
writer.WriteStartObject();
writer.WriteMember("columns");
writer.WriteStartArray();
foreach (DataColumn column in view.Table.Columns)
context.Export(column.ColumnName, writer);
writer.WriteEndArray();
writer.WriteMember("rows");
writer.WriteStartArray();
foreach (DataRowView row in view)
context.Export(row.Row.ItemArray, writer);
writer.WriteEndArray();
writer.WriteEndObject();
}
/// <summary>
/// Writes the JSON representation of the object.
/// </summary>
/// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
/// <param name="value">The value.</param>
/// <param name="serializer">The calling serializer.</param>
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
DataTable table = (DataTable)value;
writer.WriteStartArray();
foreach (DataRow row in table.Rows)
{
writer.WriteStartObject();
foreach (DataColumn column in row.Table.Columns)
{
writer.WritePropertyName(column.ColumnName);
serializer.Serialize(writer, row[column]);
}
writer.WriteEndObject();
}
writer.WriteEndArray();
}
/// <summary>
/// Writes the JSON representation of the object.
/// </summary>
/// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
/// <param name="value">The value.</param>
/// <param name="serializer">The calling serializer.</param>
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
DataTable table = (DataTable)value;
DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver;
writer.WriteStartArray();
foreach (DataRow row in table.Rows)
{
writer.WriteStartObject();
foreach (DataColumn column in row.Table.Columns)
{
writer.WritePropertyName((resolver != null) ? resolver.ResolvePropertyName(column.ColumnName) : column.ColumnName);
serializer.Serialize(writer, row[column]);
}
writer.WriteEndObject();
}
writer.WriteEndArray();
}
private void SerializeList(JsonWriter writer, IList values, JsonArrayContract contract)
{
contract.InvokeOnSerializing(values);
SerializeStack.Add(values);
bool isReference = contract.IsReference ?? HasFlag(_serializer.PreserveReferencesHandling, PreserveReferencesHandling.Arrays);
bool includeTypeDetails = HasFlag(_serializer.TypeNameHandling, TypeNameHandling.Arrays);
if (isReference || includeTypeDetails)
{
writer.WriteStartObject();
if (isReference)
{
writer.WritePropertyName(JsonTypeReflector.IdPropertyName);
writer.WriteValue(_serializer.ReferenceResolver.GetReference(values));
}
if (includeTypeDetails)
{
WriteTypeProperty(writer, values.GetType());
}
writer.WritePropertyName(JsonTypeReflector.ArrayValuesPropertyName);
}
writer.WriteStartArray();
for (int i = 0; i < values.Count; i++)
{
object value = values[i];
if (ShouldWriteReference(value, null))
{
WriteReference(writer, value);
}
else
{
if (!CheckForCircularReference(value, null))
continue;
SerializeValue(writer, value, null);
}
}
writer.WriteEndArray();
if (isReference)
{
writer.WriteEndObject();
}
SerializeStack.RemoveAt(SerializeStack.Count - 1);
contract.InvokeOnSerialized(values);
}
public void WriteReadWrite()
{
StringBuilder sb = new StringBuilder();
StringWriter sw = new StringWriter(sb);
using (JsonWriter jsonWriter = new JsonWriter(sw))
{
jsonWriter.WriteStartArray();
jsonWriter.WriteValue(true);
jsonWriter.WriteStartObject();
jsonWriter.WritePropertyName("integer");
jsonWriter.WriteValue(99);
jsonWriter.WritePropertyName("string");
jsonWriter.WriteValue("how now brown cow?");
jsonWriter.WritePropertyName("array");
jsonWriter.WriteStartArray();
for (int i = 0; i < 5; i++)
{
jsonWriter.WriteValue(i);
}
jsonWriter.WriteStartObject();
jsonWriter.WritePropertyName("decimal");
jsonWriter.WriteValue(990.00990099m);
jsonWriter.WriteEndObject();
jsonWriter.WriteValue(5);
jsonWriter.WriteEndArray();
jsonWriter.WriteEndObject();
jsonWriter.WriteValue("This is a string.");
jsonWriter.WriteNull();
jsonWriter.WriteNull();
jsonWriter.WriteEndArray();
}
string json = sb.ToString();
JsonSerializer serializer = new JsonSerializer();
object jsonObject = serializer.Deserialize(new JsonReader(new StringReader(json)));
sb = new StringBuilder();
sw = new StringWriter(sb);
using (JsonWriter jsonWriter = new JsonWriter(sw))
{
serializer.Serialize(sw, jsonObject);
}
Assert.AreEqual(json, sb.ToString());
}
//Metode til at skrive slutningen af JSON formattet
public void Finish()
{
writer.WriteEndArray();
writer.WriteEndObject();
writer.Close();
}
public void WriteSchema(JsonSchema schema)
{
ValidationUtils.ArgumentNotNull(schema, "schema");
if (!_resolver.LoadedSchemas.Contains(schema))
{
_resolver.LoadedSchemas.Add(schema);
}
_writer.WriteStartObject();
WritePropertyIfNotNull(_writer, JsonSchemaConstants.IdPropertyName, schema.Id);
WritePropertyIfNotNull(_writer, JsonSchemaConstants.TitlePropertyName, schema.Title);
WritePropertyIfNotNull(_writer, JsonSchemaConstants.DescriptionPropertyName, schema.Description);
WritePropertyIfNotNull(_writer, JsonSchemaConstants.OptionalPropertyName, schema.Optional);
WritePropertyIfNotNull(_writer, JsonSchemaConstants.ReadOnlyPropertyName, schema.ReadOnly);
WritePropertyIfNotNull(_writer, JsonSchemaConstants.HiddenPropertyName, schema.Hidden);
WritePropertyIfNotNull(_writer, JsonSchemaConstants.TransientPropertyName, schema.Transient);
if (schema.Type != null)
{
WriteType(JsonSchemaConstants.TypePropertyName, _writer, schema.Type.Value);
}
if (!schema.AllowAdditionalProperties)
{
_writer.WritePropertyName(JsonSchemaConstants.AdditionalPropertiesPropertyName);
_writer.WriteValue(schema.AllowAdditionalProperties);
}
else
{
if (schema.AdditionalProperties != null)
{
_writer.WritePropertyName(JsonSchemaConstants.AdditionalPropertiesPropertyName);
ReferenceOrWriteSchema(schema.AdditionalProperties);
}
}
if (schema.Properties != null)
{
_writer.WritePropertyName(JsonSchemaConstants.PropertiesPropertyName);
_writer.WriteStartObject();
foreach (KeyValuePair <string, JsonSchema> property in schema.Properties)
{
_writer.WritePropertyName(property.Key);
ReferenceOrWriteSchema(property.Value);
}
_writer.WriteEndObject();
}
WriteItems(schema);
WritePropertyIfNotNull(_writer, JsonSchemaConstants.MinimumPropertyName, schema.Minimum);
WritePropertyIfNotNull(_writer, JsonSchemaConstants.MaximumPropertyName, schema.Maximum);
WritePropertyIfNotNull(_writer, JsonSchemaConstants.MinimumLengthPropertyName, schema.MinimumLength);
WritePropertyIfNotNull(_writer, JsonSchemaConstants.MaximumLengthPropertyName, schema.MaximumLength);
WritePropertyIfNotNull(_writer, JsonSchemaConstants.MinimumItemsPropertyName, schema.MinimumItems);
WritePropertyIfNotNull(_writer, JsonSchemaConstants.MaximumItemsPropertyName, schema.MaximumItems);
WritePropertyIfNotNull(_writer, JsonSchemaConstants.MaximumDecimalsPropertyName, schema.MaximumDecimals);
WritePropertyIfNotNull(_writer, JsonSchemaConstants.FormatPropertyName, schema.Format);
WritePropertyIfNotNull(_writer, JsonSchemaConstants.PatternPropertyName, schema.Pattern);
if (schema.Enum != null)
{
_writer.WritePropertyName(JsonSchemaConstants.EnumPropertyName);
_writer.WriteStartArray();
foreach (JToken token in schema.Enum)
{
token.WriteTo(_writer);
}
_writer.WriteEndArray();
}
if (schema.Default != null)
{
_writer.WritePropertyName(JsonSchemaConstants.DefaultPropertyName);
schema.Default.WriteTo(_writer);
}
if (schema.Options != null)
{
_writer.WritePropertyName(JsonSchemaConstants.OptionsPropertyName);
_writer.WriteStartArray();
foreach (KeyValuePair <JToken, string> option in schema.Options)
{
_writer.WriteStartObject();
_writer.WritePropertyName(JsonSchemaConstants.OptionValuePropertyName);
option.Key.WriteTo(_writer);
if (option.Value != null)
{
_writer.WritePropertyName(JsonSchemaConstants.OptionLabelPropertyName);
_writer.WriteValue(option.Value);
}
_writer.WriteEndObject();
}
_writer.WriteEndArray();
}
if (schema.Disallow != null)
{
WriteType(JsonSchemaConstants.DisallowPropertyName, _writer, schema.Disallow.Value);
}
if (schema.Extends != null)
{
_writer.WritePropertyName(JsonSchemaConstants.ExtendsPropertyName);
ReferenceOrWriteSchema(schema.Extends);
}
_writer.WriteEndObject();
}
private void SerializeGroupedNodes(JsonWriter writer, XmlNode node)
{
// group nodes together by name
Dictionary<string, List<XmlNode>> nodesGroupedByName = new Dictionary<string, List<XmlNode>>();
for (int i = 0; i < node.ChildNodes.Count; i++)
{
XmlNode childNode = node.ChildNodes[i];
string nodeName = GetPropertyName(childNode);
List<XmlNode> nodes;
if (!nodesGroupedByName.TryGetValue(nodeName, out nodes))
{
nodes = new List<XmlNode>();
nodesGroupedByName.Add(nodeName, nodes);
}
nodes.Add(childNode);
}
// loop through grouped nodes. write single name instances as normal,
// write multiple names together in an array
foreach (KeyValuePair<string, List<XmlNode>> nodeNameGroup in nodesGroupedByName)
{
List<XmlNode> groupedNodes = nodeNameGroup.Value;
bool writeArray;
if (groupedNodes.Count == 1)
{
XmlNode singleNode = groupedNodes[0];
XmlAttribute jsonArrayAttribute = (singleNode.Attributes != null) ? singleNode.Attributes["Array", JsonNamespaceUri] : null;
if (jsonArrayAttribute != null)
writeArray = XmlConvert.ToBoolean(jsonArrayAttribute.Value);
else
writeArray = false;
}
else
{
writeArray = true;
}
if (!writeArray)
{
SerializeNode(writer, groupedNodes[0], true);
}
else
{
string elementNames = nodeNameGroup.Key;
writer.WritePropertyName(nodeNameGroup.Key);
writer.WriteStartArray();
for (int i = 0; i < groupedNodes.Count; i++)
{
SerializeNode(writer, groupedNodes[i], false);
}
writer.WriteEndArray();
}
}
}
/// <summary>
/// Write the JSON string. This will convert all the properties to a JSON string.
/// This is done manaully to improve conversion time. The default serializer will check
/// each property if it can convert. This will convert the properties automatically. This
/// will double the speed.
///
/// Newtonsoft.Json.JsonConvert.SerializeObject(ensemble.NmeaData).
///
/// </summary>
/// <param name="writer">JSON Writer.</param>
/// <param name="value">Object to write to JSON.</param>
/// <param name="serializer">Serializer to convert the object.</param>
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
// Cast the object
var data = value as NmeaDataSet;
// Start the object
writer.Formatting = Formatting.None; // Make the text not indented, so not as human readable. This will save disk space
writer.WriteStartObject(); // Start the JSON object
// Write the base values
writer.WriteRaw(data.ToJsonBaseStub());
writer.WriteRaw(",");
// Write the NMEA strings
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_NMEASTRINGS);
if (data.NmeaStrings != null)
{
writer.WriteStartArray();
for (int x = 0; x < data.NmeaStrings.Count; x++)
{
writer.WriteValue(data.NmeaStrings[x]);
}
writer.WriteEndArray();
}
else
{
writer.WriteNull();
}
// End the object
writer.WriteEndObject();
}
private void SerializeCities(JsonWriter jw)
{
jw.WritePropertyName("cities");
jw.WriteStartArray();
foreach (var city in cityManager.AllCities().Where(c => c.Deleted == City.DeletedState.NotDeleted))
{
jw.WriteStartObject();
jw.WritePropertyName("id");
jw.WriteValue(city.Id);
jw.WritePropertyName("player_id");
var owner = city.Owner;
jw.WriteValue(owner == null ? null : (uint?)owner.PlayerId);
jw.WritePropertyName("name");
jw.WriteValue(city.Name);
jw.WritePropertyName("x");
jw.WriteValue(city.PrimaryPosition.X);
jw.WritePropertyName("y");
jw.WriteValue(city.PrimaryPosition.Y);
jw.WritePropertyName("value");
jw.WriteValue(city.Value);
jw.WritePropertyName("radius");
jw.WriteValue(city.Radius);
jw.WritePropertyName("loot_stolen");
jw.WriteValue(city.LootStolen);
jw.WritePropertyName("attack_points");
jw.WriteValue(city.AttackPoint);
jw.WritePropertyName("defense_point");
jw.WriteValue(city.DefensePoint);
jw.WritePropertyName("expense_value");
jw.WriteValue(city.ExpenseValue);
jw.WritePropertyName("troops");
jw.WriteStartArray();
foreach (var troop in city.TroopObjects.Where(x => x.InWorld))
{
jw.WriteStartObject();
jw.WritePropertyName("x");
jw.WriteValue(troop.PrimaryPosition.X);
jw.WritePropertyName("y");
jw.WriteValue(troop.PrimaryPosition.Y);
jw.WritePropertyName("state");
var stub = troop.Stub;
jw.WriteValue(stub != null ? stub.State.ToString() : TroopState.Idle.ToString());
jw.WriteEndObject();
}
jw.WriteEndArray();
jw.WriteEndObject();
}
jw.WriteEndArray();
}
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 WriteEndArray()
{
_textWriter.WriteEndArray();
_innerWriter.WriteEndArray();
base.WriteEndArray();
}
private void SerializeList(JsonWriter writer, IWrappedCollection values, JsonArrayContract contract, JsonProperty member, JsonContract collectionValueContract)
{
contract.InvokeOnSerializing(values.UnderlyingCollection, Serializer.Context);
SerializeStack.Add(values.UnderlyingCollection);
bool isReference = contract.IsReference ?? HasFlag(Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Arrays);
bool includeTypeDetails = ShouldWriteType(TypeNameHandling.Arrays, contract, member, collectionValueContract);
if (isReference || includeTypeDetails)
{
writer.WriteStartObject();
if (isReference)
{
writer.WritePropertyName(JsonTypeReflector.IdPropertyName);
writer.WriteValue(Serializer.ReferenceResolver.GetReference(this, values.UnderlyingCollection));
}
if (includeTypeDetails)
{
WriteTypeProperty(writer, values.UnderlyingCollection.GetType());
}
writer.WritePropertyName(JsonTypeReflector.ArrayValuesPropertyName);
}
JsonContract childValuesContract = Serializer.ContractResolver.ResolveContract(contract.CollectionItemType ?? typeof(object));
writer.WriteStartArray();
int initialDepth = writer.Top;
int index = 0;
// note that an error in the IEnumerable won't be caught
#if !(UNITY_IPHONE || UNITY_IOS || UNITY_WEBGL || UNITY_XBOXONE || UNITY_XBOX360 || UNITY_PS4 || UNITY_PS3 || UNITY_WII) || (UNITY_IOS || UNITY_WEBGL || UNITY_XBOXONE || UNITY_XBOX360 || UNITY_PS4 || UNITY_PS3 || UNITY_WII && !(UNITY_3_5 || UNITY_4_0_1 || UNITY_4_1 || UNITY_4_2 || UNITY_4_3))
foreach (object value in values)
{
try
{
JsonContract valueContract = GetContractSafe(value);
if (ShouldWriteReference(value, null, valueContract))
{
WriteReference(writer, value);
}
else
{
if (CheckForCircularReference(value, null, contract))
{
SerializeValue(writer, value, valueContract, null, childValuesContract);
}
}
}
catch (Exception ex)
{
if (IsErrorHandled(values.UnderlyingCollection, contract, index, ex))
{
HandleError(writer, initialDepth);
}
else
{
throw;
}
}
finally
{
index++;
}
}
#else
values.ForEach(value =>
{
try
{
JsonContract valueContract = GetContractSafe(value);
if (ShouldWriteReference(value, null, valueContract))
{
WriteReference(writer, value);
}
else
{
if (CheckForCircularReference(value, null, contract))
{
SerializeValue(writer, value, valueContract, null, childValuesContract);
}
}
}
catch (Exception ex)
{
if (IsErrorHandled(values.UnderlyingCollection, contract, index, ex))
{
HandleError(writer, initialDepth);
}
else
{
throw;
}
}
finally
{
index++;
}
});
#endif
writer.WriteEndArray();
if (isReference || includeTypeDetails)
{
writer.WriteEndObject();
}
SerializeStack.RemoveAt(SerializeStack.Count - 1);
contract.InvokeOnSerialized(values.UnderlyingCollection, Serializer.Context);
}
public new void AsJson(JsonWriter writer, string baseUrl)
{
writer.WriteStartObject();
base.AsJson(writer, baseUrl);
writer.WritePropertyName("username");
writer.WriteValue(Username);
if (UserIds != null && UserIds.Length > 0)
{
writer.WritePropertyName("userIds");
writer.WriteStartArray();
foreach (var userId in UserIds)
{
userId.AsJson(writer, baseUrl);
}
writer.WriteEndArray();
}
writer.WritePropertyName("enabledUser");
writer.WriteValue(EnabledUser.ToString());
writer.WritePropertyName("givenName");
writer.WriteValue(GivenName);
writer.WritePropertyName("familyName");
writer.WriteValue(FamilyName);
if (!String.IsNullOrEmpty(MiddleName))
{
writer.WritePropertyName("middleName");
writer.WriteValue(MiddleName);
}
writer.WritePropertyName("role");
writer.WriteValue(Enum.GetName(typeof(Vocabulary.RoleType), Role));
if (!String.IsNullOrEmpty(Identifier))
{
writer.WritePropertyName("identifier");
writer.WriteValue(Identifier);
}
if (!String.IsNullOrEmpty(Email))
{
writer.WritePropertyName("email");
writer.WriteValue(Email);
}
if (!String.IsNullOrEmpty(SMS))
{
writer.WritePropertyName("sms");
writer.WriteValue(SMS);
}
if (!String.IsNullOrEmpty(Phone))
{
writer.WritePropertyName("phone");
writer.WriteValue(Phone);
}
if (UserAgents != null && UserAgents.Count > 0)
{
writer.WritePropertyName("agents");
writer.WriteStartArray();
UserAgents.ForEach(ua => ua.Agent.AsJsonReference(writer, baseUrl));
writer.WriteEndArray();
}
if (UserOrgs != null)
{
writer.WritePropertyName("orgs");
writer.WriteStartArray();
UserOrgs.ForEach(uo => uo.Org.AsJsonReference(writer, baseUrl));
writer.WriteEndArray();
}
if (Grades != null && Grades.Length > 0)
{
writer.WritePropertyName("grades");
writer.WriteStartArray();
foreach (var grade in Grades)
{
writer.WriteValue(grade);
}
writer.WriteEndArray();
}
if (!String.IsNullOrEmpty(Pass))
{
writer.WritePropertyName("password");
writer.WriteValue(Pass);
}
writer.WriteEndObject();
writer.Flush();
}
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");
}
}
private void WriteSchemaInternal(JSchema schema)
{
_writer.WriteStartObject();
WritePropertyIfNotNull(_writer, Constants.PropertyNames.Id, schema.Id);
WritePropertyIfNotNull(_writer, Constants.PropertyNames.Title, schema.Title);
WritePropertyIfNotNull(_writer, Constants.PropertyNames.Description, schema.Description);
if (schema._extensionData != null)
{
foreach (KeyValuePair <string, JToken> extensionDataPair in schema._extensionData)
{
_writer.WritePropertyName(extensionDataPair.Key);
WriteToken(schema, _writer, extensionDataPair.Value);
}
}
if (schema.Type != null)
{
WriteType(Constants.PropertyNames.Type, _writer, schema.Type.Value);
}
if (schema.Default != null)
{
_writer.WritePropertyName(Constants.PropertyNames.Default);
schema.Default.WriteTo(_writer);
}
if (!schema.AllowAdditionalProperties)
{
_writer.WritePropertyName(Constants.PropertyNames.AdditionalProperties);
_writer.WriteValue(schema.AllowAdditionalProperties);
}
else
{
if (schema.AdditionalProperties != null)
{
ReferenceOrWriteSchema(schema, schema.AdditionalProperties, Constants.PropertyNames.AdditionalProperties);
}
}
if (!schema.AllowAdditionalItems)
{
_writer.WritePropertyName(Constants.PropertyNames.AdditionalItems);
_writer.WriteValue(schema.AllowAdditionalItems);
}
else
{
if (schema.AdditionalItems != null)
{
ReferenceOrWriteSchema(schema, schema.AdditionalItems, Constants.PropertyNames.AdditionalItems);
}
}
WriteSchemaDictionaryIfNotNull(schema, _writer, Constants.PropertyNames.Properties, schema._properties);
WriteRequired(schema);
WriteSchemaDictionaryIfNotNull(schema, _writer, Constants.PropertyNames.PatternProperties, schema._patternProperties);
WriteItems(schema);
WritePropertyIfNotDefault(_writer, Constants.PropertyNames.UniqueItems, schema.UniqueItems);
WritePropertyIfNotNull(_writer, Constants.PropertyNames.Minimum, schema.Minimum);
WritePropertyIfNotNull(_writer, Constants.PropertyNames.Maximum, schema.Maximum);
WritePropertyIfNotDefault(_writer, Constants.PropertyNames.ExclusiveMinimum, schema.ExclusiveMinimum);
WritePropertyIfNotDefault(_writer, Constants.PropertyNames.ExclusiveMaximum, schema.ExclusiveMaximum);
WritePropertyIfNotNull(_writer, Constants.PropertyNames.MinimumLength, schema.MinimumLength);
WritePropertyIfNotNull(_writer, Constants.PropertyNames.MaximumLength, schema.MaximumLength);
WritePropertyIfNotNull(_writer, Constants.PropertyNames.MinimumItems, schema.MinimumItems);
WritePropertyIfNotNull(_writer, Constants.PropertyNames.MaximumItems, schema.MaximumItems);
WritePropertyIfNotNull(_writer, Constants.PropertyNames.MinimumProperties, schema.MinimumProperties);
WritePropertyIfNotNull(_writer, Constants.PropertyNames.MaximumProperties, schema.MaximumProperties);
WritePropertyIfNotNull(_writer, Constants.PropertyNames.MultipleOf, schema.MultipleOf);
WritePropertyIfNotNull(_writer, Constants.PropertyNames.Pattern, schema.Pattern);
WritePropertyIfNotNull(_writer, Constants.PropertyNames.Format, schema.Format);
if (schema._enum != null && schema._enum.Count > 0)
{
_writer.WritePropertyName(Constants.PropertyNames.Enum);
_writer.WriteStartArray();
foreach (JToken token in schema._enum)
{
token.WriteTo(_writer);
}
_writer.WriteEndArray();
}
WriteSchemas(schema, schema._allOf, Constants.PropertyNames.AllOf);
WriteSchemas(schema, schema._anyOf, Constants.PropertyNames.AnyOf);
WriteSchemas(schema, schema._oneOf, Constants.PropertyNames.OneOf);
WriteSchema(schema, schema.Not, Constants.PropertyNames.Not);
_writer.WriteEndObject();
}
private void SerializeList(JsonWriter writer, IList values, JsonArrayContract contract)
{
contract.InvokeOnSerializing(values);
SerializeStack.Add(values);
bool isReference = contract.IsReference ?? HasFlag(Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Arrays);
bool includeTypeDetails = HasFlag(Serializer.TypeNameHandling, TypeNameHandling.Arrays);
if (isReference || includeTypeDetails)
{
writer.WriteStartObject();
if (isReference)
{
writer.WritePropertyName(JsonTypeReflector.IdPropertyName);
writer.WriteValue(Serializer.ReferenceResolver.GetReference(values));
}
if (includeTypeDetails)
{
WriteTypeProperty(writer, values.GetType());
}
writer.WritePropertyName(JsonTypeReflector.ArrayValuesPropertyName);
}
writer.WriteStartArray();
int initialDepth = writer.Top;
for (int i = 0; i < values.Count; i++)
{
try
{
object value = values[i];
if (ShouldWriteReference(value, null))
{
WriteReference(writer, value);
}
else
{
if (!CheckForCircularReference(value, null))
{
continue;
}
SerializeValue(writer, value, null);
}
}
catch (Exception ex)
{
if (IsErrorHandled(values, contract, i, ex))
{
HandleError(writer, initialDepth);
}
else
{
throw;
}
}
}
writer.WriteEndArray();
if (isReference)
{
writer.WriteEndObject();
}
SerializeStack.RemoveAt(SerializeStack.Count - 1);
contract.InvokeOnSerialized(values);
}
private void WriteToken(JSchema context, JsonWriter writer, JToken token, bool isDefinitions = false)
{
if (token is JObject o)
{
JSchemaAnnotation?schemaAnnotation = o.Annotation <JSchemaAnnotation>();
JSchema? tokenSchema = schemaAnnotation?.GetSchema(null);
if (tokenSchema != null)
{
ReferenceOrWriteSchema(context, tokenSchema, null, isDefinitions);
}
else
{
writer.WriteStartObject();
foreach (JProperty property in o.Properties())
{
writer.WritePropertyName(property.Name);
JToken value = property.Value;
if (value != null)
{
WriteToken(context, writer, value, isDefinitions);
}
else
{
writer.WriteNull();
}
}
writer.WriteEndObject();
}
}
else if (token is JArray)
{
JArray a = (JArray)token;
writer.WriteStartArray();
for (int i = 0; i < a.Count; i++)
{
WriteToken(context, writer, a[i]);
}
writer.WriteEndArray();
}
else if (token is JConstructor)
{
JConstructor c = (JConstructor)token;
writer.WriteStartConstructor(c.Name !);
foreach (JToken t in c.Children())
{
WriteToken(context, writer, t);
}
writer.WriteEndConstructor();
}
else if (token is JValue)
{
token.WriteTo(writer);
}
else
{
writer.WriteNull();
}
}
private void SerializeList(JsonWriter writer, IList values, JsonArrayContract contract, JsonProperty member, JsonContract collectionValueContract)
{
contract.InvokeOnSerializing(values, Serializer.Context);
SerializeStack.Add(values);
bool isReference = contract.IsReference ?? HasFlag(Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Arrays);
bool includeTypeDetails = ShouldWriteType(TypeNameHandling.Arrays, contract, member, collectionValueContract);
if (isReference || includeTypeDetails)
{
writer.WriteStartObject();
if (isReference)
{
writer.WritePropertyName(JsonTypeReflector.IdPropertyName);
writer.WriteValue(Serializer.ReferenceResolver.GetReference(values));
}
if (includeTypeDetails)
{
WriteTypeProperty(writer, values.GetType());
}
writer.WritePropertyName(JsonTypeReflector.ArrayValuesPropertyName);
}
JsonContract childValuesContract = Serializer.ContractResolver.ResolveContract(contract.CollectionItemType ?? typeof(object));
writer.WriteStartArray();
int initialDepth = writer.Top;
for (int i = 0; i < values.Count; i++)
{
try
{
object value = values[i];
JsonContract valueContract = GetContractSafe(value);
if (ShouldWriteReference(value, null, valueContract))
{
WriteReference(writer, value);
}
else
{
if (!CheckForCircularReference(value, null, contract))
continue;
SerializeValue(writer, value, valueContract, null, childValuesContract);
}
}
catch (Exception ex)
{
if (IsErrorHandled(values, contract, i, ex))
HandleError(writer, initialDepth);
else
throw;
}
}
writer.WriteEndArray();
if (isReference || includeTypeDetails)
{
writer.WriteEndObject();
}
SerializeStack.RemoveAt(SerializeStack.Count - 1);
contract.InvokeOnSerialized(values, Serializer.Context);
}
private void WriteSchemaObjectInternal(JSchema schema)
{
_writer.WriteStartObject();
if (schema == _rootSchema)
{
Uri?resolvedVersionUri = (_version != SchemaVersion.Unset)
? SchemaVersionHelpers.MapSchemaVersion(_version)
: schema.SchemaVersion;
WritePropertyIfNotNull(_writer, Constants.PropertyNames.Schema, resolvedVersionUri);
}
if (EnsureVersion(SchemaVersion.Draft6))
{
WritePropertyIfNotNull(_writer, Constants.PropertyNames.Id, schema.Id);
}
else
{
WritePropertyIfNotNull(_writer, Constants.PropertyNames.IdDraft4, schema.Id);
}
WritePropertyIfNotNull(_writer, Constants.PropertyNames.Anchor, schema.Anchor);
WritePropertyIfNotNull(_writer, Constants.PropertyNames.RecursiveAnchor, schema.RecursiveAnchor);
WritePropertyIfNotNull(_writer, Constants.PropertyNames.RecursiveRef, schema.RecursiveReference);
WritePropertyIfNotNull(_writer, Constants.PropertyNames.Title, schema.Title);
WritePropertyIfNotNull(_writer, Constants.PropertyNames.Description, schema.Description);
if (schema._extensionData != null)
{
foreach (KeyValuePair <string, JToken> extensionDataPair in schema._extensionData)
{
bool isDefinitions = schema == _rootSchema && Constants.PropertyNames.IsDefinition(extensionDataPair.Key);
_writer.WritePropertyName(extensionDataPair.Key);
WriteToken(schema, _writer, extensionDataPair.Value, isDefinitions);
}
}
if (schema.Type != null && schema.Type != JSchemaType.None)
{
WriteType(Constants.PropertyNames.Type, _writer, schema.Type.Value);
}
if (schema.Default != null)
{
_writer.WritePropertyName(Constants.PropertyNames.Default);
schema.Default.WriteTo(_writer);
}
if (schema._allowAdditionalProperties != null)
{
_writer.WritePropertyName(Constants.PropertyNames.AdditionalProperties);
_writer.WriteValue(schema._allowAdditionalProperties);
}
else if (schema.AdditionalProperties != null)
{
ReferenceOrWriteSchema(schema, schema.AdditionalProperties, Constants.PropertyNames.AdditionalProperties);
}
if (schema._allowAdditionalItems != null)
{
_writer.WritePropertyName(Constants.PropertyNames.AdditionalItems);
_writer.WriteValue(schema._allowAdditionalItems);
}
else if (schema.AdditionalItems != null)
{
ReferenceOrWriteSchema(schema, schema.AdditionalItems, Constants.PropertyNames.AdditionalItems);
}
if (schema.AllowUnevaluatedProperties != null)
{
_writer.WritePropertyName(Constants.PropertyNames.UnevaluatedProperties);
_writer.WriteValue(schema.AllowUnevaluatedProperties);
}
else if (schema.UnevaluatedProperties != null)
{
ReferenceOrWriteSchema(schema, schema.UnevaluatedProperties, Constants.PropertyNames.UnevaluatedProperties);
}
if (schema.AllowUnevaluatedItems != null)
{
_writer.WritePropertyName(Constants.PropertyNames.UnevaluatedItems);
_writer.WriteValue(schema.AllowUnevaluatedItems);
}
else if (schema.UnevaluatedItems != null)
{
ReferenceOrWriteSchema(schema, schema.UnevaluatedItems, Constants.PropertyNames.UnevaluatedItems);
}
WriteSchemaDictionaryIfNotNull(schema, _writer, Constants.PropertyNames.Properties, schema._properties);
WriteRequired(schema);
WriteSchemaDictionaryIfNotNull(schema, _writer, Constants.PropertyNames.PatternProperties, schema._patternProperties);
WriteItems(schema);
WritePropertyIfNotDefault(_writer, Constants.PropertyNames.UniqueItems, schema.UniqueItems);
if (EnsureVersion(SchemaVersion.Draft6))
{
WritePropertyIfNotNull(_writer, schema.ExclusiveMinimum ? Constants.PropertyNames.ExclusiveMinimum : Constants.PropertyNames.Minimum, schema.Minimum);
WritePropertyIfNotNull(_writer, schema.ExclusiveMaximum ? Constants.PropertyNames.ExclusiveMaximum : Constants.PropertyNames.Maximum, schema.Maximum);
}
else
{
WritePropertyIfNotNull(_writer, Constants.PropertyNames.Minimum, schema.Minimum);
WritePropertyIfNotNull(_writer, Constants.PropertyNames.Maximum, schema.Maximum);
WritePropertyIfNotDefault(_writer, Constants.PropertyNames.ExclusiveMinimum, schema.ExclusiveMinimum);
WritePropertyIfNotDefault(_writer, Constants.PropertyNames.ExclusiveMaximum, schema.ExclusiveMaximum);
}
WritePropertyIfNotNull(_writer, Constants.PropertyNames.MinimumLength, schema.MinimumLength);
WritePropertyIfNotNull(_writer, Constants.PropertyNames.MaximumLength, schema.MaximumLength);
WritePropertyIfNotNull(_writer, Constants.PropertyNames.MinimumItems, schema.MinimumItems);
WritePropertyIfNotNull(_writer, Constants.PropertyNames.MaximumItems, schema.MaximumItems);
WritePropertyIfNotNull(_writer, Constants.PropertyNames.MinimumProperties, schema.MinimumProperties);
WritePropertyIfNotNull(_writer, Constants.PropertyNames.MaximumProperties, schema.MaximumProperties);
WritePropertyIfNotNull(_writer, Constants.PropertyNames.MinimumContains, schema.MinimumContains);
WritePropertyIfNotNull(_writer, Constants.PropertyNames.MaximumContains, schema.MaximumContains);
WritePropertyIfNotNull(_writer, Constants.PropertyNames.MultipleOf, schema.MultipleOf);
WritePropertyIfNotNull(_writer, Constants.PropertyNames.Pattern, schema.Pattern);
WritePropertyIfNotNull(_writer, Constants.PropertyNames.Format, schema.Format);
if (EnsureVersion(SchemaVersion.Draft7))
{
WritePropertyIfNotNull(_writer, Constants.PropertyNames.ContentEncoding, schema.ContentEncoding);
WritePropertyIfNotNull(_writer, Constants.PropertyNames.ContentMediaType, schema.ContentMediaType);
WritePropertyIfNotNull(_writer, Constants.PropertyNames.WriteOnly, schema.WriteOnly);
WritePropertyIfNotNull(_writer, Constants.PropertyNames.ReadOnly, schema.ReadOnly);
}
if (!schema._enum.IsNullOrEmpty())
{
_writer.WritePropertyName(Constants.PropertyNames.Enum);
_writer.WriteStartArray();
foreach (JToken token in schema._enum)
{
token.WriteTo(_writer);
}
_writer.WriteEndArray();
}
if (EnsureVersion(SchemaVersion.Draft6))
{
if (schema.Const != null)
{
_writer.WritePropertyName(Constants.PropertyNames.Const);
schema.Const.WriteTo(_writer);
}
WriteSchema(schema, schema.PropertyNames, Constants.PropertyNames.PropertyNamesSchema);
WriteSchema(schema, schema.Contains, Constants.PropertyNames.Contains);
}
WriteSchemas(schema, schema._allOf, Constants.PropertyNames.AllOf);
WriteSchemas(schema, schema._anyOf, Constants.PropertyNames.AnyOf);
WriteSchemas(schema, schema._oneOf, Constants.PropertyNames.OneOf);
WriteSchema(schema, schema.Not, Constants.PropertyNames.Not);
if (EnsureVersion(SchemaVersion.Draft7))
{
WriteSchema(schema, schema.If, Constants.PropertyNames.If);
WriteSchema(schema, schema.Then, Constants.PropertyNames.Then);
WriteSchema(schema, schema.Else, Constants.PropertyNames.Else);
}
WriteSchemaDictionaryIfNotNull(schema, _writer, Constants.PropertyNames.DependentSchemas, schema._dependentSchemas);
if (!schema._dependentRequired.IsNullOrEmpty())
{
_writer.WritePropertyName(Constants.PropertyNames.DependentRequired);
_writer.WriteStartObject();
foreach (KeyValuePair <string, IList <string> > dependentRequired in schema._dependentRequired)
{
_writer.WritePropertyName(dependentRequired.Key);
_writer.WriteStartArray();
for (int i = 0; i < dependentRequired.Value.Count; i++)
{
_writer.WriteValue(dependentRequired.Value[i]);
}
_writer.WriteEndArray();
}
_writer.WriteEndObject();
}
if (!schema._dependencies.IsNullOrEmpty())
{
_writer.WritePropertyName(Constants.PropertyNames.Dependencies);
_writer.WriteStartObject();
foreach (KeyValuePair <string, object> dependency in schema._dependencies)
{
if (dependency.Value is JSchema s)
{
ReferenceOrWriteSchema(schema, s, dependency.Key);
}
else if (dependency.Value is IList <string> a)
{
_writer.WritePropertyName(dependency.Key);
_writer.WriteStartArray();
for (int i = 0; i < a.Count; i++)
{
_writer.WriteValue(a[i]);
}
_writer.WriteEndArray();
}
}
_writer.WriteEndObject();
}
if (schema.Ref != null)
{
WriteReference(schema, schema.Ref, Constants.PropertyNames.Ref);
}
_writer.WriteEndObject();
}
/// <exclude/>
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
writer.WriteStartArray();
if (value == null)
{
writer.WriteEndArray();
return;
}
List <BasePost> basePosts = (List <BasePost>)value;
if (basePosts.Count > 0)
{
foreach (var basePost in basePosts)
{
JObject jo;
switch (basePost)
{
case TextPost sp:
jo = JObject.FromObject(sp);
break;
case QuotePost sp:
jo = JObject.FromObject(sp);
break;
case PhotoPost sp:
jo = JObject.FromObject(sp);
break;
case LinkPost sp:
jo = JObject.FromObject(sp);
break;
case AnswerPost sp:
jo = JObject.FromObject(sp);
break;
case AudioPost sp:
jo = JObject.FromObject(sp);
break;
case ChatPost sp:
jo = JObject.FromObject(sp);
break;
case VideoPost sp:
jo = JObject.FromObject(sp);
break;
default:
jo = JObject.FromObject(basePost);
break;
}
jo.WriteTo(writer);
}
}
writer.WriteEndArray();
}
public void Serialize(JsonWriter writer)
{
writer.WritePropertyName(Title);
writer.WriteStartObject();
if (TypeFormat.Type == ParameterType.Object)
{
writer.WritePropertyName("$ref");
writer.WriteValue(string.Format("#/definitions/{0}", Ref));
}
else
{
if (!string.IsNullOrWhiteSpace(Description))
{
writer.WritePropertyName("description");
writer.WriteValue(Description);
}
if (TypeFormat.Type != ParameterType.Unknown)
{
writer.WritePropertyName("type");
writer.WriteValue(TypeFormat.Type.ToString().ToLower());
if (!string.IsNullOrWhiteSpace(TypeFormat.Format))
{
writer.WritePropertyName("format");
writer.WriteValue(TypeFormat.Format);
}
}
if (TypeFormat.Type == ParameterType.Array && Items != null)
{
writer.WritePropertyName("items");
Items.Serialize(writer);
}
if (!string.IsNullOrWhiteSpace(Default))
{
writer.WritePropertyName("default");
writer.WriteValue(Default);
}
if (Example != null)
{
writer.WritePropertyName("example");
if (Example.GetType().IsArray)
{
writer.WriteStartArray();
foreach (var value in (object[])Example)
{
writer.WriteValue(value);
}
writer.WriteEndArray();
}
else if (Example.GetType() == typeof(string) &&
((string)Example).StartsWith("{") &&
((string)Example).EndsWith("}"))
{
//Write Raw Value for Json example
writer.WriteRawValue((string)Example);
}
else
{
writer.WriteValue(Example);
}
}
if (Maximum != decimal.MaxValue)
{
writer.WritePropertyName("maximum");
writer.WriteValue(Maximum);
writer.WritePropertyName("exclusiveMaximum");
writer.WriteValue(ExclusiveMaximum);
}
if (Minimum != decimal.MinValue)
{
writer.WritePropertyName("minimum");
writer.WriteValue(Minimum);
writer.WritePropertyName("exclusiveMinimum");
writer.WriteValue(ExclusiveMinimum);
}
if (MaxLength != int.MaxValue)
{
writer.WritePropertyName("maxLength");
writer.WriteValue(MaxLength);
}
if (MinLength != int.MinValue)
{
writer.WritePropertyName("minLength");
writer.WriteValue(MinLength);
}
if (!string.IsNullOrWhiteSpace(Pattern))
{
writer.WritePropertyName("pattern");
writer.WriteValue(Pattern);
}
if (MaxItems != int.MaxValue)
{
writer.WritePropertyName("maxItems");
writer.WriteValue(MaxItems);
}
if (MinItems != int.MinValue)
{
writer.WritePropertyName("minItems");
writer.WriteValue(MinItems);
}
writer.WritePropertyName("uniqueItems");
writer.WriteValue(UniqueItems);
if (Enum != null && Enum.Any())
{
writer.WritePropertyName("enum");
writer.WriteStartArray();
foreach (int e in Enum)
{
writer.WriteValue(e);
}
writer.WriteEndArray();
}
if (MultipleOf != decimal.MinValue)
{
writer.WritePropertyName("multipleOf");
writer.WriteValue(MultipleOf);
}
}
writer.WriteEndObject();
}
public void WriteJson(JsonWriter writer)
{
writer.WriteStartObject();
writer.WritePropertyName(nameof(Header));
Header.WriteJson(writer);
writer.WritePropertyName(nameof(ExtendedHeader));
ExtendedHeader.WriteJson(writer);
writer.WritePropertyName(nameof(UserDataEntries));
writer.WriteStartArray();
for (int i = 0; i < UserDataEntries.Length; ++i)
{
UserDataEntries[i].WriteJson(writer);
}
writer.WriteEndArray();
writer.WritePropertyName(nameof(particleData));
writer.WriteStartArray();
for (int i = 0; i < particleData.Length; ++i)
{
writer.WriteRawValue(particleData[i].ToRoundTripString());
}
writer.WriteEndArray();
writer.WritePropertyName(nameof(NonUniformKeys));
writer.WriteStartArray();
for (int i = 0; i < NonUniformKeys.Count; ++i)
{
writer.WriteRawValue(NonUniformKeys[i].ToRoundTripString());
}
writer.WriteEndArray();
writer.WritePropertyName(nameof(Attachpoints));
writer.WriteStartArray();
foreach (BrgAttachpoint attachpoint in Attachpoints)
{
attachpoint.WriteJson(writer);
}
writer.WriteEndArray();
writer.WritePropertyName(nameof(Vertices));
writer.WriteStartArray();
for (int i = 0; i < Vertices.Count; ++i)
{
Vertices[i].WriteJson(writer);
}
writer.WriteEndArray();
writer.WritePropertyName(nameof(Normals));
writer.WriteStartArray();
for (int i = 0; i < Normals.Count; ++i)
{
Normals[i].WriteJson(writer);
}
writer.WriteEndArray();
writer.WritePropertyName(nameof(TextureCoordinates));
writer.WriteStartArray();
for (int i = 0; i < TextureCoordinates.Count; ++i)
{
TextureCoordinates[i].WriteJson(writer);
}
writer.WriteEndArray();
writer.WritePropertyName(nameof(Colors));
writer.WriteStartArray();
for (int i = 0; i < Colors.Count; ++i)
{
Colors[i].WriteJson(writer);
}
writer.WriteEndArray();
writer.WritePropertyName(nameof(Faces));
writer.WriteStartArray();
for (int i = 0; i < Faces.Count; ++i)
{
writer.WriteStartArray();
writer.WriteValue(Faces[i].Indices[0]);
writer.WriteValue(Faces[i].Indices[1]);
writer.WriteValue(Faces[i].Indices[2]);
writer.WriteEndArray();
}
writer.WriteEndArray();
writer.WritePropertyName("FaceMaterials");
writer.WriteStartArray();
for (int i = 0; i < Faces.Count; ++i)
{
writer.WriteValue(Faces[i].MaterialIndex);
}
writer.WriteEndArray();
writer.WritePropertyName(nameof(MeshAnimations));
writer.WriteStartArray();
for (int i = 0; i < MeshAnimations.Count; ++i)
{
((BrgMesh)MeshAnimations[i]).WriteJson(writer);
}
writer.WriteEndArray();
writer.WriteEndObject();
}
private static void GenerateItem(SmallBOD bod, RewardCalculator calc, JsonWriter writer)
{
var items = bod.ComputeRewards(true);
writer.WriteStartObject();
writer.WritePropertyName("points");
writer.WriteValue(calc.ComputePoints(bod).ToString());
writer.WritePropertyName("material");
if (bod.Material == BulkMaterialType.None)
{
writer.WriteValue("Iron");
}
else
{
writer.WriteValue(bod.Material.ToString());
}
writer.WritePropertyName("materialindex");
writer.WriteValue((int)bod.Material + "");
writer.WritePropertyName("qty");
writer.WriteValue(bod.AmountMax.ToString());
writer.WritePropertyName("bodtype");
if (bod.Type.IsSubclassOf(typeof(BaseArmor)))
{
writer.WriteValue("Armor");
}
if (bod.Type.IsSubclassOf(typeof(BaseWeapon)))
{
writer.WriteValue("Weapon");
}
writer.WritePropertyName("excep");
writer.WriteValue(bod.RequireExceptional);
writer.WritePropertyName("rewards");
writer.WriteStartArray();
foreach (var r in items)
{
writer.WriteStartObject();
writer.WritePropertyName("Name");
if (r is SpecialScroll)
{
var pscroll = r as SpecialScroll;
var name = string.Format("a power scroll of {0} ({1} Skill)", pscroll.GetName(), pscroll.Value);
writer.WriteValue(name);
}
else
{
if (r.LabelNumber == 0)
{
writer.WriteValue(r.Name);
}
else
{
writer.WriteValue(CliLoc.LocToString(r.LabelNumber));
}
}
writer.WritePropertyName("type");
writer.WriteValue(CraftItem.ItemIDOf(r.GetType()));
writer.WriteEndObject();
}
writer.WriteEndArray();
writer.WriteEndObject();
// var points = calc.ComputePoints(qty, v, (BulkMaterialType)res, 1, null);
// var reward = calc.LookupRewards(points);
// var gold = calc.ComputeGold(qty, v, (BulkMaterialType)res, 1, null);
}
/// <summary>
/// Write the JSON string. This will convert all the properties to a JSON string.
/// This is done manaully to improve conversion time. The default serializer will check
/// each property if it can convert. This will convert the properties automatically. This
/// will double the speed.
///
/// Newtonsoft.Json.JsonConvert.SerializeObject(ensemble.RangeTrackingData).
///
/// </summary>
/// <param name="writer">JSON Writer.</param>
/// <param name="value">Object to write to JSON.</param>
/// <param name="serializer">Serializer to convert the object.</param>
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
// Cast the object
var data = value as RangeTrackingDataSet;
// Start the object
writer.Formatting = Formatting.None; // Make the text not indented, so not as human readable. This will save disk space
writer.WriteStartObject(); // Start the JSON object
// Write the base values
writer.WriteRaw(data.ToJsonBaseStub());
writer.WriteRaw(",");
// Number of Beams
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_NUMBEAMS);
writer.WriteValue(data.NumBeams);
// SNR
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_RT_SNR);
writer.WriteStartArray();
for (int beam = 0; beam < data.SNR.Length; beam++)
{
writer.WriteValue(data.SNR[beam]);
}
writer.WriteEndArray();
// Range
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_RT_RANGE);
writer.WriteStartArray();
for (int beam = 0; beam < data.Range.Length; beam++)
{
writer.WriteValue(data.Range[beam]);
}
writer.WriteEndArray();
// Pings
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_RT_PINGS);
writer.WriteStartArray();
for (int beam = 0; beam < data.Pings.Length; beam++)
{
writer.WriteValue(data.Pings[beam]);
}
writer.WriteEndArray();
// End the object
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 void StringEscaping()
{
StringBuilder sb = new StringBuilder();
StringWriter sw = new StringWriter(sb);
using (JsonWriter jsonWriter = new JsonWriter(sw))
{
jsonWriter.WriteStartArray();
jsonWriter.WriteValue(@"""These pretzels are making me thirsty!""");
jsonWriter.WriteValue("Jeff's house was burninated.");
jsonWriter.WriteValue(@"1. You don't talk about fight club.
2. You don't talk about fight club.");
jsonWriter.WriteValue("35% of\t statistics\n are made\r up.");
jsonWriter.WriteEndArray();
}
string expected = @"[""\""These pretzels are making me thirsty!\"""",""Jeff's house was burninated."",""1. You don't talk about fight club.\r\n2. You don't talk about fight club."",""35% of\t statistics\n are made\r up.""]";
string result = sb.ToString();
Console.WriteLine("StringEscaping");
Console.WriteLine(result);
Assert.AreEqual(expected, result);
}
internal static void WriteVariant(this JsonWriter stream, object value)
{
var type = value?.GetType();
stream.WriteStartObject();
stream.WritePropertyName("Type");
stream.WriteVariantType(type);
stream.WritePropertyName("Value");
var variantType = ToVariantType(type);
// ReSharper disable PossibleNullReferenceException
switch (variantType)
{
case VariantType.Null:
case VariantType.Void:
stream.WriteStartObject();
stream.WriteEndObject();
break;
case VariantType.Bool:
stream.WriteValue((bool)value);
break;
case VariantType.Int16:
stream.WriteValue((short)value);
break;
case VariantType.Uint16:
stream.WriteValue((ushort)value);
break;
case VariantType.Int:
stream.WriteValue((int)value);
break;
case VariantType.Uint:
stream.WriteValue((uint)value);
break;
case VariantType.Int64:
stream.WriteValue((long)value);
break;
case VariantType.Uint64:
stream.WriteValue((ulong)value);
break;
case VariantType.Float:
stream.WriteValue((float)value);
break;
case VariantType.Double:
stream.WriteValue((double)value);
break;
case VariantType.Pointer:
stream.WriteValue((ulong)(IntPtr)value);
break;
case VariantType.String:
stream.WriteValue((string)value);
break;
case VariantType.Object:
stream.WriteValue(((FlaxEngine.Object)value).ID);
break;
case VariantType.Asset:
stream.WriteValue(((Asset)value).ID);
break;
case VariantType.Blob:
stream.WriteValue(Convert.ToBase64String((byte[])value));
break;
case VariantType.Enum:
stream.WriteValue(Convert.ToUInt64(value));
break;
case VariantType.Vector2:
{
var asVector2 = (Vector2)value;
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asVector2.X);
stream.WritePropertyName("Y");
stream.WriteValue(asVector2.Y);
stream.WriteEndObject();
break;
}
case VariantType.Vector3:
{
var asVector3 = (Vector3)value;
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asVector3.X);
stream.WritePropertyName("Y");
stream.WriteValue(asVector3.Y);
stream.WritePropertyName("Z");
stream.WriteValue(asVector3.Z);
stream.WriteEndObject();
break;
}
case VariantType.Vector4:
{
var asVector4 = (Vector4)value;
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asVector4.X);
stream.WritePropertyName("Y");
stream.WriteValue(asVector4.Y);
stream.WritePropertyName("Z");
stream.WriteValue(asVector4.Z);
stream.WritePropertyName("W");
stream.WriteValue(asVector4.W);
stream.WriteEndObject();
break;
}
case VariantType.Int2:
{
var asInt2 = (Int2)value;
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asInt2.X);
stream.WritePropertyName("Y");
stream.WriteValue(asInt2.Y);
stream.WriteEndObject();
break;
}
case VariantType.Int3:
{
var asInt3 = (Int3)value;
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asInt3.X);
stream.WritePropertyName("Y");
stream.WriteValue(asInt3.Y);
stream.WritePropertyName("Z");
stream.WriteValue(asInt3.Z);
stream.WriteEndObject();
break;
}
case VariantType.Int4:
{
var asInt4 = (Int4)value;
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asInt4.X);
stream.WritePropertyName("Y");
stream.WriteValue(asInt4.Y);
stream.WritePropertyName("Z");
stream.WriteValue(asInt4.Z);
stream.WritePropertyName("W");
stream.WriteValue(asInt4.W);
stream.WriteEndObject();
break;
}
case VariantType.Color:
{
var asColor = (Color)value;
stream.WriteStartObject();
stream.WritePropertyName("R");
stream.WriteValue(asColor.R);
stream.WritePropertyName("G");
stream.WriteValue(asColor.G);
stream.WritePropertyName("B");
stream.WriteValue(asColor.B);
stream.WritePropertyName("A");
stream.WriteValue(asColor.A);
stream.WriteEndObject();
break;
}
case VariantType.Guid:
stream.WriteValue((Guid)value);
break;
case VariantType.BoundingBox:
{
var asBoundingBox = (BoundingBox)value;
stream.WriteStartObject();
stream.WritePropertyName("Minimum");
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asBoundingBox.Minimum.X);
stream.WritePropertyName("Y");
stream.WriteValue(asBoundingBox.Minimum.Y);
stream.WritePropertyName("Z");
stream.WriteValue(asBoundingBox.Minimum.Z);
stream.WriteEndObject();
stream.WritePropertyName("Maximum");
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asBoundingBox.Maximum.X);
stream.WritePropertyName("Y");
stream.WriteValue(asBoundingBox.Maximum.Y);
stream.WritePropertyName("Z");
stream.WriteValue(asBoundingBox.Maximum.Z);
stream.WriteEndObject();
stream.WriteEndObject();
break;
}
case VariantType.BoundingSphere:
{
var asBoundingSphere = (BoundingSphere)value;
stream.WriteStartObject();
stream.WritePropertyName("Center");
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asBoundingSphere.Center.X);
stream.WritePropertyName("Y");
stream.WriteValue(asBoundingSphere.Center.Y);
stream.WritePropertyName("Z");
stream.WriteValue(asBoundingSphere.Center.Z);
stream.WriteEndObject();
stream.WritePropertyName("Radius");
stream.WriteValue(asBoundingSphere.Radius);
stream.WriteEndObject();
break;
}
case VariantType.Quaternion:
{
var asQuaternion = (Quaternion)value;
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asQuaternion.X);
stream.WritePropertyName("Y");
stream.WriteValue(asQuaternion.Y);
stream.WritePropertyName("Z");
stream.WriteValue(asQuaternion.Z);
stream.WritePropertyName("W");
stream.WriteValue(asQuaternion.W);
stream.WriteEndObject();
break;
}
case VariantType.Transform:
{
var asTransform = (Transform)value;
stream.WriteStartObject();
stream.WritePropertyName("Translation");
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asTransform.Translation.X);
stream.WritePropertyName("Y");
stream.WriteValue(asTransform.Translation.Y);
stream.WritePropertyName("Z");
stream.WriteValue(asTransform.Translation.Z);
stream.WriteEndObject();
stream.WritePropertyName("Orientation");
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asTransform.Orientation.X);
stream.WritePropertyName("Y");
stream.WriteValue(asTransform.Orientation.Y);
stream.WritePropertyName("Z");
stream.WriteValue(asTransform.Orientation.Z);
stream.WritePropertyName("W");
stream.WriteValue(asTransform.Orientation.W);
stream.WriteEndObject();
stream.WritePropertyName("Scale");
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asTransform.Scale.X);
stream.WritePropertyName("Y");
stream.WriteValue(asTransform.Scale.Y);
stream.WritePropertyName("Z");
stream.WriteValue(asTransform.Scale.Z);
stream.WriteEndObject();
stream.WriteEndObject();
break;
}
case VariantType.Rectangle:
{
var asRectangle = (Rectangle)value;
stream.WriteStartObject();
stream.WritePropertyName("Location");
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asRectangle.Location.X);
stream.WritePropertyName("Y");
stream.WriteValue(asRectangle.Location.Y);
stream.WriteEndObject();
stream.WritePropertyName("Size");
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asRectangle.Size.X);
stream.WritePropertyName("Y");
stream.WriteValue(asRectangle.Size.Y);
stream.WriteEndObject();
stream.WriteEndObject();
break;
}
case VariantType.Ray:
{
var asRay = (Ray)value;
stream.WriteStartObject();
stream.WritePropertyName("Position");
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asRay.Position.X);
stream.WritePropertyName("Y");
stream.WriteValue(asRay.Position.Y);
stream.WritePropertyName("Z");
stream.WriteValue(asRay.Position.Z);
stream.WriteEndObject();
stream.WritePropertyName("Direction");
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asRay.Direction.X);
stream.WritePropertyName("Y");
stream.WriteValue(asRay.Direction.Y);
stream.WritePropertyName("Z");
stream.WriteValue(asRay.Direction.Z);
stream.WriteEndObject();
stream.WriteEndObject();
break;
}
case VariantType.Matrix:
{
var asMatrix = (Matrix)value;
stream.WriteStartObject();
stream.WritePropertyName("M11");
stream.WriteValue(asMatrix.M11);
stream.WritePropertyName("M12");
stream.WriteValue(asMatrix.M12);
stream.WritePropertyName("M13");
stream.WriteValue(asMatrix.M13);
stream.WritePropertyName("M14");
stream.WriteValue(asMatrix.M14);
stream.WritePropertyName("M21");
stream.WriteValue(asMatrix.M21);
stream.WritePropertyName("M22");
stream.WriteValue(asMatrix.M22);
stream.WritePropertyName("M23");
stream.WriteValue(asMatrix.M23);
stream.WritePropertyName("M24");
stream.WriteValue(asMatrix.M24);
stream.WritePropertyName("M31");
stream.WriteValue(asMatrix.M31);
stream.WritePropertyName("M32");
stream.WriteValue(asMatrix.M32);
stream.WritePropertyName("M33");
stream.WriteValue(asMatrix.M33);
stream.WritePropertyName("M34");
stream.WriteValue(asMatrix.M34);
stream.WritePropertyName("M41");
stream.WriteValue(asMatrix.M41);
stream.WritePropertyName("M42");
stream.WriteValue(asMatrix.M42);
stream.WritePropertyName("M43");
stream.WriteValue(asMatrix.M43);
stream.WritePropertyName("M44");
stream.WriteValue(asMatrix.M44);
stream.WriteEndObject();
break;
}
case VariantType.Array:
{
stream.WriteStartArray();
foreach (var e in (Array)value)
{
stream.WriteVariant(e);
}
stream.WriteEndArray();
break;
}
case VariantType.Dictionary:
{
stream.WriteStartArray();
foreach (var e in (Dictionary <object, object>)value)
{
stream.WritePropertyName("Key");
stream.WriteVariant(e.Key);
stream.WritePropertyName("Value");
stream.WriteVariant(e.Value);
}
stream.WriteEndArray();
break;
}
case VariantType.Typename:
if (value is Type)
{
stream.WriteValue(((Type)value).FullName);
}
else if (value is ScriptType)
{
stream.WriteValue(((ScriptType)value).TypeName);
}
break;
case VariantType.ManagedObject:
case VariantType.Structure:
{
var json = FlaxEngine.Json.JsonSerializer.Serialize(value, type);
stream.WriteRaw(json);
break;
}
default: throw new ArgumentOutOfRangeException($"Unknown Variant Type {variantType} for type {type.FullName}.");
}
// ReSharper restore PossibleNullReferenceException
stream.WriteEndObject();
}
private void SerializeList(JsonWriter writer, IEnumerable values, JsonArrayContract contract, JsonProperty member, JsonContainerContract collectionContract, JsonProperty containerProperty)
{
IWrappedCollection wrappedCollection = values as IWrappedCollection;
object underlyingList = wrappedCollection != null ? wrappedCollection.UnderlyingCollection : values;
OnSerializing(writer, contract, underlyingList);
_serializeStack.Add(underlyingList);
bool hasWrittenMetadataObject = WriteStartArray(writer, underlyingList, contract, member, collectionContract, containerProperty);
writer.WriteStartArray();
int initialDepth = writer.Top;
int index = 0;
IEnumerator enumerator;
try
{
enumerator = values.GetEnumerator();
}
catch (Exception e)
{
throw new InvalidOperationException("Could not get enumerator for property: " + member, e);
}
using (enumerator as IDisposable)
{
while (true)
{
try
{
if (enumerator.MoveNext() == false)
break;
}
catch (Exception e)
{
throw new InvalidOperationException("Could not move to next value for property: " + member, e);
}
object value;
try
{
value = enumerator.Current;
}
catch (Exception e)
{
throw new InvalidOperationException("Could not get current value for property: " + member, e);
}
try
{
JsonContract valueContract = contract.FinalItemContract ?? GetContractSafe(value);
if (ShouldWriteReference(value, null, valueContract, contract, member))
{
WriteReference(writer, value);
}
else
{
if (CheckForCircularReference(writer, value, null, valueContract, contract, member))
{
SerializeValue(writer, value, valueContract, null, contract, member);
}
}
}
catch (Exception ex)
{
if (IsErrorHandled(underlyingList, contract, index, null, writer.ContainerPath, ex))
HandleError(writer, initialDepth);
else
throw;
}
finally
{
index++;
}
}
}
writer.WriteEndArray();
if (hasWrittenMetadataObject)
writer.WriteEndObject();
_serializeStack.RemoveAt(_serializeStack.Count - 1);
OnSerialized(writer, contract, underlyingList);
}
public override void Serialize(JsonWriter writer)
{
writer.WriteStartObject();
if (Camera != null)
{
writer.WritePropertyName("camera");
writer.WriteValue(Camera.Id);
}
if (Children != null && Children.Count > 0)
{
writer.WritePropertyName("children");
writer.WriteStartArray();
foreach (var child in Children)
{
writer.WriteValue(child.Id);
}
writer.WriteEndArray();
}
if (Skin != null)
{
writer.WritePropertyName("skin");
writer.WriteValue(Skin.Id);
}
if (Matrix != Matrix4x4.identity)
{
writer.WritePropertyName("matrix");
writer.WriteStartArray();
for (var i = 0; i < 16; i++)
{
writer.WriteValue(Matrix[i]);
}
writer.WriteEndArray();
}
if (Mesh != null)
{
writer.WritePropertyName("mesh");
writer.WriteValue(Mesh.Id);
}
if (Rotation != Quaternion.identity)
{
writer.WritePropertyName("rotation");
writer.WriteStartArray();
writer.WriteValue(Rotation.x);
writer.WriteValue(Rotation.y);
writer.WriteValue(Rotation.z);
writer.WriteValue(Rotation.w);
writer.WriteEndArray();
}
if (Scale != Vector3.one)
{
writer.WritePropertyName("scale");
writer.WriteStartArray();
writer.WriteValue(Scale.x);
writer.WriteValue(Scale.y);
writer.WriteValue(Scale.z);
writer.WriteEndArray();
}
if (Translation != Vector3.zero)
{
writer.WritePropertyName("translation");
writer.WriteStartArray();
writer.WriteValue(Translation.x);
writer.WriteValue(Translation.y);
writer.WriteValue(Translation.z);
writer.WriteEndArray();
}
if (Weights != null && Weights.Count > 0)
{
writer.WritePropertyName("weights");
writer.WriteStartArray();
foreach (var weight in Weights)
{
writer.WriteValue(weight);
}
writer.WriteEndArray();
}
base.Serialize(writer);
writer.WriteEndObject();
}
private void SerializeList(JsonWriter writer, IWrappedCollection values, JsonArrayContract contract, JsonProperty member, JsonContract collectionValueContract)
{
contract.InvokeOnSerializing(values.UnderlyingCollection, Serializer.Context);
_serializeStack.Add(values.UnderlyingCollection);
bool isReference = contract.IsReference ?? HasFlag(Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Arrays);
bool includeTypeDetails = ShouldWriteType(TypeNameHandling.Arrays, contract, member, collectionValueContract);
if (isReference || includeTypeDetails)
{
writer.WriteStartObject();
if (isReference)
{
writer.WritePropertyName(JsonTypeReflector.IdPropertyName);
writer.WriteValue(Serializer.ReferenceResolver.GetReference(this, values.UnderlyingCollection));
}
if (includeTypeDetails)
{
WriteTypeProperty(writer, values.UnderlyingCollection.GetType());
}
writer.WritePropertyName(JsonTypeReflector.ArrayValuesPropertyName);
}
if (contract.CollectionItemContract == null)
{
contract.CollectionItemContract = Serializer.ContractResolver.ResolveContract(contract.CollectionItemType ?? typeof(object));
}
JsonContract collectionItemValueContract = (contract.CollectionItemContract.UnderlyingType.IsSealed) ? contract.CollectionItemContract : null;
writer.WriteStartArray();
int initialDepth = writer.Top;
int index = 0;
// note that an error in the IEnumerable won't be caught
foreach (object value in values)
{
try
{
JsonContract valueContract = collectionItemValueContract ?? GetContractSafe(value);
if (ShouldWriteReference(value, null, valueContract))
{
WriteReference(writer, value);
}
else
{
if (CheckForCircularReference(value, null, contract))
{
SerializeValue(writer, value, valueContract, null, contract.CollectionItemContract);
}
}
}
catch (Exception ex)
{
if (IsErrorHandled(values.UnderlyingCollection, contract, index, ex))
{
HandleError(writer, initialDepth);
}
else
{
throw;
}
}
finally
{
index++;
}
}
writer.WriteEndArray();
if (isReference || includeTypeDetails)
{
writer.WriteEndObject();
}
_serializeStack.RemoveAt(_serializeStack.Count - 1);
contract.InvokeOnSerialized(values.UnderlyingCollection, Serializer.Context);
}
public override void WriteTo(JsonWriter writer)
{
writer.WriteStartArray();
foreach (JToken token in Children())
{
token.WriteTo(writer);
}
writer.WriteEndArray();
}
/// <summary>
/// Write the JSON string. This will convert all the properties to a JSON string.
/// This is done manaully to improve conversion time. The default serializer will check
/// each property if it can convert. This will convert the properties automatically. This
/// will double the speed.
///
/// Newtonsoft.Json.JsonConvert.SerializeObject(ensemble.InstrumentVelocityData).
///
/// </summary>
/// <param name="writer">JSON Writer.</param>
/// <param name="value">Object to write to JSON.</param>
/// <param name="serializer">Serializer to convert the object.</param>
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
// Cast the object
var data = value as InstrumentVelocityDataSet;
// Start the object
writer.Formatting = Formatting.None; // Make the text not indented, so not as human readable. This will save disk space
writer.WriteStartObject(); // Start the JSON object
// Write the base values
writer.WriteRaw(data.ToJsonBaseStub());
writer.WriteRaw(",");
// Write the float[,] array data
// This will be an array of arrays
// Each array element will contain an array with the 4 beam's value
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_INSTRUMENTVELOCITYDATA);
writer.WriteStartArray();
for (int bin = 0; bin < data.NumElements; bin++)
{
// Write an array of float values for each beam's value
writer.WriteStartArray();
for (int beam = 0; beam < data.ElementsMultiplier; beam++)
{
writer.WriteValue(data.InstrumentVelocityData[bin, beam]);
}
writer.WriteEndArray();
}
writer.WriteEndArray();
// End the object
writer.WriteEndObject();
}
private void SerializeList(JsonWriter writer, IWrappedCollection values, JsonArrayContract contract, JsonProperty member, JsonContainerContract collectionContract, JsonProperty containerProperty)
{
contract.InvokeOnSerializing(values.UnderlyingCollection, Serializer.Context);
_serializeStack.Add(values.UnderlyingCollection);
bool hasWrittenMetadataObject = WriteStartArray(writer, values.UnderlyingCollection, contract, member, collectionContract, containerProperty);
writer.WriteStartArray();
int initialDepth = writer.Top;
int index = 0;
// note that an error in the IEnumerable won't be caught
foreach (object value in values)
{
try
{
JsonContract valueContract = contract.FinalItemContract ?? GetContractSafe(value);
if (ShouldWriteReference(value, null, valueContract, contract, member))
{
WriteReference(writer, value);
}
else
{
if (CheckForCircularReference(writer, value, null, valueContract, contract, member))
{
SerializeValue(writer, value, valueContract, null, contract, member);
}
}
}
catch (Exception ex)
{
if (IsErrorHandled(values.UnderlyingCollection, contract, index, writer.ContainerPath, ex))
HandleError(writer, initialDepth);
else
throw;
}
finally
{
index++;
}
}
writer.WriteEndArray();
if (hasWrittenMetadataObject)
writer.WriteEndObject();
_serializeStack.RemoveAt(_serializeStack.Count - 1);
contract.InvokeOnSerialized(values.UnderlyingCollection, Serializer.Context);
}
/// <summary>
/// Writes the JSON representation of the object.
/// </summary>
/// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
/// <param name="value">The value.</param>
/// <param name="serializer">The calling serializer.</param>
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver;
Type unionType = UnionTypeLookupCache.Get(value.GetType());
Union union = UnionCache.Get(unionType);
int tag = (int)union.TagReader.Invoke(value);
UnionCase caseInfo = union.Cases.Single(c => c.Tag == tag);
writer.WriteStartObject();
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(CasePropertyName) : CasePropertyName);
writer.WriteValue(caseInfo.Name);
if (caseInfo.Fields != null && caseInfo.Fields.Length > 0)
{
object[] fields = (object[])caseInfo.FieldReader.Invoke(value);
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(FieldsPropertyName) : FieldsPropertyName);
writer.WriteStartArray();
foreach (object field in fields)
{
serializer.Serialize(writer, field);
}
writer.WriteEndArray();
}
writer.WriteEndObject();
}
private void WriteType(string propertyName, JsonWriter writer, JsonSchemaType type)
{
IList<JsonSchemaType> types;
if (System.Enum.IsDefined(typeof(JsonSchemaType), type))
{
types = new List<JsonSchemaType> { type };
}
else
{
types = EnumUtils.GetFlagsValues(type).Where(v => v != JsonSchemaType.None).ToList();
}
if (types.Count == 0)
{
return;
}
writer.WritePropertyName(propertyName);
if (types.Count == 1)
{
writer.WriteValue(JsonSchemaBuilder.MapType(types[0]));
return;
}
writer.WriteStartArray();
foreach (JsonSchemaType jsonSchemaType in types)
{
writer.WriteValue(JsonSchemaBuilder.MapType(jsonSchemaType));
}
writer.WriteEndArray();
}
private void SerializeList(JsonWriter writer, IWrappedCollection values, JsonArrayContract contract, JsonProperty member, JsonContract collectionValueContract)
{
contract.InvokeOnSerializing(values.UnderlyingCollection, Serializer.Context);
SerializeStack.Add(values.UnderlyingCollection);
bool isReference = contract.IsReference ?? HasFlag(Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Arrays);
bool includeTypeDetails = ShouldWriteType(TypeNameHandling.Arrays, contract, member, collectionValueContract);
if (isReference || includeTypeDetails)
{
writer.WriteStartObject();
if (isReference)
{
writer.WritePropertyName(JsonTypeReflector.IdPropertyName);
writer.WriteValue(Serializer.ReferenceResolver.GetReference(this, values.UnderlyingCollection));
}
if (includeTypeDetails)
{
WriteTypeProperty(writer, values.UnderlyingCollection.GetType());
}
writer.WritePropertyName(JsonTypeReflector.ArrayValuesPropertyName);
}
JsonContract childValuesContract = Serializer.ContractResolver.ResolveContract(contract.CollectionItemType ?? typeof(object));
writer.WriteStartArray();
int initialDepth = writer.Top;
int index = 0;
// note that an error in the IEnumerable won't be caught
#if !(UNITY_IPHONE || UNITY_IOS)
foreach (object value in values)
{
try
{
JsonContract valueContract = GetContractSafe(value);
if (ShouldWriteReference(value, null, valueContract))
{
WriteReference(writer, value);
}
else
{
if (CheckForCircularReference(value, null, contract))
{
SerializeValue(writer, value, valueContract, null, childValuesContract);
}
}
}
catch (Exception ex)
{
if (IsErrorHandled(values.UnderlyingCollection, contract, index, ex))
HandleError(writer, initialDepth);
else
throw;
}
finally
{
index++;
}
}
#else
values.ForEach(value =>
{
try
{
JsonContract valueContract = GetContractSafe(value);
if (ShouldWriteReference(value, null, valueContract))
{
WriteReference(writer, value);
}
else
{
if (CheckForCircularReference(value, null, contract))
{
SerializeValue(writer, value, valueContract, null, childValuesContract);
}
}
}
catch (Exception ex)
{
if (IsErrorHandled(values.UnderlyingCollection, contract, index, ex))
HandleError(writer, initialDepth);
else
throw;
}
finally
{
index++;
}
});
#endif
writer.WriteEndArray();
if (isReference || includeTypeDetails)
{
writer.WriteEndObject();
}
SerializeStack.RemoveAt(SerializeStack.Count - 1);
contract.InvokeOnSerialized(values.UnderlyingCollection, Serializer.Context);
}
/// <summary>
/// Converts XML to JsonML array form.
/// </summary>
public static void EncodeArrayForm(XmlReader reader, JsonWriter writer)
{
if (reader == null) throw new ArgumentNullException("reader");
if (writer == null) throw new ArgumentNullException("writer");
if (reader.MoveToContent() != XmlNodeType.Element)
throw new ArgumentException(null, "reader");
writer.WriteStartArray();
writer.WriteString(reader.Name);
//
// Write attributes
//
if (reader.MoveToFirstAttribute())
{
writer.WriteStartObject();
do
{
writer.WriteMember(reader.Name);
writer.WriteString(reader.Value);
}
while (reader.MoveToNextAttribute());
writer.WriteEndObject();
reader.MoveToElement();
}
bool isEmpty = reader.IsEmptyElement;
if (!isEmpty)
{
reader.Read();
//
// Write child nodes (text, CDATA and element)
//
while (reader.NodeType != XmlNodeType.EndElement)
{
if (reader.NodeType == XmlNodeType.Text || reader.NodeType == XmlNodeType.CDATA)
{
writer.WriteString(reader.Value);
reader.Read();
}
else if (reader.NodeType == XmlNodeType.Element)
{
Encode(reader, writer);
}
else
{
reader.Read();
}
}
}
writer.WriteEndArray();
reader.Read();
}
public override void Serialize(JsonWriter writer)
{
writer.WriteStartObject();
writer.WritePropertyName("attributes");
writer.WriteStartObject();
foreach (var attribute in Attributes)
{
writer.WritePropertyName(attribute.Key);
writer.WriteValue(attribute.Value.Id);
}
writer.WriteEndObject();
if (Indices != null)
{
writer.WritePropertyName("indices");
writer.WriteValue(Indices.Id);
}
if (Material != null)
{
writer.WritePropertyName("material");
writer.WriteValue(Material.Id);
}
if (Mode != DrawMode.Triangles)
{
writer.WritePropertyName("mode");
writer.WriteValue((int)Mode);
}
if (Targets != null && Targets.Count > 0)
{
writer.WritePropertyName("targets");
writer.WriteStartArray();
foreach (var target in Targets)
{
writer.WriteStartObject();
foreach (var attribute in target)
{
writer.WritePropertyName(attribute.Key);
writer.WriteValue(attribute.Value.Id);
}
writer.WriteEndObject();
}
writer.WriteEndArray();
}
// GLTF does not support morph target names, serialize in extras for now
// https://github.com/KhronosGroup/glTF/issues/1036
if (TargetNames != null && TargetNames.Count > 0)
{
writer.WritePropertyName("extras");
writer.WriteStartObject();
writer.WritePropertyName("targetNames");
writer.WriteStartArray();
foreach (var targetName in TargetNames)
{
writer.WriteValue(targetName);
}
writer.WriteEndArray();
writer.WriteEndObject();
}
base.Serialize(writer);
writer.WriteEndObject();
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var tagHelper = (TagHelperDescriptor)value;
writer.WriteStartObject();
writer.WritePropertyName(nameof(TagHelperDescriptor.Kind));
writer.WriteValue(tagHelper.Kind);
writer.WritePropertyName(nameof(TagHelperDescriptor.Name));
writer.WriteValue(tagHelper.Name);
writer.WritePropertyName(nameof(TagHelperDescriptor.AssemblyName));
writer.WriteValue(tagHelper.AssemblyName);
if (tagHelper.Documentation != null)
{
writer.WritePropertyName(nameof(TagHelperDescriptor.Documentation));
writer.WriteValue(tagHelper.Documentation);
}
if (tagHelper.TagOutputHint != null)
{
writer.WritePropertyName(nameof(TagHelperDescriptor.TagOutputHint));
writer.WriteValue(tagHelper.TagOutputHint);
}
writer.WritePropertyName(nameof(TagHelperDescriptor.CaseSensitive));
writer.WriteValue(tagHelper.CaseSensitive);
writer.WritePropertyName(nameof(TagHelperDescriptor.TagMatchingRules));
writer.WriteStartArray();
foreach (var ruleDescriptor in tagHelper.TagMatchingRules)
{
WriteTagMatchingRule(writer, ruleDescriptor, serializer);
}
writer.WriteEndArray();
if (tagHelper.BoundAttributes != null && tagHelper.BoundAttributes.Count > 0)
{
writer.WritePropertyName(nameof(TagHelperDescriptor.BoundAttributes));
writer.WriteStartArray();
foreach (var boundAttribute in tagHelper.BoundAttributes)
{
WriteBoundAttribute(writer, boundAttribute, serializer);
}
writer.WriteEndArray();
}
if (tagHelper.AllowedChildTags != null && tagHelper.AllowedChildTags.Count > 0)
{
writer.WritePropertyName(nameof(TagHelperDescriptor.AllowedChildTags));
writer.WriteStartArray();
foreach (var allowedChildTag in tagHelper.AllowedChildTags)
{
WriteAllowedChildTags(writer, allowedChildTag, serializer);
}
writer.WriteEndArray();
}
if (tagHelper.Diagnostics != null && tagHelper.Diagnostics.Count > 0)
{
writer.WritePropertyName(nameof(TagHelperDescriptor.Diagnostics));
serializer.Serialize(writer, tagHelper.Diagnostics);
}
writer.WritePropertyName(nameof(TagHelperDescriptor.Metadata));
WriteMetadata(writer, tagHelper.Metadata);
writer.WriteEndObject();
}
//public List<Security> security { get; set; }
public void Serialize(JsonWriter writer)
{
writer.WritePropertyName(Id);
writer.WriteStartObject();
if (Tags != null && Tags.Any())
{
writer.WritePropertyName("tags");
writer.WriteStartArray();
foreach (string tag in Tags)
{
writer.WriteValue(tag);
}
writer.WriteEndArray();
}
if (!string.IsNullOrWhiteSpace(Summary))
{
writer.WritePropertyName("summary");
writer.WriteValue(Summary);
}
if (!string.IsNullOrWhiteSpace(Description))
{
writer.WritePropertyName("description");
writer.WriteValue(Description);
}
if (ExternalDocs != null)
{
writer.WritePropertyName("externalDocs");
ExternalDocs.Serialize(writer);
}
if (!string.IsNullOrWhiteSpace(OperationId))
{
writer.WritePropertyName("operationId");
writer.WriteValue(OperationId);
}
if (Consumes != null && Consumes.Any())
{
writer.WritePropertyName("consumes");
writer.WriteStartArray();
foreach (string cons in Consumes)
{
writer.WriteValue(cons);
}
writer.WriteEndArray();
}
if (Produces != null && Produces.Any())
{
writer.WritePropertyName("produces");
writer.WriteStartArray();
foreach (string prod in Produces)
{
writer.WriteValue(prod);
}
writer.WriteEndArray();
}
if (Parameters != null && Parameters.Any())
{
writer.WritePropertyName("parameters");
writer.WriteStartArray();
foreach (ParameterBase p in Parameters)
{
p.Serialize(writer);
}
writer.WriteEndArray();
}
if (Responses != null && Responses.Any())
{
writer.WritePropertyName("responses");
writer.WriteStartObject();
foreach (Response r in Responses)
{
r.Serialize(writer);
}
writer.WriteEndObject();
}
if (Schemes != null && Schemes.Any())
{
writer.WritePropertyName("schemes");
writer.WriteStartArray();
foreach (string sch in Schemes)
{
writer.WriteValue(sch);
}
writer.WriteEndArray();
}
if (Deprecated)
{
writer.WritePropertyName("deprecated");
writer.WriteValue(Deprecated);
}
writer.WriteEndObject();
}
private void ToJson(JsonWriter writer, BaseCriteria criteria, JsonSerializer serializer)
{
if (criteria is null ||
criteria.IsEmpty)
{
writer.WriteNull();
return;
}
if (criteria is ValueCriteria valueCriteria)
{
var value = valueCriteria.Value;
if (value != null && value is IEnumerable && !(value is string))
{
// make sure that first value in array won't be recognized as a operator
// while deserializing (e.g. if values are [">", "a", "b"], serialize them
// as [[">", "a", "b"]] so that the first > won't be recognized as GE operator.
writer.WriteStartArray();
serializer.Serialize(writer, value);
writer.WriteEndArray();
return;
}
serializer.Serialize(writer, value);
return;
}
if (criteria is ParamCriteria prm)
{
writer.WriteStartArray();
serializer.Serialize(writer, prm.Name);
writer.WriteEndArray();
return;
}
if (criteria is Criteria crit)
{
writer.WriteStartArray();
serializer.Serialize(writer, crit.Expression);
writer.WriteEndArray();
return;
}
if (criteria is UnaryCriteria unary)
{
writer.WriteStartArray();
writer.WriteValue(OperatorToKey[(int)unary.Operator]);
ToJson(writer, unary.Operand, serializer);
writer.WriteEndArray();
return;
}
if (criteria is BinaryCriteria binary)
{
writer.WriteStartArray();
ToJson(writer, binary.LeftOperand, serializer);
writer.WriteValue(OperatorToKey[(int)binary.Operator]);
ToJson(writer, binary.RightOperand, serializer);
writer.WriteEndArray();
return;
}
throw new JsonSerializationException(string.Format("Can't serialize criteria of type {0}", criteria.GetType().FullName));
}
private void SerializeList(JsonWriter writer, IEnumerable values, JsonArrayContract contract, JsonProperty member, JsonContainerContract collectionContract, JsonProperty containerProperty)
{
object underlyingList = values is IWrappedCollection wrappedCollection ? wrappedCollection.UnderlyingCollection : values;
OnSerializing(writer, contract, underlyingList);
_serializeStack.Add(underlyingList);
bool hasWrittenMetadataObject = WriteStartArray(writer, underlyingList, contract, member, collectionContract, containerProperty);
writer.WriteStartArray();
int initialDepth = writer.Top;
int index = 0;
// note that an error in the IEnumerable won't be caught
foreach (object value in values)
{
try
{
JsonContract valueContract = contract.FinalItemContract ?? GetContractSafe(value);
if (ShouldWriteReference(value, null, valueContract, contract, member))
{
WriteReference(writer, value);
}
else
{
if (CheckForCircularReference(writer, value, null, valueContract, contract, member))
{
SerializeValue(writer, value, valueContract, null, contract, member);
}
}
}
catch (Exception ex)
{
if (IsErrorHandled(underlyingList, contract, index, null, writer.ContainerPath, ex))
{
HandleError(writer, initialDepth);
}
else
{
throw;
}
}
finally
{
index++;
}
}
writer.WriteEndArray();
if (hasWrittenMetadataObject)
{
writer.WriteEndObject();
}
_serializeStack.RemoveAt(_serializeStack.Count - 1);
OnSerialized(writer, contract, underlyingList);
}
public override void WriteJson(JsonWriter writer, BooleanFunction value, JsonSerializer serializer)
{
IReferenceResolver resolver = serializer.Context.Context as IReferenceResolver;
if (value is BooleanOperator)
{
writer.WriteStartObject();
writer.WritePropertyName("$id");
serializer.Serialize(writer, new Guid(resolver.GetReference(null, value)));
writer.WritePropertyName("$type");
serializer.Serialize(writer, nameof(BooleanOperator));
writer.WritePropertyName("Consumer");
if (value.Consumer == null)
{
serializer.Serialize(writer, null);
}
else
{
serializer.Serialize(writer, value.Consumer, value.Consumer.GetType());
}
writer.WritePropertyName("Name");
serializer.Serialize(writer, value.Name);
BooleanOperator source = (BooleanOperator)value;
writer.WritePropertyName("Operands");
if (source.Operands == null)
{
serializer.Serialize(writer, null);
}
else if (source.Operands.Count == 0)
{
writer.WriteStartArray();
writer.WriteEndArray();
}
else
{
writer.WriteStartArray();
foreach (BooleanFunction item in source.Operands)
{
serializer.Serialize(writer, item, item.GetType());
}
writer.WriteEndArray();
}
writer.WriteEndObject();
}
else if (value is ComparisonOperator)
{
writer.WriteStartObject();
writer.WritePropertyName("$id");
serializer.Serialize(writer, new Guid(resolver.GetReference(null, value)));
writer.WritePropertyName("$type");
serializer.Serialize(writer, nameof(ComparisonOperator));
writer.WritePropertyName("Consumer");
if (value.Consumer == null)
{
serializer.Serialize(writer, null);
}
else
{
serializer.Serialize(writer, value.Consumer, value.Consumer.GetType());
}
writer.WritePropertyName("Name");
serializer.Serialize(writer, value.Name);
ComparisonOperator source = (ComparisonOperator)value;
writer.WritePropertyName("LeftExpression");
if (source.LeftExpression == null)
{
serializer.Serialize(writer, null);
}
else
{
serializer.Serialize(writer, source.LeftExpression, source.LeftExpression.GetType());
}
writer.WritePropertyName("RightExpression");
if (source.RightExpression == null)
{
serializer.Serialize(writer, null);
}
else
{
serializer.Serialize(writer, source.RightExpression, source.RightExpression.GetType());
}
writer.WriteEndObject();
}
}
private void SerializeGroupedNodes(JsonWriter writer, IXmlNode node, XmlNamespaceManager manager, bool writePropertyName)
{
// group nodes together by name
Dictionary<string, List<IXmlNode>> nodesGroupedByName = new Dictionary<string, List<IXmlNode>>();
for (int i = 0; i < node.ChildNodes.Count; i++)
{
IXmlNode childNode = node.ChildNodes[i];
string nodeName = GetPropertyName(childNode, manager);
List<IXmlNode> nodes;
if (!nodesGroupedByName.TryGetValue(nodeName, out nodes))
{
nodes = new List<IXmlNode>();
nodesGroupedByName.Add(nodeName, nodes);
}
nodes.Add(childNode);
}
// loop through grouped nodes. write single name instances as normal,
// write multiple names together in an array
foreach (KeyValuePair<string, List<IXmlNode>> nodeNameGroup in nodesGroupedByName)
{
List<IXmlNode> groupedNodes = nodeNameGroup.Value;
bool writeArray;
if (groupedNodes.Count == 1)
{
writeArray = IsArray(groupedNodes[0]);
}
else
{
writeArray = true;
}
if (!writeArray)
{
SerializeNode(writer, groupedNodes[0], manager, writePropertyName);
}
else
{
string elementNames = nodeNameGroup.Key;
if (writePropertyName)
writer.WritePropertyName(elementNames);
writer.WriteStartArray();
for (int i = 0; i < groupedNodes.Count; i++)
{
SerializeNode(writer, groupedNodes[i], manager, false);
}
writer.WriteEndArray();
}
}
}
public override void Serialize(JsonWriter writer)
{
writer.WriteStartObject();
if (PbrMetallicRoughness != null)
{
writer.WritePropertyName("pbrMetallicRoughness");
PbrMetallicRoughness.Serialize(writer);
}
if (CommonConstant != null)
{
writer.WritePropertyName("commonConstant");
CommonConstant.Serialize(writer);
}
if (NormalTexture != null)
{
writer.WritePropertyName("normalTexture");
NormalTexture.Serialize(writer);
}
if (OcclusionTexture != null)
{
writer.WritePropertyName("occlusionTexture");
OcclusionTexture.Serialize(writer);
}
if (EmissiveTexture != null)
{
writer.WritePropertyName("emissiveTexture");
EmissiveTexture.Serialize(writer);
}
if (EmissiveFactor != Color.black)
{
writer.WritePropertyName("emissiveFactor");
writer.WriteStartArray();
writer.WriteValue(EmissiveFactor.r);
writer.WriteValue(EmissiveFactor.g);
writer.WriteValue(EmissiveFactor.b);
writer.WriteEndArray();
}
if (AlphaMode != AlphaMode.OPAQUE)
{
writer.WritePropertyName("alphaMode");
writer.WriteValue(AlphaMode.ToString());
}
if (AlphaCutoff != 0.5)
{
writer.WritePropertyName("alphaCutoff");
writer.WriteValue(AlphaCutoff);
}
if (DoubleSided)
{
writer.WritePropertyName("doubleSided");
writer.WriteValue(true);
}
base.Serialize(writer);
writer.WriteEndObject();
}
private void SerializeMultidimensionalArray(JsonWriter writer, Array values, JsonArrayContract contract, JsonProperty member, int initialDepth, int[] indices)
{
int dimension = indices.Length;
int[] newIndices = new int[dimension + 1];
for (int i = 0; i < dimension; i++)
{
newIndices[i] = indices[i];
}
writer.WriteStartArray();
for (int i = 0; i < values.GetLength(dimension); i++)
{
newIndices[dimension] = i;
bool isTopLevel = (newIndices.Length == values.Rank);
if (isTopLevel)
{
object value = values.GetValue(newIndices);
try
{
JsonContract valueContract = contract.FinalItemContract ?? GetContractSafe(value);
if (ShouldWriteReference(value, null, valueContract, contract, member))
{
WriteReference(writer, value);
}
else
{
if (CheckForCircularReference(writer, value, null, valueContract, contract, member))
{
SerializeValue(writer, value, valueContract, null, contract, member);
}
}
}
catch (Exception ex)
{
if (IsErrorHandled(values, contract, i, writer.ContainerPath, ex))
HandleError(writer, initialDepth + 1);
else
throw;
}
}
else
{
SerializeMultidimensionalArray(writer, values, contract, member, initialDepth + 1, newIndices);
}
}
writer.WriteEndArray();
}
public void WriteSchema(JsonSchema schema)
{
ValidationUtils.ArgumentNotNull(schema, "schema");
if (!_resolver.LoadedSchemas.Contains(schema))
{
_resolver.LoadedSchemas.Add(schema);
}
_writer.WriteStartObject();
WritePropertyIfNotNull(_writer, JsonSchemaConstants.IdPropertyName, schema.Id);
WritePropertyIfNotNull(_writer, JsonSchemaConstants.TitlePropertyName, schema.Title);
WritePropertyIfNotNull(_writer, JsonSchemaConstants.DescriptionPropertyName, schema.Description);
WritePropertyIfNotNull(_writer, JsonSchemaConstants.RequiredPropertyName, schema.Required);
WritePropertyIfNotNull(_writer, JsonSchemaConstants.ReadOnlyPropertyName, schema.ReadOnly);
WritePropertyIfNotNull(_writer, JsonSchemaConstants.HiddenPropertyName, schema.Hidden);
WritePropertyIfNotNull(_writer, JsonSchemaConstants.TransientPropertyName, schema.Transient);
if (schema.Type != null)
{
WriteType(JsonSchemaConstants.TypePropertyName, _writer, schema.Type.Value);
}
if (!schema.AllowAdditionalProperties)
{
_writer.WritePropertyName(JsonSchemaConstants.AdditionalPropertiesPropertyName);
_writer.WriteValue(schema.AllowAdditionalProperties);
}
else
{
if (schema.AdditionalProperties != null)
{
_writer.WritePropertyName(JsonSchemaConstants.AdditionalPropertiesPropertyName);
ReferenceOrWriteSchema(schema.AdditionalProperties);
}
}
if (!schema.AllowAdditionalItems)
{
_writer.WritePropertyName(JsonSchemaConstants.AdditionalItemsPropertyName);
_writer.WriteValue(schema.AllowAdditionalItems);
}
else
{
if (schema.AdditionalItems != null)
{
_writer.WritePropertyName(JsonSchemaConstants.AdditionalItemsPropertyName);
ReferenceOrWriteSchema(schema.AdditionalItems);
}
}
WriteSchemaDictionaryIfNotNull(_writer, JsonSchemaConstants.PropertiesPropertyName, schema.Properties);
WriteSchemaDictionaryIfNotNull(_writer, JsonSchemaConstants.PatternPropertiesPropertyName, schema.PatternProperties);
WriteItems(schema);
WritePropertyIfNotNull(_writer, JsonSchemaConstants.MinimumPropertyName, schema.Minimum);
WritePropertyIfNotNull(_writer, JsonSchemaConstants.MaximumPropertyName, schema.Maximum);
WritePropertyIfNotNull(_writer, JsonSchemaConstants.ExclusiveMinimumPropertyName, schema.ExclusiveMinimum);
WritePropertyIfNotNull(_writer, JsonSchemaConstants.ExclusiveMaximumPropertyName, schema.ExclusiveMaximum);
WritePropertyIfNotNull(_writer, JsonSchemaConstants.MinimumLengthPropertyName, schema.MinimumLength);
WritePropertyIfNotNull(_writer, JsonSchemaConstants.MaximumLengthPropertyName, schema.MaximumLength);
WritePropertyIfNotNull(_writer, JsonSchemaConstants.MinimumItemsPropertyName, schema.MinimumItems);
WritePropertyIfNotNull(_writer, JsonSchemaConstants.MaximumItemsPropertyName, schema.MaximumItems);
WritePropertyIfNotNull(_writer, JsonSchemaConstants.DivisibleByPropertyName, schema.DivisibleBy);
WritePropertyIfNotNull(_writer, JsonSchemaConstants.FormatPropertyName, schema.Format);
WritePropertyIfNotNull(_writer, JsonSchemaConstants.PatternPropertyName, schema.Pattern);
if (schema.Enum != null)
{
_writer.WritePropertyName(JsonSchemaConstants.EnumPropertyName);
_writer.WriteStartArray();
foreach (JToken token in schema.Enum)
{
token.WriteTo(_writer);
}
_writer.WriteEndArray();
}
if (schema.Default != null)
{
_writer.WritePropertyName(JsonSchemaConstants.DefaultPropertyName);
schema.Default.WriteTo(_writer);
}
if (schema.Disallow != null)
{
WriteType(JsonSchemaConstants.DisallowPropertyName, _writer, schema.Disallow.Value);
}
if (schema.Extends != null && schema.Extends.Count > 0)
{
_writer.WritePropertyName(JsonSchemaConstants.ExtendsPropertyName);
if (schema.Extends.Count == 1)
{
ReferenceOrWriteSchema(schema.Extends[0]);
}
else
{
_writer.WriteStartArray();
foreach (JsonSchema jsonSchema in schema.Extends)
{
ReferenceOrWriteSchema(jsonSchema);
}
_writer.WriteEndArray();
}
}
_writer.WriteEndObject();
}
/// <summary>
/// Write the JSON string. This will convert all the properties to a JSON string.
/// This is done manaully to improve conversion time. The default serializer will check
/// each property if it can convert. This will convert the properties automatically. This
/// will double the speed.
///
/// Newtonsoft.Json.JsonConvert.SerializeObject(ensemble.BottomTrackData).
///
/// </summary>
/// <param name="writer">JSON Writer.</param>
/// <param name="value">Object to write to JSON.</param>
/// <param name="serializer">Serializer to convert the object.</param>
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
// Cast the object
var data = value as BottomTrackDataSet;
// Start the object
writer.Formatting = Formatting.None; // Make the text not indented, so not as human readable. This will save disk space
writer.WriteStartObject(); // Start the JSON object
// Write the base values
writer.WriteRaw(data.ToJsonBaseStub());
writer.WriteRaw(",");
// FirstPingTime
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_FIRSTPINGTIME);
writer.WriteValue(data.FirstPingTime);
// LastPingTime
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_LASTPINGTIME);
writer.WriteValue(data.LastPingTime);
// Heading
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_HEADING);
writer.WriteValue(data.Heading);
// Pitch
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_PITCH);
writer.WriteValue(data.Pitch);
// Roll
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_ROLL);
writer.WriteValue(data.Roll);
// WaterTemp
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_WATERTEMP);
writer.WriteValue(data.WaterTemp);
// SystemTemp
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_SYSTEMP);
writer.WriteValue(data.SystemTemp);
// Salinity
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_SALINITY);
writer.WriteValue(data.Salinity);
// Pressure
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_PRESSURE);
writer.WriteValue(data.Pressure);
// TransducerDepth
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_TRANSDUCERDEPTH);
writer.WriteValue(data.TransducerDepth);
// SpeedOfSound
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_SPEEDOFSOUND);
writer.WriteValue(data.SpeedOfSound);
// Status Value
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_STATUS);
writer.WriteValue(data.Status.Value);
// NumBeams
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_NUMBEAMS);
writer.WriteValue(data.NumBeams);
// ActualPingCount
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_ACTUALPINGCOUNT);
writer.WriteValue(data.ActualPingCount);
// Range
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_RANGE);
writer.WriteStartArray();
for (int beam = 0; beam < data.NumBeams; beam++)
{
writer.WriteValue(data.Range[beam]);
}
writer.WriteEndArray();
// SNR
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_SNR);
writer.WriteStartArray();
for (int beam = 0; beam < data.NumBeams; beam++)
{
writer.WriteValue(data.SNR[beam]);
}
writer.WriteEndArray();
// Amplitude
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_AMPLITUDE);
writer.WriteStartArray();
for (int beam = 0; beam < data.NumBeams; beam++)
{
writer.WriteValue(data.Amplitude[beam]);
}
writer.WriteEndArray();
// Correlation
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_CORRELATION);
writer.WriteStartArray();
for (int beam = 0; beam < data.NumBeams; beam++)
{
writer.WriteValue(data.Correlation[beam]);
}
writer.WriteEndArray();
// Beam Velocity
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_BEAMVELOCITY);
writer.WriteStartArray();
for (int beam = 0; beam < data.NumBeams; beam++)
{
writer.WriteValue(data.BeamVelocity[beam]);
}
writer.WriteEndArray();
// Good Beam Velocity
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_BEAMGOOD);
writer.WriteStartArray();
for (int beam = 0; beam < data.NumBeams; beam++)
{
writer.WriteValue(data.BeamGood[beam]);
}
writer.WriteEndArray();
// Instrument Velocity
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_INSTRUMENTVELOCITY);
writer.WriteStartArray();
for (int beam = 0; beam < data.NumBeams; beam++)
{
writer.WriteValue(data.InstrumentVelocity[beam]);
}
writer.WriteEndArray();
// Good Instrument Velocity
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_INSTRUMENTGOOD);
writer.WriteStartArray();
for (int beam = 0; beam < data.NumBeams; beam++)
{
writer.WriteValue(data.InstrumentGood[beam]);
}
writer.WriteEndArray();
// Earth Velocity
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_EARTHVELOCITY);
writer.WriteStartArray();
for (int beam = 0; beam < data.NumBeams; beam++)
{
writer.WriteValue(data.EarthVelocity[beam]);
}
writer.WriteEndArray();
// Good Earth Velocity
writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_EARTHGOOD);
writer.WriteStartArray();
for (int beam = 0; beam < data.NumBeams; beam++)
{
writer.WriteValue(data.EarthGood[beam]);
}
writer.WriteEndArray();
// End the object
writer.WriteEndObject();
}
private static void WriteJsonInstance(JsonWriter writer, XmlJsonInstance instance)
{
switch (instance.NodeType)
{
case XPathNodeType.Attribute:
writer.WriteObject(instance.Name, instance.Value);
break;
case XPathNodeType.Element:
if (instance.IsPartOfArray() && instance.WriteStartArray())
{
writer.WriteObjectName(instance.Name);
}
else if (!instance.IsPartOfArray())
{
writer.WriteObjectName(instance.Name);
}
if (instance.WriteStartArray())
{
writer.WriteStartArray();
writer.WriteStartObject();
}
else
{
writer.WriteStartObject();
}
break;
case XPathNodeType.Text:
writer.WriteObject(instance.Name, instance.Value);
break;
}
if (instance.WriteValueSeperator())
{
if ((!instance.WriteStartArray() &&
(!instance.IsPartOfArray() && instance.NodeType == XPathNodeType.Attribute)) ||
instance.NodeType == XPathNodeType.Text)
{
writer.WriteValueSeperator();
}
}
if (instance.Instances.Count > 0)
{
instance.Instances.Sort(JsonInstanceCollection.Compare);
foreach (XmlJsonInstance childInstance in instance.Instances)
{
WriteJsonInstance(writer, childInstance);
}
}
switch (instance.NodeType)
{
case XPathNodeType.Attribute:
break;
case XPathNodeType.Element:
if (instance.WriteEndArray())
{
writer.WriteEndObject();
writer.WriteEndArray();
}
else
{
writer.WriteEndObject();
}
if (instance.WriteValueSeperator())
{
writer.WriteValueSeperator();
}
break;
}
}
/// <summary>
/// Converts XML to JsonML object form.
/// </summary>
public static void EncodeObjectForm(XmlReader reader, JsonWriter writer)
{
if (reader == null) throw new ArgumentNullException("reader");
if (writer == null) throw new ArgumentNullException("writer");
if (reader.MoveToContent() != XmlNodeType.Element)
throw new ArgumentException(null, "reader");
writer.WriteStartObject();
writer.WriteMember("tagName");
writer.WriteString(reader.Name);
//
// Write attributes
//
if (reader.MoveToFirstAttribute())
{
do
{
writer.WriteMember(reader.Name);
writer.WriteString(reader.Value);
}
while (reader.MoveToNextAttribute());
reader.MoveToElement();
}
bool isEmpty = reader.IsEmptyElement;
if (!isEmpty)
{
reader.Read();
int childCount = 0;
//
// Write child nodes (text, CDATA and element)
//
XmlNodeType nodeType;
while ((nodeType = reader.NodeType) != XmlNodeType.EndElement)
{
if (nodeType == XmlNodeType.Text
|| nodeType == XmlNodeType.CDATA
|| nodeType == XmlNodeType.Element)
{
if (childCount == 0)
{
writer.WriteMember("childNodes");
writer.WriteStartArray();
}
if (nodeType == XmlNodeType.Text || nodeType == XmlNodeType.CDATA)
{
writer.WriteString(reader.Value);
reader.Read();
}
else if (nodeType == XmlNodeType.Element)
{
EncodeObjectForm(reader, writer);
}
childCount++;
}
else
{
reader.Read();
}
}
if (childCount > 0)
writer.WriteEndArray();
}
writer.WriteEndObject();
reader.Read();
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
serializer.ContractResolver = new JsonResolver();
var packet = (Packet)value;
writer.WriteStartObject();
Action <string, object> Serialize = (string name, object obj) => {
writer.WritePropertyName(name);
serializer.Serialize(writer, obj);
};
if (Informative)
{
Serialize("ID", packet.packetID);
Serialize("Name", packet.GetName());
Serialize("Type", packet.GetPacketTypeName());
Serialize("Origin", packet.GetOrigin());
Serialize("Delay", packet.delay);
}
else
{
Serialize("ID", packet.packetID);
Serialize("TypeID", packet.type);
Serialize("Length", packet.incomingLength);
Serialize("GUID", packet.incomingGUID);
Serialize("Data", packet.baseStream.ToArray());
}
if (packet.length > 1 && Informative)
{
if (packet.type == Packet.PacketType.RUST)
{
writer.WritePropertyName("Content");
writer.WriteStartObject();
packet.Position = 1;
switch (packet.rustID)
{
case Packet.Rust.Approved:
Serialize("ProtoBuf", ProtoBuf.Approval.Deserialize(packet));
break;
case Packet.Rust.Auth:
var bytes = packet.BytesWithSize();
Serialize("AuthData", BitConverter.ToString(bytes).Replace("-", ""));
break;
case Packet.Rust.ConsoleCommand:
Serialize("Command", packet.String());
break;
case Packet.Rust.ConsoleMessage:
Serialize("Message", packet.String());
break;
case Packet.Rust.DisconnectReason:
Serialize("Reason", packet.String());
break;
case Packet.Rust.Effect:
Serialize("ProtoBuf", EffectData.Deserialize(packet));
break;
case Packet.Rust.Entities:
Serialize("Num", packet.UInt32());
Serialize("ProtoBuf", ProtoBuf.Entity.Deserialize(packet));
break;
case Packet.Rust.EntityDestroy:
Serialize("UID", packet.UInt32());
Serialize("Destroy Mode", packet.UInt8());
break;
case Packet.Rust.EntityPosition:
writer.WritePropertyName("Entity Positions");
writer.WriteStartArray();
while (packet.unread >= 28L)
{
writer.WriteStartObject();
Serialize("Entity ID", packet.EntityID());
Serialize("Position", packet.Vector3());
Serialize("Rotation", packet.Vector3());
writer.WriteEndObject();
}
writer.WriteEndArray();
break;
case Packet.Rust.GiveUserInformation:
Serialize("ProtocolVersion", packet.UInt8());
Serialize("Steam ID", packet.UInt64());
Serialize("Protocol", packet.UInt32());
Serialize("OS Name", packet.String());
Serialize("Steam Name", packet.String());
Serialize("Branch", packet.String());
break;
case Packet.Rust.GroupChange:
Serialize("Entity ID", packet.EntityID());
Serialize("Group ID", packet.GroupID());
break;
case Packet.Rust.GroupDestroy:
Serialize("Group ID", packet.GroupID());
break;
case Packet.Rust.GroupEnter:
Serialize("Group ID", packet.GroupID());
break;
case Packet.Rust.GroupLeave:
Serialize("Group ID", packet.GroupID());
break;
case Packet.Rust.Message:
Serialize("String 1 (PlayerName?)", packet.String());
Serialize("String 2 (PlayerMsg?)", packet.String());
break;
case Packet.Rust.RPCMessage:
Serialize("UID", packet.UInt32());
Serialize("Name ID", packet.UInt32());
Serialize("Source Connection", packet.UInt64());
break;
case Packet.Rust.Ready:
Serialize("ProtoBuf", ProtoBuf.ClientReady.Deserialize(packet));
break;
case Packet.Rust.Tick:
Serialize("ProtoBuf", PlayerTick.Deserialize(packet));
break;
default:
break;
}
writer.WriteEndObject();
}
}
writer.WriteEndObject();
}
