public static IILGen GenerateLoad(this IILGen ilGenerator, IFieldHandler fieldHandler, Type typeWanted, Action <IILGen> pushReaderOrCtx, ITypeConvertorGenerator typeConvertorGenerator)
{
fieldHandler.Load(ilGenerator,
fieldHandler.NeedsCtx() ? pushReaderOrCtx : PushReaderFromCtx(pushReaderOrCtx));
typeConvertorGenerator.GenerateConversion(fieldHandler.HandledType(), typeWanted)(ilGenerator);
return(ilGenerator);
}
void IterateInlineDict(ref SpanReader reader, IFieldHandler keyHandler, IFieldHandler valueHandler, bool skipping, HashSet <int>?knownInlineRefs)
{
var skip = skipping || _visitor != null && !_visitor.StartDictionary();
var count = reader.ReadVUInt32();
while (count-- > 0)
{
var skipKey = skip || _visitor != null && !_visitor.StartDictKey();
IterateHandler(ref reader, keyHandler, skipKey, knownInlineRefs);
if (!skipKey)
{
_visitor?.EndDictKey();
}
var skipValue = skip || _visitor != null && !_visitor.StartDictValue();
IterateHandler(ref reader, valueHandler, skipValue, knownInlineRefs);
if (!skipValue)
{
_visitor?.EndDictValue();
}
}
if (!skip)
{
_visitor?.EndDictionary();
}
}
public virtual IFieldHandler CreateFromName(string handlerName, byte[] configuration, FieldHandlerOptions options)
{
IFieldHandler fallbackFieldHandler = null;
foreach (var fieldHandler in BasicSerializersFactory.FieldHandlers)
{
if (fieldHandler.Name == handlerName)
{
fallbackFieldHandler = fieldHandler;
if (fieldHandler.IsCompatibleWith(fieldHandler.HandledType(), options))
{
return(fieldHandler);
}
}
}
if (fallbackFieldHandler != null)
{
return(fallbackFieldHandler);
}
if (handlerName == EnumFieldHandler.HandlerName)
{
return(new EnumFieldHandler(configuration));
}
if (handlerName == ListFieldHandler.HandlerName)
{
return(new ListFieldHandler(_provider.FieldHandlerFactory, _provider.TypeConvertorGenerator, configuration));
}
if (handlerName == DictionaryFieldHandler.HandlerName)
{
return(new DictionaryFieldHandler(_provider.FieldHandlerFactory, _provider.TypeConvertorGenerator, configuration));
}
return(null);
}
void IterateInlineDict(AbstractBufferedReader reader, IFieldHandler keyHandler, IFieldHandler valueHandler, bool skipping)
{
var skip = skipping || _visitor != null && !_visitor.StartDictionary();
var count = reader.ReadVUInt32();
while (count-- > 0)
{
var skipKey = skip || _visitor != null && !_visitor.StartDictKey();
IterateHandler(reader, keyHandler, skipKey, null);
if (!skipKey)
{
_visitor?.EndDictKey();
}
var skipValue = skip || _visitor != null && !_visitor.StartDictValue();
IterateHandler(reader, valueHandler, skipValue, null);
if (!skipValue)
{
_visitor?.EndDictValue();
}
}
if (!skip)
{
_visitor?.EndDictionary();
}
}
public IFieldHandler SpecializeLoadForType(Type type, IFieldHandler typeHandler)
{
if (_type == type)
{
return(this);
}
if (!IsCompatibleWith(type))
{
Debug.Fail("strange");
return(this);
}
var wantedItemType = type.GetGenericArguments()[0];
var wantedItemHandler = default(IFieldHandler);
var listFieldHandler = typeHandler as ListFieldHandler;
if (listFieldHandler != null)
{
wantedItemHandler = listFieldHandler._itemsHandler;
}
var itemSpecialized = _itemsHandler.SpecializeLoadForType(wantedItemType, wantedItemHandler);
if (itemSpecialized == wantedItemHandler)
{
return(typeHandler);
}
if (_typeConvertorGenerator.GenerateConversion(itemSpecialized.HandledType(), wantedItemType) == null)
{
Debug.Fail("even more strange");
return(this);
}
return(new ListFieldHandler(_fieldHandlerFactory, _typeConvertorGenerator, type, itemSpecialized));
}
ListFieldHandler(IFieldHandlerFactory fieldHandlerFactory, ITypeConvertorGenerator typeConvertorGenerator, Type type, IFieldHandler itemSpecialized)
{
_fieldHandlerFactory = fieldHandlerFactory;
_typeConvertorGenerator = typeConvertorGenerator;
_type = type;
_itemsHandler = itemSpecialized;
}
public PropertyInf(AbstractBufferedReader reader, IFieldHandlerFactory fieldHandlerFactory)
{
_name = reader.ReadString();
var resultFieldHandlerName = reader.ReadString();
_fieldHandler = fieldHandlerFactory.CreateFromName(resultFieldHandlerName, reader.ReadByteArray(), FieldHandlerOptions.None);
}
public static IILGen GenerateSkip(this IILGen ilGenerator, IFieldHandler fieldHandler,
Action <IILGen> pushReaderOrCtx)
{
fieldHandler.Skip(ilGenerator,
fieldHandler.NeedsCtx() ? pushReaderOrCtx : PushReaderFromCtx(pushReaderOrCtx));
return(ilGenerator);
}
public IFieldHandler SpecializeLoadForType(Type type, IFieldHandler typeHandler)
{
if (typeHandler == this)
{
return(this);
}
var enumTypeHandler = typeHandler as EnumFieldHandler;
if (enumTypeHandler != null && _signed == enumTypeHandler._signed)
{
if (type.GetCustomAttributes(typeof(BinaryCompatibilityOnlyAttribute), false).Length != 0)
{
if (new EnumConfiguration(Configuration).IsBinaryRepresentationSubsetOf(new EnumConfiguration(enumTypeHandler.Configuration)))
{
return(typeHandler);
}
}
else
{
if (new EnumConfiguration(Configuration).IsSubsetOf(new EnumConfiguration(enumTypeHandler.Configuration)))
{
return(typeHandler);
}
}
}
if (_enumType == null && type.IsEnum)
{
if (_configuration.SequenceEqual(new EnumConfiguration(type).ToConfiguration()))
{
_enumType = type;
}
}
return(this);
}
public ODBDictionaryConfiguration(IObjectDB odb, IFieldHandler keyHandler, IFieldHandler valueHandler, bool preferInline)
{
_odb = odb;
_keyHandler = keyHandler;
_valueHandler = valueHandler;
_preferInline = preferInline;
}
ODBDictionaryConfiguration(IFieldHandler keyHandler, Type keyType, IFieldHandler?valueHandler, Type?valueType)
{
KeyHandler = keyHandler;
KeyType = keyType;
ValueHandler = valueHandler;
ValueType = valueType;
}
ListFieldHandler(IFieldHandlerFactory fieldHandlerFactory, ITypeConvertorGenerator typeConvertorGenerator, Type type, IFieldHandler itemSpecialized)
{
_fieldHandlerFactory = fieldHandlerFactory;
_typeConvertorGenerator = typeConvertorGenerator;
_type = type;
_itemsHandler = itemSpecialized;
}
public static IILGen GenerateFreeContent(this IILGen ilGenerator, IFieldHandler fieldHandler, Action <IILGen> pushReaderOrCtx,
ref NeedsFreeContent needsFreeContent)
{
UpdateNeedsFreeContent(fieldHandler.FreeContent(ilGenerator,
fieldHandler.NeedsCtx() ? pushReaderOrCtx : PushReaderFromCtx(pushReaderOrCtx)), ref needsFreeContent);
return(ilGenerator);
}
public ListFieldHandler(IFieldHandlerFactory fieldHandlerFactory, ITypeConvertorGenerator typeConvertorGenerator, byte[] configuration)
{
_fieldHandlerFactory = fieldHandlerFactory;
_typeConvertorGenerator = typeConvertorGenerator;
_configuration = configuration;
var reader = new ByteArrayReader(configuration);
_itemsHandler = _fieldHandlerFactory.CreateFromReader(reader, FieldHandlerOptions.None);
}
public static IILGen GenerateFreeContent(this IILGen ilGenerator, IFieldHandler fieldHandler, Action <IILGen> pushReaderOrCtx, ref bool needsFreeContent)
{
if (fieldHandler.FreeContent(ilGenerator, fieldHandler.NeedsCtx() ? pushReaderOrCtx : PushReaderFromCtx(pushReaderOrCtx)))
{
needsFreeContent = true;
}
return(ilGenerator);
}
ODBSetFieldHandler(IObjectDB odb, byte[] configuration, IFieldHandler specializedKeyHandler)
{
_odb = odb;
_typeConvertGenerator = odb.TypeConvertorGenerator;
_configuration = configuration;
_keysHandler = specializedKeyHandler;
CreateConfiguration();
}
public IFieldHandler SpecializeLoadForType(Type type, IFieldHandler typeHandler)
{
if (HandledType() == type || !IsCompatibleWith(type, FieldHandlerOptions.None))
{
return(this);
}
return(new ConvertingHandler(this, type));
}
public IFieldHandler SpecializeLoadForType(Type type, IFieldHandler typeHandler)
{
if (typeof(ByteBuffer) == type)
{
return(new ByteBufferHandler(this));
}
return(this);
}
DictionaryFieldHandler(IFieldHandlerFactory fieldHandlerFactory, ITypeConvertorGenerator typeConvertorGenerator, Type type, IFieldHandler keySpecialized, IFieldHandler valueSpecialized)
{
_fieldHandlerFactory = fieldHandlerFactory;
_typeConvertorGenerator = typeConvertorGenerator;
_type = type;
_keysHandler = keySpecialized;
_valuesHandler = valueSpecialized;
}
public IFieldHandler SpecializeLoadForType(Type type, IFieldHandler typeHandler)
{
if (typeof (ByteBuffer) == type)
{
return new ByteBufferHandler(this);
}
return this;
}
DictionaryFieldHandler(IFieldHandlerFactory fieldHandlerFactory, ITypeConvertorGenerator typeConvertorGenerator, Type type, IFieldHandler keySpecialized, IFieldHandler valueSpecialized)
{
_fieldHandlerFactory = fieldHandlerFactory;
_typeConvertorGenerator = typeConvertorGenerator;
_type = type;
_keysHandler = keySpecialized;
_valuesHandler = valueSpecialized;
}
public IFieldHandler SpecializeLoadForType(Type type, IFieldHandler typeHandler)
{
if (HandledType() == type || !IsCompatibleWith(type, FieldHandlerOptions.None))
{
return this;
}
return new ConvertingHandler(this, type);
}
DictionaryFieldHandler(IFieldHandlerFactory fieldHandlerFactory, ITypeConvertorGenerator typeConvertGenerator, Type type, IFieldHandler keySpecialized, IFieldHandler valueSpecialized)
{
_fieldHandlerFactory = fieldHandlerFactory;
_typeConvertGenerator = typeConvertGenerator;
_type = type;
_keysHandler = keySpecialized;
_valuesHandler = valueSpecialized;
Configuration = Array.Empty <byte>();
}
public NullableFieldHandler(IFieldHandlerFactory fieldHandlerFactory, ITypeConvertorGenerator typeConvertorGenerator, byte[] configuration)
{
_fieldHandlerFactory = fieldHandlerFactory;
_typeConvertorGenerator = typeConvertorGenerator;
Configuration = configuration;
var reader = new SpanReader(configuration);
_itemHandler = _fieldHandlerFactory.CreateFromReader(ref reader, FieldHandlerOptions.None);
}
public ListFieldHandler(IFieldHandlerFactory fieldHandlerFactory, ITypeConvertorGenerator typeConvertorGenerator, byte[] configuration)
{
_fieldHandlerFactory = fieldHandlerFactory;
_typeConvertorGenerator = typeConvertorGenerator;
_configuration = configuration;
var reader = new ByteArrayReader(configuration);
_itemsHandler = _fieldHandlerFactory.CreateFromReader(reader, FieldHandlerOptions.None);
}
ListFieldHandler(IFieldHandlerFactory fieldHandlerFactory, ITypeConvertorGenerator typeConvertGenerator, Type type, IFieldHandler itemSpecialized)
{
_fieldHandlerFactory = fieldHandlerFactory;
_typeConvertGenerator = typeConvertGenerator;
_type = type;
_isSet = type.InheritsOrImplements(typeof(ISet <>));
_itemsHandler = itemSpecialized;
Configuration = Array.Empty <byte>();
}
public DictionaryFieldHandler(IFieldHandlerFactory fieldHandlerFactory, ITypeConvertorGenerator typeConvertGenerator, byte[] configuration)
{
_fieldHandlerFactory = fieldHandlerFactory;
_typeConvertGenerator = typeConvertGenerator;
Configuration = configuration;
var reader = new ByteArrayReader(configuration);
_keysHandler = _fieldHandlerFactory.CreateFromReader(reader, FieldHandlerOptions.None);
_valuesHandler = _fieldHandlerFactory.CreateFromReader(reader, FieldHandlerOptions.None);
}
public IFieldHandler SpecializeLoadForType(Type type, IFieldHandler typeHandler)
{
var needType = Unwrap(type);
if (needType.IsInterface || needType.IsAbstract || type != needType && needType == HandledType())
{
return(new DBObjectFieldHandler(_objectDb, needType, needType != type));
}
return(this);
}
ODBDictionaryFieldHandler(IObjectDB odb, byte[] configuration, int configurationId, IFieldHandler specializedKeyHandler, IFieldHandler specializedValueHandler)
{
_odb = odb;
_fieldHandlerFactory = odb.FieldHandlerFactory;
_typeConvertorGenerator = odb.TypeConvertorGenerator;
_configuration = configuration;
_keysHandler = specializedKeyHandler;
_valuesHandler = specializedValueHandler;
CreateConfiguration();
}
ODBDictionaryFieldHandler(IObjectDB odb, byte[] configuration, int configurationId, IFieldHandler specializedKeyHandler, IFieldHandler specializedValueHandler)
{
_odb = odb;
_fieldHandlerFactory = odb.FieldHandlerFactory;
_typeConvertorGenerator = odb.TypeConvertorGenerator;
_configuration = configuration;
_keysHandler = specializedKeyHandler;
_valuesHandler = specializedValueHandler;
CreateConfiguration();
}
public ListFieldHandler(IFieldHandlerFactory fieldHandlerFactory, ITypeConvertorGenerator typeConvertorGenerator, Type type)
{
_fieldHandlerFactory = fieldHandlerFactory;
_typeConvertorGenerator = typeConvertorGenerator;
_type = type;
_itemsHandler = _fieldHandlerFactory.CreateFromType(type.GetGenericArguments()[0], FieldHandlerOptions.None);
var writer = new ByteBufferWriter();
writer.WriteFieldHandler(_itemsHandler);
_configuration = writer.Data.ToByteArray();
}
public ListFieldHandler(IFieldHandlerFactory fieldHandlerFactory, ITypeConvertorGenerator typeConvertorGenerator, Type type)
{
_fieldHandlerFactory = fieldHandlerFactory;
_typeConvertorGenerator = typeConvertorGenerator;
_type = type;
_itemsHandler = _fieldHandlerFactory.CreateFromType(type.GetGenericArguments()[0], FieldHandlerOptions.None);
var writer = new ByteBufferWriter();
writer.WriteFieldHandler(_itemsHandler);
_configuration = writer.Data.ToByteArray();
}
public ODBDictionaryFieldHandler(IObjectDB odb, byte[] configuration)
{
_odb = odb;
_fieldHandlerFactory = odb.FieldHandlerFactory;
_typeConvertorGenerator = odb.TypeConvertorGenerator;
_configuration = configuration;
var reader = new ByteArrayReader(configuration);
_keysHandler = _fieldHandlerFactory.CreateFromReader(reader, FieldHandlerOptions.Orderable | FieldHandlerOptions.AtEndOfStream);
_valuesHandler = _fieldHandlerFactory.CreateFromReader(reader, FieldHandlerOptions.None);
CreateConfiguration();
}
public ODBSetFieldHandler(IObjectDB odb, Type type, IFieldHandlerFactory fieldHandlerFactory)
{
_odb = odb;
_typeConvertGenerator = odb.TypeConvertorGenerator;
_type = type;
_keysHandler = fieldHandlerFactory.CreateFromType(type.GetGenericArguments()[0], FieldHandlerOptions.Orderable | FieldHandlerOptions.AtEndOfStream);
var writer = new ByteBufferWriter();
writer.WriteFieldHandler(_keysHandler);
_configuration = writer.Data.ToByteArray();
CreateConfiguration();
}
object CreateWriter(IFieldHandler fieldHandler, Type realType)
{
//Action<T, AbstractBufferedWriter, IWriterCtx>
var delegateType = typeof(Action<,,>).MakeGenericType(realType, typeof(AbstractBufferedWriter), typeof(IWriterCtx));
var dm = ILBuilder.Instance.NewMethod(fieldHandler.Name + "Writer", delegateType);
var ilGenerator = dm.Generator;
Action<IILGen> pushWriterOrCtx = il => il.Ldarg((ushort)(1 + (fieldHandler.NeedsCtx() ? 1 : 0)));
fieldHandler.Save(ilGenerator, pushWriterOrCtx,
il => il.Ldarg(0).Do(_typeConvertorGenerator.GenerateConversion(realType, fieldHandler.HandledType())));
ilGenerator.Ret();
return dm.Create();
}
object CreateWriter(IFieldHandler fieldHandler, Type realType)
{
//Action<T, ref SpanWriter, IWriterCtx>
var delegateType = typeof(WriterFun <>).MakeGenericType(realType);
var dm = ILBuilder.Instance.NewMethod(fieldHandler.Name + "Writer", delegateType);
var ilGenerator = dm.Generator;
fieldHandler.Save(ilGenerator, il => il.Ldarg(1), il => il.Ldarg(2),
il => il.Ldarg(0).Do(_typeConvertGenerator.GenerateConversion(realType, fieldHandler.HandledType()) !));
ilGenerator.Ret();
return(dm.Create());
}
public ODBDictionaryFieldHandler(IObjectDB odb, byte[] configuration)
{
_odb = odb;
_fieldHandlerFactory = odb.FieldHandlerFactory;
_typeConvertorGenerator = odb.TypeConvertorGenerator;
_configuration = configuration;
var reader = new ByteArrayReader(configuration);
_keysHandler = _fieldHandlerFactory.CreateFromReader(reader, FieldHandlerOptions.Orderable | FieldHandlerOptions.AtEndOfStream);
_valuesHandler = _fieldHandlerFactory.CreateFromReader(reader, FieldHandlerOptions.None);
CreateConfiguration();
}
public ListFieldHandler(IFieldHandlerFactory fieldHandlerFactory, ITypeConvertorGenerator typeConvertGenerator, Type type)
{
_fieldHandlerFactory = fieldHandlerFactory;
_typeConvertGenerator = typeConvertGenerator;
_type = type;
_isSet = type.InheritsOrImplements(typeof(ISet <>));
_itemsHandler = _fieldHandlerFactory.CreateFromType(type.GetGenericArguments()[0], FieldHandlerOptions.None);
var writer = new SpanWriter();
writer.WriteFieldHandler(_itemsHandler);
Configuration = writer.GetSpan().ToArray();
}
void IterateSet(ulong dictId, IFieldHandler keyHandler)
{
if (_visitor != null && !_visitor.StartSet())
{
return;
}
var o = ObjectDB.AllDictionariesPrefix.Length;
var prefix = new byte[o + PackUnpack.LengthVUInt(dictId)];
Array.Copy(ObjectDB.AllDictionariesPrefix, prefix, o);
PackUnpack.PackVUInt(prefix, ref o, dictId);
long prevProtectionCounter = 0;
long pos = 0;
while (true)
{
if (pos == 0)
{
if (!_trkv.FindFirstKey(prefix))
{
break;
}
}
else
{
if (_trkv.CursorMovedCounter != prevProtectionCounter)
{
if (!_trkv.SetKeyIndex(prefix, pos))
{
break;
}
}
else
{
if (!_trkv.FindNextKey(prefix))
{
break;
}
}
}
_fastVisitor.MarkCurrentKeyAsUsed(_trkv);
prevProtectionCounter = _trkv.CursorMovedCounter;
if (_visitor == null || _visitor.StartSetKey())
{
var keyReader = new SpanReader(_trkv.GetKey().Slice(prefix.Length));
IterateHandler(ref keyReader, keyHandler, false, null);
_visitor?.EndSetKey();
}
pos++;
}
_visitor?.EndSet();
}
object CreateWriter(IFieldHandler fieldHandler, Type realType)
{
//Action<T, AbstractBufferedWriter, IWriterCtx>
var delegateType = typeof(Action <, ,>).MakeGenericType(realType, typeof(AbstractBufferedWriter), typeof(IWriterCtx));
var dm = ILBuilder.Instance.NewMethod(fieldHandler.Name + "Writer", delegateType);
var ilGenerator = dm.Generator;
Action <IILGen> pushWriterOrCtx = il => il.Ldarg((ushort)(1 + (fieldHandler.NeedsCtx() ? 1 : 0)));
fieldHandler.Save(ilGenerator, pushWriterOrCtx,
il => il.Ldarg(0).Do(_typeConvertorGenerator.GenerateConversion(realType, fieldHandler.HandledType())));
ilGenerator.Ret();
return(dm.Create());
}
public ODBDictionaryFieldHandler(IObjectDB odb, Type type)
{
_odb = odb;
_fieldHandlerFactory = odb.FieldHandlerFactory;
_typeConvertorGenerator = odb.TypeConvertorGenerator;
_type = type;
_keysHandler = _fieldHandlerFactory.CreateFromType(type.GetGenericArguments()[0], FieldHandlerOptions.Orderable | FieldHandlerOptions.AtEndOfStream);
_valuesHandler = _fieldHandlerFactory.CreateFromType(type.GetGenericArguments()[1], FieldHandlerOptions.None);
var writer = new ByteBufferWriter();
writer.WriteFieldHandler(_keysHandler);
writer.WriteFieldHandler(_valuesHandler);
_configuration = writer.Data.ToByteArray();
CreateConfiguration();
}
object CreateReader(IFieldHandler fieldHandler, Type realType)
{
//Func<AbstractBufferedReader, IReaderCtx, T>
var delegateType = typeof(Func<,,>).MakeGenericType(typeof(AbstractBufferedReader), typeof(IReaderCtx),
realType);
var dm = ILBuilder.Instance.NewMethod(fieldHandler.Name + "Reader", delegateType);
var ilGenerator = dm.Generator;
Action<IILGen> pushReaderOrCtx = il => il.Ldarg((ushort)(fieldHandler.NeedsCtx() ? 1 : 0));
fieldHandler.Load(ilGenerator, pushReaderOrCtx);
ilGenerator
.Do(_typeConvertorGenerator.GenerateConversion(fieldHandler.HandledType(), realType))
.Ret();
return dm.Create();
}
public MethodInf(AbstractBufferedReader reader, IFieldHandlerFactory fieldHandlerFactory)
{
_name = reader.ReadString();
_ifaceName = reader.ReadString();
var resultFieldHandlerName = reader.ReadString();
if (resultFieldHandlerName != null)
{
_resultFieldHandler = fieldHandlerFactory.CreateFromName(resultFieldHandlerName, reader.ReadByteArray(), FieldHandlerOptions.None);
}
var parameterCount = reader.ReadVUInt32();
_parameters = new ParameterInf[parameterCount];
for (int i = 0; i < _parameters.Length; i++)
{
_parameters[i] = new ParameterInf(reader, fieldHandlerFactory);
}
}
public MethodInf(MethodInfo method, IFieldHandlerFactory fieldHandlerFactory)
{
MethodInfo = method;
_name = method.Name;
foreach (var itf in GetInterfacesForMethod(method.DeclaringType, method.GetBaseDefinition()))
{
_ifaceName = itf.Name;
break;
}
var syncReturnType = method.ReturnType.UnwrapTask();
if (syncReturnType != typeof(void))
_resultFieldHandler = fieldHandlerFactory.CreateFromType(syncReturnType, FieldHandlerOptions.None);
var parameterInfos = method.GetParameters();
_parameters = new ParameterInf[parameterInfos.Length];
for (int i = 0; i < parameterInfos.Length; i++)
{
_parameters[i] = new ParameterInf(parameterInfos[i], fieldHandlerFactory);
}
}
public IFieldHandler SpecializeLoadForType(Type type, IFieldHandler typeHandler)
{
if (_type == type) return this;
if (!IsCompatibleWith(type))
{
Debug.Fail("strange");
return this;
}
var wantedItemType = type.GetGenericArguments()[0];
var wantedItemHandler = default(IFieldHandler);
var listFieldHandler = typeHandler as ListFieldHandler;
if (listFieldHandler != null)
{
wantedItemHandler = listFieldHandler._itemsHandler;
}
var itemSpecialized = _itemsHandler.SpecializeLoadForType(wantedItemType, wantedItemHandler);
if (itemSpecialized == wantedItemHandler)
{
return typeHandler;
}
if (_typeConvertorGenerator.GenerateConversion(itemSpecialized.HandledType(), wantedItemType) == null)
{
Debug.Fail("even more strange");
return this;
}
return new ListFieldHandler(_fieldHandlerFactory, _typeConvertorGenerator, type, itemSpecialized);
}
public ParameterInf(AbstractBufferedReader reader, IFieldHandlerFactory fieldHandlerFactory)
{
_name = reader.ReadString();
var handlerName = reader.ReadString();
_fieldHandler = fieldHandlerFactory.CreateFromName(handlerName, reader.ReadByteArray(), FieldHandlerOptions.None);
}
TableFieldInfo(string name, IFieldHandler handler)
{
_name = name;
_handler = handler;
}
public ODBDictionaryConfiguration(IObjectDB odb, IFieldHandler keyHandler, IFieldHandler valueHandler)
{
_odb = odb;
_keyHandler = keyHandler;
_valueHandler = valueHandler;
}
public IFieldHandler SpecializeLoadForType(Type type, IFieldHandler typeHandler)
{
throw new InvalidOperationException();
}
public ConvertingHandler(IFieldHandler fieldHandler, Type type)
{
_fieldHandler = fieldHandler;
_type = type;
}
public IFieldHandler SpecializeLoadForType(Type type, IFieldHandler typeHandler)
{
if (_type != type)
GenerateType(type);
if (_type == type) return this;
if (!IsCompatibleWithCore(type)) return this;
var arguments = type.GetGenericArguments();
var wantedKeyHandler = default(IFieldHandler);
var wantedValueHandler = default(IFieldHandler);
var dictTypeHandler = typeHandler as ODBDictionaryFieldHandler;
if (dictTypeHandler != null)
{
wantedKeyHandler = dictTypeHandler._keysHandler;
wantedValueHandler = dictTypeHandler._valuesHandler;
}
var specializedKeyHandler = _keysHandler.SpecializeLoadForType(arguments[0], wantedKeyHandler);
var specializedValueHandler = _valuesHandler.SpecializeLoadForType(arguments[1], wantedValueHandler);
if (wantedKeyHandler == specializedKeyHandler && (wantedValueHandler == specializedValueHandler || wantedValueHandler.HandledType()==specializedValueHandler.HandledType()))
{
return typeHandler;
}
return new ODBDictionaryFieldHandler(_odb, _configuration, _configurationId, specializedKeyHandler, specializedValueHandler);
}
public PropertyInf(PropertyInfo property, IFieldHandlerFactory fieldHandlerFactory)
{
_name = property.Name;
_fieldHandler= fieldHandlerFactory.CreateFromType(property.PropertyType, FieldHandlerOptions.None);
}
public IFieldHandler SpecializeLoadForType(Type type, IFieldHandler typeHandler)
{
if (this == typeHandler) return this;
var myType = HandledType();
if (type != myType && Unwrap(type) == myType && typeHandler.HandledType() == type)
return typeHandler;
return this;
}
public ParameterInf(ParameterInfo parameter, IFieldHandlerFactory fieldHandlerFactory)
{
_name = parameter.Name;
_fieldHandler = fieldHandlerFactory.CreateFromType(parameter.ParameterType, FieldHandlerOptions.None);
}
public IFieldHandler SpecializeLoadForType(Type type, IFieldHandler typeHandler)
{
if (typeHandler == this) return this;
var enumTypeHandler = typeHandler as EnumFieldHandler;
if (enumTypeHandler != null)
{
if (_signed == enumTypeHandler._signed && new EnumConfiguration(Configuration).IsSubsetOf(new EnumConfiguration(enumTypeHandler.Configuration)))
{
return typeHandler;
}
}
if (_enumType == null && type.IsEnum)
{
if (_configuration.SequenceEqual(new EnumConfiguration(type).ToConfiguration()))
{
_enumType = type;
}
}
return this;
}
public IFieldHandler SpecializeLoadForType(Type type, IFieldHandler typeHandler)
{
return this;
}
public IFieldHandler SpecializeLoadForType(Type type, IFieldHandler typeHandler)
{
if (_type == type) return this;
if (!IsCompatibleWith(type))
{
Debug.Fail("strange");
return this;
}
var wantedKeyType = type.GetGenericArguments()[0];
var wantedValueType = type.GetGenericArguments()[1];
var wantedKeyHandler = default(IFieldHandler);
var wantedValueHandler = default(IFieldHandler);
var dictTypeHandler = typeHandler as DictionaryFieldHandler;
if (dictTypeHandler != null)
{
wantedKeyHandler = dictTypeHandler._keysHandler;
wantedValueHandler = dictTypeHandler._valuesHandler;
}
var keySpecialized = _keysHandler.SpecializeLoadForType(wantedKeyType, wantedKeyHandler);
if (_typeConvertorGenerator.GenerateConversion(keySpecialized.HandledType(), wantedKeyType) == null)
{
Debug.Fail("even more strange key");
return this;
}
var valueSpecialized = _valuesHandler.SpecializeLoadForType(wantedValueType, wantedValueHandler);
if (_typeConvertorGenerator.GenerateConversion(valueSpecialized.HandledType(), wantedValueType) == null)
{
Debug.Fail("even more strange value");
return this;
}
if (wantedKeyHandler == keySpecialized && wantedValueHandler == valueSpecialized)
{
return typeHandler;
}
return new DictionaryFieldHandler(_fieldHandlerFactory, _typeConvertorGenerator, type, keySpecialized, valueSpecialized);
}
