protected virtual ITypeHandler4 TypeHandlerForClass(ObjectContainerBase container , IReflectClass fieldType) { container.ShowInternalClasses(true); try { return(container.TypeHandlerForClass(Handlers4.BaseType(fieldType))); } finally { container.ShowInternalClasses(false); } }
private void WriteObject(IWriteContext context, ITypeHandler4 typeHandler, object obj) { if (IsPlainObject(obj)) { context.WriteObject(new PlainObjectHandler(), obj); return; } if (Handlers4.UseDedicatedSlot(context, typeHandler)) { context.WriteObject(obj); } else { typeHandler.Write(context, obj); } }
public void Defragment(ITypeHandler4 handler) { ITypeHandler4 typeHandler = HandlerRegistry.CorrectHandlerVersion(this, handler); if (Handlers4.UseDedicatedSlot(this, typeHandler)) { if (Handlers4.HasClassIndex(typeHandler)) { CopyID(); } else { CopyUnindexedID(); } return; } typeHandler.Defragment(this); }
private ClassMetadata DetectFieldType() { IReflectClass claxx = _containingClass.ClassReflector(); if (claxx == null) { return(null); } _reflectField = claxx.GetDeclaredField(_name); if (_reflectField == null) { return(null); } IReflectClass fieldType = _reflectField.GetFieldType(); if (fieldType == null) { return(null); } return(Handlers4.ErasedFieldType(Container(), fieldType)); }
public ITypeHandler4 ConfiguredTypeHandler(IReflectClass claxx) { object cachedHandler = _mapReflectorToTypeHandler.Get(claxx); if (null != cachedHandler) { return((ITypeHandler4)cachedHandler); } ITypeHandler4 typeHandler = Container().ConfigImpl.TypeHandlerForClass(claxx, HandlerVersion ); if (typeHandler is IBuiltinTypeHandler) { ((IBuiltinTypeHandler)typeHandler).RegisterReflector(Reflector()); } if (Handlers4.IsValueType(typeHandler)) { MapClassToTypeHandler(claxx, typeHandler); } return(typeHandler); }
/// <summary>return false if class not completely initialized, otherwise true</summary> internal virtual bool ContinueSet(Db4objects.Db4o.Internal.Transaction trans, IUpdateDepth updateDepth) { if (!BitIsTrue(Const4.Continue)) { return(true); } if (!_class.StateOK()) { return(false); } if (!_class.AspectsAreInitialized()) { return(false); } if (DTrace.enabled) { DTrace.Continueset.Log(GetID()); } BitFalse(Const4.Continue); MarshallingContext context = new MarshallingContext(trans, this, updateDepth, true ); Handlers4.Write(ClassMetadata().TypeHandler(), context, GetObject()); Pointer4 pointer = context.AllocateSlot(); ByteArrayBuffer buffer = context.ToWriteBuffer(pointer); ObjectContainerBase container = trans.Container(); container.WriteNew(trans, pointer, _class, buffer); object obj = _object; ObjectOnNew(trans, obj); if (_class.HasIdentity()) { _object = container.NewWeakReference(this, obj); } SetStateClean(); EndProcessing(); return(true); }
public sealed override void CascadeActivation(IActivationContext context) { if (!Alive()) { return; } object cascadeTo = CascadingTarget(context); if (cascadeTo == null) { return; } IActivationContext cascadeContext = context.ForObject(cascadeTo); ClassMetadata classMetadata = cascadeContext.ClassMetadata(); if (classMetadata == null) { return; } EnsureObjectIsActive(cascadeContext); Handlers4.CascadeActivation(cascadeContext, classMetadata.TypeHandler()); }
private void EnsureObjectIsActive(IActivationContext context) { if (!context.Depth().Mode().IsActivate()) { return; } if (Handlers4.IsValueType(GetHandler())) { return; } ObjectContainerBase container = context.Container(); ClassMetadata classMetadata = container.ClassMetadataForObject(context.TargetObject ()); if (classMetadata == null || !classMetadata.HasIdentity()) { return; } if (container.IsActive(context.TargetObject())) { return; } container.StillToActivate(context.Descend()); }
private void InitializeFieldType() { ObjectContainerBase stream = ContainingClass().Container(); IReflectClass storedClass = stream.Reflector().ForClass(TranslatorStoredClass(_translator )); Configure(storedClass, false); IReflectClass baseType = Handlers4.BaseType(storedClass); stream.ShowInternalClasses(true); try { _fieldType = stream.ProduceClassMetadata(baseType); } finally { stream.ShowInternalClasses(false); } if (null == _fieldType) { throw new InvalidOperationException("Cannot produce class metadata for " + baseType + "!"); } }
public override IPreparedComparison PrepareComparison(IContext context, object source ) { return(Handlers4.PrepareComparisonFor(TypeHandler(), context, source)); }
public override object InstantiateTransient(UnmarshallingContext context) { return(Handlers4.ReadValueType(context, CorrectHandlerVersion(context))); }
private int CalculateLinkLength(IHandlerVersionContext context) { return(Handlers4.CalculateLinkLength(HandlerRegistry.CorrectHandlerVersion(context , GetHandler()))); }
public bool CanLoadByIndex() { return(Handlers4.CanLoadFieldByIndex(GetHandler())); }
internal virtual bool SupportsIndex() { return(Alive() && (GetHandler() is IIndexable4) && (!Handlers4.IsUntyped(GetHandler ()))); }
public object Run() { Handlers4.Activate(context, this._enclosing._typeHandler); return(null); }
private int CalculateLinkLength() { return(Handlers4.CalculateLinkLength(GetHandler())); }