private SerializerPair TryGetIntrinsicSerializer(TypeInfo typeInfo)
{
if (!ReflectionSerializerVerifier.HasIntrinsicMethods(typeInfo))
{
return(null);
}
var genericArguments = typeInfo.GetGenericArguments();
if (genericArguments.Length == 1)
{
var argument = genericArguments[0];
var staticRead = GetReadStaticSerializer(typeInfo, argument);
var staticWrite = GetWriteStaticDeserializer(typeInfo);
return(SerializerPair.CreateFromMethods(staticRead, staticWrite, GetOrRegisterSerializerInternal(argument)));
}
if (genericArguments.Length == 0)
{
var staticRead = GetReadStaticSerializer(typeInfo);
var staticWrite = GetWriteStaticDeserializer(typeInfo);
return(SerializerPair.CreateFromMethods(staticRead, staticWrite));
}
return(null);
}
private SerializerPair CreateStaticReaderSingleGeneric(MemberInfo memberInfo, Type type, Type implementingType, bool allowNullable)
{
var argumentType = type.GetTypeInfo().GetGenericArguments()[0];
var readPropertyMethod = GetReadStaticSerializer(implementingType.GetTypeInfo(), argumentType);
var writePropertyMethod = GetWriteStaticDeserializer(implementingType.GetTypeInfo());
var argumentSerializerPair = GetOrCreateMemberSerializer(memberInfo, serializerType: argumentType, allowNullable: allowNullable);
return(SerializerPair.CreateFromMethods(readPropertyMethod, writePropertyMethod, argumentSerializerPair));
}
private SerializerPair CreateStaticReaderTwoGeneric([NotNull] MemberInfo memberInfo, [NotNull] Type type, [NotNull] Type implementingType)
{
var keyType = type.GetTypeInfo().GetGenericArguments()[0];
var valueType = type.GetTypeInfo().GetGenericArguments()[1];
var types = new[]
{
typeof(SerializationCtx),
typeof(UnsafeReader),
typeof(CtxReadDelegate <>).MakeGenericType(keyType),
typeof(CtxWriteDelegate <>).MakeGenericType(keyType),
typeof(CtxReadDelegate <>).MakeGenericType(valueType),
typeof(CtxWriteDelegate <>).MakeGenericType(valueType)
};
var methodInfo = implementingType.GetTypeInfo().GetMethod("Read", types);
var readPropertyMethod = methodInfo.NotNull();
var writeStaticDeserializer = GetWriteStaticDeserializer(implementingType.GetTypeInfo());
var keySerializer = GetOrCreateMemberSerializer(memberInfo, serializerType: keyType, allowNullable: false);
var valueSerializer = GetOrCreateMemberSerializer(memberInfo, serializerType: valueType, allowNullable: true);
return(SerializerPair.CreateFromMethods(readPropertyMethod, writeStaticDeserializer, keySerializer, valueSerializer));
}
public static SerializerPair TryGetIntrinsicSerializer(TypeInfo typeInfo, Func <Type, SerializerPair> getInstanceSerializer)
{
if (ReflectionSerializerVerifier.HasIntrinsicNonProtocolMethods(typeInfo))
{
var genericArguments = typeInfo.GetGenericArguments();
/*
* if (genericArguments.Length == 1)
* {
* var argument = genericArguments[0];
* var staticRead = SerializerReflectionUtil.GetReadStaticSerializer(typeInfo, argument);
* var staticWrite = SerializerReflectionUtil.GetWriteStaticDeserializer(typeInfo);
* return SerializerPair.CreateFromMethods(staticRead, staticWrite, getInstanceSerializer(argument));
* }
*/
if (genericArguments.Length == 0)
{
var staticRead = SerializerReflectionUtil.GetReadStaticNonProtocolSerializer(typeInfo);
var instanceWriter = SerializerReflectionUtil.GetWriteNonProtocolDeserializer(typeInfo);
return(SerializerPair.CreateFromNonProtocolMethods(staticRead, instanceWriter));
}
return(null);
}
if (ReflectionSerializerVerifier.HasIntrinsicProtocolMethods(typeInfo))
{
var genericArguments = typeInfo.GetGenericArguments();
if (genericArguments.Length == 1)
{
var argument = genericArguments[0];
var staticRead = SerializerReflectionUtil.GetReadStaticSerializer(typeInfo, argument);
var staticWrite = SerializerReflectionUtil.GetWriteStaticDeserializer(typeInfo);
return(SerializerPair.CreateFromMethods(staticRead, staticWrite, getInstanceSerializer(argument)));
}
if (genericArguments.Length == 0)
{
var staticRead = SerializerReflectionUtil.GetReadStaticSerializer(typeInfo);
var staticWrite = SerializerReflectionUtil.GetWriteStaticDeserializer(typeInfo);
return(SerializerPair.CreateFromMethods(staticRead, staticWrite));
}
return(null);
}
else if (ReflectionSerializerVerifier.HasIntrinsicFields(typeInfo))
{
var readField = typeInfo.GetField("Read", BindingFlags.Public | BindingFlags.Static);
var writeField = typeInfo.GetField("Write", BindingFlags.Public | BindingFlags.Static);
if (readField == null)
{
Assertion.Fail($"Invalid intrinsic serializer for type {typeInfo}. Static field 'Read' with type {typeof(CtxReadDelegate<>).ToString(true)} not found");
}
if (writeField == null)
{
Assertion.Fail($"Invalid intrinsic serializer for type {typeInfo}. Static field 'Write' with type {typeof(CtxWriteDelegate<>).ToString(true)} not found");
}
var reader = readField.GetValue(null);
var writer = writeField.GetValue(null);
return(new SerializerPair(reader, writer));
}
else if (ReflectionSerializerVerifier.HasIntrinsicAttribute(typeInfo))
{
var marshallerType = typeInfo.GetCustomAttribute <RdScalarAttribute>().NotNull().Marshaller;
var marshaller = Activator.CreateInstance(marshallerType);
return((SerializerPair)ReflectionUtil.InvokeStaticGeneric(typeof(SerializerPair), nameof(SerializerPair.FromMarshaller), typeInfo, marshaller));
}
return(null);
}
