Esempio n. 1
0
        private static object ParseAnonymousValue(string json)
        {
            if (json.Length == 0)
            {
                return(null);
            }

            if (json[0] == '{' && json[json.Length - 1] == '}')
            {
                var elems = JSONParser.Split(json);
                if (elems.Count % 2 != 0)
                {
                    return(null);
                }

                var dict = new Dictionary <string, object>(elems.Count / 2);
                for (var i = 0; i < elems.Count; i += 2)
                {
                    dict[elems[i].Substring(1, elems[i].Length - 2)] = JSONParser.ParseAnonymousValue(elems[i + 1]);
                }

                return(dict);
            }

            if (json[0] == '[' && json[json.Length - 1] == ']')
            {
                var items     = JSONParser.Split(json);
                var finalList = new List <object>(items.Count);
                for (var i = 0; i < items.Count; i++)
                {
                    finalList.Add(JSONParser.ParseAnonymousValue(items[i]));
                }

                return(finalList);
            }

            if (json[0] == '"' && json[json.Length - 1] == '"')
            {
                var str = json.Substring(1, json.Length - 2);
                return(str.Replace("\\", string.Empty));
            }

            if (char.IsDigit(json[0]) || json[0] == '-')
            {
                if (json.Contains("."))
                {
                    double result;
                    double.TryParse(json, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out result);
                    return(result);
                }
                else
                {
                    int result;
                    int.TryParse(json, out result);
                    return(result);
                }
            }

            if (json == "true")
            {
                return(true);
            }

            if (json == "false")
            {
                return(false);
            }

            // handles json == "null" as well as invalid JSON
            return(null);
        }
        public bool TryToConvert(string data, System.Type componentType, string fieldName, System.Type fieldType, out object result)
        {
            DataConfigGenerator.projectConfigs = this.allConfigs;

            if (fieldType == typeof(bool))
            {
                result = int.Parse(data) == 1 ? true : false;
                return(true);
            }
            else if (fieldType == typeof(int))
            {
                result = int.Parse(data);
                return(true);
            }
            else if (fieldType == typeof(uint))
            {
                result = uint.Parse(data);
                return(true);
            }
            else if (fieldType == typeof(float))
            {
                data   = data.Replace(",", ".");
                result = float.Parse(data, System.Globalization.CultureInfo.InvariantCulture);
                return(true);
            }
            else if (fieldType == typeof(double))
            {
                data   = data.Replace(",", ".");
                result = double.Parse(data, System.Globalization.CultureInfo.InvariantCulture);
                return(true);
            }
            else if (fieldType == typeof(long))
            {
                result = long.Parse(data);
                return(true);
            }
            else if (fieldType == typeof(ulong))
            {
                result = ulong.Parse(data);
                return(true);
            }
            else if (fieldType == typeof(short))
            {
                result = short.Parse(data);
                return(true);
            }
            else if (fieldType == typeof(ushort))
            {
                result = ushort.Parse(data);
                return(true);
            }
            else if (fieldType == typeof(byte))
            {
                result = byte.Parse(data);
                return(true);
            }
            else if (fieldType == typeof(sbyte))
            {
                result = sbyte.Parse(data);
                return(true);
            }
            else if (fieldType == typeof(string))
            {
                result = data;
                return(true);
            }

            if (this.TryToFindParser(data, componentType, fieldName, fieldType, out result) == true)
            {
                return(true);
            }

            if (data.StartsWith("{") == true || data.StartsWith("[") == true)
            {
                // Custom json-struct
                result = JSONParser.FromJson(data, fieldType);
                return(true);
            }

            result = null;
            return(false);
        }
Esempio n. 3
0
        internal static object ParseValue(Type type, string json)
        {
            {
                var resJson = json;
                if (resJson[0] == '"')
                {
                    resJson = resJson.Substring(1, resJson.Length - 2);
                }

                foreach (var parser in ME.ECS.DataConfigGenerator.DataConfigGenerator.parsers)
                {
                    if (parser.IsValid(type) == true)
                    {
                        try {
                            if (parser.Parse(resJson, type, out var result) == true)
                            {
                                return(result);
                            }

                            //if (parser.Parse(data, componentType, fieldName, fieldType, out result) == true) return true;
                        } catch (System.Exception ex) {
                            UnityEngine.Debug.LogError($"Parser `{parser}` failed with exception: {ex.Message}");
                        }
                    }
                }
            }

            if (type == typeof(string))
            {
                if (json.Length <= 2)
                {
                    return(string.Empty);
                }

                var parseStringBuilder = new StringBuilder(json.Length);
                for (var i = 1; i < json.Length - 1; ++i)
                {
                    if (json[i] == '\\' && i + 1 < json.Length - 1)
                    {
                        var j = "\"\\nrtbf/".IndexOf(json[i + 1]);
                        if (j >= 0)
                        {
                            parseStringBuilder.Append("\"\\\n\r\t\b\f/"[j]);
                            ++i;
                            continue;
                        }

                        if (json[i + 1] == 'u' && i + 5 < json.Length - 1)
                        {
                            UInt32 c = 0;
                            if (UInt32.TryParse(json.Substring(i + 2, 4), System.Globalization.NumberStyles.AllowHexSpecifier, null, out c))
                            {
                                parseStringBuilder.Append((char)c);
                                i += 5;
                                continue;
                            }
                        }
                    }

                    parseStringBuilder.Append(json[i]);
                }

                return(parseStringBuilder.ToString());
            }

            if (type.IsPrimitive)
            {
                var result = Convert.ChangeType(json, type, System.Globalization.CultureInfo.InvariantCulture);
                return(result);
            }

            if (type == typeof(decimal))
            {
                decimal result;
                decimal.TryParse(json, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out result);
                return(result);
            }

            if (json == "null")
            {
                return(null);
            }

            if (type.IsEnum)
            {
                if (json[0] == '"')
                {
                    json = json.Substring(1, json.Length - 2);
                }

                try {
                    return(Enum.Parse(type, json, false));
                } catch {
                    return(0);
                }
            }

            if (type.IsArray)
            {
                var arrayType = type.GetElementType();
                if (json[0] != '[' || json[json.Length - 1] != ']')
                {
                    return(null);
                }

                var elems    = JSONParser.Split(json);
                var newArray = Array.CreateInstance(arrayType, elems.Count);
                for (var i = 0; i < elems.Count; i++)
                {
                    newArray.SetValue(JSONParser.ParseValue(arrayType, elems[i]), i);
                }

                JSONParser.splitArrayPool.Push(elems);
                return(newArray);
            }

            if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(List <>))
            {
                var listType = type.GetGenericArguments()[0];
                if (json[0] != '[' || json[json.Length - 1] != ']')
                {
                    return(null);
                }

                var elems = JSONParser.Split(json);
                var list  = (IList)type.GetConstructor(new Type[] { typeof(int) }).Invoke(new object[] { elems.Count });
                for (var i = 0; i < elems.Count; i++)
                {
                    list.Add(JSONParser.ParseValue(listType, elems[i]));
                }

                JSONParser.splitArrayPool.Push(elems);
                return(list);
            }

            if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary <,>))
            {
                Type keyType, valueType;
                {
                    var args = type.GetGenericArguments();
                    keyType   = args[0];
                    valueType = args[1];
                }

                //Refuse to parse dictionary keys that aren't of type string
                if (keyType != typeof(string))
                {
                    return(null);
                }

                //Must be a valid dictionary element
                if (json[0] != '{' || json[json.Length - 1] != '}')
                {
                    return(null);
                }

                //The list is split into key/value pairs only, this means the split must be divisible by 2 to be valid JSON
                var elems = JSONParser.Split(json);
                if (elems.Count % 2 != 0)
                {
                    return(null);
                }

                var dictionary = (IDictionary)type.GetConstructor(new Type[] { typeof(int) }).Invoke(new object[] { elems.Count / 2 });
                for (var i = 0; i < elems.Count; i += 2)
                {
                    if (elems[i].Length <= 2)
                    {
                        continue;
                    }

                    var keyValue = elems[i].Substring(1, elems[i].Length - 2);
                    var val      = JSONParser.ParseValue(valueType, elems[i + 1]);
                    dictionary[keyValue] = val;
                }

                return(dictionary);
            }

            if (type == typeof(object))
            {
                return(JSONParser.ParseAnonymousValue(json));
            }

            if (json[0] == '{' && json[json.Length - 1] == '}')
            {
                return(JSONParser.ParseObject(type, json));
            }

            return(null);
        }