public void Load(IILGen ilGenerator, Action<IILGen> pushReaderOrCtx) { ilGenerator .Do(pushReaderOrCtx) .Callvirt(() => default(IReaderCtx).ReadNativeObject()); var type = HandledType(); ilGenerator.Do(_service.TypeConvertorGenerator.GenerateConversion(typeof(object), type)); }
public void Load(IILGen ilGenerator, Action <IILGen> pushReaderOrCtx) { ilGenerator .Do(pushReaderOrCtx) .Callvirt(() => default(IReaderCtx).ReadNativeObject()); var type = HandledType(); ilGenerator.Do(_service.TypeConvertorGenerator.GenerateConversion(typeof(object), type)); }
public void GenerateLoad(IILGen ilGenerator, Action <IILGen> pushReader, Action <IILGen> pushCtx, Action <IILGen> pushDescriptor, Type targetType) { var genericArguments = targetType.GetGenericArguments(); var itemType = genericArguments.Length > 0 ? targetType.GetGenericArguments()[0] : typeof(object); if (itemType == typeof(object)) { var noValue = ilGenerator.DefineLabel(); var finish = ilGenerator.DefineLabel(); ilGenerator .Do(pushReader) .Callvirt(() => default(AbstractBufferedReader).ReadBool()) .Brfalse(noValue); _itemDescriptor.GenerateLoadEx(ilGenerator, pushReader, pushCtx, il => il.Do(pushDescriptor).LdcI4(0).Callvirt(() => default(ITypeDescriptor).NestedType(0)), typeof(object), _convertorGenerator); ilGenerator .Br(finish) .Mark(noValue) .Ldnull() .Mark(finish); } else { var localResult = ilGenerator.DeclareLocal(targetType); var finish = ilGenerator.DefineLabel(); var noValue = ilGenerator.DefineLabel(); var nullableType = typeof(Nullable <>).MakeGenericType(itemType); if (!targetType.IsAssignableFrom(nullableType)) { throw new NotSupportedException(); } ilGenerator .Do(pushReader) .Callvirt(() => default(AbstractBufferedReader).ReadBool()) .Brfalse(noValue); _itemDescriptor.GenerateLoadEx(ilGenerator, pushReader, pushCtx, il => il.Do(pushDescriptor).LdcI4(0).Callvirt(() => default(ITypeDescriptor).NestedType(0)), itemType, _convertorGenerator); ilGenerator .Newobj(nullableType.GetConstructor(new[] { itemType })) .Stloc(localResult) .BrS(finish) .Mark(noValue) .Ldloca(localResult) .InitObj(nullableType) .Mark(finish) .Ldloc(localResult); } }
public static void GenerateLoadEx(this ITypeDescriptor descriptor, IILGen ilGenerator, Action<IILGen> pushReader, Action<IILGen> pushCtx, Action<IILGen> pushDescriptor, Type asType, ITypeConvertorGenerator convertorGenerator) { if (descriptor.StoredInline) { if (descriptor.LoadNeedsHelpWithConversion && asType!=typeof(object)) { var origType = descriptor.GetPreferedType(); descriptor.GenerateLoad(ilGenerator, pushReader, pushCtx, pushDescriptor, origType); if (origType != asType) { var conv = convertorGenerator.GenerateConversion(origType, asType); if (conv == null) throw new BTDBException("Don't know how to convert " + descriptor.Name + " from " + origType.ToSimpleName() + " to " + asType.ToSimpleName()); conv(ilGenerator); } } else { descriptor.GenerateLoad(ilGenerator, pushReader, pushCtx, pushDescriptor, asType); } } else { ilGenerator .Do(pushCtx) .Callvirt(() => default(ITypeBinaryDeserializerContext).LoadObject()); if (asType != typeof(object)) ilGenerator.Castclass(asType); } }
public static void GenerateLoadEx(this ITypeDescriptor descriptor, IILGen ilGenerator, Action <IILGen> pushReader, Action <IILGen> pushCtx, Action <IILGen> pushDescriptor, Type asType, ITypeConvertorGenerator convertorGenerator) { if (descriptor.StoredInline) { if (descriptor.LoadNeedsHelpWithConversion && asType != typeof(object)) { var origType = descriptor.GetPreferedType(); descriptor.GenerateLoad(ilGenerator, pushReader, pushCtx, pushDescriptor, origType); if (origType != asType) { var conv = convertorGenerator.GenerateConversion(origType, asType); if (conv == null) { throw new BTDBException("Don't know how to convert " + descriptor.Name + " from " + origType.ToSimpleName() + " to " + asType.ToSimpleName()); } conv(ilGenerator); } } else { descriptor.GenerateLoad(ilGenerator, pushReader, pushCtx, pushDescriptor, asType); } } else { ilGenerator .Do(pushCtx) .Callvirt(() => default(ITypeBinaryDeserializerContext).LoadObject()); if (asType != typeof(object)) { ilGenerator.Castclass(asType); } } }
public void Skip(IILGen ilGenerator, Action <IILGen> pushReaderOrCtx) { var localCount = ilGenerator.DeclareLocal(typeof(uint)); var finish = ilGenerator.DefineLabel(); var next = ilGenerator.DefineLabel(); ilGenerator .Do(pushReaderOrCtx) .Callvirt(() => ((IReaderCtx)null).SkipObject()) .Brfalse(finish) .Do(Extensions.PushReaderFromCtx(pushReaderOrCtx)) .Callvirt(() => ((AbstractBufferedReader)null).ReadVUInt32()) .Stloc(localCount) .Mark(next) .Ldloc(localCount) .Brfalse(finish) .Ldloc(localCount) .LdcI4(1) .Sub() .ConvU4() .Stloc(localCount) .GenerateSkip(_keysHandler, pushReaderOrCtx) .GenerateSkip(_valuesHandler, pushReaderOrCtx) .Br(next) .Mark(finish); }
public void Skip(IILGen ilGenerator, Action <IILGen> pushReader, Action <IILGen> pushCtx) { var localCount = ilGenerator.DeclareLocal(typeof(uint)); var finish = ilGenerator.DefineLabel(); var next = ilGenerator.DefineLabel(); ilGenerator .Do(pushCtx) .Do(pushReader) .Callvirt(typeof(IReaderCtx).GetMethod(nameof(IReaderCtx.SkipObject)) !) .Brfalse(finish) .Do(pushReader) .Call(typeof(SpanReader).GetMethod(nameof(SpanReader.ReadVUInt32)) !) .Stloc(localCount) .Mark(next) .Ldloc(localCount) .Brfalse(finish) .Ldloc(localCount) .LdcI4(1) .Sub() .ConvU4() .Stloc(localCount) .GenerateSkip(_keysHandler, pushReader, pushCtx) .GenerateSkip(_valuesHandler, pushReader, pushCtx) .Br(next) .Mark(finish); }
static void WriteIdIl(IILGen ilGenerator, Action <IILGen> pushWriter, int id) { ilGenerator .Do(pushWriter) .LdcI4(id) .Call(() => default(AbstractBufferedWriter).WriteVUInt32(0)); }
public void GenerateSkip(IILGen ilGenerator, Action <IILGen> pushReader, Action <IILGen> pushCtx) { var localCount = ilGenerator.DeclareLocal(typeof(uint)); var skipFinished = ilGenerator.DefineLabel(); var next = ilGenerator.DefineLabel(); ilGenerator .Do(pushReader) .Callvirt(() => default(AbstractBufferedReader).ReadVUInt32()) .Stloc(localCount) .Ldloc(localCount) .Brfalse(skipFinished) .Mark(next) .Ldloc(localCount) .LdcI4(1) .Sub() .Stloc(localCount) .Ldloc(localCount) .Brfalse(skipFinished); _keyDescriptor.GenerateSkipEx(ilGenerator, pushReader, pushCtx); _valueDescriptor.GenerateSkipEx(ilGenerator, pushReader, pushCtx); ilGenerator .Br(next) .Mark(skipFinished); }
public bool FreeContent(IILGen ilGenerator, Action <IILGen> pushReaderOrCtx) { var localCount = ilGenerator.DeclareLocal(typeof(uint)); var finish = ilGenerator.DefineLabel(); var next = ilGenerator.DefineLabel(); var needsFreeContent = false; ilGenerator .Do(pushReaderOrCtx) .Callvirt(() => default(IReaderCtx).SkipObject()) .Brfalse(finish) .Do(Extensions.PushReaderFromCtx(pushReaderOrCtx)) .Callvirt(() => default(AbstractBufferedReader).ReadVUInt32()) .Stloc(localCount) .Mark(next) .Ldloc(localCount) .Brfalse(finish) .Ldloc(localCount) .LdcI4(1) .Sub() .ConvU4() .Stloc(localCount) .GenerateFreeContent(_itemsHandler, pushReaderOrCtx, ref needsFreeContent) .Br(next) .Mark(finish); return(needsFreeContent); }
public void Skip(IILGen ilGenerator, Action <IILGen> pushReaderOrCtx) { // TODO register dict id for deletion ilGenerator .Do(Extensions.PushReaderFromCtx(pushReaderOrCtx)) .Callvirt(() => default(AbstractBufferedReader).SkipVUInt64()); }
public void Save(IILGen ilGenerator, Action <IILGen> pushWriterOrCtx, Action <IILGen> pushValue) { if (_indirect) { ilGenerator .Do(pushWriterOrCtx) .Do(pushValue) .Call(typeof(DBIndirect <>).MakeGenericType(_type).GetMethod("SaveImpl")); return; } ilGenerator .Do(pushWriterOrCtx) .Do(pushValue) .Do(_objectDB.TypeConvertorGenerator.GenerateConversion(HandledType(), typeof(object))) .Callvirt(() => default(IWriterCtx).WriteNativeObject(null)); }
public NeedsFreeContent FreeContent(IILGen ilGenerator, Action <IILGen> pushReader, Action <IILGen> pushCtx) { var localCount = ilGenerator.DeclareLocal(typeof(uint)); var finish = ilGenerator.DefineLabel(); var next = ilGenerator.DefineLabel(); var needsFreeContent = NeedsFreeContent.No; ilGenerator .Do(pushCtx) .Do(pushReader) .Callvirt(typeof(IReaderCtx).GetMethod(nameof(IReaderCtx.SkipObject)) !) .Brfalse(finish) .Do(pushReader) .Call(typeof(SpanReader).GetMethod(nameof(SpanReader.ReadVUInt32)) !) .Stloc(localCount) .Mark(next) .Ldloc(localCount) .Brfalse(finish) .Ldloc(localCount) .LdcI4(1) .Sub() .ConvU4() .Stloc(localCount) .GenerateFreeContent(_itemsHandler, pushReader, pushCtx, ref needsFreeContent) .Br(next) .Mark(finish); return(needsFreeContent); }
void StoreCurrentPosition(IILGen ilGenerator, Action <IILGen> pushReader, IILLocal positionLoc) { ilGenerator .Do(pushReader) .Callvirt(() => default(ByteArrayReader).GetCurrentPosition()) .Stloc(positionLoc); }
public void GenerateTypeIterator(IILGen ilGenerator, Action <IILGen> pushObj, Action <IILGen> pushCtx, Type type) { var finish = ilGenerator.DefineLabel(); var next = ilGenerator.DefineLabel(); var itemType = _listTypeDescriptor._typeSerializers.LoadAsType(_listTypeDescriptor._itemDescriptor); var localList = ilGenerator.DeclareLocal(typeof(IList <>).MakeGenericType(itemType)); var localIndex = ilGenerator.DeclareLocal(typeof(int)); var localCount = ilGenerator.DeclareLocal(typeof(int)); ilGenerator .Do(pushObj) .Castclass(localList.LocalType) .Stloc(localList) .Ldloc(localList) .Callvirt(localList.LocalType.GetInterface("ICollection`1").GetProperty("Count").GetGetMethod()) .Stloc(localCount) .LdcI4(0) .Stloc(localIndex) .Mark(next) .Ldloc(localIndex) .Ldloc(localCount) .BgeUn(finish) .Do(pushCtx) .Ldloc(localList) .Ldloc(localIndex) .Callvirt(localList.LocalType.GetMethod("get_Item")) .Callvirt(() => default(IDescriptorSerializerLiteContext).StoreNewDescriptors(null)) .Ldloc(localIndex) .LdcI4(1) .Add() .Stloc(localIndex) .Br(next) .Mark(finish); }
void MemorizeCurrentPosition(IILGen ilGenerator, Action <IILGen> pushReader, IILLocal memoPositionLoc) { ilGenerator .Do(pushReader) .Call(() => default(ByteArrayReader).MemorizeCurrentPosition()) .Stloc(memoPositionLoc); }
public void Load(IILGen ilGenerator, Action <IILGen> pushReaderOrCtx) { if (_indirect) { ilGenerator .Do(pushReaderOrCtx) .Call(typeof(DBIndirect <>).MakeGenericType(_type).GetMethod("LoadImpl")); return; } ilGenerator .Do(pushReaderOrCtx) .Callvirt(() => default(IReaderCtx).ReadNativeObject()); var type = HandledType(); ilGenerator.Do(_objectDB.TypeConvertorGenerator.GenerateConversion(typeof(object), type)); }
public void Skip(IILGen ilGenerator, Action <IILGen> pushReader, Action <IILGen> pushCtx) { ilGenerator .Do(pushCtx) .Do(pushReader) .Callvirt(typeof(IReaderCtx).GetMethod(nameof(IReaderCtx.SkipNativeObject)) !); }
public void GenerateLoad(IILGen ilGenerator, Action <IILGen> pushReader, Action <IILGen> pushCtx, Action <IILGen> pushDescriptor, Type targetType) { pushReader(ilGenerator); Type typeRead; if (_signed) { ilGenerator.Call(() => default(AbstractBufferedReader).ReadVInt64()); typeRead = typeof(long); } else { ilGenerator.Call(() => default(AbstractBufferedReader).ReadVUInt64()); typeRead = typeof(ulong); } if (targetType == typeof(object)) { ilGenerator.Do(pushDescriptor); if (_signed) { ilGenerator.Newobj(() => new DynamicEnum(0L, null)); } else { ilGenerator.Newobj(() => new DynamicEnum(0UL, null)); } ilGenerator.Castclass(typeof(object)); return; } new DefaultTypeConvertorGenerator().GenerateConversion(typeRead, targetType.GetEnumUnderlyingType())(ilGenerator); }
public void Save(IILGen ilGenerator, Action <IILGen> pushWriter, Action <IILGen> pushCtx, Action <IILGen> pushValue) { var realFinish = ilGenerator.DefineLabel(); var finish = ilGenerator.DefineLabel(); var next = ilGenerator.DefineLabel(); var localValue = ilGenerator.DeclareLocal(_type !); var typeAsICollection = _type.GetInterface("ICollection`1"); var typeAsIEnumerable = _type.GetInterface("IEnumerable`1"); var getEnumeratorMethod = typeAsIEnumerable !.GetMethod("GetEnumerator"); var typeAsIEnumerator = getEnumeratorMethod !.ReturnType; var typeKeyValuePair = typeAsICollection !.GetGenericArguments()[0]; var localEnumerator = ilGenerator.DeclareLocal(typeAsIEnumerator); var localPair = ilGenerator.DeclareLocal(typeKeyValuePair); ilGenerator .Do(pushValue) .Stloc(localValue) .Do(pushCtx) .Do(pushWriter) .Ldloc(localValue) .Castclass(typeof(object)) .Callvirt(typeof(IWriterCtx).GetMethod(nameof(IWriterCtx.WriteObject)) !) .Brfalse(realFinish) .Do(pushWriter) .Ldloc(localValue) .Callvirt(typeAsICollection.GetProperty("Count") !.GetGetMethod() !) .ConvU4() .Call(typeof(SpanWriter).GetMethod(nameof(SpanWriter.WriteVUInt32)) !) .Ldloc(localValue) .Callvirt(getEnumeratorMethod) .Stloc(localEnumerator) .Try() .Mark(next) .Ldloc(localEnumerator) .Callvirt(() => default(IEnumerator).MoveNext()) .Brfalse(finish) .Ldloc(localEnumerator) .Callvirt(typeAsIEnumerator.GetProperty("Current") !.GetGetMethod() !) .Stloc(localPair); var keyAndValueTypes = _type.GetGenericArguments(); _keysHandler.Save(ilGenerator, pushWriter, pushCtx, il => il .Ldloca(localPair) .Call(typeKeyValuePair.GetProperty("Key") !.GetGetMethod() !) .Do(_typeConvertGenerator.GenerateConversion(keyAndValueTypes[0], _keysHandler.HandledType()) !)); _valuesHandler.Save(ilGenerator, pushWriter, pushCtx, il => il .Ldloca(localPair) .Call(typeKeyValuePair.GetProperty("Value") !.GetGetMethod() !) .Do(_typeConvertGenerator.GenerateConversion(keyAndValueTypes[1], _valuesHandler.HandledType()) !)); ilGenerator .Br(next) .Mark(finish) .Finally() .Ldloc(localEnumerator) .Callvirt(() => default(IDisposable).Dispose()) .EndTry() .Mark(realFinish); }
public void Save(IILGen ilGenerator, Action<IILGen> pushWriterOrCtx, Action<IILGen> pushValue) { ilGenerator .Do(pushWriterOrCtx) .Do(pushValue) .Do(_service.TypeConvertorGenerator.GenerateConversion(HandledType(), typeof(object))) .Callvirt(() => default(IWriterCtx).WriteNativeObject(null)); }
public void Save(IILGen ilGenerator, Action <IILGen> pushWriterOrCtx, Action <IILGen> pushValue) { ilGenerator .Do(pushWriterOrCtx) .Do(pushValue) .Do(_service.TypeConvertorGenerator.GenerateConversion(HandledType(), typeof(object))) .Callvirt(() => default(IWriterCtx).WriteNativeObject(null)); }
public void Load(IILGen ilGenerator, Action <IILGen> pushReader, Action <IILGen> pushCtx) { if (_indirect) { ilGenerator .Do(pushReader) .Do(pushCtx) .Call(typeof(DBIndirect <>).MakeGenericType(_type !).GetMethod(nameof(DBIndirect <object> .LoadImpl)) !); return; } ilGenerator .Do(pushCtx) .Do(pushReader) .Callvirt(typeof(IReaderCtx).GetMethod(nameof(IReaderCtx.ReadNativeObject)) !); var type = HandledType(); ilGenerator.Do(_objectDb.TypeConvertorGenerator.GenerateConversion(typeof(object), type) !); }
static void WriteShortPrefixIl(IILGen ilGenerator, Action <IILGen> pushWriter, byte[] prefix) { foreach (byte b in prefix) { ilGenerator .Do(pushWriter) .LdcI4(b) .Call(() => default(AbstractBufferedWriter).WriteUInt8(0)); } }
public bool FreeContent(IILGen ilGenerator, Action<IILGen> pushReaderOrCtx) { var tableInfo = ((ObjectDB) _objectDB).TablesInfo.FindByType(HandledType()); //decides upon current version (null for object types never stored in DB) var needsContent = tableInfo == null || tableInfo.GetFreeContent(tableInfo.ClientTypeVersion).Item1; ilGenerator .Do(pushReaderOrCtx) .Callvirt(() => default(IReaderCtx).FreeContentInNativeObject()); return needsContent; }
public void Save(IILGen ilGenerator, Action <IILGen> pushWriter, Action <IILGen> pushCtx, Action <IILGen> pushValue) { if (_indirect) { ilGenerator .Do(pushWriter) .Do(pushCtx) .Do(pushValue) .Call(typeof(DBIndirect <>).MakeGenericType(_type !).GetMethod(nameof(DBIndirect <object> .SaveImpl)) !); return; } ilGenerator .Do(pushCtx) .Do(pushWriter) .Do(pushValue) .Do(_objectDb.TypeConvertorGenerator.GenerateConversion(HandledType(), typeof(object)) !) .Callvirt(typeof(IWriterCtx).GetMethod(nameof(IWriterCtx.WriteNativeObject)) !); }
public void Save(IILGen ilGenerator, Action <IILGen> pushWriterOrCtx, Action <IILGen> pushValue) { var realfinish = ilGenerator.DefineLabel(); var finish = ilGenerator.DefineLabel(); var next = ilGenerator.DefineLabel(); var localValue = ilGenerator.DeclareLocal(_type); var typeAsICollection = _type.GetInterface("ICollection`1"); var typeAsIEnumerable = _type.GetInterface("IEnumerable`1"); var getEnumeratorMethod = typeAsIEnumerable.GetMethod("GetEnumerator"); var typeAsIEnumerator = getEnumeratorMethod.ReturnType; var typeKeyValuePair = typeAsICollection.GetGenericArguments()[0]; var localEnumerator = ilGenerator.DeclareLocal(typeAsIEnumerator); var localPair = ilGenerator.DeclareLocal(typeKeyValuePair); ilGenerator .Do(pushValue) .Stloc(localValue) .Do(pushWriterOrCtx) .Ldloc(localValue) .Castclass(typeof(object)) .Callvirt(() => default(IWriterCtx).WriteObject(null)) .Brfalse(realfinish) .Do(Extensions.PushWriterFromCtx(pushWriterOrCtx)) .Ldloc(localValue) .Callvirt(typeAsICollection.GetProperty("Count").GetGetMethod()) .ConvU4() .Callvirt(() => default(AbstractBufferedWriter).WriteVUInt32(0)) .Ldloc(localValue) .Callvirt(getEnumeratorMethod) .Stloc(localEnumerator) .Try() .Mark(next) .Ldloc(localEnumerator) .Callvirt(() => default(IEnumerator).MoveNext()) .Brfalse(finish) .Ldloc(localEnumerator) .Callvirt(typeAsIEnumerator.GetProperty("Current").GetGetMethod()) .Stloc(localPair); _keysHandler.Save(ilGenerator, Extensions.PushWriterOrCtxAsNeeded(pushWriterOrCtx, _keysHandler.NeedsCtx()), il => il .Ldloca(localPair) .Call(typeKeyValuePair.GetProperty("Key").GetGetMethod()) .Do(_typeConvertorGenerator.GenerateConversion(_type.GetGenericArguments()[0], _keysHandler.HandledType()))); _valuesHandler.Save(ilGenerator, Extensions.PushWriterOrCtxAsNeeded(pushWriterOrCtx, _valuesHandler.NeedsCtx()), il => il .Ldloca(localPair) .Call(typeKeyValuePair.GetProperty("Value").GetGetMethod()) .Do(_typeConvertorGenerator.GenerateConversion(_type.GetGenericArguments()[1], _valuesHandler.HandledType()))); ilGenerator .Br(next) .Mark(finish) .Finally() .Ldloc(localEnumerator) .Callvirt(() => default(IDisposable).Dispose()) .EndTry() .Mark(realfinish); }
public bool FreeContent(IILGen ilGenerator, Action <IILGen> pushReaderOrCtx) { var fakeMethod = ILBuilder.Instance.NewMethod <Action>("Relation_fake"); var fakeGenerator = fakeMethod.Generator; if (_keysHandler.FreeContent(fakeGenerator, _ => { })) { throw new BTDBException("Not supported IDictionary in IDictionary key"); } var containsNestedIDictionaries = _valuesHandler.FreeContent(fakeGenerator, _ => { }); if (!containsNestedIDictionaries) { ilGenerator .Do(pushReaderOrCtx) .Castclass(typeof(IDBReaderCtx)) .Do(Extensions.PushReaderFromCtx(pushReaderOrCtx)) .Callvirt(() => default(AbstractBufferedReader).ReadVUInt64()) .Callvirt(() => default(IDBReaderCtx).RegisterDict(0ul)); } else { var genericArguments = _type.GetGenericArguments(); var instanceType = typeof(ODBDictionary <,>).MakeGenericType(genericArguments); var dictId = ilGenerator.DeclareLocal(typeof(ulong)); ilGenerator .Do(pushReaderOrCtx) .Castclass(typeof(IDBReaderCtx)) .Do(Extensions.PushReaderFromCtx(pushReaderOrCtx)) .Callvirt(() => default(AbstractBufferedReader).ReadVUInt64()) .Stloc(dictId) .Ldloc(dictId) .Callvirt(() => default(IDBReaderCtx).RegisterDict(0ul)) .Do(pushReaderOrCtx) .Ldloc(dictId) .LdcI4(_configurationId) //ODBDictionary.DoFreeContent(IReaderCtx ctx, ulong id, int cfgId) .Call(instanceType.GetMethod("DoFreeContent")); } return(true); }
public void Skip(IILGen ilGenerator, Action <IILGen> pushReader, Action <IILGen>?pushCtx) { var finish = ilGenerator.DefineLabel(); ilGenerator .Do(pushReader) .Call(typeof(SpanReader).GetMethod(nameof(SpanReader.ReadBool)) !) .Brfalse(finish) .GenerateSkip(_itemHandler, pushReader, pushCtx) .Mark(finish); }
public bool FreeContent(IILGen ilGenerator, Action <IILGen> pushReaderOrCtx) { var tableInfo = ((ObjectDB)_objectDB).TablesInfo.FindByType(HandledType()); //decides upon current version (null for object types never stored in DB) var needsContent = tableInfo == null || tableInfo.GetFreeContent(tableInfo.ClientTypeVersion).Item1; ilGenerator .Do(pushReaderOrCtx) .Callvirt(() => default(IReaderCtx).FreeContentInNativeObject()); return(needsContent); }
public void Save(IILGen ilGenerator, Action <IILGen> pushWriterOrCtx, Action <IILGen> pushValue) { var genericArguments = _type.GetGenericArguments(); var instanceType = typeof(ODBDictionary <,>).MakeGenericType(genericArguments); ilGenerator .Do(pushWriterOrCtx) .Do(pushValue) .LdcI4(_configurationId) .Call(instanceType.GetMethod("DoSave")); }
public NeedsFreeContent FreeContent(IILGen ilGenerator, Action <IILGen> pushReader, Action <IILGen> pushCtx) { var fakeMethod = ILBuilder.Instance.NewMethod <Action>("Relation_fake"); var fakeGenerator = fakeMethod.Generator; if (_keysHandler.FreeContent(fakeGenerator, _ => { }, _ => { }) == NeedsFreeContent.Yes) { throw new BTDBException("Not supported 'free content' in IDictionary key"); } if (_valuesHandler.FreeContent(fakeGenerator, _ => { }, _ => { }) == NeedsFreeContent.No) { ilGenerator .Do(pushCtx) .Castclass(typeof(IDBReaderCtx)) .Do(pushReader) .Call(typeof(SpanReader).GetMethod(nameof(SpanReader.ReadVUInt64)) !) .Callvirt(() => default(IDBReaderCtx).RegisterDict(0ul)); } else { var genericArguments = _type !.GetGenericArguments(); var instanceType = typeof(ODBDictionary <,>).MakeGenericType(genericArguments); var dictId = ilGenerator.DeclareLocal(typeof(ulong)); ilGenerator .Do(pushCtx) .Castclass(typeof(IDBReaderCtx)) .Do(pushReader) .Call(typeof(SpanReader).GetMethod(nameof(SpanReader.ReadVUInt64)) !) .Stloc(dictId) .Ldloc(dictId) .Callvirt(() => default(IDBReaderCtx).RegisterDict(0ul)) .Do(pushCtx) .Ldloc(dictId) .LdcI4(GetConfigurationId(_type)) //ODBDictionary.DoFreeContent(IReaderCtx ctx, ulong id, int cfgId) .Call(instanceType.GetMethod(nameof(ODBDictionary <int, int> .DoFreeContent)) !); } return(NeedsFreeContent.Yes); }
public void GenerateSkip(IILGen ilGenerator, Action <IILGen> pushReader, Action <IILGen> pushCtx) { var finish = ilGenerator.DefineLabel(); ilGenerator .Do(pushReader) .Callvirt(() => default(AbstractBufferedReader).ReadBool()) .Brfalse(finish); _itemDescriptor.GenerateSkipEx(ilGenerator, pushReader, pushCtx); ilGenerator .Mark(finish); }
public void Save(IILGen ilGenerator, Action <IILGen> pushWriter, Action <IILGen> pushCtx, Action <IILGen> pushValue) { var genericArguments = _type !.GetGenericArguments(); var instanceType = typeof(ODBSet <>).MakeGenericType(genericArguments); ilGenerator .Do(pushWriter) .Do(pushCtx) .Do(pushValue) .LdcI4(_configurationId) .Call(instanceType.GetMethod(nameof(ODBSet <int> .DoSave)) !); }
public static void GenerateSkipEx(this ITypeDescriptor descriptor, IILGen ilGenerator, Action<IILGen> pushReader, Action<IILGen> pushCtx) { if (descriptor.StoredInline) { descriptor.GenerateSkip(ilGenerator, pushReader, pushCtx); } else { ilGenerator .Do(pushCtx) .Callvirt(() => default(ITypeBinaryDeserializerContext).SkipObject()); } }
public static void GenerateSaveEx(this ITypeDescriptor descriptor, IILGen ilGenerator, Action<IILGen> pushWriter, Action<IILGen> pushCtx, Action<IILGen> pushSubValue, Type subValueType) { if (descriptor.StoredInline) { descriptor.GenerateSave(ilGenerator, pushWriter, pushCtx, pushSubValue, subValueType); } else { ilGenerator .Do(pushCtx) .Do(pushSubValue) .Callvirt(() => default(ITypeBinarySerializerContext).StoreObject(null)); } }
public static void GenerateLoadEx(this ITypeDescriptor descriptor, IILGen ilGenerator, Action<IILGen> pushReader, Action<IILGen> pushCtx, Action<IILGen> pushDescriptor, Type asType) { if (descriptor.StoredInline) { descriptor.GenerateLoad(ilGenerator, pushReader, pushCtx, pushDescriptor, asType); } else { ilGenerator .Do(pushCtx) .Callvirt(() => default(ITypeBinaryDeserializerContext).LoadObject()); if (asType != typeof(object)) ilGenerator.Castclass(asType); } }
public void Load(IILGen ilGenerator, Action<IILGen> pushReaderOrCtx) { var localCount = ilGenerator.DeclareLocal(typeof(uint)); var localResultOfObject = ilGenerator.DeclareLocal(typeof(object)); var localResult = ilGenerator.DeclareLocal(HandledType()); var loadSkipped = ilGenerator.DefineLabel(); var loadFinished = ilGenerator.DefineLabel(); var finish = ilGenerator.DefineLabel(); var next = ilGenerator.DefineLabel(); object fake; ilGenerator .Do(pushReaderOrCtx) .Ldloca(localResultOfObject) .Callvirt(() => default(IReaderCtx).ReadObject(out fake)) .Brfalse(loadSkipped) .Do(Extensions.PushReaderFromCtx(pushReaderOrCtx)) .Callvirt(() => default(AbstractBufferedReader).ReadVUInt32()) .Stloc(localCount) .Ldloc(localCount) .Newobj(typeof(List<>).MakeGenericType(_type.GetGenericArguments()[0]).GetConstructor(new[] { typeof(int) })) .Stloc(localResult) .Do(pushReaderOrCtx) .Ldloc(localResult) .Castclass(typeof(object)) .Callvirt(() => default(IReaderCtx).RegisterObject(null)) .Mark(next) .Ldloc(localCount) .Brfalse(loadFinished) .Ldloc(localCount) .LdcI4(1) .Sub() .ConvU4() .Stloc(localCount) .Ldloc(localResult) .GenerateLoad(_itemsHandler, _type.GetGenericArguments()[0], pushReaderOrCtx, _typeConvertorGenerator) .Callvirt(_type.GetInterface("ICollection`1").GetMethod("Add")) .Br(next) .Mark(loadFinished) .Do(pushReaderOrCtx) .Callvirt(() => default(IReaderCtx).ReadObjectDone()) .Br(finish) .Mark(loadSkipped) .Ldloc(localResultOfObject) .Isinst(_type) .Stloc(localResult) .Mark(finish) .Ldloc(localResult); }
public void Save(IILGen ilGenerator, Action<IILGen> pushWriterOrCtx, Action<IILGen> pushValue) { var finish = ilGenerator.DefineLabel(); var next = ilGenerator.DefineLabel(); var localValue = ilGenerator.DeclareLocal(_type); var localIndex = ilGenerator.DeclareLocal(typeof(int)); var localCount = ilGenerator.DeclareLocal(typeof(int)); ilGenerator .Do(pushValue) .Stloc(localValue) .Do(pushWriterOrCtx) .Ldloc(localValue) .Castclass(typeof(object)) .Callvirt(() => default(IWriterCtx).WriteObject(null)) .Brfalse(finish) .Ldloc(localValue) .Callvirt(_type.GetInterface("ICollection`1").GetProperty("Count").GetGetMethod()) .Stloc(localCount) .Do(Extensions.PushWriterFromCtx(pushWriterOrCtx)) .Ldloc(localCount) .ConvU4() .Callvirt(() => default(AbstractBufferedWriter).WriteVUInt32(0)) .Mark(next) .Ldloc(localIndex) .Ldloc(localCount) .BgeUn(finish); _itemsHandler.Save(ilGenerator, Extensions.PushWriterOrCtxAsNeeded(pushWriterOrCtx, _itemsHandler.NeedsCtx()), il => il .Ldloc(localValue) .Ldloc(localIndex) .Callvirt(_type.GetMethod("get_Item")) .Do(_typeConvertorGenerator.GenerateConversion(_type.GetGenericArguments()[0], _itemsHandler.HandledType()))); ilGenerator .Ldloc(localIndex) .LdcI4(1) .Add() .Stloc(localIndex) .Br(next) .Mark(finish); }
public void Skip(IILGen ilGenerator, Action<IILGen> pushReaderOrCtx) { var localCount = ilGenerator.DeclareLocal(typeof(uint)); var finish = ilGenerator.DefineLabel(); var next = ilGenerator.DefineLabel(); ilGenerator .Do(pushReaderOrCtx) .Callvirt(() => ((IReaderCtx)null).SkipObject()) .Brfalse(finish) .Do(Extensions.PushReaderFromCtx(pushReaderOrCtx)) .Callvirt(() => ((AbstractBufferedReader)null).ReadVUInt32()) .Stloc(localCount) .Mark(next) .Ldloc(localCount) .Brfalse(finish) .Ldloc(localCount) .LdcI4(1) .Sub() .ConvU4() .Stloc(localCount) .GenerateSkip(_keysHandler, pushReaderOrCtx) .GenerateSkip(_valuesHandler, pushReaderOrCtx) .Br(next) .Mark(finish); }
public void GenerateLoad(IILGen ilGenerator, Action<IILGen> pushReader, Action<IILGen> pushCtx, Action<IILGen> pushDescriptor, Type targetType) { var localCount = ilGenerator.DeclareLocal(typeof(int)); var targetIDictionary = targetType.GetInterface("IDictionary`2") ?? targetType; var targetTypeArguments = targetIDictionary.GetGenericArguments(); var keyType = _typeSerializers.LoadAsType(_keyDescriptor, targetTypeArguments[0]); var valueType = _typeSerializers.LoadAsType(_valueDescriptor, targetTypeArguments[1]); var dictionaryType = typeof(DictionaryWithDescriptor<,>).MakeGenericType(keyType, valueType); if (!targetType.IsAssignableFrom(dictionaryType)) throw new InvalidOperationException(); var localDict = ilGenerator.DeclareLocal(dictionaryType); var loadFinished = ilGenerator.DefineLabel(); var next = ilGenerator.DefineLabel(); ilGenerator .Do(pushReader) .Callvirt(() => default(AbstractBufferedReader).ReadVUInt32()) .ConvI4() .Dup() .LdcI4(1) .Sub() .Stloc(localCount) .Brfalse(loadFinished) .Ldloc(localCount) .Do(pushDescriptor) .Newobj(dictionaryType.GetConstructor(new[] { typeof(int), typeof(ITypeDescriptor) })) .Stloc(localDict) .Mark(next) .Ldloc(localCount) .Brfalse(loadFinished) .Ldloc(localCount) .LdcI4(1) .Sub() .Stloc(localCount) .Ldloc(localDict); _keyDescriptor.GenerateLoadEx(ilGenerator, pushReader, pushCtx, il => il.Do(pushDescriptor).LdcI4(0).Callvirt(() => default(ITypeDescriptor).NestedType(0)), keyType, _convertorGenerator); _valueDescriptor.GenerateLoadEx(ilGenerator, pushReader, pushCtx, il => il.Do(pushDescriptor).LdcI4(1).Callvirt(() => default(ITypeDescriptor).NestedType(0)), valueType, _convertorGenerator); ilGenerator .Callvirt(dictionaryType.GetMethod("Add")) .Br(next) .Mark(loadFinished) .Ldloc(localDict) .Castclass(targetType); }
public void Skip(IILGen ilGenerator, Action<IILGen> pushReaderOrCtx) { ilGenerator .Do(pushReaderOrCtx) .Callvirt(() => default(IReaderCtx).SkipNativeObject()); }
public void GenerateTypeIterator(IILGen ilGenerator, Action<IILGen> pushObj, Action<IILGen> pushCtx) { var finish = ilGenerator.DefineLabel(); var next = ilGenerator.DefineLabel(); var itemType = _listTypeDescriptor._typeSerializers.LoadAsType(_listTypeDescriptor._itemDescriptor); var localList = ilGenerator.DeclareLocal(typeof(IList<>).MakeGenericType(itemType)); var localIndex = ilGenerator.DeclareLocal(typeof(int)); var localCount = ilGenerator.DeclareLocal(typeof(int)); ilGenerator .Do(pushObj) .Castclass(localList.LocalType) .Dup() .Stloc(localList) .Callvirt(localList.LocalType.GetInterface("ICollection`1").GetProperty("Count").GetGetMethod()) .Stloc(localCount) .LdcI4(0) .Stloc(localIndex) .Mark(next) .Ldloc(localIndex) .Ldloc(localCount) .BgeUn(finish) .Do(pushCtx) .Ldloc(localList) .Ldloc(localIndex) .Callvirt(localList.LocalType.GetMethod("get_Item")) .Callvirt(() => default(IDescriptorSerializerLiteContext).StoreNewDescriptors(null)) .Ldloc(localIndex) .LdcI4(1) .Add() .Stloc(localIndex) .Br(next) .Mark(finish); }
public void GenerateLoad(IILGen ilGenerator, Action<IILGen> pushReader, Action<IILGen> pushCtx, Action<IILGen> pushDescriptor, Type targetType) { pushReader(ilGenerator); Type typeRead; if (_signed) { ilGenerator.Call(() => default(AbstractBufferedReader).ReadVInt64()); typeRead = typeof(long); } else { ilGenerator.Call(() => default(AbstractBufferedReader).ReadVUInt64()); typeRead = typeof(ulong); } if (targetType == typeof(object)) { ilGenerator.Do(pushDescriptor); if (_signed) { ilGenerator.Newobj(() => new DynamicEnum(0L, null)); } else { ilGenerator.Newobj(() => new DynamicEnum(0UL, null)); } ilGenerator.Castclass(typeof(object)); return; } new DefaultTypeConvertorGenerator().GenerateConversion(typeRead, targetType.GetEnumUnderlyingType())(ilGenerator); }
public void GenerateLoad(IILGen ilGenerator, Action<IILGen> pushReader, Action<IILGen> pushCtx, Action<IILGen> pushDescriptor, Type targetType) { if (targetType == typeof(object)) { var resultLoc = ilGenerator.DeclareLocal(typeof(DynamicObject), "result"); var labelNoCtx = ilGenerator.DefineLabel(); ilGenerator .Do(pushDescriptor) .Castclass(typeof(ObjectTypeDescriptor)) .Newobj(typeof(DynamicObject).GetConstructor(new[] { typeof(ObjectTypeDescriptor) })) .Stloc(resultLoc) .Do(pushCtx) .BrfalseS(labelNoCtx) .Do(pushCtx) .Ldloc(resultLoc) .Callvirt(() => default(ITypeBinaryDeserializerContext).AddBackRef(null)) .Mark(labelNoCtx); var idx = 0; foreach (var pair in _fields) { var idxForCapture = idx; ilGenerator.Ldloc(resultLoc); ilGenerator.LdcI4(idx); pair.Value.GenerateLoadEx(ilGenerator, pushReader, pushCtx, il => il.Do(pushDescriptor) .LdcI4(idxForCapture) .Callvirt(() => default(ITypeDescriptor).NestedType(0)), typeof(object), _typeSerializers.ConvertorGenerator); ilGenerator.Callvirt(() => default(DynamicObject).SetFieldByIdxFast(0, null)); idx++; } ilGenerator .Ldloc(resultLoc) .Castclass(typeof(object)); } else { var resultLoc = ilGenerator.DeclareLocal(targetType, "result"); var labelNoCtx = ilGenerator.DefineLabel(); ilGenerator .Newobj(targetType.GetConstructor(Type.EmptyTypes)) .Stloc(resultLoc) .Do(pushCtx) .BrfalseS(labelNoCtx) .Do(pushCtx) .Ldloc(resultLoc) .Callvirt(() => default(ITypeBinaryDeserializerContext).AddBackRef(null)) .Mark(labelNoCtx); var props = targetType.GetProperties(); for (var idx = 0; idx < _fields.Count; idx++) { var idxForCapture = idx; var pair = _fields[idx]; var prop = props.FirstOrDefault(p => GetPersitentName(p) == pair.Key); if (prop == null || !_typeSerializers.IsSafeToLoad(prop.PropertyType)) { pair.Value.GenerateSkipEx(ilGenerator, pushReader, pushCtx); continue; } ilGenerator.Ldloc(resultLoc); pair.Value.GenerateLoadEx(ilGenerator, pushReader, pushCtx, il => il.Do(pushDescriptor).LdcI4(idxForCapture).Callvirt(() => default(ITypeDescriptor).NestedType(0)), prop.PropertyType, _typeSerializers.ConvertorGenerator); ilGenerator.Callvirt(prop.GetSetMethod()); } ilGenerator.Ldloc(resultLoc); } }
public void GenerateSave(IILGen ilGenerator, Action<IILGen> pushWriter, Action<IILGen> pushCtx, Action<IILGen> pushValue, Type valueType) { if (GetPreferedType() != valueType) throw new ArgumentException("value type does not match my type"); var locValue = ilGenerator.DeclareLocal(_type, "value"); ilGenerator .Do(pushValue) .Stloc(locValue); foreach (var pairi in _fields) { var pair = pairi; var methodInfo = _type.GetProperties().First(p => GetPersitentName(p) == pair.Key).GetGetMethod(); pair.Value.GenerateSaveEx(ilGenerator, pushWriter, pushCtx, il => il.Ldloc(locValue).Callvirt(methodInfo), methodInfo.ReturnType); } }
public void GenerateTypeIterator(IILGen ilGenerator, Action<IILGen> pushObj, Action<IILGen> pushCtx, Type type) { var allProps = _objectTypeDescriptor.GetPreferedType().GetProperties(); foreach (var pair in _objectTypeDescriptor._fields) { if (pair.Value.Sealed) continue; ilGenerator .Do(pushCtx) .Do(pushObj) .Castclass(_objectTypeDescriptor._type) .Callvirt(allProps.First(p => GetPersitentName(p) == pair.Key).GetGetMethod()) .Callvirt(() => default(IDescriptorSerializerLiteContext).StoreNewDescriptors(null)); } }
public void GenerateSkip(IILGen ilGenerator, Action<IILGen> pushReader, Action<IILGen> pushCtx) { var localCount = ilGenerator.DeclareLocal(typeof(uint)); var skipFinished = ilGenerator.DefineLabel(); var next = ilGenerator.DefineLabel(); ilGenerator .Do(pushReader) .Callvirt(() => default(AbstractBufferedReader).ReadVUInt32()) .Stloc(localCount) .Ldloc(localCount) .Brfalse(skipFinished) .Mark(next) .Ldloc(localCount) .LdcI4(1) .Sub() .Stloc(localCount) .Ldloc(localCount) .Brfalse(skipFinished); _keyDescriptor.GenerateSkipEx(ilGenerator, pushReader, pushCtx); _valueDescriptor.GenerateSkipEx(ilGenerator, pushReader, pushCtx); ilGenerator .Br(next) .Mark(skipFinished); }
public void GenerateLoad(IILGen ilGenerator, Action<IILGen> pushReader, Action<IILGen> pushCtx, Action<IILGen> pushDescriptor, Type targetType) { var localCount = ilGenerator.DeclareLocal(typeof(int)); var itemType = _typeSerializers.LoadAsType(_itemDescriptor); var listType = typeof(ListWithDescriptor<>).MakeGenericType(itemType); if (!targetType.IsAssignableFrom(listType)) throw new NotSupportedException(); var localList = ilGenerator.DeclareLocal(listType); var loadFinished = ilGenerator.DefineLabel(); var next = ilGenerator.DefineLabel(); ilGenerator .Do(pushReader) .Callvirt(() => default(AbstractBufferedReader).ReadVUInt32()) .ConvI4() .Dup() .Stloc(localCount) .Brfalse(loadFinished) .Ldloc(localCount) .LdcI4(1) .Sub() .Dup() .Stloc(localCount) .Do(pushDescriptor) .Newobj(listType.GetConstructor(new[] { typeof(int), typeof(ITypeDescriptor) })) .Stloc(localList) .Mark(next) .Ldloc(localCount) .Brfalse(loadFinished) .Ldloc(localCount) .LdcI4(1) .Sub() .Stloc(localCount) .Ldloc(localList); _itemDescriptor.GenerateLoadEx(ilGenerator, pushReader, pushCtx, il => il.Do(pushDescriptor).LdcI4(0).Callvirt(() => default(ITypeDescriptor).NestedType(0)), itemType); ilGenerator .Callvirt(listType.GetInterface("ICollection`1").GetMethod("Add")) .Br(next) .Mark(loadFinished) .Ldloc(localList) .Castclass(targetType); }
public void Skip(IILGen ilGenerator, Action<IILGen> pushReaderOrCtx) { // TODO register dict id for deletion ilGenerator .Do(Extensions.PushReaderFromCtx(pushReaderOrCtx)) .Callvirt(() => default(AbstractBufferedReader).SkipVUInt64()); }
public void GenerateSave(IILGen ilGenerator, Action<IILGen> pushWriter, Action<IILGen> pushCtx, Action<IILGen> pushValue, Type valueType) { var finish = ilGenerator.DefineLabel(); var next = ilGenerator.DefineLabel(); var notnull = ilGenerator.DefineLabel(); var itemType = GetItemType(valueType); var localList = ilGenerator.DeclareLocal( typeof(IList<>).MakeGenericType(itemType)); var localIndex = ilGenerator.DeclareLocal(typeof(int)); var localCount = ilGenerator.DeclareLocal(typeof(int)); ilGenerator .Do(pushValue) .Castclass(localList.LocalType) .Dup() .Stloc(localList) .BrtrueS(notnull) .Do(pushWriter) .LdcI4(0) .Callvirt(() => default(AbstractBufferedWriter).WriteVUInt32(0)) .Br(finish) .Mark(notnull) .Ldloc(localList) .Callvirt(localList.LocalType.GetInterface("ICollection`1").GetProperty("Count").GetGetMethod()) .Stloc(localCount) .Do(pushWriter) .Ldloc(localCount) .LdcI4(1) .Add() .ConvU4() .Callvirt(() => default(AbstractBufferedWriter).WriteVUInt32(0)) .LdcI4(0) .Stloc(localIndex) .Mark(next) .Ldloc(localIndex) .Ldloc(localCount) .BgeUn(finish); _itemDescriptor.GenerateSaveEx(ilGenerator, pushWriter, pushCtx, il => il.Ldloc(localList) .Ldloc(localIndex) .Callvirt(localList.LocalType.GetMethod("get_Item")), itemType); ilGenerator .Ldloc(localIndex) .LdcI4(1) .Add() .Stloc(localIndex) .Br(next) .Mark(finish); }
public void Save(IILGen ilGenerator, Action<IILGen> pushWriterOrCtx, Action<IILGen> pushValue) { var genericArguments = _type.GetGenericArguments(); var instanceType = typeof(ODBDictionary<,>).MakeGenericType(genericArguments); ilGenerator .Do(pushWriterOrCtx) .Do(pushValue) .LdcI4(_configurationId) .Call(instanceType.GetMethod("DoSave")); }
public void Save(IILGen ilGenerator, Action<IILGen> pushWriterOrCtx, Action<IILGen> pushValue) { if (_indirect) { ilGenerator .Do(pushWriterOrCtx) .Do(pushValue) .Call(typeof(DBIndirect<>).MakeGenericType(_type).GetMethod("SaveImpl")); return; } ilGenerator .Do(pushWriterOrCtx) .Do(pushValue) .Do(_objectDB.TypeConvertorGenerator.GenerateConversion(HandledType(), typeof(object))) .Callvirt(() => default(IWriterCtx).WriteNativeObject(null)); }
public void Load(IILGen ilGenerator, Action<IILGen> pushReaderOrCtx) { var genericArguments = _type.GetGenericArguments(); var instanceType = typeof(ODBDictionary<,>).MakeGenericType(genericArguments); var constructorInfo = instanceType.GetConstructor( new[] { typeof(IInternalObjectDBTransaction), typeof(ODBDictionaryConfiguration), typeof(ulong) }); ilGenerator .Do(pushReaderOrCtx) .Castclass(typeof(IDBReaderCtx)) .Callvirt(() => default(IDBReaderCtx).GetTransaction()) .Do(pushReaderOrCtx) .Castclass(typeof(IDBReaderCtx)) .LdcI4(_configurationId) .Callvirt(() => default(IDBReaderCtx).FindInstance(0)) .Castclass(typeof(ODBDictionaryConfiguration)) .Do(Extensions.PushReaderFromCtx(pushReaderOrCtx)) .Callvirt(() => default(AbstractBufferedReader).ReadVUInt64()) .Newobj(constructorInfo) .Castclass(_type); }
public void Load(IILGen ilGenerator, Action<IILGen> pushReaderOrCtx) { if (_indirect) { ilGenerator .Do(pushReaderOrCtx) .Call(typeof (DBIndirect<>).MakeGenericType(_type).GetMethod("LoadImpl")); return; } ilGenerator .Do(pushReaderOrCtx) .Callvirt(() => default(IReaderCtx).ReadNativeObject()); var type = HandledType(); ilGenerator.Do(_objectDB.TypeConvertorGenerator.GenerateConversion(typeof(object), type)); }
public bool FreeContent(IILGen ilGenerator, Action<IILGen> pushReaderOrCtx) { var fakeMethod = ILBuilder.Instance.NewMethod<Action>("Relation_fake"); var fakeGenerator = fakeMethod.Generator; if (_keysHandler.FreeContent(fakeGenerator, _ => { })) throw new BTDBException("Not supported IDictionary in IDictionary key"); var containsNestedIDictionaries = _valuesHandler.FreeContent(fakeGenerator, _ => { }); if (!containsNestedIDictionaries) { ilGenerator .Do(pushReaderOrCtx) .Castclass(typeof(IDBReaderCtx)) .Do(Extensions.PushReaderFromCtx(pushReaderOrCtx)) .Callvirt(() => default(AbstractBufferedReader).ReadVUInt64()) .Callvirt(() => default(IDBReaderCtx).RegisterDict(0ul)); } else { var genericArguments = _type.GetGenericArguments(); var instanceType = typeof(ODBDictionary<,>).MakeGenericType(genericArguments); var dictId = ilGenerator.DeclareLocal(typeof(ulong)); ilGenerator .Do(pushReaderOrCtx) .Castclass(typeof(IDBReaderCtx)) .Do(Extensions.PushReaderFromCtx(pushReaderOrCtx)) .Callvirt(() => default(AbstractBufferedReader).ReadVUInt64()) .Stloc(dictId) .Ldloc(dictId) .Callvirt(() => default(IDBReaderCtx).RegisterDict(0ul)) .Do(pushReaderOrCtx) .Ldloc(dictId) .LdcI4(_configurationId) //ODBDictionary.DoFreeContent(IReaderCtx ctx, ulong id, int cfgId) .Call(instanceType.GetMethod("DoFreeContent")); } return true; }
public void GenerateSave(IILGen ilGenerator, Action<IILGen> pushWriter, Action<IILGen> pushCtx, Action<IILGen> pushValue, Type saveType) { var notnull = ilGenerator.DefineLabel(); var completeFinish = ilGenerator.DefineLabel(); var notDictionary = ilGenerator.DefineLabel(); var keyType = saveType.GetGenericArguments()[0]; var valueType = saveType.GetGenericArguments()[1]; var typeAsIDictionary = typeof(IDictionary<,>).MakeGenericType(keyType, valueType); var typeAsICollection = typeAsIDictionary.GetInterface("ICollection`1"); var localDict = ilGenerator.DeclareLocal(typeAsIDictionary); ilGenerator .Do(pushValue) .Castclass(typeAsIDictionary) .Stloc(localDict) .Ldloc(localDict) .Brtrue(notnull) .Do(pushWriter) .Callvirt(() => default(AbstractBufferedWriter).WriteByteZero()) .Br(completeFinish) .Mark(notnull) .Do(pushWriter) .Ldloc(localDict) .Callvirt(typeAsICollection.GetProperty("Count").GetGetMethod()) .LdcI4(1) .Add() .Callvirt(() => default(AbstractBufferedWriter).WriteVUInt32(0)); { var typeAsDictionary = typeof(Dictionary<,>).MakeGenericType(keyType, valueType); var getEnumeratorMethod = typeAsDictionary.GetMethods() .Single(m => m.Name == "GetEnumerator" && m.ReturnType.IsValueType && m.GetParameters().Length == 0); var typeAsIEnumerator = getEnumeratorMethod.ReturnType; var currentGetter = typeAsIEnumerator.GetProperty("Current").GetGetMethod(); var typeKeyValuePair = currentGetter.ReturnType; var localEnumerator = ilGenerator.DeclareLocal(typeAsIEnumerator); var localPair = ilGenerator.DeclareLocal(typeKeyValuePair); var finish = ilGenerator.DefineLabel(); var next = ilGenerator.DefineLabel(); ilGenerator .Ldloc(localDict) .Castclass(typeAsDictionary) .Brfalse(notDictionary) .Ldloc(localDict) .Castclass(typeAsDictionary) .Callvirt(getEnumeratorMethod) .Stloc(localEnumerator) .Try() .Mark(next) .Ldloca(localEnumerator) .Call(typeAsIEnumerator.GetMethod("MoveNext")) .Brfalse(finish) .Ldloca(localEnumerator) .Call(currentGetter) .Stloc(localPair); _keyDescriptor.GenerateSaveEx(ilGenerator, pushWriter, pushCtx, il => il.Ldloca(localPair).Call(typeKeyValuePair.GetProperty("Key").GetGetMethod()), keyType); _valueDescriptor.GenerateSaveEx(ilGenerator, pushWriter, pushCtx, il => il.Ldloca(localPair).Call(typeKeyValuePair.GetProperty("Value").GetGetMethod()), valueType); ilGenerator .Br(next) .Mark(finish) .Finally() .Ldloca(localEnumerator) .Constrained(typeAsIEnumerator) .Callvirt(() => default(IDisposable).Dispose()) .EndTry() .Br(completeFinish); } { var getEnumeratorMethod = typeAsIDictionary.GetInterface("IEnumerable`1").GetMethod("GetEnumerator"); var typeAsIEnumerator = getEnumeratorMethod.ReturnType; var currentGetter = typeAsIEnumerator.GetProperty("Current").GetGetMethod(); var typeKeyValuePair = currentGetter.ReturnType; var localEnumerator = ilGenerator.DeclareLocal(typeAsIEnumerator); var localPair = ilGenerator.DeclareLocal(typeKeyValuePair); var finish = ilGenerator.DefineLabel(); var next = ilGenerator.DefineLabel(); ilGenerator .Mark(notDictionary) .Ldloc(localDict) .Callvirt(getEnumeratorMethod) .Stloc(localEnumerator) .Try() .Mark(next) .Ldloc(localEnumerator) .Callvirt(() => default(IEnumerator).MoveNext()) .Brfalse(finish) .Ldloc(localEnumerator) .Callvirt(currentGetter) .Stloc(localPair); _keyDescriptor.GenerateSaveEx(ilGenerator, pushWriter, pushCtx, il => il.Ldloca(localPair).Call(typeKeyValuePair.GetProperty("Key").GetGetMethod()), keyType); _valueDescriptor.GenerateSaveEx(ilGenerator, pushWriter, pushCtx, il => il.Ldloca(localPair).Call(typeKeyValuePair.GetProperty("Value").GetGetMethod()), valueType); ilGenerator .Br(next) .Mark(finish) .Finally() .Ldloc(localEnumerator) .Callvirt(() => default(IDisposable).Dispose()) .EndTry() .Mark(completeFinish); } }
public void GenerateTypeIterator(IILGen ilGenerator, Action<IILGen> pushObj, Action<IILGen> pushCtx) { var finish = ilGenerator.DefineLabel(); var next = ilGenerator.DefineLabel(); var keyType = _owner._typeSerializers.LoadAsType(_owner._keyDescriptor); var valueType = _owner._typeSerializers.LoadAsType(_owner._valueDescriptor); var typeAsIDictionary = typeof(IDictionary<,>).MakeGenericType(keyType, valueType); var typeAsICollection = typeAsIDictionary.GetInterface("ICollection`1"); var typeAsIEnumerable = typeAsIDictionary.GetInterface("IEnumerable`1"); var getEnumeratorMethod = typeAsIEnumerable.GetMethod("GetEnumerator"); var typeAsIEnumerator = getEnumeratorMethod.ReturnType; var typeKeyValuePair = typeAsICollection.GetGenericArguments()[0]; var localEnumerator = ilGenerator.DeclareLocal(typeAsIEnumerator); var localPair = ilGenerator.DeclareLocal(typeKeyValuePair); ilGenerator .Do(pushObj) .Castclass(typeAsIDictionary) .Callvirt(getEnumeratorMethod) .Stloc(localEnumerator) .Try() .Mark(next) .Ldloc(localEnumerator) .Callvirt(() => default(IEnumerator).MoveNext()) .Brfalse(finish) .Ldloc(localEnumerator) .Callvirt(typeAsIEnumerator.GetProperty("Current").GetGetMethod()) .Stloc(localPair); if (!_owner._keyDescriptor.Sealed) { ilGenerator .Do(pushCtx) .Ldloca(localPair) .Call(typeKeyValuePair.GetProperty("Key").GetGetMethod()) .Callvirt(() => default(IDescriptorSerializerLiteContext).StoreNewDescriptors(null)); } if (!_owner._valueDescriptor.Sealed) { ilGenerator .Do(pushCtx) .Ldloca(localPair) .Call(typeKeyValuePair.GetProperty("Value").GetGetMethod()) .Callvirt(() => default(IDescriptorSerializerLiteContext).StoreNewDescriptors(null)); } ilGenerator .Br(next) .Mark(finish) .Finally() .Ldloc(localEnumerator) .Callvirt(() => default(IDisposable).Dispose()) .EndTry(); }
public void GenerateTypeIterator(IILGen ilGenerator, Action<IILGen> pushObj, Action<IILGen> pushCtx, Type type) { var finish = ilGenerator.DefineLabel(); var next = ilGenerator.DefineLabel(); var keyType = _owner._typeSerializers.LoadAsType(_owner._keyDescriptor); var valueType = _owner._typeSerializers.LoadAsType(_owner._valueDescriptor); if (_owner._type == null) _owner._type = type; var isDict = _owner._type != null && _owner._type.GetGenericTypeDefinition() == typeof(Dictionary<,>); var typeAsIDictionary = isDict ? _owner._type : typeof(IDictionary<,>).MakeGenericType(keyType, valueType); var getEnumeratorMethod = isDict ? typeAsIDictionary.GetMethods() .Single( m => m.Name == "GetEnumerator" && m.ReturnType.IsValueType && m.GetParameters().Length == 0) : typeAsIDictionary.GetInterface("IEnumerable`1").GetMethod("GetEnumerator"); var typeAsIEnumerator = getEnumeratorMethod.ReturnType; var currentGetter = typeAsIEnumerator.GetProperty("Current").GetGetMethod(); var typeKeyValuePair = currentGetter.ReturnType; var localEnumerator = ilGenerator.DeclareLocal(typeAsIEnumerator); var localPair = ilGenerator.DeclareLocal(typeKeyValuePair); ilGenerator .Do(pushObj) .Castclass(typeAsIDictionary) .Callvirt(getEnumeratorMethod) .Stloc(localEnumerator) .Try() .Mark(next) .Do(il => { if (isDict) { il .Ldloca(localEnumerator) .Call(typeAsIEnumerator.GetMethod("MoveNext")); } else { il .Ldloc(localEnumerator) .Callvirt(() => default(IEnumerator).MoveNext()); } }) .Brfalse(finish) .Do(il => { if (isDict) { il .Ldloca(localEnumerator) .Call(currentGetter); } else { il .Ldloc(localEnumerator) .Callvirt(currentGetter); } }) .Stloc(localPair); if (!_owner._keyDescriptor.Sealed) { ilGenerator .Do(pushCtx) .Ldloca(localPair) .Call(typeKeyValuePair.GetProperty("Key").GetGetMethod()) .Callvirt(() => default(IDescriptorSerializerLiteContext).StoreNewDescriptors(null)); } if (!_owner._valueDescriptor.Sealed) { ilGenerator .Do(pushCtx) .Ldloca(localPair) .Call(typeKeyValuePair.GetProperty("Value").GetGetMethod()) .Callvirt(() => default(IDescriptorSerializerLiteContext).StoreNewDescriptors(null)); } ilGenerator .Br(next) .Mark(finish) .Finally() .Do(il => { if (isDict) { il .Ldloca(localEnumerator) .Constrained(typeAsIEnumerator); } else { il.Ldloc(localEnumerator); } }) .Callvirt(() => default(IDisposable).Dispose()) .EndTry(); }
public void Save(IILGen ilGenerator, Action<IILGen> pushWriterOrCtx, Action<IILGen> pushValue) { var realfinish = ilGenerator.DefineLabel(); var finish = ilGenerator.DefineLabel(); var next = ilGenerator.DefineLabel(); var localValue = ilGenerator.DeclareLocal(_type); var typeAsICollection = _type.GetInterface("ICollection`1"); var typeAsIEnumerable = _type.GetInterface("IEnumerable`1"); var getEnumeratorMethod = typeAsIEnumerable.GetMethod("GetEnumerator"); var typeAsIEnumerator = getEnumeratorMethod.ReturnType; var typeKeyValuePair = typeAsICollection.GetGenericArguments()[0]; var localEnumerator = ilGenerator.DeclareLocal(typeAsIEnumerator); var localPair = ilGenerator.DeclareLocal(typeKeyValuePair); ilGenerator .Do(pushValue) .Stloc(localValue) .Do(pushWriterOrCtx) .Ldloc(localValue) .Castclass(typeof(object)) .Callvirt(() => default(IWriterCtx).WriteObject(null)) .Brfalse(realfinish) .Do(Extensions.PushWriterFromCtx(pushWriterOrCtx)) .Ldloc(localValue) .Callvirt(typeAsICollection.GetProperty("Count").GetGetMethod()) .ConvU4() .Callvirt(() => default(AbstractBufferedWriter).WriteVUInt32(0)) .Ldloc(localValue) .Callvirt(getEnumeratorMethod) .Stloc(localEnumerator) .Try() .Mark(next) .Ldloc(localEnumerator) .Callvirt(() => default(IEnumerator).MoveNext()) .Brfalse(finish) .Ldloc(localEnumerator) .Callvirt(typeAsIEnumerator.GetProperty("Current").GetGetMethod()) .Stloc(localPair); _keysHandler.Save(ilGenerator, Extensions.PushWriterOrCtxAsNeeded(pushWriterOrCtx, _keysHandler.NeedsCtx()), il => il .Ldloca(localPair) .Call(typeKeyValuePair.GetProperty("Key").GetGetMethod()) .Do(_typeConvertorGenerator.GenerateConversion(_type.GetGenericArguments()[0], _keysHandler.HandledType()))); _valuesHandler.Save(ilGenerator, Extensions.PushWriterOrCtxAsNeeded(pushWriterOrCtx, _valuesHandler.NeedsCtx()), il => il .Ldloca(localPair) .Call(typeKeyValuePair.GetProperty("Value").GetGetMethod()) .Do(_typeConvertorGenerator.GenerateConversion(_type.GetGenericArguments()[1], _valuesHandler.HandledType()))); ilGenerator .Br(next) .Mark(finish) .Finally() .Ldloc(localEnumerator) .Callvirt(() => default(IDisposable).Dispose()) .EndTry() .Mark(realfinish); }