Пример #1
0
        public static object ObjectStringToType(StringSegment strType)
        {
            var type = ExtractType(strType);

            if (type != null)
            {
                var parseFn       = Serializer.GetParseStringSegmentFn(type);
                var propertyValue = parseFn(strType);
                return(propertyValue);
            }

            if (JsConfig.ConvertObjectTypesIntoStringDictionary && !strType.IsNullOrEmpty())
            {
                if (strType.GetChar(0) == JsWriter.MapStartChar)
                {
                    var dynamicMatch = DeserializeDictionary <TSerializer> .ParseDictionary <string, object>(strType, null, v => Serializer.UnescapeString(v).Value, v => Serializer.UnescapeString(v).Value);

                    if (dynamicMatch != null && dynamicMatch.Count > 0)
                    {
                        return(dynamicMatch);
                    }
                }

                if (strType.GetChar(0) == JsWriter.ListStartChar)
                {
                    return(DeserializeList <List <object>, TSerializer> .ParseStringSegment(strType));
                }
            }

            var primitiveType = JsConfig.TryToParsePrimitiveTypeValues ? ParsePrimitive(strType.Value) : null;

            if (primitiveType != null)
            {
                return(primitiveType);
            }

            if (Serializer.ObjectDeserializer != null)
            {
                return(Serializer.ObjectDeserializer(strType));
            }

            return(Serializer.UnescapeString(strType).Value);
        }
Пример #2
0
        private ParseStringSegmentDelegate GetCoreParseStringSegmentFn <T>()
        {
            var type = Nullable.GetUnderlyingType(typeof(T)) ?? typeof(T);

            if (JsConfig <T> .HasDeserializeFn)
            {
                return(value => JsConfig <T> .ParseFn(Serializer, value.Value));
            }

            if (type.IsEnum)
            {
                return(x => ParseUtils.TryParseEnum(type, Serializer.UnescapeSafeString(x).Value));
            }

            if (type == typeof(string))
            {
                return(v => Serializer.UnescapeString(v).Value);
            }

            if (type == typeof(object))
            {
                return(DeserializeType <TSerializer> .ObjectStringToType);
            }

            var specialParseFn = ParseUtils.GetSpecialParseMethod(type);

            if (specialParseFn != null)
            {
                return(v => specialParseFn(v.Value));
            }

            if (type.IsArray)
            {
                return(DeserializeArray <T, TSerializer> .ParseStringSegment);
            }

            var builtInMethod = DeserializeBuiltin <T> .ParseStringSegment;

            if (builtInMethod != null)
            {
                return(value => builtInMethod(Serializer.UnescapeSafeString(value)));
            }

            if (type.HasGenericType())
            {
                if (type.IsOrHasGenericInterfaceTypeOf(typeof(IList <>)))
                {
                    return(DeserializeList <T, TSerializer> .ParseStringSegment);
                }

                if (type.IsOrHasGenericInterfaceTypeOf(typeof(IDictionary <,>)))
                {
                    return(DeserializeDictionary <TSerializer> .GetParseStringSegmentMethod(type));
                }

                if (type.IsOrHasGenericInterfaceTypeOf(typeof(ICollection <>)))
                {
                    return(DeserializeCollection <TSerializer> .GetParseStringSegmentMethod(type));
                }

                if (type.HasAnyTypeDefinitionsOf(typeof(Queue <>)) ||
                    type.HasAnyTypeDefinitionsOf(typeof(Stack <>)))
                {
                    return(DeserializeSpecializedCollections <T, TSerializer> .ParseStringSegment);
                }

                if (type.IsOrHasGenericInterfaceTypeOf(typeof(KeyValuePair <,>)))
                {
                    return(DeserializeKeyValuePair <TSerializer> .GetParseStringSegmentMethod(type));
                }

                if (type.IsOrHasGenericInterfaceTypeOf(typeof(IEnumerable <>)))
                {
                    return(DeserializeEnumerable <T, TSerializer> .ParseStringSegment);
                }

                var customFn = DeserializeCustomGenericType <TSerializer> .GetParseStringSegmentMethod(type);

                if (customFn != null)
                {
                    return(customFn);
                }
            }

            var pclParseFn = PclExport.Instance.GetJsReaderParseStringSegmentMethod <TSerializer>(typeof(T));

            if (pclParseFn != null)
            {
                return(pclParseFn);
            }

            var isDictionary = typeof(T) != typeof(IEnumerable) && typeof(T) != typeof(ICollection) &&
                               (typeof(T).IsAssignableFrom(typeof(IDictionary)) || typeof(T).HasInterface(typeof(IDictionary)));

            if (isDictionary)
            {
                return(DeserializeDictionary <TSerializer> .GetParseStringSegmentMethod(type));
            }

            var isEnumerable = typeof(T).IsAssignableFrom(typeof(IEnumerable)) ||
                               typeof(T).HasInterface(typeof(IEnumerable));

            if (isEnumerable)
            {
                var parseFn = DeserializeSpecializedCollections <T, TSerializer> .ParseStringSegment;
                if (parseFn != null)
                {
                    return(parseFn);
                }
            }

            if (type.IsValueType)
            {
                //at first try to find more faster `ParseStringSegment` method
                var staticParseStringSegmentMethod = StaticParseMethod <T> .ParseStringSegment;
                if (staticParseStringSegmentMethod != null)
                {
                    return(value => staticParseStringSegmentMethod(Serializer.UnescapeSafeString(value)));
                }

                //then try to find `Parse` method
                var staticParseMethod = StaticParseMethod <T> .Parse;
                if (staticParseMethod != null)
                {
                    return(value => staticParseMethod(Serializer.UnescapeSafeString(value).Value));
                }
            }
            else
            {
                var staticParseStringSegmentMethod = StaticParseRefTypeMethod <TSerializer, T> .ParseStringSegment;
                if (staticParseStringSegmentMethod != null)
                {
                    return(value => staticParseStringSegmentMethod(Serializer.UnescapeSafeString(value)));
                }

                var staticParseMethod = StaticParseRefTypeMethod <TSerializer, T> .Parse;
                if (staticParseMethod != null)
                {
                    return(value => staticParseMethod(Serializer.UnescapeSafeString(value).Value));
                }
            }

            var typeConstructor = DeserializeType <TSerializer> .GetParseStringSegmentMethod(TypeConfig <T> .GetState());

            if (typeConstructor != null)
            {
                return(typeConstructor);
            }

            var stringConstructor = DeserializeTypeUtils.GetParseStringSegmentMethod(type);

            if (stringConstructor != null)
            {
                return(stringConstructor);
            }

            return(DeserializeType <TSerializer> .ParseAbstractType <T>);
        }