Exemplo n.º 1
0
        /// <summary>
        /// Deserialize the json datatable token to the desired object
        /// </summary>
        /// <param name="jsonToken">The json datatable token to be deserialized</param>
        /// <param name="dataType">The type of the desired object</param>
        /// <returns>The desired object instance</returns>
        public override Object Deserialize(LazyJsonToken jsonToken, Type dataType)
        {
            if (jsonToken == null || jsonToken.Type != LazyJsonType.Object || dataType == null || dataType != typeof(DataTable))
            {
                return(null);
            }

            LazyJsonObject jsonObjectDataTable = (LazyJsonObject)jsonToken;
            DataTable      dataTable           = new DataTable();

            // Rows
            if (jsonObjectDataTable["Rows"] != null && jsonObjectDataTable["Rows"].Token.Type == LazyJsonType.Array)
            {
                LazyJsonArray jsonArrayDataTableRows = (LazyJsonArray)jsonObjectDataTable["Rows"].Token;
                LazyJsonDeserializerDataRow jsonDeserializerDataRow = new LazyJsonDeserializerDataRow();

                foreach (LazyJsonToken jsonTokenDataTableRow in jsonArrayDataTableRows.TokenList)
                {
                    if (jsonTokenDataTableRow.Type == LazyJsonType.Object)
                    {
                        jsonDeserializerDataRow.Deserialize(jsonTokenDataTableRow, dataTable);
                    }
                }
            }

            return(dataTable);
        }
        /// <summary>
        /// Serialize an object to a json datatable object token
        /// </summary>
        /// <param name="data">The object to be serialized</param>
        /// <returns>The json datatable object token</returns>
        public override LazyJsonToken Serialize(Object data)
        {
            if (data == null || data is not DataTable)
            {
                return(new LazyJsonNull());
            }

            DataTable      dataTable           = (DataTable)data;
            LazyJsonObject jsonObjectDataTable = new LazyJsonObject();

            // Rows
            LazyJsonArray jsonArrayDataTableRows = new LazyJsonArray();

            jsonObjectDataTable.Add(new LazyJsonProperty("Rows", jsonArrayDataTableRows));

            LazyJsonSerializerDataRow jsonSerializerDataRow = new LazyJsonSerializerDataRow();

            foreach (DataRow dataRow in dataTable.Rows)
            {
                LazyJsonToken jsonTokenDataTableRow = jsonSerializerDataRow.Serialize(dataRow);

                if (jsonTokenDataTableRow != null && jsonTokenDataTableRow.Type != LazyJsonType.Null)
                {
                    jsonArrayDataTableRows.Add(jsonTokenDataTableRow);
                }
            }

            return(jsonObjectDataTable);
        }
        /// <summary>
        /// Serialize an object to a json array token
        /// </summary>
        /// <param name="data">The object to be serialized</param>
        /// <returns>The json array token</returns>
        public override LazyJsonToken Serialize(Object data)
        {
            if (data == null)
            {
                return(new LazyJsonNull());
            }

            Type dataType = data.GetType();

            if (dataType.IsArray == false)
            {
                return(new LazyJsonNull());
            }

            Array         dataArray = (data as Array);
            LazyJsonArray jsonArray = new LazyJsonArray();

            Type arrayElementType = dataType.GetElementType();

            Type jsonSerializerType = LazyJsonSerializer.FindTypeSerializer(arrayElementType);

            if (jsonSerializerType == null)
            {
                jsonSerializerType = LazyJsonSerializer.FindBuiltInSerializer(arrayElementType);
            }

            if (jsonSerializerType != null)
            {
                LazyJsonSerializerBase jsonSerializer = (LazyJsonSerializerBase)Activator.CreateInstance(jsonSerializerType);

                foreach (Object item in dataArray)
                {
                    jsonArray.TokenList.Add(jsonSerializer.Serialize(item));
                }
            }
            else
            {
                foreach (Object item in dataArray)
                {
                    jsonArray.TokenList.Add(LazyJsonSerializer.SerializeToken(item));
                }
            }

            return(jsonArray);
        }
Exemplo n.º 4
0
        /// <summary>
        /// Serialize an object to a json list array token
        /// </summary>
        /// <param name="data">The object to be serialized</param>
        /// <returns>The json list array token</returns>
        public override LazyJsonToken Serialize(Object data)
        {
            if (data == null)
            {
                return(new LazyJsonNull());
            }

            Type dataType = data.GetType();

            if (dataType.IsGenericType == false || dataType.GetGenericTypeDefinition() != typeof(List <>))
            {
                return(new LazyJsonNull());
            }

            Int32         itemsCount      = (Int32)dataType.GetProperties().First(x => x.Name == "Count").GetValue(data);
            PropertyInfo  propertyIndexer = dataType.GetProperties().First(x => x.GetIndexParameters().Length == 1 && x.GetIndexParameters()[0].ParameterType == typeof(Int32));
            LazyJsonArray jsonArray       = new LazyJsonArray();

            Type jsonSerializerType = LazyJsonSerializer.FindTypeSerializer(dataType.GenericTypeArguments[0]);

            if (jsonSerializerType == null)
            {
                jsonSerializerType = LazyJsonSerializer.FindBuiltInSerializer(dataType.GenericTypeArguments[0]);
            }

            if (jsonSerializerType != null)
            {
                LazyJsonSerializerBase jsonSerializer = (LazyJsonSerializerBase)Activator.CreateInstance(jsonSerializerType);

                for (int i = 0; i < itemsCount; i++)
                {
                    jsonArray.TokenList.Add(jsonSerializer.Serialize(propertyIndexer.GetValue(data, new Object[] { i })));
                }
            }
            else
            {
                for (int i = 0; i < itemsCount; i++)
                {
                    jsonArray.TokenList.Add(LazyJsonSerializer.SerializeToken(propertyIndexer.GetValue(data, new Object[] { i })));
                }
            }

            return(jsonArray);
        }
Exemplo n.º 5
0
        /// <summary>
        /// Deserialize the json array token to the desired object
        /// </summary>
        /// <param name="jsonToken">The json array token to be deserialized</param>
        /// <param name="dataType">The type of the desired object</param>
        /// <returns>The desired object instance</returns>
        public override Object Deserialize(LazyJsonToken jsonToken, Type dataType)
        {
            if (jsonToken == null || jsonToken.Type != LazyJsonType.Array || dataType == null || dataType.IsArray == false)
            {
                return(null);
            }

            LazyJsonArray jsonArray        = (LazyJsonArray)jsonToken;
            Array         array            = Array.CreateInstance(dataType.GetElementType(), jsonArray.Count);
            Type          arrayElementType = dataType.GetElementType();

            Type jsonDeserializerType = LazyJsonDeserializer.FindTypeDeserializer(arrayElementType);

            if (jsonDeserializerType == null)
            {
                jsonDeserializerType = LazyJsonDeserializer.FindBuiltInDeserializer(jsonToken, arrayElementType);
            }

            if (jsonDeserializerType != null)
            {
                LazyJsonDeserializerBase jsonDeserializer = (LazyJsonDeserializerBase)Activator.CreateInstance(jsonDeserializerType);

                for (int index = 0; index < jsonArray.Count; index++)
                {
                    array.SetValue(jsonDeserializer.Deserialize(jsonArray.TokenList[index], arrayElementType), index);
                }
            }
            else
            {
                for (int index = 0; index < jsonArray.Count; index++)
                {
                    array.SetValue(LazyJsonDeserializer.DeserializeToken(jsonArray.TokenList[index], arrayElementType), index);
                }
            }

            return(array);
        }
        /// <summary>
        /// Deserialize the json list array token to the desired object
        /// </summary>
        /// <param name="jsonToken">The json list array token to be deserialized</param>
        /// <param name="dataType">The type of the desired object</param>
        /// <returns>The desired object instance</returns>
        public override Object Deserialize(LazyJsonToken jsonToken, Type dataType)
        {
            if (jsonToken == null || jsonToken.Type != LazyJsonType.Array || dataType == null || dataType.IsGenericType == false || dataType.GetGenericTypeDefinition() != typeof(List <>))
            {
                return(null);
            }

            LazyJsonArray jsonArray = (LazyJsonArray)jsonToken;
            Object        list      = Activator.CreateInstance(dataType);
            MethodInfo    methodAdd = dataType.GetMethods().First(x => x.Name == "Add");

            Type jsonDeserializerType = LazyJsonDeserializer.FindTypeDeserializer(dataType.GenericTypeArguments[0]);

            if (jsonDeserializerType == null)
            {
                jsonDeserializerType = LazyJsonDeserializer.FindBuiltInDeserializer(jsonToken, dataType.GenericTypeArguments[0]);
            }

            if (jsonDeserializerType != null)
            {
                LazyJsonDeserializerBase jsonDeserializer = (LazyJsonDeserializerBase)Activator.CreateInstance(jsonDeserializerType);

                for (int index = 0; index < jsonArray.Count; index++)
                {
                    methodAdd.Invoke(list, new Object[] { jsonDeserializer.Deserialize(jsonArray.TokenList[index], dataType.GenericTypeArguments[0]) });
                }
            }
            else
            {
                for (int index = 0; index < jsonArray.Count; index++)
                {
                    methodAdd.Invoke(list, new Object[] { LazyJsonDeserializer.DeserializeToken(jsonArray.TokenList[index], dataType.GenericTypeArguments[0]) });
                }
            }

            return(list);
        }
Exemplo n.º 7
0
        /// <summary>
        /// Write an array on the json
        /// </summary>
        /// <param name="stringBuilder">The string builder</param>
        /// <param name="jsonWriterOptions">The json writer options</param>
        /// <param name="jsonArray">The json array</param>
        /// <param name="jsonPathType">The json path type</param>
        private static void WriteArray(StringBuilder stringBuilder, LazyJsonWriterOptions jsonWriterOptions, LazyJsonArray jsonArray, LazyJsonPathType jsonPathType)
        {
            String value        = String.Empty;
            String openBracket  = "{0}{1}{2}";
            String closeBracket = "{0}{1}{2}";

            if (jsonWriterOptions.Indent == true)
            {
                jsonWriterOptions.IndentLevel++;
                value = Environment.NewLine + jsonWriterOptions.IndentValue + "{0}";
                jsonWriterOptions.IndentLevel--;

                if (jsonPathType == LazyJsonPathType.ArrayIndex)
                {
                    openBracket  = String.Format(openBracket, Environment.NewLine, jsonWriterOptions.IndentValue, "[");
                    closeBracket = String.Format(closeBracket, Environment.NewLine, jsonWriterOptions.IndentValue, "]");
                }
                else if (jsonPathType == LazyJsonPathType.Property)
                {
                    openBracket  = "[";
                    closeBracket = String.Format(closeBracket, Environment.NewLine, jsonWriterOptions.IndentValue, "]");
                }
            }
            else
            {
                value        = "{0}";
                openBracket  = "[";
                closeBracket = "]";
            }

            stringBuilder.Append(openBracket);
            for (int i = 0; i < jsonArray.TokenList.Count; i++)
            {
                switch (jsonArray.TokenList[i].Type)
                {
                case LazyJsonType.Null:
                    #region LazyJsonType.Null

                    stringBuilder.Append(String.Format(value, "null"));

                    #endregion LazyJsonType.Null
                    break;

                case LazyJsonType.Boolean:
                    #region LazyJsonType.Boolean

                    LazyJsonBoolean jsonBoolean = (LazyJsonBoolean)jsonArray.TokenList[i];
                    stringBuilder.Append(String.Format(value, jsonBoolean.Value == null ? "null" : jsonBoolean.Value.ToString().ToLower()));

                    #endregion LazyJsonType.Boolean
                    break;

                case LazyJsonType.Integer:
                    #region LazyJsonType.Integer

                    LazyJsonInteger jsonInteger = (LazyJsonInteger)jsonArray.TokenList[i];
                    stringBuilder.Append(String.Format(value, jsonInteger.Value == null ? "null" : jsonInteger.Value));

                    #endregion LazyJsonType.Integer
                    break;

                case LazyJsonType.Decimal:
                    #region LazyJsonType.Decimal

                    LazyJsonDecimal jsonDecimal = (LazyJsonDecimal)jsonArray.TokenList[i];
                    stringBuilder.Append(String.Format(value, jsonDecimal.Value == null ? "null" : jsonDecimal.Value.ToString().Replace(',', '.')));

                    #endregion LazyJsonType.Decimal
                    break;

                case LazyJsonType.String:
                    #region LazyJsonType.String

                    LazyJsonString jsonString = (LazyJsonString)jsonArray.TokenList[i];
                    stringBuilder.Append(String.Format(value, jsonString.Value == null ? "null" : "\"" + jsonString.Value + "\""));

                    #endregion LazyJsonType.String
                    break;

                case LazyJsonType.Object:
                    #region LazyJsonType.Object

                    jsonWriterOptions.IndentLevel++;
                    WriteObject(stringBuilder, jsonWriterOptions, (LazyJsonObject)jsonArray.TokenList[i], LazyJsonPathType.ArrayIndex);
                    jsonWriterOptions.IndentLevel--;

                    #endregion LazyJsonType.Object
                    break;

                case LazyJsonType.Array:
                    #region LazyJsonType.Array

                    jsonWriterOptions.IndentLevel++;
                    WriteArray(stringBuilder, jsonWriterOptions, (LazyJsonArray)jsonArray.TokenList[i], LazyJsonPathType.ArrayIndex);
                    jsonWriterOptions.IndentLevel--;

                    #endregion LazyJsonType.Array
                    break;
                }
                stringBuilder.Append(",");
            }

            if (stringBuilder[stringBuilder.Length - 1] == ',')
            {
                stringBuilder.Remove(stringBuilder.Length - 1, 1);
            }

            stringBuilder.Append(closeBracket);
        }
Exemplo n.º 8
0
        /// <summary>
        /// Find token at the specified jPath
        /// </summary>
        /// <param name="jPath">The jPath location of the token</param>
        /// <param name="renameWith">A new property name to the token at specified jPath if it's an object</param>
        /// <param name="replaceWith">A new token to override the token at specified jPath</param>
        /// <param name="remove">Indicate if the token should be removed</param>
        /// <returns>The located token</returns>
        private LazyJsonToken InternalFind(String jPath, String renameWith = null, LazyJsonToken replaceWith = null, Boolean remove = false)
        {
            List <LazyJsonPathNode> pathNodeList = LazyJsonPath.Parse(jPath);

            if (pathNodeList.Count == 0)
            {
                return(null);
            }

            LazyJsonToken jsonTokenParent = this.Root;
            LazyJsonToken jsonToken       = null;
            Int32         pathIndex       = 0;

            if (pathNodeList.Count == 1)
            {
                if (replaceWith != null)
                {
                    this.Root = replaceWith;
                }

                return(jsonTokenParent);
            }

            pathNodeList.RemoveAt(0);

            #region Find parent token

            for (pathIndex = 0; pathIndex < (pathNodeList.Count - 1); pathIndex++)
            {
                if (pathNodeList[pathIndex].Type == LazyJsonPathType.Property)
                {
                    if (jsonTokenParent.Type != LazyJsonType.Object)
                    {
                        return(null);
                    }

                    LazyJsonProperty jsonProperty = ((LazyJsonObject)jsonTokenParent)[((LazyJsonPathProperty)pathNodeList[pathIndex]).Name];

                    if (jsonProperty == null)
                    {
                        return(null);
                    }

                    jsonTokenParent = jsonProperty.Token;
                }
                else if (pathNodeList[pathIndex].Type == LazyJsonPathType.ArrayIndex)
                {
                    if (jsonTokenParent.Type != LazyJsonType.Array)
                    {
                        return(null);
                    }

                    jsonTokenParent = ((LazyJsonArray)jsonTokenParent)[Convert.ToInt32(((LazyJsonPathArrayIndex)pathNodeList[pathIndex]).Index)];
                }
            }

            #endregion Find parent token

            #region Find token

            if (pathNodeList[pathIndex].Type == LazyJsonPathType.Property)
            {
                if (jsonTokenParent.Type != LazyJsonType.Object)
                {
                    return(null);
                }

                LazyJsonObject   jsonObjectParent = (LazyJsonObject)jsonTokenParent;
                LazyJsonProperty jsonProperty     = jsonObjectParent[((LazyJsonPathProperty)pathNodeList[pathIndex]).Name];

                if (jsonProperty == null)
                {
                    return(null);
                }

                jsonToken = jsonProperty.Token;

                if (remove == true)
                {
                    jsonObjectParent.Remove(jsonProperty.Name);
                }
                else
                {
                    if (renameWith != null)
                    {
                        jsonProperty.Name = renameWith;
                    }

                    if (replaceWith != null)
                    {
                        jsonProperty.Token = replaceWith;
                    }
                }
            }
            else if (pathNodeList[pathIndex].Type == LazyJsonPathType.ArrayIndex)
            {
                if (jsonTokenParent.Type != LazyJsonType.Array)
                {
                    return(null);
                }

                LazyJsonArray jsonArrayParent = (LazyJsonArray)jsonTokenParent;
                Int32         index           = Convert.ToInt32(((LazyJsonPathArrayIndex)pathNodeList[pathIndex]).Index);

                jsonToken = jsonArrayParent[index];

                if (jsonToken != null)
                {
                    if (remove == true)
                    {
                        jsonArrayParent.TokenList.RemoveAt(index);
                    }
                    else
                    {
                        if (replaceWith != null)
                        {
                            jsonArrayParent[index] = replaceWith;
                        }
                    }
                }
            }

            #endregion Find token

            return(jsonToken);
        }
Exemplo n.º 9
0
        /// <summary>
        /// Serialize an object to a json dictionary array token
        /// </summary>
        /// <param name="data">The object to be serialized</param>
        /// <returns>The json dictionary array token</returns>
        public override LazyJsonToken Serialize(Object data)
        {
            if (data == null)
            {
                return(new LazyJsonNull());
            }

            Type dataType = data.GetType();

            if (dataType.IsGenericType == false || dataType.GetGenericTypeDefinition() != typeof(Dictionary <,>))
            {
                return(new LazyJsonNull());
            }

            Object        collection = null;
            Int32         itemsCount = (Int32)dataType.GetProperties().First(x => x.Name == "Count").GetValue(data);
            LazyJsonArray jsonArray  = new LazyJsonArray();

            Array keysArray = Array.CreateInstance(dataType.GenericTypeArguments[0], itemsCount);

            collection = dataType.GetProperties().First(x => x.Name == "Keys").GetValue(data);
            collection.GetType().GetMethods().First(x => x.Name == "CopyTo").Invoke(collection, new Object[] { keysArray, 0 });

            Array valuesArray = Array.CreateInstance(dataType.GenericTypeArguments[1], itemsCount);

            collection = dataType.GetProperties().First(x => x.Name == "Values").GetValue(data);
            collection.GetType().GetMethods().First(x => x.Name == "CopyTo").Invoke(collection, new Object[] { valuesArray, 0 });

            Type jsonSerializerType = null;
            LazyJsonSerializerBase jsonSerializerKey   = null;
            LazyJsonSerializerBase jsonSerializerValue = null;

            // Keys serializer
            jsonSerializerType = LazyJsonSerializer.FindTypeSerializer(dataType.GenericTypeArguments[0]);

            if (jsonSerializerType == null)
            {
                jsonSerializerType = LazyJsonSerializer.FindBuiltInSerializer(dataType.GenericTypeArguments[0]);
            }

            if (jsonSerializerType != null)
            {
                jsonSerializerKey = (LazyJsonSerializerBase)Activator.CreateInstance(jsonSerializerType);
            }

            // Values serializer
            jsonSerializerType = LazyJsonSerializer.FindTypeSerializer(dataType.GenericTypeArguments[1]);

            if (jsonSerializerType == null)
            {
                jsonSerializerType = LazyJsonSerializer.FindBuiltInSerializer(dataType.GenericTypeArguments[1]);
            }

            if (jsonSerializerType != null)
            {
                jsonSerializerValue = (LazyJsonSerializerBase)Activator.CreateInstance(jsonSerializerType);
            }

            for (int i = 0; i < itemsCount; i++)
            {
                LazyJsonToken jsonTokenKey   = null;
                LazyJsonToken jsonTokenValue = null;

                if (jsonSerializerKey != null)
                {
                    jsonTokenKey = jsonSerializerKey.Serialize(keysArray.GetValue(i));
                }
                else
                {
                    jsonTokenKey = LazyJsonSerializer.SerializeToken(keysArray.GetValue(i));
                }

                if (jsonSerializerValue != null)
                {
                    jsonTokenValue = jsonSerializerValue.Serialize(valuesArray.GetValue(i));
                }
                else
                {
                    jsonTokenValue = LazyJsonSerializer.SerializeToken(valuesArray.GetValue(i));
                }

                LazyJsonArray jsonArrayKeyValuePair = new LazyJsonArray();
                jsonArrayKeyValuePair.TokenList.Add(jsonTokenKey);
                jsonArrayKeyValuePair.TokenList.Add(jsonTokenValue);
                jsonArray.Add(jsonArrayKeyValuePair);
            }

            return(jsonArray);
        }
Exemplo n.º 10
0
        /// <summary>
        /// Append a json token at specified jPath
        /// </summary>
        /// <param name="jPath">The jPath location to append the token</param>
        /// <param name="jsonToken">The json token</param>
        public void AppendToken(String jPath, LazyJsonToken jsonToken)
        {
            if (jPath == "$")
            {
                this.Root = jsonToken != null ? jsonToken : new LazyJsonNull();
            }
            else
            {
                List <LazyJsonPathNode> jsonPathNodeList = LazyJsonPath.Parse(jPath);
                String jPathParent = String.Join('.', jsonPathNodeList.ToJsonPathNodeArray(), 0, jsonPathNodeList.Count - 1);

                LazyJsonToken jsonTokenParent = Find(jPathParent);

                if (jsonTokenParent != null)
                {
                    if (jsonPathNodeList[jsonPathNodeList.Count - 1].Type == LazyJsonPathType.ArrayIndex)
                    {
                        if (jsonTokenParent.Type == LazyJsonType.Array)
                        {
                            LazyJsonPathArrayIndex jsonPathArrayIndex = (LazyJsonPathArrayIndex)jsonPathNodeList[jsonPathNodeList.Count - 1];
                            ((LazyJsonArray)jsonTokenParent)[Convert.ToInt32(jsonPathArrayIndex.Index)] = jsonToken;
                        }
                        else
                        {
                            LazyJsonArray jsonArray = new LazyJsonArray();
                            jsonArray.Add(jsonToken);

                            Find(jPathParent, replaceWith: jsonArray);
                        }
                    }
                    else if (jsonPathNodeList[jsonPathNodeList.Count - 1].Type == LazyJsonPathType.Property)
                    {
                        if (jsonTokenParent.Type == LazyJsonType.Object)
                        {
                            LazyJsonPathProperty jsonPathProperty = (LazyJsonPathProperty)jsonPathNodeList[jsonPathNodeList.Count - 1];
                            ((LazyJsonObject)jsonTokenParent)[jsonPathProperty.Name] = new LazyJsonProperty(jsonPathProperty.Name, jsonToken);
                        }
                        else
                        {
                            LazyJsonObject jsonObject = new LazyJsonObject();
                            jsonObject.Add(new LazyJsonProperty(((LazyJsonPathProperty)jsonPathNodeList[jsonPathNodeList.Count - 1]).Name, jsonToken));

                            Find(jPathParent, replaceWith: jsonObject);
                        }
                    }
                }
                else
                {
                    if (jsonPathNodeList[jsonPathNodeList.Count - 1].Type == LazyJsonPathType.ArrayIndex)
                    {
                        LazyJsonArray jsonArray = new LazyJsonArray();
                        jsonArray.Add(jsonToken);

                        AppendToken(jPathParent, jsonArray);
                    }
                    else if (jsonPathNodeList[jsonPathNodeList.Count - 1].Type == LazyJsonPathType.Property)
                    {
                        LazyJsonObject jsonObject = new LazyJsonObject();
                        jsonObject.Add(new LazyJsonProperty(((LazyJsonPathProperty)jsonPathNodeList[jsonPathNodeList.Count - 1]).Name, jsonToken));

                        AppendToken(jPathParent, jsonObject);
                    }
                }
            }
        }
Exemplo n.º 11
0
 /// <summary>
 /// Append a json array token at specified jPath
 /// </summary>
 /// <param name="jPath">The jPath location to append the token</param>
 /// <param name="jsonArray">The json array token</param>
 public void AppendArray(String jPath, LazyJsonArray jsonArray)
 {
     AppendToken(jPath, jsonArray);
 }
Exemplo n.º 12
0
        /// <summary>
        /// Read a property on the json
        /// </summary>
        /// <param name="json">The json</param>
        /// <param name="jsonReaderOptions">The json reader options</param>
        /// <param name="jsonReaderResult">The json reader result</param>
        /// <param name="jsonProperty">The json property</param>
        /// <param name="line">The current line</param>
        /// <param name="index">The current index</param>
        private static void ReadProperty(String json, LazyJsonReaderOptions jsonReaderOptions, LazyJsonReaderResult jsonReaderResult, LazyJsonProperty jsonProperty, ref Int32 line, ref Int32 index)
        {
            LazyJsonString jsonStringPropertyName = new LazyJsonString();

            ReadString(json, jsonReaderOptions, jsonReaderResult, jsonStringPropertyName, ref line, ref index);
            jsonProperty.Name = jsonStringPropertyName.Value;

            if (index < json.Length)
            {
                while (index < json.Length)
                {
                    if (json[index] == ' ')
                    {
                        index++; continue;
                    }
                    if (json[index] == '\r')
                    {
                        index++; continue;
                    }
                    if (json[index] == '\n')
                    {
                        index++; line++; continue;
                    }
                    if (json[index] == '\t')
                    {
                        index++; continue;
                    }

                    if (json[index] == '/')
                    {
                        index++;
                        LazyJsonComments jsonComments = new LazyJsonComments();
                        ReadComments(json, jsonReaderOptions, jsonReaderResult, jsonComments, ref line, ref index);

                        if (index >= json.Length)
                        {
                            jsonReaderResult.Success = false;
                            jsonReaderResult.ErrorList.Add(String.Format(Properties.Resources.LazyJsonReaderUnexpectedCharacter, line, " : ", String.Empty));
                        }
                    }
                    else if (json[index] == ':')
                    {
                        index++;
                        break;
                    }
                    else
                    {
                        jsonReaderResult.Success = false;
                        jsonReaderResult.ErrorList.Add(String.Format(Properties.Resources.LazyJsonReaderInvalidObjectPropertyValue, line, json[index]));
                        index = json.Length; // Exit
                    }
                }

                if (index < json.Length)
                {
                    while (index < json.Length)
                    {
                        if (json[index] == ' ')
                        {
                            index++; continue;
                        }
                        if (json[index] == '\r')
                        {
                            index++; continue;
                        }
                        if (json[index] == '\n')
                        {
                            index++; line++; continue;
                        }
                        if (json[index] == '\t')
                        {
                            index++; continue;
                        }

                        if (json[index] == '/')
                        {
                            index++;
                            LazyJsonComments jsonComments = new LazyJsonComments();
                            ReadComments(json, jsonReaderOptions, jsonReaderResult, jsonComments, ref line, ref index);

                            if (index >= json.Length)
                            {
                                jsonReaderResult.Success = false;
                                jsonReaderResult.ErrorList.Add(String.Format(Properties.Resources.LazyJsonReaderUnexpectedCharacter, line, " : ", String.Empty));
                            }
                        }
                        else if (json[index] == '[')
                        {
                            index++;
                            LazyJsonArray jsonArray = new LazyJsonArray();
                            ReadArray(json, jsonReaderOptions, jsonReaderResult, jsonArray, ref line, ref index);
                            jsonProperty.Token = jsonArray;
                            break;
                        }
                        else if (json[index] == '{')
                        {
                            index++;
                            LazyJsonObject jsonObject = new LazyJsonObject();
                            ReadObject(json, jsonReaderOptions, jsonReaderResult, jsonObject, ref line, ref index);
                            jsonProperty.Token = jsonObject;
                            break;
                        }
                        else if (json[index] == '\"')
                        {
                            index++;
                            LazyJsonString jsonString = new LazyJsonString();
                            ReadString(json, jsonReaderOptions, jsonReaderResult, jsonString, ref line, ref index);
                            jsonProperty.Token = jsonString;
                            break;
                        }
                        else if (json[index] == '-')
                        {
                            LazyJsonToken jsonToken = null;
                            ReadIntegerOrDecimal(json, jsonReaderOptions, jsonReaderResult, out jsonToken, ref line, ref index);
                            jsonProperty.Token = jsonToken;
                            break;
                        }
                        else if (Char.IsDigit(json[index]) == true)
                        {
                            LazyJsonToken jsonToken = null;
                            ReadIntegerOrDecimal(json, jsonReaderOptions, jsonReaderResult, out jsonToken, ref line, ref index);
                            jsonProperty.Token = jsonToken;
                            break;
                        }
                        else if (Char.IsLetter(json[index]) == true)
                        {
                            LazyJsonToken jsonToken = null;
                            ReadNullOrBoolean(json, jsonReaderOptions, jsonReaderResult, out jsonToken, ref line, ref index);
                            jsonProperty.Token = jsonToken;
                            break;
                        }
                        else
                        {
                            jsonReaderResult.Success = false;
                            jsonReaderResult.ErrorList.Add(String.Format(Properties.Resources.LazyJsonReaderInvalidObjectPropertyValue, line, json[index]));
                            index = json.Length; // Exit
                        }
                    }
                }
                else
                {
                    jsonReaderResult.Success = false;
                    jsonReaderResult.ErrorList.Add(String.Format(Properties.Resources.LazyJsonReaderInvalidObjectPropertyValue, line, String.Empty));
                }
            }
            else
            {
                jsonReaderResult.Success = false;
                jsonReaderResult.ErrorList.Add(String.Format(Properties.Resources.LazyJsonReaderInvalidObjectPropertyValue, line, String.Empty));
            }
        }
Exemplo n.º 13
0
        /// <summary>
        /// Read the root node of the json
        /// </summary>
        /// <param name="json">The json</param>
        /// <param name="jsonReaderOptions">The json reader options</param>
        /// <param name="lazyJson">The lazy json</param>
        private static void ReadRoot(String json, LazyJsonReaderOptions jsonReaderOptions, LazyJson lazyJson)
        {
            Int32 line  = 1;
            Int32 index = 0;

            while (index < json.Length)
            {
                if (json[index] == ' ')
                {
                    index++; continue;
                }
                if (json[index] == '\r')
                {
                    index++; continue;
                }
                if (json[index] == '\n')
                {
                    index++; line++; continue;
                }
                if (json[index] == '\t')
                {
                    index++; continue;
                }

                if (json[index] == '/')
                {
                    index++;
                    LazyJsonComments jsonComments = new LazyJsonComments();
                    ReadComments(json, jsonReaderOptions, lazyJson.ReaderResult, jsonComments, ref line, ref index);

                    if (index >= json.Length && jsonComments.IsInBlock == true && jsonComments.IsInBlockComplete == false)
                    {
                        lazyJson.ReaderResult.Success = false;
                        lazyJson.ReaderResult.ErrorList.Add(String.Format(Properties.Resources.LazyJsonReaderUnexpectedCharacter, line, "*/", String.Empty));
                    }
                }
                else if (json[index] == '[')
                {
                    index++;
                    LazyJsonArray jsonArray = new LazyJsonArray();
                    ReadArray(json, jsonReaderOptions, lazyJson.ReaderResult, jsonArray, ref line, ref index);

                    if (lazyJson.ReaderResult.Success == true)
                    {
                        lazyJson.Root = jsonArray;
                    }

                    break;
                }
                else if (json[index] == '{')
                {
                    index++;
                    LazyJsonObject jsonObject = new LazyJsonObject();
                    ReadObject(json, jsonReaderOptions, lazyJson.ReaderResult, jsonObject, ref line, ref index);

                    if (lazyJson.ReaderResult.Success == true)
                    {
                        lazyJson.Root = jsonObject;
                    }

                    break;
                }
                else if (json[index] == '\"')
                {
                    index++;
                    LazyJsonString jsonString = new LazyJsonString();
                    ReadString(json, jsonReaderOptions, lazyJson.ReaderResult, jsonString, ref line, ref index);

                    if (lazyJson.ReaderResult.Success == true)
                    {
                        lazyJson.Root = jsonString;
                    }

                    break;
                }
                else if (json[index] == '-')
                {
                    LazyJsonToken jsonToken = null;
                    ReadIntegerOrDecimal(json, jsonReaderOptions, lazyJson.ReaderResult, out jsonToken, ref line, ref index);

                    if (lazyJson.ReaderResult.Success == true)
                    {
                        lazyJson.Root = jsonToken;
                    }

                    break;
                }
                else if (Char.IsDigit(json[index]) == true)
                {
                    LazyJsonToken jsonToken = null;
                    ReadIntegerOrDecimal(json, jsonReaderOptions, lazyJson.ReaderResult, out jsonToken, ref line, ref index);

                    if (lazyJson.ReaderResult.Success == true)
                    {
                        lazyJson.Root = jsonToken;
                    }

                    break;
                }
                else if (Char.IsLetter(json[index]) == true)
                {
                    LazyJsonToken jsonToken = null;
                    ReadNullOrBoolean(json, jsonReaderOptions, lazyJson.ReaderResult, out jsonToken, ref line, ref index);

                    if (lazyJson.ReaderResult.Success == true)
                    {
                        lazyJson.Root = jsonToken;
                    }

                    break;
                }
                else
                {
                    lazyJson.Root = new LazyJsonNull();

                    lazyJson.ReaderResult.Success = false;
                    lazyJson.ReaderResult.ErrorList.Add(String.Format(Properties.Resources.LazyJsonReaderUnexpectedCharacter, line, "//", json[index]));
                    index = json.Length; // Exit

                    break;
                }
            }

            while (index < json.Length)
            {
                if (json[index] == ' ')
                {
                    index++; continue;
                }
                if (json[index] == '\r')
                {
                    index++; continue;
                }
                if (json[index] == '\n')
                {
                    index++; line++; continue;
                }
                if (json[index] == '\t')
                {
                    index++; continue;
                }

                if (json[index] == '/')
                {
                    index++;
                    LazyJsonComments jsonComments = new LazyJsonComments();
                    ReadComments(json, jsonReaderOptions, lazyJson.ReaderResult, jsonComments, ref line, ref index);

                    if (index >= json.Length && jsonComments.IsInBlock == true && jsonComments.IsInBlockComplete == false)
                    {
                        lazyJson.ReaderResult.Success = false;
                        lazyJson.ReaderResult.ErrorList.Add(String.Format(Properties.Resources.LazyJsonReaderUnexpectedCharacter, line, "*/", String.Empty));
                    }
                }
                else
                {
                    lazyJson.Root = new LazyJsonNull();

                    lazyJson.ReaderResult.Success = false;
                    lazyJson.ReaderResult.ErrorList.Add(String.Format(Properties.Resources.LazyJsonReaderUnexpectedCharacter, line, "//", json[index]));
                    index = json.Length; // Exit

                    break;
                }
            }
        }
        /// <summary>
        /// Deserialize the json dictionary array token to the desired object
        /// </summary>
        /// <param name="jsonToken">The json dictionary array token to be deserialized</param>
        /// <param name="dataType">The type of the desired object</param>
        /// <returns>The desired object instance</returns>
        public override Object Deserialize(LazyJsonToken jsonToken, Type dataType)
        {
            if (jsonToken == null || jsonToken.Type != LazyJsonType.Array || dataType == null || dataType.IsGenericType == false || dataType.GetGenericTypeDefinition() != typeof(Dictionary <,>))
            {
                return(null);
            }

            LazyJsonArray jsonArray  = (LazyJsonArray)jsonToken;
            Object        dictionary = Activator.CreateInstance(dataType);
            MethodInfo    methodAdd  = dataType.GetMethods().First(x => x.Name == "Add");

            Type jsonDeserializerType = null;
            LazyJsonDeserializerBase jsonDeserializerKey   = null;
            LazyJsonDeserializerBase jsonDeserializerValue = null;

            // Keys deserializer
            jsonDeserializerType = LazyJsonDeserializer.FindTypeDeserializer(dataType.GenericTypeArguments[0]);

            if (jsonDeserializerType == null)
            {
                jsonDeserializerType = LazyJsonDeserializer.FindBuiltInDeserializer(jsonToken, dataType.GenericTypeArguments[0]);
            }

            if (jsonDeserializerType != null)
            {
                jsonDeserializerKey = (LazyJsonDeserializerBase)Activator.CreateInstance(jsonDeserializerType);
            }

            // Values deserializer
            jsonDeserializerType = LazyJsonDeserializer.FindTypeDeserializer(dataType.GenericTypeArguments[1]);

            if (jsonDeserializerType == null)
            {
                jsonDeserializerType = LazyJsonDeserializer.FindBuiltInDeserializer(jsonToken, dataType.GenericTypeArguments[1]);
            }

            if (jsonDeserializerType != null)
            {
                jsonDeserializerValue = (LazyJsonDeserializerBase)Activator.CreateInstance(jsonDeserializerType);
            }

            for (int index = 0; index < jsonArray.Count; index++)
            {
                if (jsonArray.TokenList[index].Type != LazyJsonType.Array)
                {
                    continue;
                }

                LazyJsonArray jsonArrayKeyValuePair = (LazyJsonArray)jsonArray.TokenList[index];

                if (jsonArrayKeyValuePair.TokenList.Count != 2)
                {
                    continue;
                }

                Object key   = null;
                Object value = null;

                if (jsonDeserializerKey != null)
                {
                    key = jsonDeserializerKey.Deserialize(jsonArrayKeyValuePair.TokenList[0], dataType.GenericTypeArguments[0]);
                }
                else
                {
                    key = LazyJsonDeserializer.DeserializeToken(jsonArrayKeyValuePair.TokenList[0], dataType.GenericTypeArguments[0]);
                }

                if (jsonDeserializerValue != null)
                {
                    value = jsonDeserializerValue.Deserialize(jsonArrayKeyValuePair.TokenList[1], dataType.GenericTypeArguments[1]);
                }
                else
                {
                    value = LazyJsonDeserializer.DeserializeToken(jsonArrayKeyValuePair.TokenList[1], dataType.GenericTypeArguments[1]);
                }

                methodAdd.Invoke(dictionary, new Object[] { key, value });
            }

            return(dictionary);
        }