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);
}
public static void InitAot <T>()
{
var hold = DeserializeBuiltin <T> .Parse;
hold = DeserializeArray <T[], TSerializer> .Parse;
DeserializeType <TSerializer> .ExtractType(null);
DeserializeArrayWithElements <T, TSerializer> .ParseGenericArray(null, null);
DeserializeCollection <TSerializer> .ParseCollection <T>(null, null, null);
DeserializeListWithElements <T, TSerializer> .ParseGenericList(null, null, null);
}
private 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);
if (stringConstructor != null)
{
return(stringConstructor);
}
return(DeserializeType <TSerializer> .ParseAbstractType <T>);
}
public ParseStringDelegate GetParseFn <T>()
{
var type = Nullable.GetUnderlyingType(typeof(T)) ?? typeof(T);
if (type.IsEnum)
{
return(x => Enum.Parse(type, x, true));
}
if (type == typeof(string))
{
return(Serializer.ParseString);
}
if (type == typeof(object))
{
return(DeserializeType <TSerializer> .ObjectStringToType);
}
var specialParseFn = ParseUtils.GetSpecialParseMethod(type);
if (specialParseFn != null)
{
return(specialParseFn);
}
if (type.IsEnum)
{
return(x => Enum.Parse(type, x, true));
}
if (type.IsArray)
{
return(DeserializeArray <T, TSerializer> .Parse);
}
var builtInMethod = DeserializeBuiltin <T> .Parse;
if (builtInMethod != null)
{
return(value => builtInMethod(Serializer.ParseRawString(value)));
}
if (JsConfig <T> .SerializeFn != null)
{
return(value => JsConfig <T> .ParseFn(Serializer.ParseRawString(value)));
}
if (type.IsGenericType())
{
if (type.IsOrHasGenericInterfaceTypeOf(typeof(IList <>)))
{
return(DeserializeList <T, TSerializer> .Parse);
}
if (type.IsOrHasGenericInterfaceTypeOf(typeof(IDictionary <,>)))
{
return(DeserializeDictionary <TSerializer> .GetParseMethod(type));
}
if (type.IsOrHasGenericInterfaceTypeOf(typeof(ICollection <>)))
{
return(DeserializeCollection <TSerializer> .GetParseMethod(type));
}
if (type.HasAnyTypeDefinitionsOf(typeof(Queue <>)) ||
type.HasAnyTypeDefinitionsOf(typeof(Stack <>)))
{
return(DeserializeSpecializedCollections <T, TSerializer> .Parse);
}
if (type.IsOrHasGenericInterfaceTypeOf(typeof(IEnumerable <>)))
{
return(DeserializeEnumerable <T, TSerializer> .Parse);
}
}
var isCollection = typeof(T).IsOrHasGenericInterfaceTypeOf(typeof(ICollection));
if (isCollection)
{
var isDictionary = typeof(T).IsAssignableFrom(typeof(IDictionary)) ||
typeof(T).HasInterface(typeof(IDictionary));
if (isDictionary)
{
return(DeserializeDictionary <TSerializer> .GetParseMethod(type));
}
return(DeserializeEnumerable <T, TSerializer> .Parse);
}
var isEnumerable = typeof(T).IsAssignableFrom(typeof(IEnumerable)) ||
typeof(T).HasInterface(typeof(IEnumerable));
if (isEnumerable)
{
var parseFn = DeserializeSpecializedCollections <T, TSerializer> .Parse;
if (parseFn != null)
{
return(parseFn);
}
}
if (type.IsValueType)
{
var staticParseMethod = StaticParseMethod <T> .Parse;
if (staticParseMethod != null)
{
return(value => staticParseMethod(Serializer.ParseRawString(value)));
}
}
else
{
var staticParseMethod = StaticParseRefTypeMethod <TSerializer, T> .Parse;
if (staticParseMethod != null)
{
return(value => staticParseMethod(Serializer.ParseRawString(value)));
}
}
var typeConstructor = DeserializeType <TSerializer> .GetParseMethod(TypeConfig <T> .GetState());
if (typeConstructor != null)
{
return(typeConstructor);
}
var stringConstructor = DeserializeTypeUtils.GetParseMethod(type);
if (stringConstructor != null)
{
return(stringConstructor);
}
return(DeserializeType <TSerializer> .ParseAbstractType <T>);
}
private ParseStringDelegate GetCoreParseFn <T>()
{
var type = Nullable.GetUnderlyingType(typeof(T)) ?? typeof(T);
if (JsConfig <T> .HasDeserializeFn)
{
return(value => JsConfig <T> .ParseFn(Serializer, value));
}
if (type.IsEnum())
{
return(x => Enum.Parse(type, Serializer.UnescapeSafeString(x), true));
}
if (type == typeof(string))
{
return(Serializer.UnescapeString);
}
if (type == typeof(object))
{
return(DeserializeType <TSerializer> .ObjectStringToType);
}
var specialParseFn = ParseUtils.GetSpecialParseMethod(type);
if (specialParseFn != null)
{
return(specialParseFn);
}
if (type.IsEnum())
{
return(x => Enum.Parse(type, x, true));
}
if (type.IsArray)
{
return(DeserializeArray <T, TSerializer> .Parse);
}
var builtInMethod = DeserializeBuiltin <T> .Parse;
if (builtInMethod != null)
{
return(value => builtInMethod(Serializer.UnescapeSafeString(value)));
}
if (type.HasGenericType())
{
if (type.IsOrHasGenericInterfaceTypeOf(typeof(IList <>)))
{
return(DeserializeList <T, TSerializer> .Parse);
}
if (type.IsOrHasGenericInterfaceTypeOf(typeof(IDictionary <,>)))
{
return(DeserializeDictionary <TSerializer> .GetParseMethod(type));
}
if (type.IsOrHasGenericInterfaceTypeOf(typeof(ICollection <>)))
{
return(DeserializeCollection <TSerializer> .GetParseMethod(type));
}
if (type.HasAnyTypeDefinitionsOf(typeof(Queue <>)) ||
type.HasAnyTypeDefinitionsOf(typeof(Stack <>)))
{
return(DeserializeSpecializedCollections <T, TSerializer> .Parse);
}
if (type.IsOrHasGenericInterfaceTypeOf(typeof(KeyValuePair <,>)))
{
return(DeserializeKeyValuePair <TSerializer> .GetParseMethod(type));
}
if (type.IsOrHasGenericInterfaceTypeOf(typeof(IEnumerable <>)))
{
return(DeserializeEnumerable <T, TSerializer> .Parse);
}
}
#if !NETFX_CORE
#if NET40
if (typeof(T).IsAssignableFrom(typeof(System.Dynamic.IDynamicMetaObjectProvider)) ||
typeof(T).HasInterface(typeof(System.Dynamic.IDynamicMetaObjectProvider)))
{
return(DeserializeDynamic <TSerializer> .Parse);
}
#endif
#endif
var isDictionary = typeof(T) != typeof(IEnumerable) && typeof(T) != typeof(ICollection) &&
(typeof(T).AssignableFrom(typeof(IDictionary)) || typeof(T).HasInterface(typeof(IDictionary)));
if (isDictionary)
{
return(DeserializeDictionary <TSerializer> .GetParseMethod(type));
}
var isEnumerable = typeof(T).AssignableFrom(typeof(IEnumerable)) ||
typeof(T).HasInterface(typeof(IEnumerable));
if (isEnumerable)
{
var parseFn = DeserializeSpecializedCollections <T, TSerializer> .Parse;
if (parseFn != null)
{
return(parseFn);
}
}
if (type.IsValueType())
{
var staticParseMethod = StaticParseMethod <T> .Parse;
if (staticParseMethod != null)
{
return(value => staticParseMethod(Serializer.UnescapeSafeString(value)));
}
}
else
{
var staticParseMethod = StaticParseRefTypeMethod <TSerializer, T> .Parse;
if (staticParseMethod != null)
{
return(value => staticParseMethod(Serializer.UnescapeSafeString(value)));
}
}
var typeConstructor = DeserializeType <TSerializer> .GetParseMethod(TypeConfig <T> .GetState());
if (typeConstructor != null)
{
return(typeConstructor);
}
var stringConstructor = DeserializeTypeUtils.GetParseMethod(type);
if (stringConstructor != null)
{
return(stringConstructor);
}
return(DeserializeType <TSerializer> .ParseAbstractType <T>);
}
public ParseStringDelegate GetParseFn <T>()
{
var type = Nullable.GetUnderlyingType(typeof(T)) ?? typeof(T);
if (type.IsEnum)
{
return(x => Enum.Parse(type, x, false));
}
if (type == typeof(string))
{
return(Serializer.ParseString);
}
if (type == typeof(object))
{
return(x => x);
}
var specialParseFn = ParseUtils.GetSpecialParseMethod(type);
if (specialParseFn != null)
{
return(specialParseFn);
}
if (type.IsEnum)
{
return(x => Enum.Parse(type, x, false));
}
if (type.IsArray)
{
return(DeserializeArray <T, TSerializer> .Parse);
}
var builtInMethod = DeserializeBuiltin <T> .Parse;
if (builtInMethod != null)
{
return(value => builtInMethod(Serializer.ParseRawString(value)));
}
if (type.IsGenericType())
{
if (type.IsOrHasGenericInterfaceTypeOf(typeof(IList <>)))
{
return(DeserializeList <T, TSerializer> .Parse);
}
if (type.IsOrHasGenericInterfaceTypeOf(typeof(IDictionary <,>)))
{
return(DeserializeDictionary <TSerializer> .GetParseMethod(type));
}
if (type.IsOrHasGenericInterfaceTypeOf(typeof(ICollection <>)))
{
return(DeserializeCollection <TSerializer> .GetParseMethod(type));
}
if (type.HasAnyTypeDefinitionsOf(typeof(Queue <>)) ||
type.HasAnyTypeDefinitionsOf(typeof(Stack <>)))
{
return(DeserializeSpecializedCollections <T, TSerializer> .Parse);
}
if (type.IsOrHasGenericInterfaceTypeOf(typeof(IEnumerable <>)))
{
return(DeserializeEnumerable <T, TSerializer> .Parse);
}
}
var staticParseMethod = StaticParseMethod <T> .Parse;
if (staticParseMethod != null)
{
return(value => staticParseMethod(Serializer.ParseRawString(value)));
}
var typeConstructor = DeserializeType <TSerializer> .GetParseMethod(type);
if (typeConstructor != null)
{
return(typeConstructor);
}
var stringConstructor = DeserializeTypeUtils.GetParseMethod(type);
if (stringConstructor != null)
{
return(stringConstructor);
}
return(null);
}