protected override void ExportValue(ExportContext context, object value, JsonWriter writer)
        {
            Debug.Assert(context != null);
            Debug.Assert(value != null);
            Debug.Assert(writer != null);
            
            if (_properties.Count == 0)
            {
                writer.WriteString(value.ToString());
            }
            else
            {
                writer.WriteStartObject();

                foreach (PropertyDescriptor property in _properties)
                {
                    object propertyValue = property.GetValue(value);
                
                    if (!JsonNull.LogicallyEquals(propertyValue))
                    {
                        writer.WriteMember(property.Name);
                        context.Export(propertyValue, writer);
                    }
                }

                writer.WriteEndObject();
            }
        }
    /// <summary>
    /// Writes the JSON representation of the object.
    /// </summary>
    /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
    /// <param name="value">The value.</param>
    /// <param name="serializer">The calling serializer.</param>
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
      IEntityKeyMember entityKeyMember = DynamicWrapper.CreateWrapper<IEntityKeyMember>(value);
      Type keyType = (entityKeyMember.Value != null) ? entityKeyMember.Value.GetType() : null;

      writer.WriteStartObject();
      writer.WritePropertyName("Key");
      writer.WriteValue(entityKeyMember.Key);
      writer.WritePropertyName("Type");
      writer.WriteValue((keyType != null) ? keyType.FullName : null);

      writer.WritePropertyName("Value");

      if (keyType != null)
      {
        string valueJson;
        if (JsonSerializerInternalWriter.TryConvertToString(entityKeyMember.Value, keyType, out valueJson))
          writer.WriteValue(valueJson);
        else
          writer.WriteValue(entityKeyMember.Value);
      }
      else
      {
        writer.WriteNull();
      }

      writer.WriteEndObject();
    }
        protected override void FormatOther(object o, JsonWriter writer)
        {
            if (writer == null)
                throw new ArgumentNullException("writer");

            if (JNull.LogicallyEquals(o))
            {
                FormatNull(o, writer);
                return;
            }

            writer.WriteStartObject();

            if (_properties == null)
                _properties = TypeDescriptor.GetProperties(o);

            foreach (PropertyDescriptor property in _properties)
            {
                // TODO: Allow someone to indicate via an attribute (e.g. JsonIgnore) that a property should be excluded.

                object value = property.GetValue(o);
                
                if (!JNull.LogicallyEquals(value))
                {
                    writer.WriteMember(property.Name);
                    writer.WriteValue(value);
                }
            }

            writer.WriteEndObject();
        }
Example #4
0
        private static void ExportDataSet(ExportContext context, DataSet dataSet, JsonWriter writer)
        {
            Debug.Assert(context != null);
            Debug.Assert(dataSet != null);
            Debug.Assert(writer != null);

            writer.WriteStartObject();
    
            foreach (DataTable table in dataSet.Tables)
            {
                writer.WriteMember(table.TableName);

                //
                // If there is an exporter (perhaps an override) for the 
                // DataTable in effect then use it. Otherwise our 
                // DataTableExporter.
                //

                IExporter tableExporter = context.FindExporter(table.GetType());
                
                if (tableExporter != null)
                    tableExporter.Export(context, table, writer);
                else
                    DataTableExporter.ExportTable(context, table, writer);
            }
    
            writer.WriteEndObject();
        }
        /// <summary>
        /// Writes the JSON representation of the object.
        /// </summary>
        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
        /// <param name="value">The value.</param>
        /// <param name="serializer">The calling serializer.</param>
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            DataTable table = (DataTable)value;
            DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver;

            writer.WriteStartArray();

            foreach (DataRow row in table.Rows)
            {
                writer.WriteStartObject();
                foreach (DataColumn column in row.Table.Columns)
                {
                    object columnValue = row[column];

                    if (serializer.NullValueHandling == NullValueHandling.Ignore && (columnValue == null || columnValue == DBNull.Value))
                    {
                        continue;
                    }

                    writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(column.ColumnName) : column.ColumnName);
                    serializer.Serialize(writer, columnValue);
                }
                writer.WriteEndObject();
            }

            writer.WriteEndArray();
        }
        /// <summary>
        /// Writes the JSON representation of the object.
        /// </summary>
        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
        /// <param name="value">The value.</param>
        /// <param name="serializer">The calling serializer.</param>
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver;

            IEntityKeyMember entityKeyMember = DynamicWrapper.CreateWrapper<IEntityKeyMember>(value);
            Type keyType = (entityKeyMember.Value != null) ? entityKeyMember.Value.GetType() : null;

            writer.WriteStartObject();
            writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(KeyPropertyName) : KeyPropertyName);
            writer.WriteValue(entityKeyMember.Key);
            writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(TypePropertyName) : TypePropertyName);
            writer.WriteValue((keyType != null) ? keyType.FullName : null);

            writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(ValuePropertyName) : ValuePropertyName);

            if (keyType != null)
            {
                string valueJson;
                if (JsonSerializerInternalWriter.TryConvertToString(entityKeyMember.Value, keyType, out valueJson))
                    writer.WriteValue(valueJson);
                else
                    writer.WriteValue(entityKeyMember.Value);
            }
            else
            {
                writer.WriteNull();
            }

            writer.WriteEndObject();
        }
        /// <summary>
        /// Writes the JSON representation of the object.
        /// </summary>
        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
        /// <param name="value">The value.</param>
        /// <param name="serializer">The calling serializer.</param>
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            EnsureReflectionObject(value.GetType());

            DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver;

            string keyName = (string)_reflectionObject.GetValue(value, KeyPropertyName);
            object keyValue = _reflectionObject.GetValue(value, ValuePropertyName);

            Type keyValueType = (keyValue != null) ? keyValue.GetType() : null;

            writer.WriteStartObject();
            writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(KeyPropertyName) : KeyPropertyName);
            writer.WriteValue(keyName);
            writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(TypePropertyName) : TypePropertyName);
            writer.WriteValue((keyValueType != null) ? keyValueType.FullName : null);

            writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(ValuePropertyName) : ValuePropertyName);

            if (keyValueType != null)
            {
                string valueJson;
                if (JsonSerializerInternalWriter.TryConvertToString(keyValue, keyValueType, out valueJson))
                    writer.WriteValue(valueJson);
                else
                    writer.WriteValue(keyValue);
            }
            else
            {
                writer.WriteNull();
            }

            writer.WriteEndObject();
        }
Example #8
0
 public void WritesEmptyObject()
 {
     var sw = new StringWriter();
     var writer = new JsonWriter(sw);
     writer.WriteStartObject();
     writer.WriteEnd();
     Assert.AreEqual("{}", sw.ToString());
 }
 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");
   }
 }
Example #10
0
 public void WritesSinglePropertyObject()
 {
     var sw = new StringWriter();
     var writer = new JsonWriter(sw);
     writer.WriteStartObject();
     writer.WriteName("A").WriteValue(1);
     writer.WriteEnd();
     Assert.AreEqual("{\"A\": 1}", sw.ToString());
 }
Example #11
0
        protected override void ExportValue(ExportContext context, object value, JsonWriter writer)
        {
            if (context == null) throw new ArgumentNullException("context");
            if (writer == null) throw new ArgumentNullException("writer");

            writer.WriteStartObject();
            ExportMembers(context, (ExpandoObject) value, writer);
            writer.WriteEndObject();
        }
Example #12
0
 private void WriteJson(JsonWriter writer, Regex regex)
 {
   writer.WriteStartObject();
   writer.WritePropertyName("Pattern");
   writer.WriteValue(regex.ToString());
   writer.WritePropertyName("Options");
   writer.WriteValue(regex.Options);
   writer.WriteEndObject();
 }
 // Token: 0x0600019E RID: 414
 // RVA: 0x0002BC3C File Offset: 0x00029E3C
 public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
 {
     ReflectionObject reflectionObject = KeyValuePairConverter.ReflectionObjectPerType.Get(value.GetType());
     DefaultContractResolver defaultContractResolver = serializer.ContractResolver as DefaultContractResolver;
     writer.WriteStartObject();
     writer.WritePropertyName((defaultContractResolver != null) ? defaultContractResolver.GetResolvedPropertyName("Key") : "Key");
     serializer.Serialize(writer, reflectionObject.GetValue(value, "Key"), reflectionObject.GetType("Key"));
     writer.WritePropertyName((defaultContractResolver != null) ? defaultContractResolver.GetResolvedPropertyName("Value") : "Value");
     serializer.Serialize(writer, reflectionObject.GetValue(value, "Value"), reflectionObject.GetType("Value"));
     writer.WriteEndObject();
 }
    /// <summary>
    /// Writes the JSON representation of the object.
    /// </summary>
    /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
    /// <param name="value">The value.</param>
    public override void WriteJson(JsonWriter writer, object value)
    {
      XmlNode node = value as XmlNode;

      if (node == null)
        throw new ArgumentException("Value must be an XmlNode", "value");

      writer.WriteStartObject();
      SerializeNode(writer, node, true);
      writer.WriteEndObject();
    }
        internal static void FormatTable(DataTable table, JsonWriter writer)
        {
            Debug.Assert(table != null);
            Debug.Assert(writer != null);

            writer.WriteStartObject();
            
            writer.WriteMember("rows");
            writer.WriteValue(table.Rows);

            writer.WriteEndObject();
        }
     private static void FormatRowView(DataRowView rowView, JsonWriter writer)
     {
         writer.WriteStartObject();
 
         foreach (DataColumn column in rowView.DataView.Table.Columns)
         {
             writer.WriteMember(column.ColumnName);
             writer.WriteValue(rowView[column.Ordinal]);
         }
 
         writer.WriteEndObject();
     }
     private static void FormatDataSet(DataSet dataSet, JsonWriter writer)
     {
         writer.WriteStartObject();
 
         foreach (DataTable table in dataSet.Tables)
         {
             writer.WriteMember(table.TableName);
             DataTableFormatter.FormatTable(table, writer);
         }
 
         writer.WriteEndObject();
     }
Example #18
0
 public void UnnamedObjectProperty()
 {
     var sw = new StringWriter();
     var writer = new JsonWriter(sw);
     writer.WriteStartObject();
     try {
         writer.WriteValue(1);
         Assert.Fail("Did not throw the expected exception");
     } catch (NotSupportedException ex) {
         Assert.AreEqual("Object properties must have a name written first", ex.Message);
     }
 }
        protected override void ExportValue(ExportContext context, object value, JsonWriter writer)
        {
            Debug.Assert(context != null);
            Debug.Assert(value != null);
            Debug.Assert(writer != null);
            
            if (_properties.Count == 0)
            {
                writer.WriteString(value.ToString());
            }
            else
            {
                ObjectReferenceTracker tracker = null;
                
                try
                {
                    writer.WriteStartObject();

                    foreach (PropertyDescriptor property in _properties)
                    {
                        object propertyValue = property.GetValue(value);
                
                        if (!JsonNull.LogicallyEquals(propertyValue))
                        {
                            writer.WriteMember(property.Name);

                            if (tracker == null)
                            {
                                //
                                // We are about to enter a deeper scope so 
                                // start tracking the current object being 
                                // exported. This will help to detect 
                                // recursive references that may occur 
                                // through this exporter deeper in the tree.
                                //
                                
                                tracker = TrackObject(context, value);
                            }

                            context.Export(propertyValue, writer);
                        }
                    }

                    writer.WriteEndObject();
                }
                finally
                {
                    if (tracker != null)
                        tracker.Pop(value);
                }
            }
        }
    /// <summary>
    /// Writes the JSON representation of the object.
    /// </summary>
    /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
    /// <param name="value">The value.</param>
    /// <param name="serializer">The calling serializer.</param>
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
      Type t = value.GetType();
      PropertyInfo keyProperty = t.GetProperty("Key");
      PropertyInfo valueProperty = t.GetProperty("Value");

      writer.WriteStartObject();
      writer.WritePropertyName("Key");
      serializer.Serialize(writer, ReflectionUtils.GetMemberValue(keyProperty, value));
      writer.WritePropertyName("Value");
      serializer.Serialize(writer, ReflectionUtils.GetMemberValue(valueProperty, value));
      writer.WriteEndObject();
    }
        /// <summary>
        /// Writes the JSON representation of the object.
        /// </summary>
        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
        /// <param name="value">The value.</param>
        /// <param name="serializer">The calling serializer.</param>
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            ReflectionObject reflectionObject = ReflectionObjectPerType.Get(value.GetType());

            DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver;

            writer.WriteStartObject();
            writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(KeyName) : KeyName);
            serializer.Serialize(writer, reflectionObject.GetValue(value, KeyName), reflectionObject.GetType(KeyName));
            writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(ValueName) : ValueName);
            serializer.Serialize(writer, reflectionObject.GetValue(value, ValueName), reflectionObject.GetType(ValueName));
            writer.WriteEndObject();
        }
 private void WriteJsonValue(JsonWriter writer, IJsonValue value)
 {
   switch (value.ValueType)
   {
     case JsonValueType.Array:
       {
         JsonArray a = value.GetArray();
         writer.WriteStartArray();
         for (int i = 0; i < a.Count; i++)
         {
           WriteJsonValue(writer, a[i]);
         }
         writer.WriteEndArray();
       }
       break;
     case JsonValueType.Boolean:
       {
         writer.WriteValue(value.GetBoolean());
       }
       break;
     case JsonValueType.Null:
       {
         writer.WriteNull();
       }
       break;
     case JsonValueType.Number:
       {
         writer.WriteValue(value.GetNumber());
       }
       break;
     case JsonValueType.Object:
       {
         JsonObject o = value.GetObject();
         writer.WriteStartObject();
         foreach (KeyValuePair<string, IJsonValue> v in o)
         {
           writer.WritePropertyName(v.Key);
           WriteJsonValue(writer, v.Value);
         }
         writer.WriteEndObject();
       }
       break;
     case JsonValueType.String:
       {
         writer.WriteValue(value.GetString());
       }
       break;
     default:
       throw new ArgumentOutOfRangeException("ValueType");
   }
 }
 protected override void ExportValue(object value, JsonWriter writer)
 {
     writer.WriteStartObject();
     
     IDictionary dictionary = (IDictionary) value;
     
     foreach (DictionaryEntry entry in dictionary)
     {
         writer.WriteMember(entry.Key.ToString());
         writer.WriteValue(entry.Value);
     }
     
     writer.WriteEndObject();
 }
        internal static void FormatDataRow(DataRow row, JsonWriter writer)
        {
            Debug.Assert(row != null);
            Debug.Assert(writer != null);

            writer.WriteStartObject();
    
            foreach (DataColumn column in row.Table.Columns)
            {
                writer.WriteMember(column.ColumnName);
                writer.WriteValue(row[column]);
            }
    
            writer.WriteEndObject();
        }
        /// <summary>
        /// Writes the JSON representation of the object.
        /// </summary>
        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
        /// <param name="serializer">The calling serializer.</param>
        /// <param name="value">The value.</param>
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            IXmlNode node = WrapXml(value);

            XmlNamespaceManager manager = new XmlNamespaceManager(new NameTable());
            PushParentNamespaces(node, manager);

            if (!OmitRootObject)
                writer.WriteStartObject();

            SerializeNode(writer, node, manager, !OmitRootObject);

            if (!OmitRootObject)
                writer.WriteEndObject();
        }
		private void SerializePrimitive(JsonWriter writer, object value, JsonPrimitiveContract contract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerProperty) {
			if (contract.UnderlyingType == typeof(byte[])) {
				bool includeTypeDetails = ShouldWriteType(TypeNameHandling.Objects, contract, member, containerContract, containerProperty);
				if (includeTypeDetails) {
					writer.WriteStartObject();
					WriteTypeProperty(writer, contract.CreatedType);
					writer.WritePropertyName(JsonTypeReflector.ValuePropertyName);
					writer.WriteValue(value);
					writer.WriteEndObject();
					return;
				}
			}

			writer.WriteValue(value);
		}
        private static void ExportDataSet(DataSet dataSet, JsonWriter writer)
        {
            Debug.Assert(dataSet != null);
            Debug.Assert(writer != null);

            writer.WriteStartObject();
    
            foreach (DataTable table in dataSet.Tables)
            {
                writer.WriteMember(table.TableName);
                DataTableExporter.ExportTable(table, writer);
            }
    
            writer.WriteEndObject();
        }
Example #28
0
        internal static void ExportRecord(ExportContext context, ICustomTypeDescriptor record, JsonWriter writer)
        {
            Debug.Assert(context != null);
            Debug.Assert(record != null);
            Debug.Assert(writer != null);
            
            writer.WriteStartObject();
                        
            foreach (PropertyDescriptor property in record.GetProperties())
            {
                writer.WriteMember(property.Name);
                context.Export(property.GetValue(record), writer);
            }

            writer.WriteEndObject();
        }
Example #29
0
    /// <summary>
    /// Writes the JSON representation of the object.
    /// </summary>
    /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
    /// <param name="value">The value.</param>
    /// <param name="serializer">The calling serializer.</param>
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
      Type t = value.GetType();
      PropertyInfo keyProperty = t.GetProperty(KeyName);
      PropertyInfo valueProperty = t.GetProperty(ValueName);

      DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver;

      writer.WriteStartObject();

      writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(KeyName) : KeyName);
      serializer.Serialize(writer, ReflectionUtils.GetMemberValue(keyProperty, value));
      writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(ValueName) : ValueName);
      serializer.Serialize(writer, ReflectionUtils.GetMemberValue(valueProperty, value));
      writer.WriteEndObject();
    }
        internal static void ExportRow(ExportContext context, DataRow row, JsonWriter writer)
        {
            Debug.Assert(context != null);
            Debug.Assert(row != null);
            Debug.Assert(writer != null);

            writer.WriteStartObject();
    
            foreach (DataColumn column in row.Table.Columns)
            {
                writer.WriteMember(column.ColumnName);
                context.Export(row[column], writer);
            }
    
            writer.WriteEndObject();
        }
Example #31
0
        public static void Serialize(Madingley.Common.Configuration configuration, TextWriter textWriter)
        {
            Action <Newtonsoft.Json.JsonWriter, Madingley.Common.FunctionalGroupDefinition> JsonAddPropertyFunctionalGroupDefinition = (JsonWriter, value) =>
            {
                JsonWriter.WriteStartObject();
                Common.Writer.PropertyKeyValuePairs(JsonWriter, "Definitions", value.Definitions, Common.Writer.PropertyString);
                Common.Writer.PropertyKeyValuePairs(JsonWriter, "Properties", value.Properties, Common.Writer.PropertyDouble);
                JsonWriter.WriteEndObject();
            };

            Action <Newtonsoft.Json.JsonWriter, string, Madingley.Common.FunctionalGroupDefinitions> JsonAddPropertyFunctionalGroupDefinitions = (JsonWriter, name, value) =>
            {
                JsonWriter.WritePropertyName(name);
                JsonWriter.WriteStartObject();
                Common.Writer.PropertyArray(JsonWriter, "Data", value.Data, JsonAddPropertyFunctionalGroupDefinition);
                Common.Writer.PropertyInlineArray(JsonWriter, "Definitions", value.Definitions, Common.Writer.WriteString);
                Common.Writer.PropertyInlineArray(JsonWriter, "Properties", value.Properties, Common.Writer.WriteString);
                JsonWriter.WriteEndObject();
            };

            Action <Newtonsoft.Json.JsonWriter, string, Madingley.Common.ScenarioParameter> JsonAddPropertyScenarioParameter = (JsonWriter, name, value) =>
            {
                JsonWriter.WritePropertyName(name);
                JsonWriter.WriteStartObject();
                Common.Writer.PropertyString(JsonWriter, "ParamString", value.ParamString);
                Common.Writer.PropertyDouble(JsonWriter, "ParamDouble1", value.ParamDouble1);
                Common.Writer.PropertyDouble(JsonWriter, "ParamDouble2", value.ParamDouble2);
                JsonWriter.WriteEndObject();
            };

            Action <Newtonsoft.Json.JsonWriter, Madingley.Common.ScenarioParameters> JsonAddScenarioParameter = (JsonWriter, value) =>
            {
                JsonWriter.WriteStartObject();
                Common.Writer.PropertyString(JsonWriter, "Label", value.Label);
                Common.Writer.PropertyInt(JsonWriter, "SimulationNumber", value.SimulationNumber);
                Common.Writer.PropertyKeyValuePairs(JsonWriter, "Parameters", value.Parameters, JsonAddPropertyScenarioParameter);
                JsonWriter.WriteEndObject();
            };

            Action <Newtonsoft.Json.JsonWriter, string, Madingley.Common.EcologicalParameters> JsonAddEcologicalParameters = (JsonWriter, name, ecologicalParameters) =>
            {
                JsonWriter.WritePropertyName(name);
                JsonWriter.WriteStartObject();
                Common.Writer.PropertyKeyValuePairs(JsonWriter, "Parameters", ecologicalParameters.Parameters, Common.Writer.PropertyDouble);
                Common.Writer.PropertyInlineArray(JsonWriter, "TimeUnits", ecologicalParameters.TimeUnits, Common.Writer.WriteString);
                JsonWriter.WriteEndObject();
            };

            using (var writer = new Newtonsoft.Json.JsonTextWriter(textWriter))
            {
                writer.Formatting = Newtonsoft.Json.Formatting.Indented;

                writer.WriteStartObject();
                Common.Writer.PropertyString(writer, "GlobalModelTimeStepUnit", configuration.GlobalModelTimeStepUnit);
                Common.Writer.PropertyInt(writer, "NumTimeSteps", configuration.NumTimeSteps);
                Common.Writer.PropertyInt(writer, "BurninTimeSteps", configuration.BurninTimeSteps);
                Common.Writer.PropertyInt(writer, "ImpactTimeSteps", configuration.ImpactTimeSteps);
                Common.Writer.PropertyInt(writer, "RecoveryTimeSteps", configuration.RecoveryTimeSteps);
                Common.Writer.PropertyBoolean(writer, "RunCellsInParallel", configuration.RunCellsInParallel);
                Common.Writer.PropertyBoolean(writer, "RunSimulationsInParallel", configuration.RunSimulationsInParallel);
                Common.Writer.PropertyString(writer, "RunRealm", configuration.RunRealm);
                Common.Writer.PropertyBoolean(writer, "DrawRandomly", configuration.DrawRandomly);
                Common.Writer.PropertyDouble(writer, "ExtinctionThreshold", configuration.ExtinctionThreshold);
                Common.Writer.PropertyInt(writer, "MaxNumberOfCohorts", configuration.MaxNumberOfCohorts);
                Common.Writer.PropertyBoolean(writer, "DispersalOnly", configuration.DispersalOnly);
                Common.Writer.PropertyString(writer, "DispersalOnlyType", configuration.DispersalOnlyType);
                Common.Writer.PropertyDouble(writer, "PlanktonDispersalThreshold", configuration.PlanktonDispersalThreshold);
                JsonAddPropertyFunctionalGroupDefinitions(writer, "CohortFunctionalGroupDefinitions", configuration.CohortFunctionalGroupDefinitions);
                JsonAddPropertyFunctionalGroupDefinitions(writer, "StockFunctionalGroupDefinitions", configuration.StockFunctionalGroupDefinitions);
                Common.Writer.PropertyInlineArray(writer, "ImpactCellIndices", configuration.ImpactCellIndices, Common.Writer.WriteInt);
                Common.Writer.PropertyBoolean(writer, "ImpactAll", configuration.ImpactAll);
                Common.Writer.PropertyArray(writer, "ScenarioParameters", configuration.ScenarioParameters, JsonAddScenarioParameter);
                Common.Writer.PropertyInt(writer, "ScenarioIndex", configuration.ScenarioIndex);
                Common.Writer.PropertyInt(writer, "Simulation", configuration.Simulation);
                JsonAddEcologicalParameters(writer, "EcologicalParameters", configuration.EcologicalParameters);
                Common.Writer.PropertyInlineArray(writer, "FileNames", configuration.FileNames, Common.Writer.WriteString);
                writer.WriteEndObject();
            }
        }
Example #32
0
        public static void WriteTo(this ICursor source, JsonWriter writer, bool stripNullValues = true)
        {
            if (source == null || source.IsNull)
            {
                writer.WriteNull();
            }
            else
            {
                switch (source.Schema.DataType)
                {
                case DataType.Class:
                    if (source.Schema.Id == (int)BuiltInSchema.Variable)
                    {
                        var content = source.GoTo((int)VariableLayout.Data, true);
                        if (!content.IsNull &&
                            content.Schema.DataType != DataType.String &&
                            content.Schema.DataType != DataType.Boolean &&
                            (content.Schema.DataType == DataType.List ||
                             content.Schema.DataType == DataType.MultiChoice ||
                             EditablePrimitive.IsSupportedType(content.Schema.DataType)
                            )
                            )
                        {
                            writer.WriteStartObject();
                            writer.WritePropertyName("@schema");
                            writer.WriteValue(source.Schema.Name);
                            writer.WritePropertyName("DataSchema");
                            writer.WriteValue(content.Schema.Name);
                            writer.WritePropertyName("Data");
                            content.WriteTo(writer, stripNullValues);
                            writer.WriteEndObject();
                        }
                        else
                        {
                            content.WriteTo(writer, stripNullValues);
                        }
                    }
                    else
                    {
                        writer.WriteStartObject();
                        writer.WritePropertyName("@schema");
                        writer.WriteValue(source.Schema.Name);
                        foreach (var f in source.Schema.Fields)
                        {
                            var field = source.GoTo(f, false);
                            if (!stripNullValues || !field.IsNull)
                            {
                                writer.WritePropertyName(f.Name);
                                field.WriteTo(writer, stripNullValues);
                            }
                        }
                        writer.WriteEndObject();
                    }
                    break;

                case DataType.MultiChoice:
                case DataType.List:
                {
                    writer.WriteStartArray();
                    for (int i = 0; i < source.Count; ++i)
                    {
                        var field = source.GoTo(i, false);
                        if (!stripNullValues || !field.IsNull)
                        {
                            field.WriteTo(writer, stripNullValues);
                        }
                    }
                    writer.WriteEndArray();
                }
                break;

                default:
                {
                    EditablePrimitive.PrimitiveType typeHelper;
                    if (EditablePrimitive.TryGetPrimitiveTypeHelper(source.Schema, out typeHelper))
                    {
                        typeHelper.JsonWrite(writer, source.Get());
                    }
                    else
                    {
                        throw new Exception(string.Format("Unable to convert data type '{0}' to JSON string.", source.Schema.DataType));
                    }
                }
                break;
                }
            }
        }
Example #33
0
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            switch (value)
            {
            case PsbNull _:
                writer.WriteNull();
                break;

            case PsbBool b:
                writer.WriteValue(b.Value);
                break;

            case PsbNumber num:
                switch (num.NumberType)
                {
                case PsbNumberType.Int:
                    writer.WriteValue(num.IntValue);
                    break;

                case PsbNumberType.Float:
                    if (num.FloatValue.IsFinite() && !UseHexNumber)
                    {
                        writer.WriteValue(num.FloatValue);
                    }
                    else
                    {
                        writer.WriteValue($"{Consts.NumberStringPrefix}{num.IntValue:X8}f");
                    }
                    //writer.WriteRawValue(num.FloatValue.ToString("R"));
                    break;

                case PsbNumberType.Double:
                    if (num.DoubleValue.IsFinite() && !UseHexNumber)
                    {
                        writer.WriteValue(num.DoubleValue);
                    }
                    else
                    {
                        writer.WriteValue($"{Consts.NumberStringPrefix}{num.LongValue:X16}d");
                    }
                    break;

                default:
                    writer.WriteValue(num.LongValue);
                    break;
                }
                break;

            case PsbString str:
                writer.WriteValue(str.Value);
                break;

            case PsbResource res:
                //writer.WriteValue(Convert.ToBase64String(res.Data, Base64FormattingOptions.None));
                writer.WriteValue($"{Consts.ResourceIdentifier}{res.Index}");
                break;

            case PsbArray array:
                writer.WriteValue(array.Value);
                break;

            case PsbList collection:
                if (ArrayCollapse)
                {
                    writer.WriteStartArray();
                    if (collection.Count > 0 && !(collection[0] is IPsbCollection))
                    {
                        writer.Formatting = Formatting.None;
                    }
                    foreach (var obj in collection)
                    {
                        WriteJson(writer, obj, serializer);
                    }
                    writer.WriteEndArray();
                    writer.Formatting = Formatting.Indented;
                }
                else
                {
                    writer.WriteStartArray();
                    foreach (var obj in collection)
                    {
                        WriteJson(writer, obj, serializer);
                    }
                    writer.WriteEndArray();
                }
                break;

            case PsbDictionary dictionary:
                writer.WriteStartObject();
                foreach (var obj in dictionary)
                {
                    writer.WritePropertyName(obj.Key);
                    WriteJson(writer, obj.Value, serializer);
                }
                writer.WriteEndObject();
                break;

            default:
                break;
            }
        }
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            var  ws           = (WorkspaceModel)value;
            bool isCustomNode = value is CustomNodeWorkspaceModel;

            writer.WriteStartObject();
            writer.WritePropertyName("Uuid");
            if (isCustomNode)
            {
                writer.WriteValue((ws as CustomNodeWorkspaceModel).CustomNodeId.ToString());
            }
            else
            {
                writer.WriteValue(ws.Guid.ToString());
            }
            // TODO: revisit IsCustomNode during DYN/DYF convergence
            writer.WritePropertyName("IsCustomNode");
            writer.WriteValue(value is CustomNodeWorkspaceModel ? true : false);
            if (isCustomNode)
            {
                writer.WritePropertyName("Category");
                writer.WriteValue(((CustomNodeWorkspaceModel)value).Category);
            }

            // Description
            writer.WritePropertyName("Description");
            if (isCustomNode)
            {
                writer.WriteValue(((CustomNodeWorkspaceModel)ws).Description);
            }
            else
            {
                writer.WriteValue(ws.Description);
            }
            writer.WritePropertyName("Name");
            writer.WriteValue(ws.Name);

            //element resolver
            writer.WritePropertyName("ElementResolver");
            serializer.Serialize(writer, ws.ElementResolver);

            //inputs
            writer.WritePropertyName("Inputs");
            //find nodes which are inputs and get their inputData if its not null.
            var inputNodeDatas = ws.Nodes.Where((node) => node.IsSetAsInput == true && node.InputData != null)
                                 .Select(inputNode => inputNode.InputData).ToList();

            serializer.Serialize(writer, inputNodeDatas);

            //outputs
            writer.WritePropertyName("Outputs");
            //find nodes which are outputs and get their outputData if its not null.
            var outputNodeDatas = ws.Nodes.Where((node) => node.IsSetAsOutput == true && node.OutputData != null)
                                  .Select(outputNode => outputNode.OutputData).ToList();

            serializer.Serialize(writer, outputNodeDatas);

            //nodes
            writer.WritePropertyName("Nodes");
            serializer.Serialize(writer, ws.Nodes);

            //connectors
            writer.WritePropertyName("Connectors");
            serializer.Serialize(writer, ws.Connectors);

            // Dependencies
            writer.WritePropertyName("Dependencies");
            writer.WriteStartArray();
            var functions = ws.Nodes.Where(n => n is Function);

            if (functions.Any())
            {
                var deps = functions.Cast <Function>().Select(f => f.Definition.FunctionId).Distinct();
                foreach (var d in deps)
                {
                    writer.WriteValue(d);
                }
            }
            writer.WriteEndArray();

            if (engine != null)
            {
                // Bindings
                writer.WritePropertyName(Configurations.BindingsTag);
                writer.WriteStartArray();

                // Selecting all nodes that are either a DSFunction,
                // a DSVarArgFunction or a CodeBlockNodeModel into a list.
                var nodeGuids =
                    ws.Nodes.Where(
                        n => n is DSFunction || n is DSVarArgFunction || n is CodeBlockNodeModel || n is Function)
                    .Select(n => n.GUID);

                var nodeTraceDataList = engine.LiveRunnerRuntimeCore.RuntimeData.GetTraceDataForNodes(nodeGuids,
                                                                                                      this.engine.LiveRunnerRuntimeCore.DSExecutable);

                // serialize given node-data-list pairs into an Json.
                if (nodeTraceDataList.Any())
                {
                    foreach (var pair in nodeTraceDataList)
                    {
                        writer.WriteStartObject();
                        writer.WritePropertyName(Configurations.NodeIdAttribName);
                        // Set the node ID attribute for this element.
                        var nodeGuid = pair.Key.ToString();
                        writer.WriteValue(nodeGuid);
                        writer.WritePropertyName(Configurations.BingdingTag);
                        // D4R binding
                        writer.WriteStartObject();
                        foreach (var data in pair.Value)
                        {
                            writer.WritePropertyName(data.ID);
                            writer.WriteValue(data.Data);
                        }
                        writer.WriteEndObject();
                        writer.WriteEndObject();
                    }
                }
                writer.WriteEndArray();
                writer.WriteEndObject();
            }
        }
Example #35
0
 /// <summary>
 /// Writes the opening tag and the header for the document.
 /// </summary>
 /// <param name="mobileDoc"></param>
 public void EnterMobileDoc(MobileDoc mobileDoc)
 {
     _jsonWriter.WriteStartObject();
     _jsonWriter.WritePropertyName("version");
     _jsonWriter.WriteValue(mobileDoc.Version);
 }
Example #36
0
        public override void WriteJson(JsonWriter writer, object value, Newtonsoft.Json.JsonSerializer serializer)
        {
            var message = value as Message;

            writer.WriteStartObject();

            writer.WritePropertyName("Topic");
            writer.WriteValue(message.Topic);


            foreach (var name in message.Fields)
            {
                var bin        = message[name];
                var typeRecord = TypeIdentity.Instance[bin.GetInnerType()];

                if (typeRecord == null)
                {
                    continue;
                }
                if (typeRecord.CloneMethod == CloneBehaviour.Null)
                {
                    continue;
                }

                string extraType = "";
                if (!NativeJsonTypes.Contains(bin.GetInnerType()))
                {
                    extraType = "<" + typeRecord.Alias + ">";
                }

                writer.WritePropertyName(name + extraType);

                if (bin.Count != 1)
                {
                    writer.WriteStartArray();
                }

                foreach (object o in bin)
                {
                    if (o is Stream)
                    {
                        var sr = new StreamReader((Stream)o);
                        serializer.Serialize(writer, sr.ReadToEnd());
                    }
                    else
                    {
                        serializer.Serialize(writer, o, bin.GetInnerType());
                    }
                }
                if (bin.Count != 1)
                {
                    writer.WriteEndArray();
                }
            }

            writer.WritePropertyName("Stamp");
            serializer.Serialize(writer, message.TimeStamp, typeof(Time));

            JObject.FromObject(message.TimeStamp, serializer);

            writer.WriteEndObject();
        }
Example #37
0
        private void SerializeNode(JsonWriter writer, XmlNode node, bool writePropertyName)
        {
            switch (node.NodeType)
            {
            case XmlNodeType.Document:
            case XmlNodeType.DocumentFragment:
                SerializeGroupedNodes(writer, node);
                break;

            case XmlNodeType.Element:
                if (writePropertyName)
                {
                    writer.WritePropertyName(node.Name);
                }

                if (ValueAttributes(node.Attributes).Count() == 0 && node.ChildNodes.Count == 1 &&
                    node.ChildNodes[0].NodeType == XmlNodeType.Text)
                {
                    // write elements with a single text child as a name value pair
                    writer.WriteValue(node.ChildNodes[0].Value);
                }
                else if (node.ChildNodes.Count == 0 && CollectionUtils.IsNullOrEmpty(node.Attributes))
                {
                    // empty element
                    writer.WriteNull();
                }
                else if (node.ChildNodes.OfType <XmlElement>().Where(x => x.Name.StartsWith("-")).Count() > 1)
                {
                    XmlElement constructorValueElement = node.ChildNodes.OfType <XmlElement>().Where(x => x.Name.StartsWith("-")).First();
                    string     constructorName         = constructorValueElement.Name.Substring(1);

                    writer.WriteStartConstructor(constructorName);

                    for (int i = 0; i < node.ChildNodes.Count; i++)
                    {
                        SerializeNode(writer, node.ChildNodes[i], false);
                    }

                    writer.WriteEndConstructor();
                }
                else
                {
                    writer.WriteStartObject();

                    for (int i = 0; i < node.Attributes.Count; i++)
                    {
                        SerializeNode(writer, node.Attributes[i], true);
                    }

                    SerializeGroupedNodes(writer, node);

                    writer.WriteEndObject();
                }

                break;

            case XmlNodeType.Comment:
                if (writePropertyName)
                {
                    writer.WriteComment(node.Value);
                }
                break;

            case XmlNodeType.Attribute:
            case XmlNodeType.Text:
            case XmlNodeType.CDATA:
            case XmlNodeType.ProcessingInstruction:
            case XmlNodeType.Whitespace:
            case XmlNodeType.SignificantWhitespace:
                if (node.Prefix == "xmlns" && node.Value == JsonNamespaceUri)
                {
                    break;
                }
                else if (node.NamespaceURI == JsonNamespaceUri)
                {
                    break;
                }

                if (writePropertyName)
                {
                    writer.WritePropertyName(GetPropertyName(node));
                }
                writer.WriteValue(node.Value);
                break;

            case XmlNodeType.XmlDeclaration:
                XmlDeclaration declaration = (XmlDeclaration)node;
                writer.WritePropertyName(GetPropertyName(node));
                writer.WriteStartObject();

                if (!string.IsNullOrEmpty(declaration.Version))
                {
                    writer.WritePropertyName("@version");
                    writer.WriteValue(declaration.Version);
                }
                if (!string.IsNullOrEmpty(declaration.Encoding))
                {
                    writer.WritePropertyName("@encoding");
                    writer.WriteValue(declaration.Encoding);
                }
                if (!string.IsNullOrEmpty(declaration.Standalone))
                {
                    writer.WritePropertyName("@standalone");
                    writer.WriteValue(declaration.Standalone);
                }

                writer.WriteEndObject();
                break;

            default:
                throw new JsonSerializationException("Unexpected XmlNodeType when serializing nodes: " + node.NodeType);
            }
        }
Example #38
0
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            var dictionary = (IDictionary)value;

            if (dictionary == null)
            {
                writer.WriteNull();
                return;
            }

            var settings    = serializer.GetConnectionSettings();
            var seenEntries = new Dictionary <string, object>(dictionary.Count);

            Field        fieldName;
            PropertyName propertyName;
            IndexName    indexName;
            TypeName     typeName;

            foreach (DictionaryEntry entry in dictionary)
            {
                if (entry.Value == null && serializer.NullValueHandling == NullValueHandling.Ignore)
                {
                    continue;
                }
                string key;
                if (settings == null)
                {
                    key = Convert.ToString(entry.Key, CultureInfo.InvariantCulture);
                }
                else if (AsType(entry.Key, out fieldName))
                {
                    key = settings.Inferrer.Field(fieldName);
                }
                else if (AsType(entry.Key, out propertyName))
                {
                    if (propertyName?.Property != null)
                    {
                        IPropertyMapping mapping;
                        if (settings.PropertyMappings.TryGetValue(propertyName.Property, out mapping) && mapping.Ignore)
                        {
                            continue;
                        }
                    }

                    key = settings.Inferrer.PropertyName(propertyName);
                }
                else if (AsType(entry.Key, out indexName))
                {
                    key = settings.Inferrer.IndexName(indexName);
                }
                else if (AsType(entry.Key, out typeName))
                {
                    key = settings.Inferrer.TypeName(typeName);
                }
                else
                {
                    key = Convert.ToString(entry.Key, CultureInfo.InvariantCulture);
                }

                if (key != null)
                {
                    seenEntries[key] = entry.Value;
                }
            }

            writer.WriteStartObject();
            foreach (var entry in seenEntries)
            {
                writer.WritePropertyName(entry.Key);
                serializer.Serialize(writer, entry.Value);
            }
            writer.WriteEndObject();
        }
        private void SerializeDictionary(JsonWriter writer, IWrappedDictionary values, JsonDictionaryContract contract, JsonProperty member, JsonContract collectionValueContract)
        {
            contract.InvokeOnSerializing(values.UnderlyingDictionary, base.Serializer.Context);
            this.SerializeStack.Add(values.UnderlyingDictionary);
            writer.WriteStartObject();
            bool?isReference = contract.IsReference;

            if ((!isReference.HasValue ? this.HasFlag(base.Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Objects) : isReference.Value))
            {
                writer.WritePropertyName("$id");
                writer.WriteValue(base.Serializer.ReferenceResolver.GetReference(this, values.UnderlyingDictionary));
            }
            if (this.ShouldWriteType(TypeNameHandling.Objects, contract, member, collectionValueContract))
            {
                this.WriteTypeProperty(writer, values.UnderlyingDictionary.GetType());
            }
            JsonContract          jsonContract = base.Serializer.ContractResolver.ResolveContract(contract.DictionaryValueType ?? typeof(object));
            int                   top          = writer.Top;
            IDictionaryEnumerator enumerator   = values.GetEnumerator();

            try
            {
                while (enumerator.MoveNext())
                {
                    DictionaryEntry current      = (DictionaryEntry)enumerator.Current;
                    string          propertyName = this.GetPropertyName(current);
                    propertyName = (contract.PropertyNameResolver == null ? propertyName : contract.PropertyNameResolver(propertyName));
                    try
                    {
                        object       value        = current.Value;
                        JsonContract contractSafe = this.GetContractSafe(value);
                        if (this.ShouldWriteReference(value, null, contractSafe))
                        {
                            writer.WritePropertyName(propertyName);
                            this.WriteReference(writer, value);
                        }
                        else if (this.CheckForCircularReference(value, null, contract))
                        {
                            writer.WritePropertyName(propertyName);
                            this.SerializeValue(writer, value, contractSafe, null, jsonContract);
                        }
                        else
                        {
                            continue;
                        }
                    }
                    catch (Exception exception)
                    {
                        if (!base.IsErrorHandled(values.UnderlyingDictionary, contract, propertyName, exception))
                        {
                            throw;
                        }
                        else
                        {
                            this.HandleError(writer, top);
                        }
                    }
                }
            }
            finally
            {
                IDisposable disposable  = enumerator as IDisposable;
                IDisposable disposable1 = disposable;
                if (disposable != null)
                {
                    disposable1.Dispose();
                }
            }
            writer.WriteEndObject();
            this.SerializeStack.RemoveAt(this.SerializeStack.Count - 1);
            contract.InvokeOnSerialized(values.UnderlyingDictionary, base.Serializer.Context);
        }
        private void WriteRootObjectProperties(JsonWriter jsonWriter)
        {
            var att = this._propertyNameResolver.GetElasticPropertyFor(this._type);

            if (att == null)
            {
                return;
            }

            if (!att.DateDetection)
            {
                jsonWriter.WritePropertyName("date_detection");
                jsonWriter.WriteRawValue("false");
            }
            if (att.NumericDetection)
            {
                jsonWriter.WritePropertyName("numeric_detection");
                jsonWriter.WriteRawValue("true");
            }
            if (!att.IndexAnalyzer.IsNullOrEmpty())
            {
                jsonWriter.WritePropertyName("index_analyzer");
                jsonWriter.WriteValue(att.IndexAnalyzer);
            }
            if (!att.SearchAnalyzer.IsNullOrEmpty())
            {
                jsonWriter.WritePropertyName("search_analyzer");
                jsonWriter.WriteValue(att.SearchAnalyzer);
            }
            if (!att.SearchAnalyzer.IsNullOrEmpty())
            {
                jsonWriter.WritePropertyName("search_analyzer");
                jsonWriter.WriteValue(att.SearchAnalyzer);
            }
            if (!att.ParentType.IsNullOrEmpty())
            {
                jsonWriter.WritePropertyName("_parent");
                jsonWriter.WriteStartObject();
                {
                    jsonWriter.WritePropertyName("type");
                    jsonWriter.WriteValue(att.ParentType);
                }
                jsonWriter.WriteEndObject();
            }
            if (att.DisableAllField)
            {
                jsonWriter.WritePropertyName("_all");
                jsonWriter.WriteStartObject();
                {
                    jsonWriter.WritePropertyName("enabled");
                    jsonWriter.WriteValue("false");
                }
                jsonWriter.WriteEndObject();
            }
            if (att.DynamicDateFormats != null && att.DynamicDateFormats.Any())
            {
                jsonWriter.WritePropertyName("dynamic_date_formats");
                jsonWriter.WriteStartArray();
                foreach (var d in att.DynamicDateFormats)
                {
                    jsonWriter.WriteValue(d);
                }
                jsonWriter.WriteEndArray();
            }
        }
Example #41
0
        /// <summary>
        /// Serializes the object to JSON.
        /// </summary>
        /// <param name="writer">The <see cref="T: Newtonsoft.Json.JsonWriter" /> to write to.</param>
        /// <param name="obj">The object to serialize to JSON.</param>
        internal static void Serialize(JsonWriter writer, ApplicationUpgradeProgressInfo obj)
        {
            // Required properties are always serialized, optional properties are serialized when not null.
            writer.WriteStartObject();
            writer.WriteProperty(obj.UpgradeState, "UpgradeState", UpgradeStateConverter.Serialize);
            writer.WriteProperty(obj.RollingUpgradeMode, "RollingUpgradeMode", UpgradeModeConverter.Serialize);
            writer.WriteProperty(obj.FailureReason, "FailureReason", FailureReasonConverter.Serialize);
            if (obj.Name != null)
            {
                writer.WriteProperty(obj.Name, "Name", JsonWriterExtensions.WriteStringValue);
            }

            if (obj.TypeName != null)
            {
                writer.WriteProperty(obj.TypeName, "TypeName", JsonWriterExtensions.WriteStringValue);
            }

            if (obj.TargetApplicationTypeVersion != null)
            {
                writer.WriteProperty(obj.TargetApplicationTypeVersion, "TargetApplicationTypeVersion", JsonWriterExtensions.WriteStringValue);
            }

            if (obj.UpgradeDomains != null)
            {
                writer.WriteEnumerableProperty(obj.UpgradeDomains, "UpgradeDomains", UpgradeDomainInfoConverter.Serialize);
            }

            if (obj.NextUpgradeDomain != null)
            {
                writer.WriteProperty(obj.NextUpgradeDomain, "NextUpgradeDomain", JsonWriterExtensions.WriteStringValue);
            }

            if (obj.UpgradeDescription != null)
            {
                writer.WriteProperty(obj.UpgradeDescription, "UpgradeDescription", ApplicationUpgradeDescriptionConverter.Serialize);
            }

            if (obj.UpgradeDurationInMilliseconds != null)
            {
                writer.WriteProperty(obj.UpgradeDurationInMilliseconds, "UpgradeDurationInMilliseconds", JsonWriterExtensions.WriteStringValue);
            }

            if (obj.UpgradeDomainDurationInMilliseconds != null)
            {
                writer.WriteProperty(obj.UpgradeDomainDurationInMilliseconds, "UpgradeDomainDurationInMilliseconds", JsonWriterExtensions.WriteStringValue);
            }

            if (obj.UnhealthyEvaluations != null)
            {
                writer.WriteEnumerableProperty(obj.UnhealthyEvaluations, "UnhealthyEvaluations", HealthEvaluationWrapperConverter.Serialize);
            }

            if (obj.CurrentUpgradeDomainProgress != null)
            {
                writer.WriteProperty(obj.CurrentUpgradeDomainProgress, "CurrentUpgradeDomainProgress", CurrentUpgradeDomainProgressInfoConverter.Serialize);
            }

            if (obj.StartTimestampUtc != null)
            {
                writer.WriteProperty(obj.StartTimestampUtc, "StartTimestampUtc", JsonWriterExtensions.WriteStringValue);
            }

            if (obj.FailureTimestampUtc != null)
            {
                writer.WriteProperty(obj.FailureTimestampUtc, "FailureTimestampUtc", JsonWriterExtensions.WriteStringValue);
            }

            if (obj.UpgradeDomainProgressAtFailure != null)
            {
                writer.WriteProperty(obj.UpgradeDomainProgressAtFailure, "UpgradeDomainProgressAtFailure", FailureUpgradeDomainProgressInfoConverter.Serialize);
            }

            if (obj.UpgradeStatusDetails != null)
            {
                writer.WriteProperty(obj.UpgradeStatusDetails, "UpgradeStatusDetails", JsonWriterExtensions.WriteStringValue);
            }

            writer.WriteEndObject();
        }
Example #42
0
        /// <inheritdoc/>
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            // P2 to P1
            var testCase = value as TestCase;

            writer.WriteStartObject();
            writer.WritePropertyName("Properties");
            writer.WriteStartArray();

            // Version Note: In 15.0.0, if some properties in TestCase were not set, they were not serialized.
            // Starting 15.1.0, test platform sends in default values for properties that were not set. This is not
            // a breaking change.

            // TestCase.FullyQualifiedName
            writer.WriteStartObject();
            AddProperty(writer, TestCaseProperties.FullyQualifiedName, serializer);
            writer.WriteValue(testCase.FullyQualifiedName);
            writer.WriteEndObject();

            // TestCase.ExecutorUri
            writer.WriteStartObject();
            AddProperty(writer, TestCaseProperties.ExecutorUri, serializer);
            writer.WriteValue(testCase.ExecutorUri.OriginalString);
            writer.WriteEndObject();

            // TestCase.Source
            writer.WriteStartObject();
            AddProperty(writer, TestCaseProperties.Source, serializer);
            writer.WriteValue(testCase.Source);
            writer.WriteEndObject();

            // TestCase.CodeFilePath
            writer.WriteStartObject();
            AddProperty(writer, TestCaseProperties.CodeFilePath, serializer);
            writer.WriteValue(testCase.CodeFilePath);
            writer.WriteEndObject();

            // TestCase.DisplayName
            writer.WriteStartObject();
            AddProperty(writer, TestCaseProperties.DisplayName, serializer);
            writer.WriteValue(testCase.DisplayName);
            writer.WriteEndObject();

            // TestCase.Id
            writer.WriteStartObject();
            AddProperty(writer, TestCaseProperties.Id, serializer);
            writer.WriteValue(testCase.Id);
            writer.WriteEndObject();

            // TestCase.LineNumber
            writer.WriteStartObject();
            AddProperty(writer, TestCaseProperties.LineNumber, serializer);
            writer.WriteValue(testCase.LineNumber);
            writer.WriteEndObject();

            foreach (var property in testCase.GetProperties())
            {
                serializer.Serialize(writer, property);
            }

            writer.WriteEndArray();
            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);
            }

            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
            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++;
                }
            }

            writer.WriteEndArray();

            if (isReference || includeTypeDetails)
            {
                writer.WriteEndObject();
            }

            SerializeStack.RemoveAt(SerializeStack.Count - 1);

            contract.InvokeOnSerialized(values.UnderlyingCollection, Serializer.Context);
        }
Example #44
0
        public void WriteTo(ProjectionVersion projectionVersion,
                            IEnumerable <KeyValuePair <string, JToken> > extraMetaData, JsonWriter jsonWriter)
        {
            jsonWriter.WriteStartObject();
            if (projectionVersion.ProjectionId > 0)
            {
                jsonWriter.WritePropertyName("$v");
                WriteVersion(projectionVersion, jsonWriter);
            }

            if (Phase != 0)
            {
                jsonWriter.WritePropertyName("$ph");
                jsonWriter.WriteValue(Phase);
            }

            switch (Mode_)
            {
            case Mode.Phase:
                jsonWriter.WritePropertyName("$cp");
                jsonWriter.WriteValue(Completed);
                break;

            case Mode.Position:
            case Mode.EventTypeIndex:
                jsonWriter.WritePropertyName("$c");
                jsonWriter.WriteValue(CommitPosition.GetValueOrDefault());
                jsonWriter.WritePropertyName("$p");
                jsonWriter.WriteValue(PreparePosition.GetValueOrDefault());
                if (Mode_ == Mode.EventTypeIndex)
                {
                    goto case Mode.MultiStream;
                }
                break;

            case Mode.PreparePosition:
                jsonWriter.WritePropertyName("$p");
                jsonWriter.WriteValue(PreparePosition.GetValueOrDefault());
                break;

            case Mode.Stream:
            case Mode.MultiStream:
                jsonWriter.WritePropertyName("$s");
                jsonWriter.WriteStartObject();
                foreach (var stream in Streams)
                {
                    jsonWriter.WritePropertyName(stream.Key);
                    jsonWriter.WriteValue(stream.Value);
                }

                jsonWriter.WriteEndObject();
                break;

            case Mode.ByStream:
                jsonWriter.WritePropertyName("$m");
                jsonWriter.WriteValue("bs");
                jsonWriter.WritePropertyName("$c");
                jsonWriter.WriteValue(CommitPosition.GetValueOrDefault());
                jsonWriter.WritePropertyName("$s");
                jsonWriter.WriteStartArray();
                jsonWriter.WriteStartObject();
                jsonWriter.WritePropertyName(CatalogStream);
                jsonWriter.WriteValue(CatalogPosition);
                jsonWriter.WriteEndObject();
                if (!string.IsNullOrEmpty(DataStream))
                {
                    jsonWriter.WriteStartObject();
                    jsonWriter.WritePropertyName(DataStream);
                    jsonWriter.WriteValue(DataPosition);
                    jsonWriter.WriteEndObject();
                }

                jsonWriter.WriteEndArray();
                break;
            }

            if (extraMetaData != null)
            {
                foreach (var pair in extraMetaData)
                {
                    jsonWriter.WritePropertyName(pair.Key);
                    pair.Value.WriteTo(jsonWriter);
                }
            }

            jsonWriter.WriteEndObject();
        }
Example #45
0
        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 SerializeNode(JsonWriter writer, IXmlNode node, XmlNamespaceManager manager, bool writePropertyName)
        {
            switch (node.NodeType)
            {
            case XmlNodeType.Document:
            case XmlNodeType.DocumentFragment:
                SerializeGroupedNodes(writer, node, manager, writePropertyName);
                break;

            case XmlNodeType.Element:
                if (IsArray(node) && node.ChildNodes.All((IXmlNode n) => n.LocalName == node.LocalName) && node.ChildNodes.Count > 0)
                {
                    SerializeGroupedNodes(writer, node, manager, writePropertyName: false);
                }
                else
                {
                    foreach (IXmlNode attribute in node.Attributes)
                    {
                        if (attribute.NamespaceURI == "http://www.w3.org/2000/xmlns/")
                        {
                            string prefix = (!(attribute.LocalName != "xmlns")) ? string.Empty : attribute.LocalName;
                            manager.AddNamespace(prefix, attribute.Value);
                        }
                    }
                    if (writePropertyName)
                    {
                        writer.WritePropertyName(GetPropertyName(node, manager));
                    }
                    if (ValueAttributes(node.Attributes).Count() == 0 && node.ChildNodes.Count == 1 && node.ChildNodes[0].NodeType == XmlNodeType.Text)
                    {
                        writer.WriteValue(node.ChildNodes[0].Value);
                    }
                    else if (node.ChildNodes.Count == 0 && CollectionUtils.IsNullOrEmpty(node.Attributes))
                    {
                        writer.WriteNull();
                    }
                    else
                    {
                        writer.WriteStartObject();
                        for (int i = 0; i < node.Attributes.Count; i++)
                        {
                            SerializeNode(writer, node.Attributes[i], manager, writePropertyName: true);
                        }
                        SerializeGroupedNodes(writer, node, manager, writePropertyName: true);
                        writer.WriteEndObject();
                    }
                }
                break;

            case XmlNodeType.Comment:
                if (writePropertyName)
                {
                    writer.WriteComment(node.Value);
                }
                break;

            case XmlNodeType.Attribute:
            case XmlNodeType.Text:
            case XmlNodeType.CDATA:
            case XmlNodeType.ProcessingInstruction:
            case XmlNodeType.Whitespace:
            case XmlNodeType.SignificantWhitespace:
                if ((!(node.NamespaceURI == "http://www.w3.org/2000/xmlns/") || !(node.Value == "http://james.newtonking.com/projects/json")) && (!(node.NamespaceURI == "http://james.newtonking.com/projects/json") || !(node.LocalName == "Array")))
                {
                    if (writePropertyName)
                    {
                        writer.WritePropertyName(GetPropertyName(node, manager));
                    }
                    writer.WriteValue(node.Value);
                }
                break;

            case XmlNodeType.XmlDeclaration:
            {
                IXmlDeclaration xmlDeclaration = (IXmlDeclaration)node;
                writer.WritePropertyName(GetPropertyName(node, manager));
                writer.WriteStartObject();
                if (!string.IsNullOrEmpty(xmlDeclaration.Version))
                {
                    writer.WritePropertyName("@version");
                    writer.WriteValue(xmlDeclaration.Version);
                }
                if (!string.IsNullOrEmpty(xmlDeclaration.Encoding))
                {
                    writer.WritePropertyName("@encoding");
                    writer.WriteValue(xmlDeclaration.Encoding);
                }
                if (!string.IsNullOrEmpty(xmlDeclaration.Standalone))
                {
                    writer.WritePropertyName("@standalone");
                    writer.WriteValue(xmlDeclaration.Standalone);
                }
                writer.WriteEndObject();
                break;
            }

            default:
                throw new JsonSerializationException("Unexpected XmlNodeType when serializing nodes: " + node.NodeType);
            }
        }
 private void WriteStartObject()
 {
     _writer.WriteStartObject();
     IncreaseDepth();
 }
 public override void WriteStartObject()
 {
     _innerWriter.WriteStartObject();
     AfterStart();
 }
        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 override void WriteJson(JsonWriter writer, LeagueGame?value, JsonSerializer serializer)
        {
            if (value == null)
            {
                return;
            }

            var retrievalConfiguration = LgoLeagueGameRetrievalConfiguration.GetCurrentOrDefault();

            writer.WriteStartObject();

            writer.WritePropertyName(JsonSerializationHelper.GetPropertyName(value.GetType(), nameof(value.Id)));
            serializer.Serialize(writer, value.Id);

            writer.WritePropertyName(JsonSerializationHelper.GetPropertyName(value.GetType(), nameof(value.State)));
            serializer.Serialize(writer, value.State);

            if (retrievalConfiguration.IncludeGameTimeInSeconds)
            {
                writer.WritePropertyName(JsonSerializationHelper.GetPropertyName(value.GetType(), nameof(value.GameTimeInSeconds)));
                serializer.Serialize(writer, value.GameTimeInSeconds);
            }

            if (retrievalConfiguration.IncludeMode)
            {
                writer.WritePropertyName(JsonSerializationHelper.GetPropertyName(value.GetType(), nameof(value.Mode)));
                serializer.Serialize(writer, value.Mode);
            }

            if (retrievalConfiguration.IncludeTeams)
            {
                writer.WritePropertyName(JsonSerializationHelper.GetPropertyName(value.GetType(), nameof(value.Teams)));
                serializer.Serialize(writer, value.Teams);
            }

            if (retrievalConfiguration.IncludePlayers)
            {
                writer.WritePropertyName(JsonSerializationHelper.GetPropertyName(value.GetType(), nameof(value.Players)));
                serializer.Serialize(writer, value.Players);
            }

            if (retrievalConfiguration.IncludeMatchUps)
            {
                writer.WritePropertyName(JsonSerializationHelper.GetPropertyName(value.GetType(), nameof(value.MatchUps)));
                serializer.Serialize(writer, value.MatchUps);
            }

            if (retrievalConfiguration.IncludeTimers)
            {
                writer.WritePropertyName(JsonSerializationHelper.GetPropertyName(value.GetType(), nameof(value.Timers)));
                serializer.Serialize(writer, value.Timers);
            }

            if (retrievalConfiguration.IncludeEvents)
            {
                writer.WritePropertyName(JsonSerializationHelper.GetPropertyName(value.GetType(), nameof(value.Events)));
                serializer.Serialize(writer, value.Events);
            }

            if (retrievalConfiguration.IncludeEventsSinceLastUpdate)
            {
                writer.WritePropertyName(JsonSerializationHelper.GetPropertyName(value.GetType(), nameof(value.EventsSinceLastUpdate)));
                serializer.Serialize(writer, value.EventsSinceLastUpdate);
            }

            writer.WriteEndObject();
        }
Example #51
0
        public void Serialize(JsonWriter writer)
        {
            writer.WriteStartObject();

            if (!string.IsNullOrWhiteSpace(Title))
            {
                writer.WritePropertyName("title");
                writer.WriteValue(Title);
            }
            if (!string.IsNullOrWhiteSpace(Description))
            {
                writer.WritePropertyName("description");
                writer.WriteValue(Description);
            }
            writer.WritePropertyName("required");
            writer.WriteValue(Required);
            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);
                }
            }
            writer.WritePropertyName("allowEmptyValue");
            writer.WriteValue(AllowEmptyValue);
            if (TypeFormat.Type == ParameterType.Array && Items != null)
            {
                writer.WritePropertyName("items");
                Items.Serialize(writer);
            }
            if (TypeFormat.Type == ParameterType.Array)
            {
                writer.WritePropertyName("collectionFormat");
                writer.WriteValue(CollectionFormat);
            }
            if (!string.IsNullOrWhiteSpace(Default))
            {
                writer.WritePropertyName("default");
                writer.WriteValue(Default);
            }
            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 (string e in Enum)
                {
                    writer.WriteValue(e);
                }
                writer.WriteEndArray();
            }
            if (MultipleOf != decimal.MinValue)
            {
                writer.WritePropertyName("multipleOf");
                writer.WriteValue(MultipleOf);
            }

            writer.WriteEndObject();
        }
        private void SerializeList(JsonWriter writer, IWrappedCollection values, JsonArrayContract contract, JsonProperty member, JsonContract collectionValueContract)
        {
            contract.InvokeOnSerializing(values.UnderlyingCollection, base.Serializer.Context);
            SerializeStack.Add(values.UnderlyingCollection);
            bool?isReference = contract.IsReference;
            bool flag        = (!isReference.HasValue) ? HasFlag(base.Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Arrays) : isReference.Value;
            bool flag2       = ShouldWriteType(TypeNameHandling.Arrays, contract, member, collectionValueContract);

            if (flag || flag2)
            {
                writer.WriteStartObject();
                if (flag)
                {
                    writer.WritePropertyName("$id");
                    writer.WriteValue(base.Serializer.ReferenceResolver.GetReference(this, values.UnderlyingCollection));
                }
                if (flag2)
                {
                    WriteTypeProperty(writer, values.UnderlyingCollection.GetType());
                }
                writer.WritePropertyName("$values");
            }
            JsonContract collectionValueContract2 = base.Serializer.ContractResolver.ResolveContract(contract.CollectionItemType ?? typeof(object));

            writer.WriteStartArray();
            int top = writer.Top;
            int num = 0;

            foreach (object value in values)
            {
                try
                {
                    JsonContract contractSafe = GetContractSafe(value);
                    if (ShouldWriteReference(value, null, contractSafe))
                    {
                        WriteReference(writer, value);
                    }
                    else if (CheckForCircularReference(value, null, contract))
                    {
                        SerializeValue(writer, value, contractSafe, null, collectionValueContract2);
                    }
                }
                catch (Exception ex)
                {
                    if (!IsErrorHandled(values.UnderlyingCollection, contract, num, ex))
                    {
                        throw;
                    }
                    HandleError(writer, top);
                }
                finally
                {
                    num++;
                }
            }
            writer.WriteEndArray();
            if (flag || flag2)
            {
                writer.WriteEndObject();
            }
            SerializeStack.RemoveAt(SerializeStack.Count - 1);
            contract.InvokeOnSerialized(values.UnderlyingCollection, base.Serializer.Context);
        }
Example #53
0
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            if (value == null)
            {
                writer.WriteNull();
                return;
            }

            writer.WriteStartObject();

            var oldPreserveReferencesHandling = serializer.PreserveReferencesHandling;

            try
            {
                serializer.PreserveReferencesHandling = PreserveReferencesHandling.None;

                foreach (var kvp in (Parameters)value)
                {
                    writer.WritePropertyName(kvp.Key);

                    var v = kvp.Value;

                    if (v is DateTime dateTime)
                    {
                        if (dateTime.Kind == DateTimeKind.Unspecified)
                        {
                            dateTime = DateTime.SpecifyKind(dateTime, DateTimeKind.Local);
                        }
                        writer.WriteValue(dateTime.GetDefaultRavenFormat());
                    }
                    else if (v is DateTimeOffset dateTimeOffset)
                    {
                        writer.WriteValue(dateTimeOffset.UtcDateTime.GetDefaultRavenFormat(true));
                    }
                    else if (v is IEnumerable enumerable)
                    {
                        var oldTypeNameHandling = serializer.TypeNameHandling;

                        try
                        {
                            serializer.TypeNameHandling = Newtonsoft.Json.TypeNameHandling.None;

                            serializer.Serialize(writer, enumerable);
                        }
                        finally
                        {
                            serializer.TypeNameHandling = oldTypeNameHandling;
                        }
                    }
                    else if (IsRavenAssembly(v))
                    {
                        var oldNullValueHandling    = serializer.NullValueHandling;
                        var oldDefaultValueHandling = serializer.DefaultValueHandling;

                        try
                        {
                            serializer.NullValueHandling    = NullValueHandling.Ignore;
                            serializer.DefaultValueHandling = DefaultValueHandling.Ignore;

                            serializer.Serialize(writer, v);
                        }
                        finally
                        {
                            serializer.NullValueHandling    = oldNullValueHandling;
                            serializer.DefaultValueHandling = oldDefaultValueHandling;
                        }
                    }
                    else
                    {
                        serializer.Serialize(writer, v);
                    }
                }
            }
            finally
            {
                serializer.PreserveReferencesHandling = oldPreserveReferencesHandling;
            }

            writer.WriteEndObject();
        }
 /// <summary>
 /// Serializes the FabricName object to JSON representing NameDescription as defined in Swagger.
 /// </summary>
 /// <param name="writer">The <see cref="T: Newtonsoft.Json.JsonWriter" /> to write to.</param>
 /// <param name="obj">The object to serialize to JSON.</param>
 internal static void Serialize(JsonWriter writer, FabricName obj)
 {
     writer.WriteStartObject();
     writer.WriteProperty(obj.ToString(), "Name", JsonWriterExtensions.WriteStringValue);
     writer.WriteEndObject();
 }
        /// <summary>
        /// Writes a geometry to its JSON representation
        /// </summary>
        /// <param name="writer">The writer</param>
        /// <param name="value">The value</param>
        /// <param name="serializer">The serializer</param>
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            var geom = value as IGeometry;

            if (geom == null)
            {
                writer.WriteNull();
                return;
            }

            writer.WriteStartObject();

            var geomType = ToGeoJsonObject(geom);

            writer.WritePropertyName("type");
            writer.WriteValue(Enum.GetName(typeof(GeoJsonObjectType), geomType));

            switch (geomType)
            {
            case GeoJsonObjectType.Point:
                if (serializer.NullValueHandling == NullValueHandling.Include || geom.Coordinate != null)
                {
                    writer.WritePropertyName("coordinates");
                    serializer.Serialize(writer, geom.Coordinate);
                }
                break;

            case GeoJsonObjectType.LineString:
            case GeoJsonObjectType.MultiPoint:
                var linealCoords = geom.Coordinates;
                if (serializer.NullValueHandling == NullValueHandling.Include || linealCoords != null)
                {
                    writer.WritePropertyName("coordinates");
                    serializer.Serialize(writer, linealCoords);
                }
                break;

            case GeoJsonObjectType.Polygon:
                var poly = geom as IPolygon;
                Debug.Assert(poly != null);
                var polygonCoords = PolygonCoordinates(poly);
                if (serializer.NullValueHandling == NullValueHandling.Include || polygonCoords != null)
                {
                    writer.WritePropertyName("coordinates");
                    serializer.Serialize(writer, polygonCoords);
                }
                break;

            case GeoJsonObjectType.MultiPolygon:
                var mpoly = geom as IMultiPolygon;
                Debug.Assert(mpoly != null);
                var list = new List <List <Coordinate[]> >();
                for (int i = 0; i < mpoly.NumGeometries; i++)
                {
                    list.Add(PolygonCoordinates((IPolygon)mpoly.GetGeometryN(i)));
                }
                if (serializer.NullValueHandling == NullValueHandling.Include || list.Count > 0)
                {
                    writer.WritePropertyName("coordinates");
                    serializer.Serialize(writer, list);
                }
                break;

            case GeoJsonObjectType.GeometryCollection:
                var gc = geom as IGeometryCollection;
                Debug.Assert(gc != null);
                writer.WritePropertyName("geometries");
                serializer.Serialize(writer, gc.Geometries);
                break;

            default:
                var coordinates = new List <Coordinate[]>();
                foreach (var geometry in ((IGeometryCollection)geom).Geometries)
                {
                    coordinates.Add(geometry.Coordinates);
                }
                if (serializer.NullValueHandling == NullValueHandling.Include || coordinates.Count > 0)
                {
                    writer.WritePropertyName("coordinates");
                    serializer.Serialize(writer, coordinates);
                }
                break;
            }

            writer.WriteEndObject();
        }
        private static void WriteDefinitionMap(JsonWriter writer, string definitionMapName, IDictionary <string, JsonSchema> definitionMap, bool sortDefinitions = false, bool addExpressionReferences = false)
        {
            if (definitionMap != null && definitionMap.Count > 0)
            {
                writer.WritePropertyName(definitionMapName);
                writer.WriteStartObject();

                IEnumerable <string> definitionNames = definitionMap.Keys;
                if (sortDefinitions)
                {
                    definitionNames = definitionNames.OrderBy(key => key);
                }

                foreach (string definitionName in definitionNames)
                {
                    JsonSchema definition = definitionMap[definitionName];

                    bool shouldAddExpressionReference = addExpressionReferences &&
                                                        (definition.JsonType != "string" ||
                                                         (definition.Enum != null &&
                                                          definition.Enum.Count() > 0 &&
                                                          definitionName != "type" &&
                                                          definitionName != "apiVersion")) &&
                                                        (definition.JsonType != "array" ||
                                                         (definitionName != "resources"));

                    if (!shouldAddExpressionReference)
                    {
                        WriteDefinition(writer, definitionName, definition);
                    }
                    else
                    {
                        string definitionDescription = null;

                        writer.WritePropertyName(definitionName);
                        writer.WriteStartObject();

                        writer.WritePropertyName("oneOf");
                        writer.WriteStartArray();

                        if (definition.Description != null)
                        {
                            definitionDescription = definition.Description;

                            definition             = definition.Clone();
                            definition.Description = null;
                        }
                        WriteDefinition(writer, definition);

                        WriteDefinition(writer, new JsonSchema()
                        {
                            Ref = "http://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#/definitions/expression"
                        });

                        writer.WriteEndArray();

                        WriteProperty(writer, "description", definitionDescription);
                        writer.WriteEndObject();
                    }
                }
                writer.WriteEndObject();
            }
        }
        private void SerializeList(JsonWriter writer, IWrappedCollection values, JsonArrayContract contract, JsonProperty member, JsonContract collectionValueContract)
        {
            contract.InvokeOnSerializing(values.UnderlyingCollection, base.Serializer.Context);
            this.SerializeStack.Add(values.UnderlyingCollection);
            bool?isReference = contract.IsReference;
            bool flag        = (!isReference.HasValue ? this.HasFlag(base.Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Arrays) : isReference.Value);
            bool flag1       = this.ShouldWriteType(TypeNameHandling.Arrays, contract, member, collectionValueContract);

            if (flag || flag1)
            {
                writer.WriteStartObject();
                if (flag)
                {
                    writer.WritePropertyName("$id");
                    writer.WriteValue(base.Serializer.ReferenceResolver.GetReference(this, values.UnderlyingCollection));
                }
                if (flag1)
                {
                    this.WriteTypeProperty(writer, values.UnderlyingCollection.GetType());
                }
                writer.WritePropertyName("$values");
            }
            JsonContract jsonContract = base.Serializer.ContractResolver.ResolveContract(contract.CollectionItemType ?? typeof(object));

            writer.WriteStartArray();
            int         top        = writer.Top;
            int         num        = 0;
            IEnumerator enumerator = values.GetEnumerator();

            try
            {
                while (enumerator.MoveNext())
                {
                    object current = enumerator.Current;
                    try
                    {
                        try
                        {
                            JsonContract contractSafe = this.GetContractSafe(current);
                            if (this.ShouldWriteReference(current, null, contractSafe))
                            {
                                this.WriteReference(writer, current);
                            }
                            else if (this.CheckForCircularReference(current, null, contract))
                            {
                                this.SerializeValue(writer, current, contractSafe, null, jsonContract);
                            }
                        }
                        catch (Exception exception)
                        {
                            if (!base.IsErrorHandled(values.UnderlyingCollection, contract, num, exception))
                            {
                                throw;
                            }
                            else
                            {
                                this.HandleError(writer, top);
                            }
                        }
                    }
                    finally
                    {
                        num++;
                    }
                }
            }
            finally
            {
                IDisposable disposable  = enumerator as IDisposable;
                IDisposable disposable1 = disposable;
                if (disposable != null)
                {
                    disposable1.Dispose();
                }
            }
            writer.WriteEndArray();
            if (flag || flag1)
            {
                writer.WriteEndObject();
            }
            this.SerializeStack.RemoveAt(this.SerializeStack.Count - 1);
            contract.InvokeOnSerialized(values.UnderlyingCollection, base.Serializer.Context);
        }
        private void SerializeDictionary(JsonWriter writer, IWrappedDictionary values, JsonDictionaryContract contract, JsonProperty member, JsonContract collectionValueContract)
        {
            contract.InvokeOnSerializing(values.UnderlyingDictionary, Serializer.Context);

            SerializeStack.Add(values.UnderlyingDictionary);
            writer.WriteStartObject();

            bool isReference = contract.IsReference ?? HasFlag(Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Objects);

            if (isReference)
            {
                writer.WritePropertyName(JsonTypeReflector.IdPropertyName);
                writer.WriteValue(Serializer.ReferenceResolver.GetReference(this, values.UnderlyingDictionary));
            }
            if (ShouldWriteType(TypeNameHandling.Objects, contract, member, collectionValueContract))
            {
                WriteTypeProperty(writer, values.UnderlyingDictionary.GetType());
            }

            JsonContract childValuesContract = Serializer.ContractResolver.ResolveContract(contract.DictionaryValueType ?? typeof(object));

            int initialDepth = writer.Top;

            // Mono Unity 3.0 fix
            IDictionary d = values;

            foreach (DictionaryEntry entry in d)
            {
                string propertyName = GetPropertyName(entry);

                propertyName = (contract.PropertyNameResolver != null)
                         ? contract.PropertyNameResolver(propertyName)
                         : propertyName;

                try
                {
                    object       value         = entry.Value;
                    JsonContract valueContract = GetContractSafe(value);

                    if (ShouldWriteReference(value, null, valueContract))
                    {
                        writer.WritePropertyName(propertyName);
                        WriteReference(writer, value);
                    }
                    else
                    {
                        if (!CheckForCircularReference(value, null, contract))
                        {
                            continue;
                        }

                        writer.WritePropertyName(propertyName);

                        SerializeValue(writer, value, valueContract, null, childValuesContract);
                    }
                }
                catch (Exception ex)
                {
                    if (IsErrorHandled(values.UnderlyingDictionary, contract, propertyName, ex))
                    {
                        HandleError(writer, initialDepth);
                    }
                    else
                    {
                        throw;
                    }
                }
            }

            writer.WriteEndObject();
            SerializeStack.RemoveAt(SerializeStack.Count - 1);

            contract.InvokeOnSerialized(values.UnderlyingDictionary, Serializer.Context);
        }
Example #59
0
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            if (!(value is NewOrderRequest request))
            {
                throw new BitfinexBadInputException("Can't serialize new order request");
            }


            writer.WriteStartArray();
            writer.WriteValue(0);
            writer.WriteValue("on");
            writer.WriteValue((object)null);

            writer.WriteStartObject();

            if (request.Gid.HasValue)
            {
                writer.WritePropertyName("gid");
                writer.WriteValue(request.Gid.Value);
            }

            writer.WritePropertyName("cid");
            writer.WriteValue(request.Cid);

            writer.WritePropertyName("type");
            writer.WriteValue(OrderConverter.SerializeType(request.Type));

            writer.WritePropertyName("symbol");
            writer.WriteValue(request.Symbol);

            writer.WritePropertyName("amount");
            writer.WriteValue(request.Amount.ToString(CultureInfo.InvariantCulture));

            if (request.Price.HasValue)
            {
                writer.WritePropertyName("price");
                writer.WriteValue(request.Price.Value.ToString(CultureInfo.InvariantCulture));
            }

            if (request.PriceTrailing.HasValue)
            {
                writer.WritePropertyName("price_trailing");
                writer.WriteValue(request.PriceTrailing.Value.ToString(CultureInfo.InvariantCulture));
            }

            if (request.PriceAuxLimit.HasValue)
            {
                writer.WritePropertyName("price_aux_limit");
                writer.WriteValue(request.PriceAuxLimit.Value.ToString(CultureInfo.InvariantCulture));
            }

            if (request.PriceOcoStop.HasValue)
            {
                writer.WritePropertyName("price_oco_stop");
                writer.WriteValue(request.PriceOcoStop.Value.ToString(CultureInfo.InvariantCulture));
            }

            if (request.Flags.HasValue)
            {
                writer.WritePropertyName("flags");
                writer.WriteValue((int)request.Flags);
            }

            if (request.TimeInForce.HasValue)
            {
                writer.WritePropertyName("tif");
                writer.WriteValue(request.TimeInForce.Value.ToString("u"));
            }

            InitMeta(request);
            if (request.Meta != null && request.Meta.Any())
            {
                writer.WritePropertyName("meta");
                WriteMeta(request.Meta, writer);
            }

            writer.WriteEndObject();
            writer.WriteEndArray();
        }
 public override void WriteStartObject()
 {
     _textWriter.WriteStartObject();
     _innerWriter.WriteStartObject();
     base.WriteStartObject();
 }