Ejemplo n.º 1
0
        public override object JsonToObject(EasyJsonData data, Type t)
        {
            if (data.IsNullValue)
            {
                return(null);
            }

            if (data.Type != EasyJsonDataType.JsonObject)
            {
                throw new EasyJsonException("Invalid JSON data type " + data.Type.ToString() + ", JSON OBJECT expected");
            }

            IDictionary      inst     = Activator.CreateInstance(t) as IDictionary;
            JsonItemMetadata metadata = _getItemMetadata(t);

            JsonToObjectFunc keyFunc = _stringDataToKey;

            if (metadata.IndexType != typeof(string))
            {
                keyFunc = _jsonDataToKey;
            }

            foreach (string name in data.Names)
            {
                object key   = keyFunc(name, metadata.IndexType);
                object value = base.JsonToObject(data[name], metadata.ElementType);

                inst.Add(key, value);
            }

            return(inst);
        }
Ejemplo n.º 2
0
        static EasyJsonData __load(string json, ref int start)
        {
            JsonUtil.SkipIgnoredChar(json, ref start, false);
            if (start == json.Length)
            {
                return(null);
            }

            EasyJsonDataType type = EasyJsonDataType.Unknown;

            switch (json[start])
            {
            case JsonUtil.OBJECT_START:
                type = EasyJsonDataType.JsonObject;
                break;

            case JsonUtil.ARRAY_START:
                type = EasyJsonDataType.JsonArray;
                break;

            case JsonUtil.STRING_QUOTE:
                type = EasyJsonDataType.JsonString;
                break;
            }

            EasyJsonData jsonData = new EasyJsonData(type);

            jsonData._load(json, ref start);

            return(jsonData);
        }
Ejemplo n.º 3
0
        public virtual object JsonToObject(EasyJsonData data, Type t)
        {
            if (data == null)
            {
                return(null);
            }

            return(_readObject(data, t));
        }
Ejemplo n.º 4
0
        public override object JsonToObject(EasyJsonData data, Type t)
        {
            if (data.IsNullValue)
            {
                return(null);
            }

            return(data.Data);
        }
Ejemplo n.º 5
0
 public override object JsonToObject(EasyJsonData data, Type t)
 {
     try
     {
         return(Enum.Parse(t, data.Data));
     }
     catch (Exception e)
     {
         throw new EasyJsonException("Fail to parse " + data.Data + " to " + t.ToString(), e);
     }
 }
Ejemplo n.º 6
0
        void _loadObject(string json, ref int start)
        {
            do
            {
                ++start;
                string name = JsonUtil.GetString(json, ref start);
                if (name == null)
                {
                    if (json[start] != JsonUtil.OBJECT_END)
                    {
                        throw new EasyJsonException("Bad JSON format");
                    }

                    break;
                }
                else
                {
                    JsonUtil.SkipIgnoredChar(json, ref start, false);
                    if (start == json.Length)
                    {
                        throw new EasyJsonException("Bad JSON format");
                    }
                    if (json[start] != JsonUtil.KV_SEPARATOR)
                    {
                        throw new EasyJsonException("Bad JSON format");
                    }

                    ++start;
                    EasyJsonData data = EasyJsonData.__load(json, ref start);

                    _object.Add(name, data);

                    JsonUtil.SkipIgnoredChar(json, ref start, false);
                    if (start < json.Length)
                    {
                        if (json[start] == JsonUtil.DATA_SEPARATOR)
                        {
                            continue;
                        }

                        if (json[start] == JsonUtil.OBJECT_END)
                        {
                            break;
                        }
                    }

                    throw new EasyJsonException("Bad JSON format");
                }
            }while (true);

            ++start;
        }
Ejemplo n.º 7
0
        public EasyJsonData this[string name]
        {
            get
            {
                if (_object == null)
                {
                    throw new EasyJsonException("Can't get JSON data using STRING name");
                }

                EasyJsonData data = null;
                _object.TryGetValue(name, out data);

                return(data);
            }
        }
Ejemplo n.º 8
0
        void _readArray(Array inst, EasyJsonData data, int[] startIdx, int dim, Type t)
        {
            for (int i = 0; i < inst.GetLength(dim); ++i)
            {
                startIdx[dim] = i;
                if (dim == inst.Rank - 1)
                {
                    inst.SetValue(base.JsonToObject(data[i], t), startIdx);
                }
                else
                {
                    _readArray(inst, data[i], startIdx, dim + 1, t);
                }
            }

            startIdx[dim] = 0;
        }
Ejemplo n.º 9
0
        public override object JsonToObject(EasyJsonData data, Type t)
        {
            string value = data.Data.ToLower();

            if (value == "true")
            {
                return(true);
            }
            else if (value == "false")
            {
                return(false);
            }
            else
            {
                throw new EasyJsonException("Can't parse " + data.Data + " to bool value");
            }
        }
Ejemplo n.º 10
0
        public override object JsonToObject(EasyJsonData data, Type t)
        {
            if (data.IsNullValue)
            {
                return(null);
            }

            Type ut = Nullable.GetUnderlyingType(t);
            EasyJsonController controller = GetController(ut);

            if (controller == null)
            {
                throw new EasyJsonException("Doesn't support JSON parser for Nullable " + ut.ToString());
            }

            return(controller.JsonToObject(data, ut));
        }
Ejemplo n.º 11
0
        public static EasyJsonData Load(string json)
        {
            if (json == null)
            {
                return(null);
            }

            int          start    = 0;
            EasyJsonData jsonData = __load(json, ref start);

            JsonUtil.SkipIgnoredChar(json, ref start, false);
            if (start < json.Length)
            {
                throw new EasyJsonException("Bad JSON format");
            }

            return(jsonData);
        }
Ejemplo n.º 12
0
        public override object JsonToObject(EasyJsonData data, Type t)
        {
            if (data.IsNullValue)
            {
                return(null);
            }

            Type inst = null;

            foreach (Assembly ass in AppDomain.CurrentDomain.GetAssemblies())
            {
                if ((inst = ass.GetType(data.Data)) != null)
                {
                    return(inst);
                }
            }

            throw new EasyJsonException("Can't find type definition " + data.Data);
        }
Ejemplo n.º 13
0
        void _loadArray(string json, ref int start)
        {
            bool allIsNull = true;

            do
            {
                ++start;
                EasyJsonData data = EasyJsonData.__load(json, ref start);

                _array.Add(data);
                if (!data.IsNullValue)
                {
                    allIsNull = false;
                }

                JsonUtil.SkipIgnoredChar(json, ref start, false);
                if (start < json.Length)
                {
                    if (json[start] == JsonUtil.DATA_SEPARATOR)
                    {
                        continue;
                    }

                    if (json[start] == JsonUtil.ARRAY_END)
                    {
                        break;
                    }
                }

                throw new EasyJsonException("Bad JSON format");
            }while (true);

            if (allIsNull)
            {
                _array.Clear();
            }

            ++start;
        }
Ejemplo n.º 14
0
        public override object JsonToObject(EasyJsonData data, Type t)
        {
            if (data.IsNullValue)
            {
                return(null);
            }

            if (data.Type != EasyJsonDataType.JsonArray)
            {
                throw new EasyJsonException("Invalid JSON data type " + data.Type.ToString() + ", JSON ARRAY expected");
            }

            JsonItemMetadata metadata = _getItemMetadata(t);
            IList            inst     = Activator.CreateInstance(t) as IList;

            for (int i = 0; i < data.Count; ++i)
            {
                object element = base.JsonToObject(data[i], metadata.ElementType);
                inst.Add(element);
            }

            return(inst);
        }
Ejemplo n.º 15
0
        public override object JsonToObject(EasyJsonData data, Type t)
        {
            if (data.IsNullValue)
            {
                return(null);
            }

            int rank = t.GetArrayRank();

            int[] lengths = new int[rank];

            EasyJsonData tmpData = data;

            for (int i = 0; i < rank; ++i)
            {
                if (tmpData.Type != EasyJsonDataType.JsonArray)
                {
                    throw new EasyJsonException("Invalid JSON data type " + tmpData.Type.ToString() + ", JSON ARRAY expected");
                }

                if (0 == (lengths[i] = tmpData.Count))
                {
                    break;
                }

                tmpData = tmpData[0];
            }

            Type  et   = t.GetElementType();
            Array inst = Array.CreateInstance(et, lengths);

            int[] idx = new int[rank];
            _readArray(inst, data, idx, 0, et);

            return(inst);
        }
Ejemplo n.º 16
0
        object _readObject(EasyJsonData data, Type t)
        {
            if (data.IsNullValue)
            {
                return(null);
            }

            try
            {
                // If user register a specific type controller but still invoke base JsonToObject, there
                // will make a loop: base -> GetController(t) -> child -> base
                if (_checkedData != data)
                {
                    _checkedData = data;

                    if (data.Type == EasyJsonDataType.JsonObject)
                    {
                        EasyJsonData typeData = data[DYNAMIC_TYPE_NAME];
                        if (typeData != null)
                        {
                            JsonSystemTypeController typeController = GetController(typeof(Type)) as JsonSystemTypeController;
                            if (typeController == null)
                            {
                                throw new EasyJsonException("Can't find System.Type controller to process dynamic type");
                            }
                            t = typeController.JsonToObject(typeData, typeof(Type)) as Type;
                        }
                    }

                    EasyJsonController controller = GetController(t);
                    if (controller != null)
                    {
                        return(controller.JsonToObject(data, t));
                    }
                }

                if (data.Type != EasyJsonDataType.JsonObject)
                {
                    throw new EasyJsonException("Can't load JSON data for " + t.ToString());
                }

                object            inst     = Activator.CreateInstance(t);
                JsonClassMetadata metadata = _getMetadata(t);

                foreach (KeyValuePair <string, FieldInfo> kv in metadata.Fields)
                {
                    EasyJsonData fieldData = data[kv.Key];
                    if (fieldData != null)
                    {
                        FieldInfo field = kv.Value;
                        field.SetValue(inst, _readObject(fieldData, field.FieldType));
                    }
                }
                foreach (KeyValuePair <string, PropertyInfo> kv in metadata.Properties)
                {
                    EasyJsonData propertyData = data[kv.Key];
                    if (propertyData != null)
                    {
                        PropertyInfo property = kv.Value;
                        property.SetValue(inst, _readObject(propertyData, property.PropertyType), null);
                    }
                }

                return(inst);
            }
            finally
            {
                _checkedData = null;
            }
        }
Ejemplo n.º 17
0
        internal object JsonToObject(string json, Type t)
        {
            EasyJsonData data = EasyJsonData.Load(json);

            return(JsonToObject(data, t));
        }
Ejemplo n.º 18
0
 public override object JsonToObject(EasyJsonData data, Type t)
 {
     return(UInt16.Parse(data.Data));
 }
Ejemplo n.º 19
0
        public static T ToObject <T>(EasyJsonData jsonData)
        {
            EasyJsonController controller = GetMainController();

            return((T)(controller.JsonToObject(jsonData, typeof(T))));
        }
Ejemplo n.º 20
0
        object _jsonDataToKey(string json, Type t)
        {
            EasyJsonData data = EasyJsonData.Load(json);

            return(base.JsonToObject(data, t));
        }
Ejemplo n.º 21
0
 public override object JsonToObject(EasyJsonData data, Type t)
 {
     return(DateTime.Parse(data.Data).ToUniversalTime());
 }
Ejemplo n.º 22
0
        public static object ToObject(EasyJsonData jsonData, Type t)
        {
            EasyJsonController controller = GetMainController();

            return(controller.JsonToObject(jsonData, t));
        }
Ejemplo n.º 23
0
 public override object JsonToObject(EasyJsonData data, Type t)
 {
     return(data);
 }