Example #1
0
    public void ValueFormatting()
    {
      StringBuilder sb = new StringBuilder();
      StringWriter sw = new StringWriter(sb);

      using (JsonWriter jsonWriter = new JsonWriter(sw))
      {
        jsonWriter.WriteStartArray();
        jsonWriter.WriteValue('@');
        jsonWriter.WriteValue("\r\n\t\f\b?{\\r\\n\"\'");
        jsonWriter.WriteValue(true);
        jsonWriter.WriteValue(10);
        jsonWriter.WriteValue(10.99);
        jsonWriter.WriteValue(0.99);
        jsonWriter.WriteValue(0.000000000000000001d);
        jsonWriter.WriteValue(0.000000000000000001m);
        jsonWriter.WriteValue(null);
        jsonWriter.WriteValue("This is a string.");
        jsonWriter.WriteNull();
        jsonWriter.WriteUndefined();
        jsonWriter.WriteEndArray();
      }

      const string expected = @"[""@"",""\r\n\t\f\b?{\\r\\n\""'"",true,10,10.99,0.99,1E-18,0.000000000000000001,,""This is a string."",null,undefined]";
      string result = sb.ToString();

      Console.WriteLine("ValueFormatting");
      Console.WriteLine(result);

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

            writer.WriteStartArray();

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

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

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

            writer.WriteEndArray();
        }
Example #3
0
 public void WritesEmptyArray()
 {
     var sw = new StringWriter();
     var writer = new JsonWriter(sw);
     writer.WriteStartArray();
     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 #5
0
 public void WritesSinglePropertyArray()
 {
     var sw = new StringWriter();
     var writer = new JsonWriter(sw);
     writer.WriteStartArray();
     writer.WriteValue(1);
     writer.WriteEnd();
     Assert.AreEqual("[1]", sw.ToString());
 }
Example #6
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.WriteStartArray();
            _exporter(context, value, writer);
            writer.WriteEndArray();
        }
        protected override void ExportValue(object value, JsonWriter writer)
        {
            IEnumerable items = (IEnumerable) value;
            
            writer.WriteStartArray();

            foreach (object item in items)
                writer.WriteValue(item);

            writer.WriteEndArray();
        }
 private void WriteJsonValue(JsonWriter writer, IJsonValue value)
 {
   switch (value.ValueType)
   {
     case JsonValueType.Array:
       {
         JsonArray a = value.GetArray();
         writer.WriteStartArray();
         for (int i = 0; i < a.Count; i++)
         {
           WriteJsonValue(writer, a[i]);
         }
         writer.WriteEndArray();
       }
       break;
     case JsonValueType.Boolean:
       {
         writer.WriteValue(value.GetBoolean());
       }
       break;
     case JsonValueType.Null:
       {
         writer.WriteNull();
       }
       break;
     case JsonValueType.Number:
       {
         writer.WriteValue(value.GetNumber());
       }
       break;
     case JsonValueType.Object:
       {
         JsonObject o = value.GetObject();
         writer.WriteStartObject();
         foreach (KeyValuePair<string, IJsonValue> v in o)
         {
           writer.WritePropertyName(v.Key);
           WriteJsonValue(writer, v.Value);
         }
         writer.WriteEndObject();
       }
       break;
     case JsonValueType.String:
       {
         writer.WriteValue(value.GetString());
       }
       break;
     default:
       throw new ArgumentOutOfRangeException("ValueType");
   }
 }
        internal static void FormatView(DataView view, JsonWriter writer)
        {
            Debug.Assert(view != null);
            Debug.Assert(writer != null);

            writer.WriteStartObject();

            writer.WriteMember("columns");

            writer.WriteStartArray();
            foreach (DataColumn column in view.Table.Columns)
                writer.WriteValue(column.ColumnName);
            writer.WriteEndArray();

            writer.WriteMember("rows");

            writer.WriteStartArray();
            foreach (DataRowView row in view)
                writer.WriteValue(row.Row.ItemArray);
            writer.WriteEndArray();

            writer.WriteEndObject();
        }
        protected override void ExportValue(ExportContext context, object value, JsonWriter writer)
        {
            Debug.Assert(context != null);
            Debug.Assert(value != null);
            Debug.Assert(writer != null);

            IEnumerable items = (IEnumerable) value;
            
            writer.WriteStartArray();

            foreach (object item in items)
                context.Export(item, writer);

            writer.WriteEndArray();
        }
        internal static void ExportView(ExportContext context, DataView view, JsonWriter writer)
        {
            Debug.Assert(context != null);
            Debug.Assert(view != null);
            Debug.Assert(writer != null);

            writer.WriteStartObject();

            writer.WriteMember("columns");

            writer.WriteStartArray();
            foreach (DataColumn column in view.Table.Columns)
                context.Export(column.ColumnName, writer);
            writer.WriteEndArray();

            writer.WriteMember("rows");

            writer.WriteStartArray();
            foreach (DataRowView row in view)
                context.Export(row.Row.ItemArray, writer);
            writer.WriteEndArray();

            writer.WriteEndObject();
        }
Example #12
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)
    {
      DataTable table = (DataTable)value;

      writer.WriteStartArray();

      foreach (DataRow row in table.Rows)
      {
        writer.WriteStartObject();
        foreach (DataColumn column in row.Table.Columns)
        {
          writer.WritePropertyName(column.ColumnName);
          serializer.Serialize(writer, row[column]);
        }
        writer.WriteEndObject();
      }

      writer.WriteEndArray();
    }
Example #13
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)
    {
      DataTable table = (DataTable)value;
      DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver;

      writer.WriteStartArray();

      foreach (DataRow row in table.Rows)
      {
        writer.WriteStartObject();
        foreach (DataColumn column in row.Table.Columns)
        {
          writer.WritePropertyName((resolver != null) ? resolver.ResolvePropertyName(column.ColumnName) : column.ColumnName);
          serializer.Serialize(writer, row[column]);
        }
        writer.WriteEndObject();
      }

      writer.WriteEndArray();
    }
Example #14
0
        public void WriteReadWrite()
        {
            StringBuilder sb = new StringBuilder();
              StringWriter sw = new StringWriter(sb);

              using (JsonWriter jsonWriter = new JsonWriter(sw))
              {
            jsonWriter.WriteStartArray();
            jsonWriter.WriteValue(true);

            jsonWriter.WriteStartObject();
            jsonWriter.WritePropertyName("integer");
            jsonWriter.WriteValue(99);
            jsonWriter.WritePropertyName("string");
            jsonWriter.WriteValue("how now brown cow?");
            jsonWriter.WritePropertyName("array");

            jsonWriter.WriteStartArray();
            for (int i = 0; i < 5; i++)
            {
              jsonWriter.WriteValue(i);
            }

            jsonWriter.WriteStartObject();
            jsonWriter.WritePropertyName("decimal");
            jsonWriter.WriteValue(990.00990099m);
            jsonWriter.WriteEndObject();

            jsonWriter.WriteValue(5);
            jsonWriter.WriteEndArray();

            jsonWriter.WriteEndObject();

            jsonWriter.WriteValue("This is a string.");
            jsonWriter.WriteNull();
            jsonWriter.WriteNull();
            jsonWriter.WriteEndArray();
              }

              string json = sb.ToString();

              JsonSerializer serializer = new JsonSerializer();

              object jsonObject = serializer.Deserialize(new JsonReader(new StringReader(json)));

              sb = new StringBuilder();
              sw = new StringWriter(sb);

              using (JsonWriter jsonWriter = new JsonWriter(sw))
              {
            serializer.Serialize(sw, jsonObject);
              }

              Assert.AreEqual(json, sb.ToString());
        }
        /// <summary>
        /// Write transformalize rows as GeoJson to a stream
        /// </summary>
        /// <param name="rows">transformalize rows</param>
        public void Write(IEnumerable <IRow> rows)
        {
            if (Equals(_context.Process.Entities.First(), _context.Entity))
            {
                _jw.WriteStartObject(); //root

                _jw.WritePropertyName("type");
                _jw.WriteValue("FeatureCollection");

                _jw.WritePropertyName("features");
                _jw.WriteStartArray(); //features
            }

            foreach (var row in rows)
            {
                _jw.WriteStartObject(); //feature
                _jw.WritePropertyName("type");
                _jw.WriteValue("Feature");
                _jw.WritePropertyName("geometry");
                _jw.WriteStartObject(); //geometry
                _jw.WritePropertyName("type");
                _jw.WriteValue("Point");

                _jw.WritePropertyName("coordinates");
                _jw.WriteStartArray();
                _jw.WriteValue(row[_longitudeField]);
                _jw.WriteValue(row[_latitudeField]);
                _jw.WriteEndArray();

                _jw.WriteEndObject(); //geometry

                _jw.WritePropertyName("properties");
                _jw.WriteStartObject(); //properties

                if (_hasDescription)
                {
                    _jw.WritePropertyName("description");
                    _jw.WriteValue(row[_descriptionField]);
                }

                if (_hasBatchValue)
                {
                    _jw.WritePropertyName("batch-value");
                    _jw.WriteValue(row[_batchField]);
                }

                if (_hasColor)
                {
                    _jw.WritePropertyName("marker-color");
                    _jw.WriteValue(row[_colorField]);
                }

                if (_hasSymbol)
                {
                    var symbol = row[_symbolField].ToString();
                    _jw.WritePropertyName("marker-symbol");
                    _jw.WriteValue(symbol);
                }

                foreach (var field in _properties)
                {
                    var name = field.Label == string.Empty ? field.Alias : field.Label;
                    _jw.WritePropertyName(name);
                    _jw.WriteValue(row[field]);
                }

                _jw.WriteEndObject(); //properties

                _jw.WriteEndObject(); //feature
            }
            if (Equals(_context.Process.Entities.Last(), _context.Entity))
            {
                _jw.WriteEndArray();  //features
                _jw.WriteEndObject(); //root
            }

            _jw.Flush();
        }
        public override void WriteJson(
            JsonWriter writer,
            object value,
            JsonSerializer serializer)
        {
            if (!(value is PatchSpec patchSpec))
            {
                throw new ArgumentOutOfRangeException("nameof(value) should be of type PatchSpec.");
            }

            IReadOnlyList <PatchOperation> patchOperations = patchSpec.PatchOperations;

            writer.WriteStartObject();

            patchSpec.RequestOptions.Match(
                (PatchItemRequestOptions patchRequestOptions) =>
            {
                if (patchRequestOptions != null)
                {
                    if (!String.IsNullOrWhiteSpace(patchRequestOptions.FilterPredicate))
                    {
                        writer.WritePropertyName(PatchConstants.PatchSpecAttributes.Condition);
                        writer.WriteValue(patchRequestOptions.FilterPredicate);
                    }
                }
            },
                (TransactionalBatchPatchItemRequestOptions transactionalBatchPatchRequestOptions) =>
            {
                if (transactionalBatchPatchRequestOptions != null)
                {
                    if (!String.IsNullOrWhiteSpace(transactionalBatchPatchRequestOptions.FilterPredicate))
                    {
                        writer.WritePropertyName(PatchConstants.PatchSpecAttributes.Condition);
                        writer.WriteValue(transactionalBatchPatchRequestOptions.FilterPredicate);
                    }
                }
            });

            writer.WritePropertyName(PatchConstants.PatchSpecAttributes.Operations);

            writer.WriteStartArray();

            foreach (PatchOperation operation in patchOperations)
            {
                writer.WriteStartObject();
                writer.WritePropertyName(PatchConstants.PropertyNames.OperationType);
                writer.WriteValue(operation.OperationType.ToEnumMemberString());
                writer.WritePropertyName(PatchConstants.PropertyNames.Path);
                writer.WriteValue(operation.Path);

                if (operation.TrySerializeValueParameter(this.userSerializer, out Stream valueStream))
                {
                    string valueParam;
                    using (valueStream)
                    {
                        using (StreamReader streamReader = new StreamReader(valueStream))
                        {
                            valueParam = streamReader.ReadToEnd();
                        }
                    }

                    writer.WritePropertyName(PatchConstants.PropertyNames.Value);
                    writer.WriteRawValue(valueParam);
                }

                writer.WriteEndObject();
            }

            writer.WriteEndArray();

            writer.WriteEndObject();
        }
    private void SerializeList(JsonWriter writer, IList values, JsonArrayContract contract)
    {
      contract.InvokeOnSerializing(values);

      SerializeStack.Add(values);

      bool isReference = contract.IsReference ?? HasFlag(_serializer.PreserveReferencesHandling, PreserveReferencesHandling.Arrays);
      bool includeTypeDetails = HasFlag(_serializer.TypeNameHandling, TypeNameHandling.Arrays);

      if (isReference || includeTypeDetails)
      {
        writer.WriteStartObject();

        if (isReference)
        {
          writer.WritePropertyName(JsonTypeReflector.IdPropertyName);
          writer.WriteValue(_serializer.ReferenceResolver.GetReference(values));
        }
        if (includeTypeDetails)
        {
          WriteTypeProperty(writer, values.GetType());
        }
        writer.WritePropertyName(JsonTypeReflector.ArrayValuesPropertyName);
      }

      writer.WriteStartArray();

      for (int i = 0; i < values.Count; i++)
      {
        object value = values[i];

        if (ShouldWriteReference(value, null))
        {
          WriteReference(writer, value);
        }
        else
        {
          if (!CheckForCircularReference(value, null))
            continue;

          SerializeValue(writer, value, null);
        }
      }

      writer.WriteEndArray();

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

      SerializeStack.RemoveAt(SerializeStack.Count - 1);

      contract.InvokeOnSerialized(values);
    }
Example #18
0
        public void Execute(IEnumerable <DataRow> rows, ISampler <DataRow> sampler, IEnumerable <ColumnMetadata> metadata, JsonWriter writer)
        {
            rows = rows ?? new List <DataRow>();
            sampler.Build(rows);
            var sampled = sampler.GetResult();

            writer.WriteStartObject();
            writer.WritePropertyName("total-rows");
            writer.WriteValue(rows.Count());
            if (sampler.GetIsSampled())
            {
                writer.WritePropertyName("sampled-rows");
                writer.WriteValue(rows.Count() - sampler.GetExcludedRowCount());
            }

            if (sampled.Count() > 0)
            {
                writer.WritePropertyName("table");
                writer.WriteStartObject();

                writer.WritePropertyName("columns");
                writer.WriteStartArray();
                var formatters = new List <IPresenter>();

                var columns = sampled.ElementAt(0).Table.Columns;
                for (var i = 0; i < columns.Count; i++)
                {
                    var meta = metadata.ElementAt(i);

                    writer.WriteStartObject();
                    writer.WritePropertyName("position");
                    writer.WriteValue(columns[i].Ordinal);
                    writer.WritePropertyName("name");
                    writer.WriteValue(columns[i].ColumnName);

                    var cpFormatter = new ColumnPropertiesFormatter();
                    writer.WritePropertyName("role");
                    writer.WriteValue(cpFormatter.GetRoleText(meta.Role));
                    writer.WritePropertyName("type");
                    writer.WriteValue(cpFormatter.GetTypeText(meta.Type));
                    if (!Tolerance.IsNullOrNone(meta.Tolerance))
                    {
                        writer.WritePropertyName("tolerance");
                        writer.WriteValue(cpFormatter.GetToleranceText(meta.Tolerance).Trim());
                    }
                    if (meta.Rounding != null)
                    {
                        writer.WritePropertyName("rounding");
                        writer.WriteValue(cpFormatter.GetRoundingText(meta.Rounding));
                    }

                    formatters.Add(new PresenterFactory().Instantiate(metadata.ElementAt(i).Type));
                    writer.WriteEndObject();
                }
                writer.WriteEndArray(); //columns

                BuildRows(sampled, formatters, writer);

                writer.WriteEndObject(); //table
            }
            writer.WriteEndObject();
        }
        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);

            //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 #20
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");
            }
        }
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            SearchRequest request = (SearchRequest)value;

            if (request == null)
            {
                return;
            }

            writer.WriteStartObject();

            writer.WritePropertyName("from");
            writer.WriteValue(request.From);

            writer.WritePropertyName("size");
            writer.WriteValue(request.Size);

            if (request.Filter != null)
            {
                writer.WritePropertyName("filtered");
                writer.WriteStartObject();
                writer.WritePropertyName("query");
                serializer.Serialize(writer, request.Query);
                writer.WritePropertyName("filter");
                serializer.Serialize(writer, request.Filter);
                writer.WriteEndObject();
            }
            else
            {
                writer.WritePropertyName("query");
                serializer.Serialize(writer, request.Query);
            }

            if (request.Fields != null && request.Fields.Count > 0)
            {
                writer.WritePropertyName("fields");
                writer.WriteStartArray();
                foreach (string field in request.Fields)
                {
                    writer.WriteValue(field);
                }
                writer.WriteEndArray();
            }

            if (request.SortFields != null && request.SortFields.Count > 0)
            {
                writer.WritePropertyName("sort");
                writer.WriteStartArray();
                foreach (SortField field in request.SortFields)
                {
                    serializer.Serialize(writer, field);
                }
                writer.WriteEndArray();
            }

            if (request.Facet != null)
            {
                writer.WritePropertyName("facets");
                serializer.Serialize(writer, request.Facet);
            }

            writer.WritePropertyName("explain");
            writer.WriteValue(request.Explain);

            writer.WritePropertyName("version");
            writer.WriteValue(request.Version);

            writer.WriteEndObject();
        }
Example #22
0
 public override void WriteStartArray()
 {
     _textWriter.WriteStartArray();
     _innerWriter.WriteStartArray();
     base.WriteStartArray();
 }
Example #23
0
        private void SerializeList(JsonWriter writer, IWrappedCollection values, JsonArrayContract contract, JsonProperty member, JsonContainerContract collectionContract, JsonProperty containerProperty)
        {
            contract.InvokeOnSerializing(values.UnderlyingCollection, Serializer.Context);

            _serializeStack.Add(values.UnderlyingCollection);

            bool hasWrittenMetadataObject = WriteStartArray(writer, values, contract, member, collectionContract, containerProperty);

            writer.WriteStartArray();

            int initialDepth = writer.Top;

            int index = 0;

            // note that an error in the IEnumerable won't be caught
            foreach (object value in values)
            {
                try
                {
                    JsonContract valueContract = contract.FinalItemContract ?? GetContractSafe(value);

                    if (ShouldWriteReference(value, null, valueContract, contract, member))
                    {
                        WriteReference(writer, value);
                    }
                    else
                    {
                        if (CheckForCircularReference(writer, value, null, valueContract, contract, member))
                        {
                            SerializeValue(writer, value, valueContract, null, contract, member);
                        }
                    }
                }
                catch (Exception ex)
                {
                    if (IsErrorHandled(values.UnderlyingCollection, contract, index, writer.ContainerPath, ex))
                    {
                        HandleError(writer, initialDepth);
                    }
                    else
                    {
                        throw;
                    }
                }
                finally
                {
                    index++;
                }
            }

            writer.WriteEndArray();

            if (hasWrittenMetadataObject)
            {
                writer.WriteEndObject();
            }

            _serializeStack.RemoveAt(_serializeStack.Count - 1);

            contract.InvokeOnSerialized(values.UnderlyingCollection, Serializer.Context);
        }
Example #24
0
        public void Serialize(JsonWriter writer)
        {
            writer.WritePropertyName(Title);
            writer.WriteStartObject();

            if (!string.IsNullOrWhiteSpace(Description))
            {
                writer.WritePropertyName("description");
                writer.WriteValue(Description);
            }
            if (TypeFormat.Type == ParameterType.Object)
            {
                writer.WritePropertyName("$ref");
                writer.WriteValue(string.Format("#/definitions/{0}", Ref));
            }
            else
            {
                if (TypeFormat.Type != ParameterType.Unknown)
                {
                    writer.WritePropertyName("type");
                    writer.WriteValue(TypeFormat.Type.ToString().ToLower());
                    if (!string.IsNullOrWhiteSpace(TypeFormat.Format))
                    {
                        writer.WritePropertyName("format");
                        writer.WriteValue(TypeFormat.Format);
                    }
                }
                if (TypeFormat.Type == ParameterType.Array && Items != null)
                {
                    writer.WritePropertyName("items");
                    Items.Serialize(writer);
                }
                if (!string.IsNullOrWhiteSpace(Default))
                {
                    writer.WritePropertyName("default");
                    writer.WriteValue(Default);
                }
                if (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, 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);
        }
        public void Serialize(JsonWriter writer)
        {
            if (TypeFormat.Type == ParameterType.Object)
            {
                // complex object

                if (!string.IsNullOrWhiteSpace(Description))
                {
                    writer.WritePropertyName("description");
                    writer.WriteValue(Description);
                }

                if (ParentSchema != null)
                {
                    writer.WritePropertyName("allOf");

                    writer.WriteStartArray();

                    writer.WritePropertyName("$ref");
                    writer.WriteValue(string.Format("#/definitions/{0}", ParentSchema.Name));

                    writer.WriteStartObject();
                }

                SerializeRequired(writer);

                SerializeExternalDocs(writer);

                SerializeProperties(writer);

                if (ParentSchema != null)
                {
                    writer.WriteEndObject();

                    writer.WriteEndArray();
                }
            }
            if (TypeFormat.Type != ParameterType.Unknown)
            {
                writer.WritePropertyName("type");
                writer.WriteValue(TypeFormat.Type.ToString().ToLower());
                if (!string.IsNullOrWhiteSpace(TypeFormat.Format))
                {
                    writer.WritePropertyName("format");
                    writer.WriteValue(TypeFormat.Format);
                }

                if (TypeFormat.Type == ParameterType.Array)
                {
                    writer.WritePropertyName("items");

                    writer.WriteStartObject();

                    writer.WritePropertyName("$ref");
                    writer.WriteValue(string.Format("#/definitions/{0}", Ref));

                    writer.WriteEndObject();
                }
                if (Enum != null && Enum.Any())
                {
                    writer.WritePropertyName("enum");
                    writer.WriteStartArray();
                    foreach (string e in Enum)
                    {
                        writer.WriteValue(e);
                    }
                    writer.WriteEndArray();
                }
            }
            else if (!string.IsNullOrWhiteSpace(Ref))
            {
                writer.WritePropertyName("$ref");
                writer.WriteValue(string.Format("#/definitions/{0}", Ref));
            }
        }
        private void SerializeList(JsonWriter writer, IList values, JsonArrayContract contract, JsonProperty member, JsonContract collectionValueContract)
        {
            contract.InvokeOnSerializing(values, Serializer.Context);

              SerializeStack.Add(values);

              bool isReference = contract.IsReference ?? HasFlag(Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Arrays);
              bool includeTypeDetails = ShouldWriteType(TypeNameHandling.Arrays, contract, member, collectionValueContract);

              if (isReference || includeTypeDetails)
              {
            writer.WriteStartObject();

            if (isReference)
            {
              writer.WritePropertyName(JsonTypeReflector.IdPropertyName);
              writer.WriteValue(Serializer.ReferenceResolver.GetReference(values));
            }
            if (includeTypeDetails)
            {
              WriteTypeProperty(writer, values.GetType());
            }
            writer.WritePropertyName(JsonTypeReflector.ArrayValuesPropertyName);
              }

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

              writer.WriteStartArray();

              int initialDepth = writer.Top;

              for (int i = 0; i < values.Count; i++)
              {
            try
            {
              object value = values[i];
              JsonContract valueContract = GetContractSafe(value);

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

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

              writer.WriteEndArray();

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

              SerializeStack.RemoveAt(SerializeStack.Count - 1);

              contract.InvokeOnSerialized(values, Serializer.Context);
        }
        private void SerializeList(JsonWriter writer, IEnumerable values, JsonArrayContract contract, JsonProperty member, JsonContainerContract collectionContract, JsonProperty containerProperty)
        {
            IWrappedCollection wrappedCollection = values as IWrappedCollection;
            object             underlyingList    = wrappedCollection != null ? wrappedCollection.UnderlyingCollection : values;

            OnSerializing(writer, contract, underlyingList);

            _serializeStack.Add(underlyingList);

            bool hasWrittenMetadataObject = WriteStartArray(writer, underlyingList, contract, member, collectionContract, containerProperty);

            writer.WriteStartArray();

            int initialDepth = writer.Top;

            int         index = 0;
            IEnumerator enumerator;

            try
            {
                enumerator = values.GetEnumerator();
            }
            catch (Exception e)
            {
                throw new InvalidOperationException("Could not get enumerator for property: " + member, e);
            }
            using (enumerator as IDisposable)
            {
                while (true)
                {
                    try
                    {
                        if (enumerator.MoveNext() == false)
                        {
                            break;
                        }
                    }
                    catch (Exception e)
                    {
                        throw new InvalidOperationException("Could not move to next value for property: " + member, e);
                    }
                    object value;
                    try
                    {
                        value = enumerator.Current;
                    }
                    catch (Exception e)
                    {
                        throw new InvalidOperationException("Could not get current value for property: " + member, e);
                    }
                    try
                    {
                        JsonContract valueContract = contract.FinalItemContract ?? GetContractSafe(value);

                        if (ShouldWriteReference(value, null, valueContract, contract, member))
                        {
                            WriteReference(writer, value);
                        }
                        else
                        {
                            if (CheckForCircularReference(writer, value, null, valueContract, contract, member))
                            {
                                SerializeValue(writer, value, valueContract, null, contract, member);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        if (IsErrorHandled(underlyingList, contract, index, null, writer.ContainerPath, ex))
                        {
                            HandleError(writer, initialDepth);
                        }
                        else
                        {
                            throw;
                        }
                    }
                    finally
                    {
                        index++;
                    }
                }
            }

            writer.WriteEndArray();

            if (hasWrittenMetadataObject)
            {
                writer.WriteEndObject();
            }

            _serializeStack.RemoveAt(_serializeStack.Count - 1);

            OnSerialized(writer, contract, underlyingList);
        }
        public new void AsJson(JsonWriter writer, string baseUrl)
        {
            writer.WriteStartObject();
            base.AsJson(writer, baseUrl);

            writer.WritePropertyName("title");
            writer.WriteValue(Title);

            if (!String.IsNullOrEmpty(IMSClassCode))
            {
                writer.WritePropertyName("classCode");
                writer.WriteValue(IMSClassCode);
            }

            writer.WritePropertyName("classType");
            writer.WriteValue(Enum.GetName(typeof(Vocabulary.IMSClassType), IMSClassType));

            if (!String.IsNullOrEmpty(Location))
            {
                writer.WritePropertyName("location");
                writer.WriteValue(Location);
            }

            if (Grades != null && Grades.Length > 0)
            {
                writer.WritePropertyName("grades");
                writer.WriteStartArray();
                foreach (var grade in Grades)
                {
                    writer.WriteValue(grade);
                }
                writer.WriteEndArray();
            }

            if (Subjects != null && Subjects.Length > 0)
            {
                writer.WritePropertyName("subjects");
                writer.WriteStartArray();
                foreach (var subject in Subjects)
                {
                    writer.WriteValue(subject);
                }
                writer.WriteEndArray();
            }

            writer.WritePropertyName("course");
            Course.AsJsonReference(writer, baseUrl);

            writer.WritePropertyName("resources");
            writer.WriteStartArray();
            if (Course.Resources != null)
            {
                foreach (var resource in Course.Resources)
                {
                    writer.WriteValue(resource);
                }
            }
            if (Resources != null)
            {
                foreach (var resource in Resources)
                {
                    writer.WriteValue(resource);
                }
            }
            writer.WriteEndArray();

            writer.WritePropertyName("school");
            School.AsJsonReference(writer, baseUrl);

            writer.WritePropertyName("terms");
            writer.WriteStartArray();
            IMSClassAcademicSessions.ForEach(join => join.AcademicSession.AsJsonReference(writer, baseUrl));
            writer.WriteEndArray();

            if (SubjectCodes != null && SubjectCodes.Length > 0)
            {
                writer.WritePropertyName("subjectCodes");
                writer.WriteStartArray();
                foreach (var subjectCode in SubjectCodes)
                {
                    writer.WriteValue(subjectCode);
                }
                writer.WriteEndArray();
            }

            if (Periods != null && Periods.Length > 0)
            {
                writer.WritePropertyName("periods");
                writer.WriteStartArray();
                foreach (var period in Periods)
                {
                    writer.WriteValue(period);
                }
                writer.WriteEndArray();
            }

            writer.WriteEndObject();
            writer.Flush();
        }
Example #30
0
        private void WriteToken(JSchema context, JsonWriter writer, JToken token, bool isDefinitions = false)
        {
            if (token is JObject)
            {
                JObject o = (JObject)token;

                JSchemaAnnotation schemaAnnotation = o.Annotation <JSchemaAnnotation>();

                if (schemaAnnotation != null)
                {
                    ReferenceOrWriteSchema(context, schemaAnnotation.Schema, null, isDefinitions);
                }
                else
                {
                    writer.WriteStartObject();

                    foreach (JProperty property in o.Properties())
                    {
                        writer.WritePropertyName(property.Name);

                        JToken value = property.Value;
                        if (value != null)
                        {
                            WriteToken(context, writer, value, isDefinitions);
                        }
                        else
                        {
                            writer.WriteNull();
                        }
                    }

                    writer.WriteEndObject();
                }
            }
            else if (token is JArray)
            {
                JArray a = (JArray)token;

                writer.WriteStartArray();

                for (int i = 0; i < a.Count; i++)
                {
                    WriteToken(context, writer, a[i]);
                }

                writer.WriteEndArray();
            }
            else if (token is JConstructor)
            {
                JConstructor c = (JConstructor)token;

                writer.WriteStartConstructor(c.Name);

                foreach (JToken t in c.Children())
                {
                    WriteToken(context, writer, t);
                }

                writer.WriteEndConstructor();
            }
            else if (token is JValue)
            {
                token.WriteTo(writer);
            }
        }
    private void SerializeGroupedNodes(JsonWriter writer, XmlNode node)
    {
      // group nodes together by name
      Dictionary<string, List<XmlNode>> nodesGroupedByName = new Dictionary<string, List<XmlNode>>();

      for (int i = 0; i < node.ChildNodes.Count; i++)
      {
        XmlNode childNode = node.ChildNodes[i];
        string nodeName = GetPropertyName(childNode);

        List<XmlNode> nodes;
        if (!nodesGroupedByName.TryGetValue(nodeName, out nodes))
        {
          nodes = new List<XmlNode>();
          nodesGroupedByName.Add(nodeName, nodes);
        }

        nodes.Add(childNode);
      }

      // loop through grouped nodes. write single name instances as normal,
      // write multiple names together in an array
      foreach (KeyValuePair<string, List<XmlNode>> nodeNameGroup in nodesGroupedByName)
      {
        List<XmlNode> groupedNodes = nodeNameGroup.Value;
        bool writeArray;

        if (groupedNodes.Count == 1)
        {
          XmlNode singleNode = groupedNodes[0];
          XmlAttribute jsonArrayAttribute = (singleNode.Attributes != null) ? singleNode.Attributes["Array", JsonNamespaceUri] : null;
          if (jsonArrayAttribute != null)
            writeArray = XmlConvert.ToBoolean(jsonArrayAttribute.Value);
          else
            writeArray = false;
        }
        else
        {
          writeArray = true;
        }

        if (!writeArray)
        {
          SerializeNode(writer, groupedNodes[0], true);
        }
        else
        {
          string elementNames = nodeNameGroup.Key;
          writer.WritePropertyName(nodeNameGroup.Key);
          writer.WriteStartArray();

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

          writer.WriteEndArray();
        }
      }
    }
Example #32
0
        private void WriteSchemaObjectInternal(JSchema schema)
        {
            _writer.WriteStartObject();

            if (schema == _rootSchema)
            {
                Uri resolvedVersionUri = (_version != SchemaVersion.Unset)
                    ? SchemaVersionHelpers.MapSchemaVersion(_version)
                    : schema.SchemaVersion;

                WritePropertyIfNotNull(_writer, Constants.PropertyNames.Schema, resolvedVersionUri);
            }

            if (EnsureVersion(SchemaVersion.Draft6))
            {
                WritePropertyIfNotNull(_writer, Constants.PropertyNames.Id, schema.Id);
            }
            else
            {
                WritePropertyIfNotNull(_writer, Constants.PropertyNames.IdDraft4, schema.Id);
            }
            WritePropertyIfNotNull(_writer, Constants.PropertyNames.Title, schema.Title);
            WritePropertyIfNotNull(_writer, Constants.PropertyNames.Description, schema.Description);

            if (schema._extensionData != null)
            {
                foreach (KeyValuePair <string, JToken> extensionDataPair in schema._extensionData)
                {
                    bool isDefinitions = schema == _rootSchema && string.Equals(extensionDataPair.Key, Constants.PropertyNames.Definitions);

                    _writer.WritePropertyName(extensionDataPair.Key);
                    WriteToken(schema, _writer, extensionDataPair.Value, isDefinitions);
                }
            }

            if (schema.Type != null)
            {
                WriteType(Constants.PropertyNames.Type, _writer, schema.Type.Value);
            }

            if (schema.Default != null)
            {
                _writer.WritePropertyName(Constants.PropertyNames.Default);
                schema.Default.WriteTo(_writer);
            }
            if (!schema.AllowAdditionalProperties)
            {
                _writer.WritePropertyName(Constants.PropertyNames.AdditionalProperties);
                _writer.WriteValue(schema.AllowAdditionalProperties);
            }
            else
            {
                if (schema.AdditionalProperties != null)
                {
                    ReferenceOrWriteSchema(schema, schema.AdditionalProperties, Constants.PropertyNames.AdditionalProperties);
                }
            }
            if (!schema.AllowAdditionalItems)
            {
                _writer.WritePropertyName(Constants.PropertyNames.AdditionalItems);
                _writer.WriteValue(schema.AllowAdditionalItems);
            }
            else
            {
                if (schema.AdditionalItems != null)
                {
                    ReferenceOrWriteSchema(schema, schema.AdditionalItems, Constants.PropertyNames.AdditionalItems);
                }
            }
            WriteSchemaDictionaryIfNotNull(schema, _writer, Constants.PropertyNames.Properties, schema._properties);
            WriteRequired(schema);
            WriteSchemaDictionaryIfNotNull(schema, _writer, Constants.PropertyNames.PatternProperties, schema._patternProperties);
            WriteItems(schema);
            WritePropertyIfNotDefault(_writer, Constants.PropertyNames.UniqueItems, schema.UniqueItems);

            if (EnsureVersion(SchemaVersion.Draft6))
            {
                WritePropertyIfNotNull(_writer, schema.ExclusiveMinimum ? Constants.PropertyNames.ExclusiveMinimum : Constants.PropertyNames.Minimum, schema.Minimum);
                WritePropertyIfNotNull(_writer, schema.ExclusiveMaximum ? Constants.PropertyNames.ExclusiveMaximum : Constants.PropertyNames.Maximum, schema.Maximum);
            }
            else
            {
                WritePropertyIfNotNull(_writer, Constants.PropertyNames.Minimum, schema.Minimum);
                WritePropertyIfNotNull(_writer, Constants.PropertyNames.Maximum, schema.Maximum);
                WritePropertyIfNotDefault(_writer, Constants.PropertyNames.ExclusiveMinimum, schema.ExclusiveMinimum);
                WritePropertyIfNotDefault(_writer, Constants.PropertyNames.ExclusiveMaximum, schema.ExclusiveMaximum);
            }

            WritePropertyIfNotNull(_writer, Constants.PropertyNames.MinimumLength, schema.MinimumLength);
            WritePropertyIfNotNull(_writer, Constants.PropertyNames.MaximumLength, schema.MaximumLength);
            WritePropertyIfNotNull(_writer, Constants.PropertyNames.MinimumItems, schema.MinimumItems);
            WritePropertyIfNotNull(_writer, Constants.PropertyNames.MaximumItems, schema.MaximumItems);
            WritePropertyIfNotNull(_writer, Constants.PropertyNames.MinimumProperties, schema.MinimumProperties);
            WritePropertyIfNotNull(_writer, Constants.PropertyNames.MaximumProperties, schema.MaximumProperties);
            WritePropertyIfNotNull(_writer, Constants.PropertyNames.MultipleOf, schema.MultipleOf);
            WritePropertyIfNotNull(_writer, Constants.PropertyNames.Pattern, schema.Pattern);
            WritePropertyIfNotNull(_writer, Constants.PropertyNames.Format, schema.Format);
            if (!schema._enum.IsNullOrEmpty())
            {
                _writer.WritePropertyName(Constants.PropertyNames.Enum);
                _writer.WriteStartArray();
                foreach (JToken token in schema._enum)
                {
                    token.WriteTo(_writer);
                }
                _writer.WriteEndArray();
            }
            if (EnsureVersion(SchemaVersion.Draft6))
            {
                if (schema.Const != null)
                {
                    _writer.WritePropertyName(Constants.PropertyNames.Const);
                    schema.Const.WriteTo(_writer);
                }
                WriteSchema(schema, schema.PropertyNames, Constants.PropertyNames.PropertyNamesSchema);
                WriteSchema(schema, schema.Contains, Constants.PropertyNames.Contains);
            }
            WriteSchemas(schema, schema._allOf, Constants.PropertyNames.AllOf);
            WriteSchemas(schema, schema._anyOf, Constants.PropertyNames.AnyOf);
            WriteSchemas(schema, schema._oneOf, Constants.PropertyNames.OneOf);
            WriteSchema(schema, schema.Not, Constants.PropertyNames.Not);

            _writer.WriteEndObject();
        }
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            BoolQuery boolQuery = (BoolQuery)value;

            if (boolQuery == null)
            {
                return;
            }

            /*
             * {
             *  "bool" : {
             *      "must" : [{}],
             *      "must_not" : [{}],
             *      "should" : [],
             *      "minimum_should_match" : mini,
             *      "boost" : boostvalue
             *  }
             * }
             */

            writer.WriteStartObject();
            writer.WritePropertyName("bool");
            writer.WriteStartObject();
            if (boolQuery.MustQuery != null && boolQuery.MustQuery.Count > 0)
            {
                writer.WritePropertyName("must");
                writer.WriteStartArray();
                foreach (IQuery query in boolQuery.MustQuery)
                {
                    serializer.Serialize(writer, query);
                }
                writer.WriteEndArray();
            }
            if (boolQuery.MustNotQuery != null && boolQuery.MustNotQuery.Count > 0)
            {
                writer.WritePropertyName("must_not");
                writer.WriteStartArray();
                foreach (IQuery query in boolQuery.MustNotQuery)
                {
                    serializer.Serialize(writer, query);
                }
                writer.WriteEndArray();
            }
            if (boolQuery.ShouldQuery != null && boolQuery.ShouldQuery.Count > 0)
            {
                writer.WritePropertyName("should");
                writer.WriteStartArray();
                foreach (IQuery query in boolQuery.ShouldQuery)
                {
                    serializer.Serialize(writer, query);
                }
                writer.WriteEndArray();
            }
            if (Math.Abs(boolQuery.Boost - Constants.DF_Boost) > 0)
            {
                writer.WritePropertyName("boost");
                writer.WriteValue(boolQuery.Boost);
            }
            writer.WriteEndObject();
            writer.WriteEndObject();
        }
Example #34
0
        public override void Serialize(JsonWriter writer)
        {
            writer.WriteStartObject();

            writer.WritePropertyName("attributes");
            writer.WriteStartObject();
            foreach (var attribute in Attributes)
            {
                writer.WritePropertyName(attribute.Key);
                writer.WriteValue(attribute.Value.Id);
            }
            writer.WriteEndObject();

            if (Indices != null)
            {
                writer.WritePropertyName("indices");
                writer.WriteValue(Indices.Id);
            }

            if (Material != null)
            {
                writer.WritePropertyName("material");
                writer.WriteValue(Material.Id);
            }

            if (Mode != DrawMode.Triangles)
            {
                writer.WritePropertyName("mode");
                writer.WriteValue((int)Mode);
            }

            if (Targets != null && Targets.Count > 0)
            {
                writer.WritePropertyName("targets");
                writer.WriteStartArray();
                foreach (var target in Targets)
                {
                    writer.WriteStartObject();

                    foreach (var attribute in target)
                    {
                        writer.WritePropertyName(attribute.Key);
                        writer.WriteValue(attribute.Value.Id);
                    }

                    writer.WriteEndObject();
                }
                writer.WriteEndArray();
            }

            // GLTF does not support morph target names, serialize in extras for now
            // https://github.com/KhronosGroup/glTF/issues/1036
            if (TargetNames != null && TargetNames.Count > 0)
            {
                writer.WritePropertyName("extras");
                writer.WriteStartObject();
                writer.WritePropertyName("targetNames");
                writer.WriteStartArray();
                foreach (var targetName in TargetNames)
                {
                    writer.WriteValue(targetName);
                }
                writer.WriteEndArray();
                writer.WriteEndObject();
            }

            base.Serialize(writer);

            writer.WriteEndObject();
        }
Example #35
0
    public void StringEscaping()
    {
      StringBuilder sb = new StringBuilder();
      StringWriter sw = new StringWriter(sb);

      using (JsonWriter jsonWriter = new JsonWriter(sw))
      {
        jsonWriter.WriteStartArray();
        jsonWriter.WriteValue(@"""These pretzels are making me thirsty!""");
        jsonWriter.WriteValue("Jeff's house was burninated.");
        jsonWriter.WriteValue(@"1. You don't talk about fight club.
2. You don't talk about fight club.");
        jsonWriter.WriteValue("35% of\t statistics\n are made\r up.");
        jsonWriter.WriteEndArray();
      }

      string expected = @"[""\""These pretzels are making me thirsty!\"""",""Jeff's house was burninated."",""1. You don't talk about fight club.\r\n2. You don't talk about fight club."",""35% of\t statistics\n are made\r up.""]";
      string result = sb.ToString();

      Console.WriteLine("StringEscaping");
      Console.WriteLine(result);

      Assert.AreEqual(expected, result);
    }
Example #36
0
        public override void Serialize(JsonWriter writer)
        {
            writer.WriteStartObject();

            if (PbrMetallicRoughness != null)
            {
                writer.WritePropertyName("pbrMetallicRoughness");
                PbrMetallicRoughness.Serialize(writer);
            }

            if (CommonConstant != null)
            {
                writer.WritePropertyName("commonConstant");
                CommonConstant.Serialize(writer);
            }

            if (NormalTexture != null)
            {
                writer.WritePropertyName("normalTexture");
                NormalTexture.Serialize(writer);
            }

            if (OcclusionTexture != null)
            {
                writer.WritePropertyName("occlusionTexture");
                OcclusionTexture.Serialize(writer);
            }

            if (EmissiveTexture != null)
            {
                writer.WritePropertyName("emissiveTexture");
                EmissiveTexture.Serialize(writer);
            }

            if (EmissiveFactor != Color.black)
            {
                writer.WritePropertyName("emissiveFactor");
                writer.WriteStartArray();
                writer.WriteValue(EmissiveFactor.r);
                writer.WriteValue(EmissiveFactor.g);
                writer.WriteValue(EmissiveFactor.b);
                writer.WriteEndArray();
            }

            if (AlphaMode != AlphaMode.OPAQUE)
            {
                writer.WritePropertyName("alphaMode");
                writer.WriteValue(AlphaMode.ToString());
            }

            if (AlphaCutoff != 0.5)
            {
                writer.WritePropertyName("alphaCutoff");
                writer.WriteValue(AlphaCutoff);
            }

            if (DoubleSided)
            {
                writer.WritePropertyName("doubleSided");
                writer.WriteValue(true);
            }

            base.Serialize(writer);

            writer.WriteEndObject();
        }
        private void SerializeList(JsonWriter writer, IEnumerable values, JsonArrayContract contract, JsonProperty member, JsonContainerContract collectionContract, JsonProperty containerProperty)
        {
            IWrappedCollection wrappedCollection = values as IWrappedCollection;
            object underlyingList = wrappedCollection != null ? wrappedCollection.UnderlyingCollection : values;

            OnSerializing(writer, contract, underlyingList);

            _serializeStack.Add(underlyingList);

            bool hasWrittenMetadataObject = WriteStartArray(writer, underlyingList, contract, member, collectionContract, containerProperty);

            writer.WriteStartArray();

            int initialDepth = writer.Top;

            int index = 0;
            IEnumerator enumerator;
            try
            {
                enumerator = values.GetEnumerator();
            }
            catch (Exception e)
            {
                throw new InvalidOperationException("Could not get enumerator for property: " + member, e);
            }
            using (enumerator as IDisposable)
            {
                while (true)
                {
                    try
                    {
                        if (enumerator.MoveNext() == false)
                            break;
                    }
                    catch (Exception e)
                    {
                        throw new InvalidOperationException("Could not move to next value for property: " + member, e);

                    }
                    object value;
                    try
                    {
                        value = enumerator.Current;
                    }
                    catch (Exception e)
                    {
                        throw new InvalidOperationException("Could not get current value for property: " + member, e);

                    }
                    try
                    {
                        JsonContract valueContract = contract.FinalItemContract ?? GetContractSafe(value);

                        if (ShouldWriteReference(value, null, valueContract, contract, member))
                        {
                            WriteReference(writer, value);
                        }
                        else
                        {
                            if (CheckForCircularReference(writer, value, null, valueContract, contract, member))
                            {
                                SerializeValue(writer, value, valueContract, null, contract, member);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        if (IsErrorHandled(underlyingList, contract, index, null, writer.ContainerPath, ex))
                            HandleError(writer, initialDepth);
                        else
                            throw;
                    }
                    finally
                    {
                        index++;
                    }
                }
            }

            writer.WriteEndArray();

            if (hasWrittenMetadataObject)
                writer.WriteEndObject();

            _serializeStack.RemoveAt(_serializeStack.Count - 1);

            OnSerialized(writer, contract, underlyingList);
        }
Example #38
0
        public override void WriteTo(JsonWriter writer)
        {
            writer.WriteStartArray();

              foreach (JToken token in Children())
              {
            token.WriteTo(writer);
              }

              writer.WriteEndArray();
        }
Example #39
0
        private void SerializeGroupedNodes(JsonWriter writer, XmlNode node)
        {
            // group nodes together by name
            Dictionary <string, List <XmlNode> > nodesGroupedByName = new Dictionary <string, List <XmlNode> >();

            for (int i = 0; i < node.ChildNodes.Count; i++)
            {
                XmlNode childNode = node.ChildNodes[i];
                string  nodeName  = GetPropertyName(childNode);

                List <XmlNode> nodes;
                if (!nodesGroupedByName.TryGetValue(nodeName, out nodes))
                {
                    nodes = new List <XmlNode>();
                    nodesGroupedByName.Add(nodeName, nodes);
                }

                nodes.Add(childNode);
            }

            // loop through grouped nodes. write single name instances as normal,
            // write multiple names together in an array
            foreach (KeyValuePair <string, List <XmlNode> > nodeNameGroup in nodesGroupedByName)
            {
                List <XmlNode> groupedNodes = nodeNameGroup.Value;
                bool           writeArray;

                if (groupedNodes.Count == 1)
                {
                    XmlNode      singleNode         = groupedNodes[0];
                    XmlAttribute jsonArrayAttribute = (singleNode.Attributes != null) ? singleNode.Attributes["Array", JsonNamespaceUri] : null;
                    if (jsonArrayAttribute != null)
                    {
                        writeArray = XmlConvert.ToBoolean(jsonArrayAttribute.Value);
                    }
                    else
                    {
                        writeArray = false;
                    }
                }
                else
                {
                    writeArray = true;
                }

                if (!writeArray)
                {
                    SerializeNode(writer, groupedNodes[0], true);
                }
                else
                {
                    string elementNames = nodeNameGroup.Key;
                    writer.WritePropertyName(nodeNameGroup.Key);
                    writer.WriteStartArray();

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

                    writer.WriteEndArray();
                }
            }
        }
    private void SerializeList(JsonWriter writer, IWrappedCollection values, JsonArrayContract contract, JsonProperty member, JsonContainerContract collectionContract, JsonProperty containerProperty)
    {
      contract.InvokeOnSerializing(values.UnderlyingCollection, Serializer.Context);

      _serializeStack.Add(values.UnderlyingCollection);

      bool hasWrittenMetadataObject = WriteStartArray(writer, values.UnderlyingCollection, contract, member, collectionContract, containerProperty);

      writer.WriteStartArray();

      int initialDepth = writer.Top;

      int index = 0;
      // note that an error in the IEnumerable won't be caught
      foreach (object value in values)
      {
        try
        {
          JsonContract valueContract = contract.FinalItemContract ?? GetContractSafe(value);

          if (ShouldWriteReference(value, null, valueContract, contract, member))
          {
            WriteReference(writer, value);
          }
          else
          {
            if (CheckForCircularReference(writer, value, null, valueContract, contract, member))
            {
              SerializeValue(writer, value, valueContract, null, contract, member);
            }
          }
        }
        catch (Exception ex)
        {
          if (IsErrorHandled(values.UnderlyingCollection, contract, index, writer.ContainerPath, ex))
            HandleError(writer, initialDepth);
          else
            throw;
        }
        finally
        {
          index++;
        }
      }

      writer.WriteEndArray();

      if (hasWrittenMetadataObject)
        writer.WriteEndObject();

      _serializeStack.RemoveAt(_serializeStack.Count - 1);

      contract.InvokeOnSerialized(values.UnderlyingCollection, Serializer.Context);
    }
Example #41
0
            /// <summary>
            /// Write the JSON string.  This will convert all the properties to a JSON string.
            /// This is done manaully to improve conversion time.  The default serializer will check
            /// each property if it can convert.  This will convert the properties automatically.  This
            /// will double the speed.
            /// 
            /// Newtonsoft.Json.JsonConvert.SerializeObject(ensemble.InstrumentVelocityData).
            /// 
            /// </summary>
            /// <param name="writer">JSON Writer.</param>
            /// <param name="value">Object to write to JSON.</param>
            /// <param name="serializer">Serializer to convert the object.</param>
            public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
            {
                // Cast the object
                var data = value as InstrumentVelocityDataSet;

                // Start the object
                writer.Formatting = Formatting.None;            // Make the text not indented, so not as human readable.  This will save disk space
                writer.WriteStartObject();                      // Start the JSON object

                // Write the base values
                writer.WriteRaw(data.ToJsonBaseStub());
                writer.WriteRaw(",");

                // Write the float[,] array data
                // This will be an array of arrays
                // Each array element will contain an array with the 4 beam's value
                writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_INSTRUMENTVELOCITYDATA);
                writer.WriteStartArray();
                for (int bin = 0; bin < data.NumElements; bin++)
                {
                    // Write an array of float values for each beam's value
                    writer.WriteStartArray();

                    for (int beam = 0; beam < data.ElementsMultiplier; beam++)
                    {
                        writer.WriteValue(data.InstrumentVelocityData[bin, beam]);
                    }

                    writer.WriteEndArray();
                }
                writer.WriteEndArray();

                // End the object
                writer.WriteEndObject();
            }
        private void WriteType(string propertyName, JsonWriter writer, JsonSchemaType type)
        {
            IList<JsonSchemaType> types;
            if (System.Enum.IsDefined(typeof(JsonSchemaType), type))
            {
                types = new List<JsonSchemaType> { type };
            }
            else
            {
                types = EnumUtils.GetFlagsValues(type).Where(v => v != JsonSchemaType.None).ToList();
            }

            if (types.Count == 0)
            {
                return;
            }

            writer.WritePropertyName(propertyName);

            if (types.Count == 1)
            {
                writer.WriteValue(JsonSchemaBuilder.MapType(types[0]));
                return;
            }

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

            Type unionType = UnionTypeLookupCache.Get(value.GetType());
            Union union = UnionCache.Get(unionType);

            int tag = (int)union.TagReader.Invoke(value);
            UnionCase caseInfo = union.Cases.Single(c => c.Tag == tag);

            writer.WriteStartObject();
            writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(CasePropertyName) : CasePropertyName);
            writer.WriteValue(caseInfo.Name);
            if (caseInfo.Fields != null && caseInfo.Fields.Length > 0)
            {
                object[] fields = (object[])caseInfo.FieldReader.Invoke(value);

                writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(FieldsPropertyName) : FieldsPropertyName);
                writer.WriteStartArray();
                foreach (object field in fields)
                {
                    serializer.Serialize(writer, field);
                }
                writer.WriteEndArray();
            }
            writer.WriteEndObject();
        }
Example #44
0
        /// <summary>
        /// Converts XML to JsonML array form.
        /// </summary>

        public static void EncodeArrayForm(XmlReader reader, JsonWriter writer)
        {
            if (reader == null) throw new ArgumentNullException("reader");
            if (writer == null) throw new ArgumentNullException("writer");

            if (reader.MoveToContent() != XmlNodeType.Element)
                throw new ArgumentException(null, "reader");

            writer.WriteStartArray();
            writer.WriteString(reader.Name);

            //
            // Write attributes
            //

            if (reader.MoveToFirstAttribute())
            {
                writer.WriteStartObject();

                do
                {
                    writer.WriteMember(reader.Name);
                    writer.WriteString(reader.Value);
                }
                while (reader.MoveToNextAttribute());

                writer.WriteEndObject();
                reader.MoveToElement();
            }

            bool isEmpty = reader.IsEmptyElement;

            if (!isEmpty)
            {
                reader.Read();

                //
                // Write child nodes (text, CDATA and element)
                //

                while (reader.NodeType != XmlNodeType.EndElement)
                {
                    if (reader.NodeType == XmlNodeType.Text || reader.NodeType == XmlNodeType.CDATA)
                    {
                        writer.WriteString(reader.Value);
                        reader.Read();
                    }
                    else if (reader.NodeType == XmlNodeType.Element)
                    {
                        Encode(reader, writer);
                    }
                    else
                    {
                        reader.Read();
                    }
                }
            }

            writer.WriteEndArray();
            reader.Read();
        }
		private void SerializeList(JsonWriter writer, IWrappedCollection values, JsonArrayContract contract, JsonProperty member, JsonContract collectionValueContract)
		{
			contract.InvokeOnSerializing(values.UnderlyingCollection, Serializer.Context);

			SerializeStack.Add(values.UnderlyingCollection);

			bool isReference = contract.IsReference ?? HasFlag(Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Arrays);
			bool includeTypeDetails = ShouldWriteType(TypeNameHandling.Arrays, contract, member, collectionValueContract);

			if (isReference || includeTypeDetails)
			{
				writer.WriteStartObject();

				if (isReference)
				{
					writer.WritePropertyName(JsonTypeReflector.IdPropertyName);
					writer.WriteValue(Serializer.ReferenceResolver.GetReference(this, values.UnderlyingCollection));
				}
				if (includeTypeDetails)
				{
					WriteTypeProperty(writer, values.UnderlyingCollection.GetType());
				}
				writer.WritePropertyName(JsonTypeReflector.ArrayValuesPropertyName);
			}

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

			writer.WriteStartArray();

			int initialDepth = writer.Top;

			int index = 0;
			// note that an error in the IEnumerable won't be caught
#if !(UNITY_IPHONE || UNITY_IOS)
			foreach (object value in values)
			{
				try
				{
					JsonContract valueContract = GetContractSafe(value);

					if (ShouldWriteReference(value, null, valueContract))
					{
						WriteReference(writer, value);
					}
					else
					{
						if (CheckForCircularReference(value, null, contract))
						{
							SerializeValue(writer, value, valueContract, null, childValuesContract);
						}
					}
				}
				catch (Exception ex)
				{
					if (IsErrorHandled(values.UnderlyingCollection, contract, index, ex))
						HandleError(writer, initialDepth);
					else
						throw;
				}
				finally
				{
					index++;
				}
			}
#else

			values.ForEach(value =>
			{
				try
				{
					JsonContract valueContract = GetContractSafe(value);

					if (ShouldWriteReference(value, null, valueContract))
					{
						WriteReference(writer, value);
					}
					else
					{
						if (CheckForCircularReference(value, null, contract))
						{
							SerializeValue(writer, value, valueContract, null, childValuesContract);
						}
					}
				}
				catch (Exception ex)
				{
					if (IsErrorHandled(values.UnderlyingCollection, contract, index, ex))
						HandleError(writer, initialDepth);
					else
						throw;
				}
				finally
				{
					index++;
				}
			});


#endif

			writer.WriteEndArray();

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

			SerializeStack.RemoveAt(SerializeStack.Count - 1);

			contract.InvokeOnSerialized(values.UnderlyingCollection, Serializer.Context);
		}
Example #46
0
        public override void Serialize(JsonWriter writer)
        {
            writer.WriteStartObject();

            if (Camera != null)
            {
                writer.WritePropertyName("camera");
                writer.WriteValue(Camera.Id);
            }

            if (Children != null && Children.Count > 0)
            {
                writer.WritePropertyName("children");
                writer.WriteStartArray();
                foreach (var child in Children)
                {
                    writer.WriteValue(child.Id);
                }
                writer.WriteEndArray();
            }

            if (Skin != null)
            {
                writer.WritePropertyName("skin");
                writer.WriteValue(Skin.Id);
            }

            if (Matrix != Matrix4x4.identity)
            {
                writer.WritePropertyName("matrix");
                writer.WriteStartArray();
                for (var i = 0; i < 16; i++)
                {
                    writer.WriteValue(Matrix[i]);
                }
                writer.WriteEndArray();
            }

            if (Mesh != null)
            {
                writer.WritePropertyName("mesh");
                writer.WriteValue(Mesh.Id);
            }

            if (Rotation != Quaternion.identity)
            {
                writer.WritePropertyName("rotation");
                writer.WriteStartArray();
                writer.WriteValue(Rotation.x);
                writer.WriteValue(Rotation.y);
                writer.WriteValue(Rotation.z);
                writer.WriteValue(Rotation.w);
                writer.WriteEndArray();
            }

            if (Scale != Vector3.one)
            {
                writer.WritePropertyName("scale");
                writer.WriteStartArray();
                writer.WriteValue(Scale.x);
                writer.WriteValue(Scale.y);
                writer.WriteValue(Scale.z);
                writer.WriteEndArray();
            }

            if (Translation != Vector3.zero)
            {
                writer.WritePropertyName("translation");
                writer.WriteStartArray();
                writer.WriteValue(Translation.x);
                writer.WriteValue(Translation.y);
                writer.WriteValue(Translation.z);
                writer.WriteEndArray();
            }

            if (Weights != null && Weights.Count > 0)
            {
                writer.WritePropertyName("weights");
                writer.WriteStartArray();
                foreach (var weight in Weights)
                {
                    writer.WriteValue(weight);
                }
                writer.WriteEndArray();
            }

            base.Serialize(writer);

            writer.WriteEndObject();
        }
        private void SerializeList(JsonWriter writer, IList values, JsonArrayContract contract, JsonProperty member)
        {
            contract.InvokeOnSerializing(values, Serializer.Context);

            SerializeStack.Add(values);

            bool isReference        = contract.IsReference ?? HasFlag(Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Arrays);
            bool includeTypeDetails = HasFlag(((member != null) ? member.TypeNameHandling : null) ?? Serializer.TypeNameHandling, TypeNameHandling.Arrays);

            if (isReference || includeTypeDetails)
            {
                writer.WriteStartObject();

                if (isReference)
                {
                    writer.WritePropertyName(JsonTypeReflector.IdPropertyName);
                    writer.WriteValue(Serializer.ReferenceResolver.GetReference(values));
                }
                if (includeTypeDetails)
                {
                    WriteTypeProperty(writer, values.GetType());
                }
                writer.WritePropertyName(JsonTypeReflector.ArrayValuesPropertyName);
            }

            writer.WriteStartArray();

            int initialDepth = writer.Top;

            for (int i = 0; i < values.Count; i++)
            {
                try
                {
                    object       value         = values[i];
                    JsonContract valueContract = GetContractSafe(value);

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

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

            writer.WriteEndArray();

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

            SerializeStack.RemoveAt(SerializeStack.Count - 1);

            contract.InvokeOnSerialized(values, Serializer.Context);
        }
Example #48
0
 public void WriteArrayStart()
 {
     _jsonWriter.WriteStartArray();
 }
Example #49
0
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            if (value != null)
            {
                if (value.GetType() == typeof(Color))
                {
                    Color color = (Color)value;
                    writer.WriteStartArray();
                    writer.WriteValue(color.r);
                    writer.WriteValue(color.g);
                    writer.WriteValue(color.b);
                    writer.WriteValue(color.a);
                    writer.WriteEndArray();
                }
                else if (value.GetType() == typeof(Vector2))
                {
                    Vector2 v = (Vector2)value;
                    writer.WriteStartArray();
                    writer.WriteValue(v.x);
                    writer.WriteValue(v.y);
                    writer.WriteEndArray();
                }
                else if (value.GetType() == typeof(Vector3))
                {
                    Vector3 v = (Vector3)value;
                    writer.WriteStartArray();
                    writer.WriteValue(v.x);
                    writer.WriteValue(v.y);
                    writer.WriteValue(v.z);
                    writer.WriteEndArray();
                }
                else if (value.GetType() == typeof(Vector4))
                {
                    Vector4 v = (Vector4)value;
                    writer.WriteStartArray();
                    writer.WriteValue(v.x);
                    writer.WriteValue(v.y);
                    writer.WriteValue(v.z);
                    writer.WriteValue(v.w);
                    writer.WriteEndArray();
                }
                else if (value.GetType() == typeof(Quaternion))
                {
                    Quaternion q = (Quaternion)value;
                    writer.WriteStartArray();
                    writer.WriteValue(q.x);
                    writer.WriteValue(q.y);
                    writer.WriteValue(q.z);
                    writer.WriteValue(q.w);
                    writer.WriteEndArray();
                }
                else if (value.GetType() == typeof(Matrix4x4))
                {
                    Matrix4x4 m = (Matrix4x4)value;
                    writer.WriteStartArray();

                    for (int y = 0; y < 4; y++)
                    {
                        for (int x = 0; x < 4; x++)
                        {
                            writer.WriteValue(m[y, x]);
                        }
                    }

                    writer.WriteEndArray();
                }
            }
        }
        private void InternalWrite(JsonWriter writer, string name, object value, JsonSerializer serializer)
        {
            JsonConverter converter;

            if (value == null)
            {
                if (serializer.NullValueHandling == NullValueHandling.Include)
                {
                    writer.WriteNull();
                }
                return;
            }

            Type valueType = value.GetType();

            if (HasConverter(serializer, valueType, out converter))
            {
                converter.WriteJson(writer, value, serializer);
            }
            else if (IsSimpleType(valueType))
            {
                // Only re-write values if the flag is switched, and they have an obvious string representation
                if (!_client.Configuration.LogPersonalInformation &&
                    (value is string || value is Uri))
                {
                    if (_piiBlacklist.Contains(name))
                    {
                        writer.WriteValue(GetHash(value.ToString()));
                    }
                    else
                    {
                        writer.WriteValue(GuidRegex.Replace(value.ToString(), GetHash));
                    }
                }
                else
                {
                    writer.WriteValue(value);
                }
            }
            else if (value is IEnumerable)
            {
                if (_client.Configuration.LogFullResponse)
                {
                    writer.WriteStartArray();
                    foreach (var o in (IEnumerable)value)
                    {
                        InternalWrite(writer, null, o, serializer);
                    }
                    writer.WriteEndArray();
                }
                else
                {
                    writer.WriteStartObject();
                    writer.WritePropertyName("Type");
                    writer.WriteValue(valueType.ToString());
                    writer.WritePropertyName("Count");
                    writer.WriteValue(((IEnumerable)value).Cast <object>().Count());
                    writer.WriteEndObject();
                }
            }
            else
            {
                var properties = valueType.GetPublicProperties();

                writer.WriteStartObject();
                foreach (var prop in properties)
                {
                    var propValue = prop.GetValue(value, null);
                    if (propValue != null || serializer.NullValueHandling == NullValueHandling.Include)
                    {
                        writer.WritePropertyName(prop.Name);
                        InternalWrite(writer, prop.Name, propValue, serializer);
                    }
                }
                writer.WriteEndObject();
            }
        }
Example #51
0
        /// <summary>
        /// WriteJson
        /// </summary>
        /// <param name="writer">json writer</param>
        /// <param name="value">object value</param>
        /// <param name="serializer">json serilaizer value</param>
        /// <returns>void</returns>
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            if (value.GetType().BaseType == Type.GetType("System.Array"))
            {
                writer.WriteStartArray();
                foreach (var arr in value as Array)
                {
                    serializer.Serialize(writer, arr);
                }
                writer.WriteEndArray();
                return;
            }

            if (value.GetType().GetProperties().Count() > 0)
            {
                writer.WriteStartObject();
                foreach (PropertyInfo propertyInfo in value.GetType().GetProperties())
                {
                    if (propertyInfo.CanRead && ((propertyInfo.PropertyType.IsArray && propertyInfo.PropertyType.GetElementType() == Type.GetType("System.Object")) || (propertyInfo.PropertyType == Type.GetType("System.Object"))))
                    {
                        object val = propertyInfo.GetValue(value, null);
                        if (!(val == null && (serializer.NullValueHandling == NullValueHandling.Ignore)))
                        {
                            string       propName      = propertyInfo.Name + "Specified";
                            PropertyInfo specifiedProp = value.GetType().GetProperty(propName);
                            if (specifiedProp != null && ((bool)specifiedProp.GetValue(value, null) == true))
                            {
                                writer.WritePropertyName(val.GetType().Name);
                                serializer.Serialize(writer, propertyInfo.GetValue(value, null));
                            }
                            else if (specifiedProp == null)
                            {
                                System.Xml.Serialization.XmlChoiceIdentifierAttribute[] attrs = (System.Xml.Serialization.XmlChoiceIdentifierAttribute[])propertyInfo.GetCustomAttributes((new System.Xml.Serialization.XmlChoiceIdentifierAttribute()).GetType(), false);
                                if (attrs.Count() > 0)
                                {
                                    System.Xml.Serialization.XmlChoiceIdentifierAttribute attr = attrs[0];

                                    PropertyInfo choiceNameProp = value.GetType().GetProperty(attr.MemberName);
                                    if (choiceNameProp.PropertyType.IsArray)
                                    {   //AnyIntuitObjects
                                        var   TypeofValue   = choiceNameProp.GetValue(value, null);
                                        Array choiceNameArr = (TypeofValue as Array);
                                        Array valueArr      = (propertyInfo.GetValue(value, null) as Array);
                                        for (int i = 0; i < choiceNameArr.Length; i++)
                                        {
                                            writer.WritePropertyName(choiceNameArr.GetValue(i).ToString());
                                            serializer.Serialize(writer, valueArr.GetValue(i));
                                        }
                                    }
                                    else
                                    {   //AnyIntuitObject
                                        var TypeofValue = choiceNameProp.GetValue(value, null);
                                        writer.WritePropertyName(TypeofValue.ToString());
                                        serializer.Serialize(writer, propertyInfo.GetValue(value, null));
                                    }
                                }
                                else
                                {
                                    Type valueType = null;

                                    if (val.GetType().IsArray)
                                    {
                                        if ((val as Array).Length > 0)
                                        {
                                            valueType = (val as Array).GetValue(0).GetType();
                                        }
                                    }
                                    else
                                    {
                                        valueType = val.GetType();
                                    }

                                    System.Xml.Serialization.XmlElementAttribute[] elementAttrs = (System.Xml.Serialization.XmlElementAttribute[])propertyInfo.GetCustomAttributes((new System.Xml.Serialization.XmlElementAttribute()).GetType(), false);
                                    foreach (System.Xml.Serialization.XmlElementAttribute attr in elementAttrs)
                                    {
                                        if (valueType.Name == attr.Type.Name)
                                        {
                                            writer.WritePropertyName(attr.ElementName);
                                            serializer.Serialize(writer, propertyInfo.GetValue(value, null));
                                        }
                                    }
                                }
                            }
                        }
                    }
                    else
                    {
                        if ((propertyInfo.GetValue(value, null) != null) && (serializer.NullValueHandling == NullValueHandling.Ignore))
                        {
                            if (propertyInfo.GetCustomAttributes(false).Contains(new Newtonsoft.Json.JsonIgnoreAttribute()) != true)
                            {
                                if (propertyInfo.GetCustomAttributes(false).Contains(new System.Xml.Serialization.XmlTextAttribute()) && propertyInfo.Name == "Value")
                                {
                                    writer.WritePropertyName("value");
                                    writer.WriteValue(propertyInfo.GetValue(value, null).ToString());
                                }
                                else
                                {
                                    string       propName      = propertyInfo.Name + "Specified";
                                    PropertyInfo specifiedProp = value.GetType().GetProperty(propName);
                                    if (specifiedProp != null && (bool)specifiedProp.GetValue(value, null) == true)
                                    {
                                        writer.WritePropertyName(propertyInfo.Name);
                                        serializer.Serialize(writer, propertyInfo.GetValue(value, null));
                                    }
                                    else if (specifiedProp == null)
                                    {
                                        //check if this has choiceIdentifier put key name as its value else put name of property
                                        System.Xml.Serialization.XmlChoiceIdentifierAttribute[] choiceattrs = (System.Xml.Serialization.XmlChoiceIdentifierAttribute[])propertyInfo.GetCustomAttributes((new System.Xml.Serialization.XmlChoiceIdentifierAttribute()).GetType(), false);
                                        if (choiceattrs.Count() > 0)
                                        {
                                            foreach (
                                                System.Xml.Serialization.XmlChoiceIdentifierAttribute choiceAttr in
                                                choiceattrs)
                                            {
                                                PropertyInfo choiceProp =
                                                    value.GetType().GetProperty(choiceAttr.MemberName);
                                                writer.WritePropertyName(choiceProp.GetValue(value, null).ToString());
                                            }
                                        }
                                        else
                                        {
                                            writer.WritePropertyName(propertyInfo.Name);
                                        }

                                        //check if its XmlArrayItem (NameValue)
                                        System.Xml.Serialization.XmlArrayItemAttribute[] arrayItemAttrs = (System.Xml.Serialization.XmlArrayItemAttribute[])propertyInfo.GetCustomAttributes((new System.Xml.Serialization.XmlArrayItemAttribute()).GetType(), false);
                                        if (arrayItemAttrs.Count() > 0)
                                        {
                                            writer.WriteStartObject();
                                            //if XmlArrayitem has name else data type will be the name
                                            if (!string.IsNullOrEmpty(arrayItemAttrs[0].ElementName))
                                            {
                                                writer.WritePropertyName(arrayItemAttrs[0].ElementName);
                                            }
                                            else
                                            {
                                                writer.WritePropertyName(propertyInfo.GetValue(value, null).GetType().GetElementType().Name);
                                            }

                                            serializer.Serialize(writer, propertyInfo.GetValue(value, null));
                                            writer.WriteEndObject();
                                        }
                                        else
                                        {
                                            serializer.Serialize(writer, propertyInfo.GetValue(value, null));
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                writer.WriteEndObject();
            }
            else
            {
                writer.WriteValue(value);
            }
        }
    /// <summary>
    /// Write a well-known binary object to JSON.
    /// </summary>
    /// <param name="lebr">
    /// The little-endian binary reader.
    /// </param>
    /// <param name="bebr">
    /// The big-endian binary reader.
    /// </param>
    /// <param name="writer">
    /// The writer.
    /// </param>
    /// <exception cref="ArgumentException">
    /// Unexpected well-known binary.
    /// </exception>
    private static void WriteObject(BinaryReader lebr, BinaryReader bebr, JsonWriter writer)
    {
        writer.WriteStartObject();
        writer.WritePropertyName("type");
        var    br    = lebr.ReadByte() == 0 ? bebr : lebr;
        int    gtype = br.ReadInt32();
        string objTypeName;

        if (!WkbTypes.TryGetValue(gtype, out objTypeName))
        {
            throw new ArgumentException(
                      string.Format(
                          "Unsupported type {0}. Supported types: {1}",
                          gtype,
                          string.Join(", ", WkbTypes.Select(kv => string.Format("({0}, {1}", kv.Key, kv.Value)))));
        }
        writer.WriteValue(objTypeName);
        if (gtype == GeometryCollectionWkb)
        {
            writer.WritePropertyName("geometries");
            writer.WriteStartArray();
            int count = br.ReadInt32();
            for (int i = 0; i < count; ++i)
            {
                WriteObject(lebr, bebr, writer);
            }
            writer.WriteEndArray();
        }
        else
        {
            writer.WritePropertyName("coordinates");
            writer.WriteStartArray();
            switch (gtype)
            {
            case PointWkb:
                writer.WriteValue(br.ReadDouble());
                writer.WriteValue(br.ReadDouble());
                break;

            case LineStringWkb:
                WriteLine(br, writer);
                break;

            case PolygonWkb:
                WritePolygon(br, writer);
                break;

            case MultiPointWkb:
                int pointCount = br.ReadInt32();
                for (int i = 0; i < pointCount; ++i)
                {
                    br    = lebr.ReadByte() == 0 ? bebr : lebr;
                    gtype = br.ReadInt32();
                    if (gtype != PointWkb)
                    {
                        throw new ArgumentException(
                                  string.Format("Expected a type of 1, got {0}", gtype),
                                  "lebr");
                    }
                    writer.WriteStartArray();
                    writer.WriteValue(br.ReadDouble());
                    writer.WriteValue(br.ReadDouble());
                    writer.WriteEndArray();
                }
                break;

            case MultiLineStringWkb:
                int lineCount = br.ReadInt32();
                for (int i = 0; i < lineCount; ++i)
                {
                    br    = lebr.ReadByte() == 0 ? bebr : lebr;
                    gtype = br.ReadInt32();
                    if (gtype != LineStringWkb)
                    {
                        throw new ArgumentException(
                                  string.Format("Expected a type of 2, got {0}", gtype),
                                  "lebr");
                    }
                    writer.WriteStartArray();
                    WriteLine(br, writer);
                    writer.WriteEndArray();
                }
                break;

            case MultiPolygonWkb:
                int polygonCount = br.ReadInt32();
                for (int i = 0; i < polygonCount; ++i)
                {
                    br    = lebr.ReadByte() == 0 ? bebr : lebr;
                    gtype = br.ReadInt32();
                    if (gtype != PolygonWkb)
                    {
                        throw new ArgumentException(
                                  string.Format("Expected a type of 3, got {0}", gtype),
                                  "lebr");
                    }
                    writer.WriteStartArray();
                    WritePolygon(br, writer);
                    writer.WriteEndArray();
                }
                break;

            default:
                throw new ArgumentException(string.Format("Unsupported geo-type {0}", gtype), "lebr");
            }
            writer.WriteEndArray();
        }
        writer.WriteEndObject();
    }
Example #53
0
    private void SerializeGroupedNodes(JsonWriter writer, IXmlNode node, XmlNamespaceManager manager, bool writePropertyName)
    {
      // group nodes together by name
      Dictionary<string, List<IXmlNode>> nodesGroupedByName = new Dictionary<string, List<IXmlNode>>();

      for (int i = 0; i < node.ChildNodes.Count; i++)
      {
        IXmlNode childNode = node.ChildNodes[i];
        string nodeName = GetPropertyName(childNode, manager);

        List<IXmlNode> nodes;
        if (!nodesGroupedByName.TryGetValue(nodeName, out nodes))
        {
          nodes = new List<IXmlNode>();
          nodesGroupedByName.Add(nodeName, nodes);
        }

        nodes.Add(childNode);
      }

      // loop through grouped nodes. write single name instances as normal,
      // write multiple names together in an array
      foreach (KeyValuePair<string, List<IXmlNode>> nodeNameGroup in nodesGroupedByName)
      {
        List<IXmlNode> groupedNodes = nodeNameGroup.Value;
        bool writeArray;

        if (groupedNodes.Count == 1)
        {
          writeArray = IsArray(groupedNodes[0]);
        }
        else
        {
          writeArray = true;
        }

        if (!writeArray)
        {
          SerializeNode(writer, groupedNodes[0], manager, writePropertyName);
        }
        else
        {
          string elementNames = nodeNameGroup.Key;

          if (writePropertyName)
            writer.WritePropertyName(elementNames);

          writer.WriteStartArray();

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

          writer.WriteEndArray();
        }
      }
    }
Example #54
0
 private void WriteStartArray()
 {
     _writer.WriteStartArray();
     IncreaseDepth();
 }
    private void SerializeMultidimensionalArray(JsonWriter writer, Array values, JsonArrayContract contract, JsonProperty member, int initialDepth, int[] indices)
    {
      int dimension = indices.Length;
      int[] newIndices = new int[dimension + 1];
      for (int i = 0; i < dimension; i++)
      {
        newIndices[i] = indices[i];
      }

      writer.WriteStartArray();

      for (int i = 0; i < values.GetLength(dimension); i++)
      {
        newIndices[dimension] = i;
        bool isTopLevel = (newIndices.Length == values.Rank);

        if (isTopLevel)
        {
          object value = values.GetValue(newIndices);

          try
          {
            JsonContract valueContract = contract.FinalItemContract ?? GetContractSafe(value);

            if (ShouldWriteReference(value, null, valueContract, contract, member))
            {
              WriteReference(writer, value);
            }
            else
            {
              if (CheckForCircularReference(writer, value, null, valueContract, contract, member))
              {
                SerializeValue(writer, value, valueContract, null, contract, member);
              }
            }
          }
          catch (Exception ex)
          {
            if (IsErrorHandled(values, contract, i, writer.ContainerPath, ex))
              HandleError(writer, initialDepth + 1);
            else
              throw;
          }
        }
        else
        {
          SerializeMultidimensionalArray(writer, values, contract, member, initialDepth + 1, newIndices);
        }
      }

      writer.WriteEndArray();
    }
Example #56
0
        public void WriteSchema(JsonSchema schema)
        {
            ValidationUtils.ArgumentNotNull(schema, "schema");

            if (!_resolver.LoadedSchemas.Contains(schema))
            {
                _resolver.LoadedSchemas.Add(schema);
            }

            _writer.WriteStartObject();
            WritePropertyIfNotNull(_writer, JsonSchemaConstants.IdPropertyName, schema.Id);
            WritePropertyIfNotNull(_writer, JsonSchemaConstants.TitlePropertyName, schema.Title);
            WritePropertyIfNotNull(_writer, JsonSchemaConstants.DescriptionPropertyName, schema.Description);
            WritePropertyIfNotNull(_writer, JsonSchemaConstants.RequiredPropertyName, schema.Required);
            WritePropertyIfNotNull(_writer, JsonSchemaConstants.ReadOnlyPropertyName, schema.ReadOnly);
            WritePropertyIfNotNull(_writer, JsonSchemaConstants.HiddenPropertyName, schema.Hidden);
            WritePropertyIfNotNull(_writer, JsonSchemaConstants.TransientPropertyName, schema.Transient);
            if (schema.Type != null)
            {
                WriteType(JsonSchemaConstants.TypePropertyName, _writer, schema.Type.Value);
            }
            if (!schema.AllowAdditionalProperties)
            {
                _writer.WritePropertyName(JsonSchemaConstants.AdditionalPropertiesPropertyName);
                _writer.WriteValue(schema.AllowAdditionalProperties);
            }
            else
            {
                if (schema.AdditionalProperties != null)
                {
                    _writer.WritePropertyName(JsonSchemaConstants.AdditionalPropertiesPropertyName);
                    ReferenceOrWriteSchema(schema.AdditionalProperties);
                }
            }
            if (!schema.AllowAdditionalItems)
            {
                _writer.WritePropertyName(JsonSchemaConstants.AdditionalItemsPropertyName);
                _writer.WriteValue(schema.AllowAdditionalItems);
            }
            else
            {
                if (schema.AdditionalItems != null)
                {
                    _writer.WritePropertyName(JsonSchemaConstants.AdditionalItemsPropertyName);
                    ReferenceOrWriteSchema(schema.AdditionalItems);
                }
            }
            WriteSchemaDictionaryIfNotNull(_writer, JsonSchemaConstants.PropertiesPropertyName, schema.Properties);
            WriteSchemaDictionaryIfNotNull(_writer, JsonSchemaConstants.PatternPropertiesPropertyName, schema.PatternProperties);
            WriteItems(schema);
            WritePropertyIfNotNull(_writer, JsonSchemaConstants.MinimumPropertyName, schema.Minimum);
            WritePropertyIfNotNull(_writer, JsonSchemaConstants.MaximumPropertyName, schema.Maximum);
            WritePropertyIfNotNull(_writer, JsonSchemaConstants.ExclusiveMinimumPropertyName, schema.ExclusiveMinimum);
            WritePropertyIfNotNull(_writer, JsonSchemaConstants.ExclusiveMaximumPropertyName, schema.ExclusiveMaximum);
            WritePropertyIfNotNull(_writer, JsonSchemaConstants.MinimumLengthPropertyName, schema.MinimumLength);
            WritePropertyIfNotNull(_writer, JsonSchemaConstants.MaximumLengthPropertyName, schema.MaximumLength);
            WritePropertyIfNotNull(_writer, JsonSchemaConstants.MinimumItemsPropertyName, schema.MinimumItems);
            WritePropertyIfNotNull(_writer, JsonSchemaConstants.MaximumItemsPropertyName, schema.MaximumItems);
            WritePropertyIfNotNull(_writer, JsonSchemaConstants.DivisibleByPropertyName, schema.DivisibleBy);
            WritePropertyIfNotNull(_writer, JsonSchemaConstants.FormatPropertyName, schema.Format);
            WritePropertyIfNotNull(_writer, JsonSchemaConstants.PatternPropertyName, schema.Pattern);
            if (schema.Enum != null)
            {
                _writer.WritePropertyName(JsonSchemaConstants.EnumPropertyName);
                _writer.WriteStartArray();
                foreach (JToken token in schema.Enum)
                {
                    token.WriteTo(_writer);
                }
                _writer.WriteEndArray();
            }
            if (schema.Default != null)
            {
                _writer.WritePropertyName(JsonSchemaConstants.DefaultPropertyName);
                schema.Default.WriteTo(_writer);
            }
            if (schema.Disallow != null)
            {
                WriteType(JsonSchemaConstants.DisallowPropertyName, _writer, schema.Disallow.Value);
            }
            if (schema.Extends != null && schema.Extends.Count > 0)
            {
                _writer.WritePropertyName(JsonSchemaConstants.ExtendsPropertyName);
                if (schema.Extends.Count == 1)
                {
                    ReferenceOrWriteSchema(schema.Extends[0]);
                }
                else
                {
                    _writer.WriteStartArray();
                    foreach (JsonSchema jsonSchema in schema.Extends)
                    {
                        ReferenceOrWriteSchema(jsonSchema);
                    }
                    _writer.WriteEndArray();
                }
            }
            _writer.WriteEndObject();
        }
Example #57
0
            /// <summary>
            /// Write the JSON string.  This will convert all the properties to a JSON string.
            /// This is done manaully to improve conversion time.  The default serializer will check
            /// each property if it can convert.  This will convert the properties automatically.  This
            /// will double the speed.
            /// 
            /// Newtonsoft.Json.JsonConvert.SerializeObject(ensemble.BottomTrackData).
            /// 
            /// </summary>
            /// <param name="writer">JSON Writer.</param>
            /// <param name="value">Object to write to JSON.</param>
            /// <param name="serializer">Serializer to convert the object.</param>
            public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
            {
                // Cast the object
                var data = value as BottomTrackDataSet;

                // Start the object
                writer.Formatting = Formatting.None;            // Make the text not indented, so not as human readable.  This will save disk space
                writer.WriteStartObject();                      // Start the JSON object

                // Write the base values
                writer.WriteRaw(data.ToJsonBaseStub());
                writer.WriteRaw(",");

                // FirstPingTime
                writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_FIRSTPINGTIME);
                writer.WriteValue(data.FirstPingTime);

                // LastPingTime
                writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_LASTPINGTIME);
                writer.WriteValue(data.LastPingTime);

                // Heading
                writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_HEADING);
                writer.WriteValue(data.Heading);

                // Pitch
                writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_PITCH);
                writer.WriteValue(data.Pitch);

                // Roll
                writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_ROLL);
                writer.WriteValue(data.Roll);

                // WaterTemp
                writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_WATERTEMP);
                writer.WriteValue(data.WaterTemp);

                // SystemTemp
                writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_SYSTEMP);
                writer.WriteValue(data.SystemTemp);

                // Salinity
                writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_SALINITY);
                writer.WriteValue(data.Salinity);

                // Pressure
                writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_PRESSURE);
                writer.WriteValue(data.Pressure);

                // TransducerDepth
                writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_TRANSDUCERDEPTH);
                writer.WriteValue(data.TransducerDepth);

                // SpeedOfSound
                writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_SPEEDOFSOUND);
                writer.WriteValue(data.SpeedOfSound);

                // Status Value
                writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_STATUS);
                writer.WriteValue(data.Status.Value);

                // NumBeams
                writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_NUMBEAMS);
                writer.WriteValue(data.NumBeams);

                // ActualPingCount
                writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_ACTUALPINGCOUNT);
                writer.WriteValue(data.ActualPingCount);

                // Range
                writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_RANGE);
                writer.WriteStartArray();
                for (int beam = 0; beam < data.NumBeams; beam++)
                {
                    writer.WriteValue(data.Range[beam]);
                }
                writer.WriteEndArray();

                // SNR
                writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_SNR);
                writer.WriteStartArray();
                for (int beam = 0; beam < data.NumBeams; beam++)
                {
                    writer.WriteValue(data.SNR[beam]);
                }
                writer.WriteEndArray();

                // Amplitude
                writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_AMPLITUDE);
                writer.WriteStartArray();
                for (int beam = 0; beam < data.NumBeams; beam++)
                {
                    writer.WriteValue(data.Amplitude[beam]);
                }
                writer.WriteEndArray();

                // Correlation
                writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_CORRELATION);
                writer.WriteStartArray();
                for (int beam = 0; beam < data.NumBeams; beam++)
                {
                    writer.WriteValue(data.Correlation[beam]);
                }
                writer.WriteEndArray();

                // Beam Velocity
                writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_BEAMVELOCITY);
                writer.WriteStartArray();
                for (int beam = 0; beam < data.NumBeams; beam++)
                {
                    writer.WriteValue(data.BeamVelocity[beam]);
                }
                writer.WriteEndArray();

                // Good Beam Velocity
                writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_BEAMGOOD);
                writer.WriteStartArray();
                for (int beam = 0; beam < data.NumBeams; beam++)
                {
                    writer.WriteValue(data.BeamGood[beam]);
                }
                writer.WriteEndArray();

                // Instrument Velocity
                writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_INSTRUMENTVELOCITY);
                writer.WriteStartArray();
                for (int beam = 0; beam < data.NumBeams; beam++)
                {
                    writer.WriteValue(data.InstrumentVelocity[beam]);
                }
                writer.WriteEndArray();

                // Good Instrument Velocity
                writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_INSTRUMENTGOOD);
                writer.WriteStartArray();
                for (int beam = 0; beam < data.NumBeams; beam++)
                {
                    writer.WriteValue(data.InstrumentGood[beam]);
                }
                writer.WriteEndArray();

                // Earth Velocity
                writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_EARTHVELOCITY);
                writer.WriteStartArray();
                for (int beam = 0; beam < data.NumBeams; beam++)
                {
                    writer.WriteValue(data.EarthVelocity[beam]);
                }
                writer.WriteEndArray();

                // Good Earth Velocity
                writer.WritePropertyName(DataSet.BaseDataSet.JSON_STR_BT_EARTHGOOD);
                writer.WriteStartArray();
                for (int beam = 0; beam < data.NumBeams; beam++)
                {
                    writer.WriteValue(data.EarthGood[beam]);
                }
                writer.WriteEndArray();

                // End the object
                writer.WriteEndObject();
            }
    private static void WriteBoundAttribute(JsonWriter writer, BoundAttributeDescriptor boundAttribute, JsonSerializer serializer)
    {
        writer.WriteStartObject();

        writer.WritePropertyName(nameof(BoundAttributeDescriptor.Kind));
        writer.WriteValue(boundAttribute.Kind);

        writer.WritePropertyName(nameof(BoundAttributeDescriptor.Name));
        writer.WriteValue(boundAttribute.Name);

        writer.WritePropertyName(nameof(BoundAttributeDescriptor.TypeName));
        writer.WriteValue(boundAttribute.TypeName);

        if (boundAttribute.IsEnum)
        {
            writer.WritePropertyName(nameof(BoundAttributeDescriptor.IsEnum));
            writer.WriteValue(boundAttribute.IsEnum);
        }

        if (boundAttribute.IndexerNamePrefix != null)
        {
            writer.WritePropertyName(nameof(BoundAttributeDescriptor.IndexerNamePrefix));
            writer.WriteValue(boundAttribute.IndexerNamePrefix);
        }

        if (boundAttribute.IsEditorRequired)
        {
            writer.WritePropertyName(nameof(BoundAttributeDescriptor.IsEditorRequired));
            writer.WriteValue(boundAttribute.IsEditorRequired);
        }

        if (boundAttribute.IndexerTypeName != null)
        {
            writer.WritePropertyName(nameof(BoundAttributeDescriptor.IndexerTypeName));
            writer.WriteValue(boundAttribute.IndexerTypeName);
        }

        if (boundAttribute.Documentation != null)
        {
            writer.WritePropertyName(nameof(BoundAttributeDescriptor.Documentation));
            writer.WriteValue(boundAttribute.Documentation);
        }

        if (boundAttribute.Diagnostics != null && boundAttribute.Diagnostics.Count > 0)
        {
            writer.WritePropertyName(nameof(BoundAttributeDescriptor.Diagnostics));
            serializer.Serialize(writer, boundAttribute.Diagnostics);
        }

        writer.WritePropertyName(nameof(BoundAttributeDescriptor.Metadata));
        WriteMetadata(writer, boundAttribute.Metadata);

        if (boundAttribute.BoundAttributeParameters != null && boundAttribute.BoundAttributeParameters.Count > 0)
        {
            writer.WritePropertyName(nameof(BoundAttributeDescriptor.BoundAttributeParameters));
            writer.WriteStartArray();
            foreach (var boundAttributeParameter in boundAttribute.BoundAttributeParameters)
            {
                WriteBoundAttributeParameter(writer, boundAttributeParameter, serializer);
            }
            writer.WriteEndArray();
        }

        writer.WriteEndObject();
    }
Example #59
0
        /// <summary>
        /// Converts XML to JsonML object form.
        /// </summary>

        public static void EncodeObjectForm(XmlReader reader, JsonWriter writer)
        {
            if (reader == null) throw new ArgumentNullException("reader");
            if (writer == null) throw new ArgumentNullException("writer");

            if (reader.MoveToContent() != XmlNodeType.Element)
                throw new ArgumentException(null, "reader");

            writer.WriteStartObject();
            writer.WriteMember("tagName");
            writer.WriteString(reader.Name);

            //
            // Write attributes
            //

            if (reader.MoveToFirstAttribute())
            {
                do
                {
                    writer.WriteMember(reader.Name);
                    writer.WriteString(reader.Value);
                }
                while (reader.MoveToNextAttribute());

                reader.MoveToElement();
            }

            bool isEmpty = reader.IsEmptyElement;

            if (!isEmpty)
            {
                reader.Read();

                int childCount = 0;

                //
                // Write child nodes (text, CDATA and element)
                //

                XmlNodeType nodeType;
                while ((nodeType = reader.NodeType) != XmlNodeType.EndElement)
                {
                    if (nodeType == XmlNodeType.Text 
                        || nodeType == XmlNodeType.CDATA 
                        || nodeType == XmlNodeType.Element)
                    {
                        if (childCount == 0)
                        {
                            writer.WriteMember("childNodes");
                            writer.WriteStartArray();
                        }

                        if (nodeType == XmlNodeType.Text || nodeType == XmlNodeType.CDATA)
                        {
                            writer.WriteString(reader.Value);
                            reader.Read();
                        }
                        else if (nodeType == XmlNodeType.Element)
                        {
                            EncodeObjectForm(reader, writer);
                        }

                        childCount++;
                    }
                    else
                    {
                        reader.Read();
                    }
                }

                if (childCount > 0)
                    writer.WriteEndArray();
            }

            writer.WriteEndObject();
            reader.Read();
        }
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        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();
    }