Example #1
0
        public static void Register <T>()
        {
            var i          = 0;
            var serializer = JsonTypeSerializer.Instance;

            if (new List <T>() != null)
            {
                i++;
            }
            if (new T[0] != null)
            {
                i++;
            }
            if (serializer.GetParseFn <T>() != null)
            {
                i++;
            }
            if (DeserializeArray <T[], JsonTypeSerializer> .Parse != null)
            {
                i++;
            }

            JsConfig <T> .ExcludeTypeInfo = false;
            //JsConfig<T>.SerializeFn = arg => "";
            //JsConfig<T>.DeSerializeFn = arg => default(T);

            DeserializeArrayWithElements <T, JsonTypeSerializer> .ParseGenericArray(null, null);

            DeserializeCollection <JsonTypeSerializer> .ParseCollection <T>(null, null, null);

            DeserializeListWithElements <T, JsonTypeSerializer> .ParseGenericList(null, null, null);

            SpecializedQueueElements <T> .ConvertToQueue(null);

            SpecializedQueueElements <T> .ConvertToStack(null);

            WriteListsOfElements <T, JsonTypeSerializer> .WriteList(null, null);

            WriteListsOfElements <T, JsonTypeSerializer> .WriteIList(null, null);

            WriteListsOfElements <T, JsonTypeSerializer> .WriteEnumerable(null, null);

            WriteListsOfElements <T, JsonTypeSerializer> .WriteListValueType(null, null);

            WriteListsOfElements <T, JsonTypeSerializer> .WriteIListValueType(null, null);

            JsonReader <T> .Parse(null);

            JsonWriter <T> .WriteFn();

            TranslateListWithElements <T> .LateBoundTranslateToGenericICollection(null, null);

            TranslateListWithConvertibleElements <T, T> .LateBoundTranslateToGenericICollection(null, null);

            QueryStringWriter <T> .WriteObject(null, null);
        }
Example #2
0
    public static void InitAot <T>()
    {
        var hold = DeserializeBuiltin <T> .Parse;

        hold = DeserializeArray <T[], TSerializer> .Parse;
        DeserializeType <TSerializer> .ExtractType(default(ReadOnlySpan <char>));

        DeserializeArrayWithElements <T, TSerializer> .ParseGenericArray(default(ReadOnlySpan <char>), null);

        DeserializeCollection <TSerializer> .ParseCollection <T>(default(ReadOnlySpan <char>), null, null);

        DeserializeListWithElements <T, TSerializer> .ParseGenericList(default(ReadOnlySpan <char>), null, null);
    }
Example #3
0
        public static void Register <T>()
        {
            var i          = 0;
            var serializer = JsonTypeSerializer.Instance;

            if (new List <T>() != null)
            {
                i++;
            }
            if (new T[0] != null)
            {
                i++;
            }
            if (serializer.GetParseFn <T>() != null)
            {
                i++;
            }
            if (DeserializeArray <T[], JsonTypeSerializer> .Parse != null)
            {
                i++;
            }

            DeserializeArrayWithElements <T, JsonTypeSerializer> .ParseGenericArray(null, null);

            DeserializeCollection <JsonTypeSerializer> .ParseCollection <T>(null, null, null);

            DeserializeListWithElements <T, JsonTypeSerializer> .ParseGenericList(null, null, null);

            SpecializedQueueElements <T> .ConvertToQueue(null);

            SpecializedQueueElements <T> .ConvertToStack(null);

            WriteListsOfElements <T, JsonTypeSerializer> .WriteList(null, null);

            WriteListsOfElements <T, JsonTypeSerializer> .WriteIList(null, null);

            WriteListsOfElements <T, JsonTypeSerializer> .WriteEnumerable(null, null);

            WriteListsOfElements <T, JsonTypeSerializer> .WriteListValueType(null, null);

            WriteListsOfElements <T, JsonTypeSerializer> .WriteIListValueType(null, null);

            JsonReader <T> .Parse(null);

            JsonWriter <T> .WriteFn();

            TranslateListWithElements <T> .LateBoundTranslateToGenericICollection(null, null);

            TranslateListWithConvertibleElements <T, T> .LateBoundTranslateToGenericICollection(null, null);
        }
Example #4
0
    /// <summary>
    /// Gets the core parse string span function.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <returns>ParseStringSpanDelegate.</returns>
    private static ParseStringSpanDelegate GetCoreParseStringSpanFn <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(Serializer.UnescapeStringAsObject);
        }

        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> .ParseStringSpan);
        }

        var builtInMethod = DeserializeBuiltin <T> .ParseStringSpan;

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

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

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

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

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

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

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

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

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

        var pclParseFn = PclExport.Instance.GetJsReaderParseStringSpanMethod <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> .GetParseStringSpanMethod(type));
        }

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

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

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

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

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

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

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

        var stringConstructor = DeserializeTypeUtils.GetParseStringSpanMethod(type);

        return(stringConstructor ?? DeserializeType <TSerializer> .ParseAbstractType <T>);
    }
Example #5
0
            internal static int Register <T, TSerializer>() where TSerializer : ITypeSerializer
            {
                var i = 0;

                if (JsonWriter <T> .WriteFn() != null)
                {
                    i++;
                }
                if (JsonWriter.Instance.GetWriteFn <T>() != null)
                {
                    i++;
                }
                if (JsonReader.Instance.GetParseFn <T>() != null)
                {
                    i++;
                }
                if (JsonReader <T> .Parse(null) != null)
                {
                    i++;
                }
                if (JsonReader <T> .GetParseFn() != null)
                {
                    i++;
                }
                //if (JsWriter.GetTypeSerializer<JsonTypeSerializer>().GetWriteFn<T>() != null) i++;
                if (new List <T>() != null)
                {
                    i++;
                }
                if (new T[0] != null)
                {
                    i++;
                }

                JsConfig <T> .ExcludeTypeInfo = false;

                if (JsConfig <T> .OnDeserializedFn != null)
                {
                    i++;
                }
                if (JsConfig <T> .HasDeserializeFn)
                {
                    i++;
                }
                if (JsConfig <T> .SerializeFn != null)
                {
                    i++;
                }
                if (JsConfig <T> .DeSerializeFn != null)
                {
                    i++;
                }
                //JsConfig<T>.SerializeFn = arg => "";
                //JsConfig<T>.DeSerializeFn = arg => default(T);
                if (TypeConfig <T> .Properties != null)
                {
                    i++;
                }



                // zhaojh
                //if (  WriteType<T, TSerializer>.testsAOT != null ) i++;

                // AOT for ServiceStack.Text.Common.ParseMethodUtilities+<GetParseFn>
                Func <string, T> t = x => default(T);

                DeserializeType <TSerializer> .ParseAbstractType <T> (null);



//*
                if (WriteType <T, TSerializer> .Write != null)
                {
                    i++;
                }
                if (WriteType <object, TSerializer> .Write != null)
                {
                    i++;
                }

                if (DeserializeBuiltin <T> .Parse != null)
                {
                    i++;
                }
                if (DeserializeArray <T[], TSerializer> .Parse != null)
                {
                    i++;
                }
                DeserializeType <TSerializer> .ExtractType(null);

                DeserializeArrayWithElements <T, TSerializer> .ParseGenericArray(null, null);

                DeserializeCollection <TSerializer> .ParseCollection <T>(null, null, null);

                DeserializeListWithElements <T, TSerializer> .ParseGenericList(null, null, null);

                SpecializedQueueElements <T> .ConvertToQueue(null);

                SpecializedQueueElements <T> .ConvertToStack(null);

//*/

                WriteListsOfElements <T, TSerializer> .WriteList(null, null);

                WriteListsOfElements <T, TSerializer> .WriteIList(null, null);

                WriteListsOfElements <T, TSerializer> .WriteEnumerable(null, null);

                WriteListsOfElements <T, TSerializer> .WriteListValueType(null, null);

                WriteListsOfElements <T, TSerializer> .WriteIListValueType(null, null);

                WriteListsOfElements <T, TSerializer> .WriteGenericArrayValueType(null, null);

                WriteListsOfElements <T, TSerializer> .WriteArray(null, null);

                TranslateListWithElements <T> .LateBoundTranslateToGenericICollection(null, null);

                TranslateListWithConvertibleElements <T, T> .LateBoundTranslateToGenericICollection(null, null);

                QueryStringWriter <T> .WriteObject(null, null);

                return(i);
            }