public PreparedArrayContainsComparison(IContext context, ArrayHandler arrayHandler , ITypeHandler4 typeHandler, object obj) { _arrayHandler = arrayHandler; _preparedComparison = Handlers4.PrepareComparisonFor(typeHandler, context, obj); _container = context.Transaction().Container(); }
public static object[] CollectionToArray(ObjectContainerBase stream, object obj) { Collection4 col = FlattenCollection(stream, obj); object[] ret = new object[col.Size()]; col.ToArray(ret); return ret; }
/// <exception cref="Db4objects.Db4o.Ext.Db4oIOException"></exception> private DatabaseIdentityIDAndUUID ReadDatabaseIdentityIDAndUUID (ObjectContainerBase container, ClassMetadata classMetadata, Slot oldSlot, bool checkClass) { if (DTrace.enabled) { DTrace.RereadOldUuid.LogLength(oldSlot.Address(), oldSlot.Length()); } var reader = container.DecryptedBufferByAddress(oldSlot.Address(), oldSlot .Length()); if (checkClass) { var realClass = ClassMetadata.ReadClass(container, reader); if (realClass != classMetadata) { return null; } } if (classMetadata.SeekToField(container.Transaction, reader, this) == HandlerVersion .Invalid) { return null; } return new DatabaseIdentityIDAndUUID(reader.ReadInt(), reader.ReadLong ()); }
public virtual void InitOnUp(Transaction systemTrans, FieldMetadata fieldMetadata ) { ObjectContainerBase anyStream = systemTrans.Container(); if (!anyStream.MaintainsIndices()) { return; } if (!fieldMetadata.SupportsIndex()) { Indexed(false); } TernaryBool indexedFlag = _config.GetAsTernaryBool(IndexedKey); if (indexedFlag.DefiniteNo()) { fieldMetadata.DropIndex((LocalTransaction)systemTrans); return; } if (UseExistingIndex(systemTrans, fieldMetadata)) { return; } if (!indexedFlag.DefiniteYes()) { return; } fieldMetadata.CreateIndex(); }
public virtual bool Dispatch(Transaction trans, object obj, int eventID) { if (methods[eventID] == null) { return(true); } object[] parameters = new object[] { trans.ObjectContainer() }; ObjectContainerBase container = trans.Container(); int stackDepth = container.StackDepth(); int topLevelCallId = container.TopLevelCallId(); container.StackDepth(0); try { object res = methods[eventID].Invoke(obj, parameters); if (res is bool) { return((bool)res); } } finally { container.StackDepth(stackDepth); container.TopLevelCallId(topLevelCallId); } return(true); }
public PrimitiveTypeMetadata(ObjectContainerBase container, ITypeHandler4 handler , int id, IReflectClass classReflector) : base(container, classReflector) { _aspects = FieldMetadata.EmptyArray; _typeHandler = handler; _id = id; }
/// <exception cref="Db4objects.Db4o.Ext.Db4oIOException"></exception> private UUIDFieldMetadata.DatabaseIdentityIDAndUUID ReadDatabaseIdentityIDAndUUID (ObjectContainerBase container, ClassMetadata classMetadata, Slot oldSlot, bool checkClass) { if (DTrace.enabled) { DTrace.RereadOldUuid.LogLength(oldSlot.Address(), oldSlot.Length()); } ByteArrayBuffer reader = container.DecryptedBufferByAddress(oldSlot.Address(), oldSlot .Length()); if (checkClass) { ClassMetadata realClass = ClassMetadata.ReadClass(container, reader); if (realClass != classMetadata) { return(null); } } if (classMetadata.SeekToField(container.Transaction, reader, this) == HandlerVersion .Invalid) { return(null); } return(new UUIDFieldMetadata.DatabaseIdentityIDAndUUID(reader.ReadInt(), reader.ReadLong ())); }
private void Marshall(Transaction trans, ObjectReference @ref, IWriteBuffer buffer , bool isNew) { if (!trans.SupportsVirtualFields()) { MarshallIgnore(buffer); return; } ObjectContainerBase stream = trans.Container(); HandlerRegistry handlers = stream._handlers; bool migrating = false; if (stream._replicationCallState == Const4.New) { IDb4oReplicationReferenceProvider provider = handlers._replicationReferenceProvider; object parentObject = @ref.GetObject(); IDb4oReplicationReference replicationReference = provider.ReferenceFor(parentObject ); if (replicationReference != null) { migrating = true; VirtualAttributes va = @ref.ProduceVirtualAttributes(); va.i_version = replicationReference.Version(); va.i_uuid = replicationReference.LongPart(); va.i_database = replicationReference.SignaturePart(); } } if (@ref.VirtualAttributes() == null) { @ref.ProduceVirtualAttributes(); migrating = false; } Marshall(trans, @ref, buffer, migrating, isNew); }
private void LogEvent(ObjectContainerBase container, string @event, int level) { if (container.ConfigImpl.MessageLevel() > level) { container.Message(string.Empty + GetID() + " " + @event + " " + _class.GetName()); } }
internal virtual void ActivateInternal(IActivationContext context) { if (null == context) { throw new ArgumentNullException(); } if (!context.Depth().RequiresActivation()) { return; } ObjectContainerBase container = context.Container(); if (context.Depth().Mode().IsRefresh()) { LogActivation(container, "refresh"); } else { if (IsActive()) { _class.CascadeActivation(context); return; } LogActivation(container, "activate"); } ReadForActivation(context); }
internal static Collection4 FlattenCollection(ObjectContainerBase stream, Object obj) { Collection4 collection41 = new Collection4(); FlattenCollection1(stream, obj, collection41); return(collection41); }
public override IReflectClass ReflectClassFromElementsEntry(ObjectContainerBase container , ArrayInfo info, int classID) { if (classID == Const4.IgnoreId) { // TODO: Here is a low-frequency mistake, extremely unlikely. // If classID == 99999 by accident then we will get ignore. return null; } info.Primitive(false); if (UseJavaHandling()) { if (classID < Const4.Primitive) { info.Primitive(true); classID -= Const4.Primitive; } } classID = -classID; ClassMetadata classMetadata = container.ClassMetadataForID(classID); if (classMetadata != null) { return ClassReflector(container.Reflector(), classMetadata, info.Primitive()); } return null; }
public LocalTransaction(ObjectContainerBase container, Transaction parentTransaction , ITransactionalIdSystem idSystem, IReferenceSystem referenceSystem) : base(container , parentTransaction, referenceSystem) { _file = (LocalObjectContainer)container; _committedCallbackDispatcher = new _ICommittedCallbackDispatcher_39(this); _idSystem = idSystem; }
public static object[] CollectionToArray(ObjectContainerBase stream, object obj) { Collection4 col = FlattenCollection(stream, obj); object[] ret = new object[col.Size()]; col.ToArray(ret); return(ret); }
public Transaction(ObjectContainerBase container, Transaction systemTransaction, IReferenceSystem referenceSystem) { // contains DeleteInfo nodes _container = container; _systemTransaction = systemTransaction; _referenceSystem = referenceSystem; }
public static ClassMetadata ErasedFieldType(ObjectContainerBase container, IReflectClass fieldType) { return(fieldType.IsInterface() ? container.ClassMetadataForID(UntypedId) : container .ProduceClassMetadata(BaseType(fieldType))); }
public LocalTransaction(ObjectContainerBase container, Transaction parentTransaction , ITransactionalIdSystem idSystem, IReferenceSystem referenceSystem) : base(container , parentTransaction, referenceSystem) { _file = (LocalObjectContainer) container; _committedCallbackDispatcher = new _ICommittedCallbackDispatcher_39(this); _idSystem = idSystem; }
protected virtual bool ObjectCanUpdate(Db4objects.Db4o.Internal.Transaction transaction , object obj) { ObjectContainerBase container = transaction.Container(); return(container.Callbacks().ObjectCanUpdate(transaction, this) && _class.DispatchEvent (transaction, obj, EventDispatchers.CanUpdate)); }
public virtual void SetObjectWeak(ObjectContainerBase container, object obj) { if (_object != null) { Platform4.KillYapRef(_object); } _object = container.NewWeakReference(this, obj); }
public virtual void SetTransaction(Transaction trans) { if (trans != null) { _trans = trans; _stream = trans.Container(); } }
private void ObjectOnNew(Db4objects.Db4o.Internal.Transaction transaction, object obj) { ObjectContainerBase container = transaction.Container(); container.Callbacks().ObjectOnNew(transaction, this); _class.DispatchEvent(transaction, obj, EventDispatchers.New); }
public virtual void Activate(Db4objects.Db4o.Internal.Transaction ta, object obj, IActivationDepth depth) { ObjectContainerBase container = ta.Container(); ActivateInternal(container.ActivationContextFor(ta, obj, depth)); container.ActivatePending(ta); }
private static TransportObjectContainer NewTransportObjectContainer(ObjectContainerBase serviceProvider, MemoryBin memoryBin) { TransportObjectContainer container = new TransportObjectContainer(serviceProvider , memoryBin); container.DeferredOpen(); return container; }
public Transaction(ObjectContainerBase container, Db4objects.Db4o.Internal.Transaction systemTransaction, IReferenceSystem referenceSystem) { // contains DeleteInfo nodes _container = container; _systemTransaction = systemTransaction; _referenceSystem = referenceSystem; }
private static TransportObjectContainer NewTransportObjectContainer(ObjectContainerBase serviceProvider, MemoryBin memoryBin) { TransportObjectContainer container = new TransportObjectContainer(serviceProvider , memoryBin); container.DeferredOpen(); return(container); }
public TransportObjectContainer(ObjectContainerBase parent, MemoryBin memoryFile) : base(parent.Config()) { _memoryBin = memoryFile; _parent = parent; _lock = parent.Lock(); _showInternalClasses = parent._showInternalClasses; Open(); }
private void CreateBTreeIndex(ObjectContainerBase stream, int btreeID) { if (stream.IsClient) { return; } _btreeIndex = ((LocalObjectContainer)stream).CreateBTreeClassIndex(btreeID); _btreeIndex.SetRemoveListener(new _IVisitor4_61(this)); }
public virtual int ClassIDFromInfo(ObjectContainerBase container, ArrayInfo info) { ClassMetadata classMetadata = container.ProduceClassMetadata(info.ReflectClass()); if (classMetadata == null) { return 0; } return classMetadata.GetID(); }
protected override void ReadIndex(ObjectContainerBase stream, ClassMetadata clazz , ByteArrayBuffer reader) { int indexID = reader.ReadInt(); if (indexID == 0) { return; } clazz.Index().Read(stream, indexID); }
public virtual GenericReflector Reflector() { ObjectContainerBase container = Container(); if (container == null) { return(null); } return(container.Reflector()); }
internal static void RemoveShutDownHook(ObjectContainerBase container) { lock (_shutdownStreamsLock) { if (_containersToBeShutdown != null) { _containersToBeShutdown.Remove(container); } } }
internal override void Marshall(Transaction trans, ObjectReference @ref, IWriteBuffer buffer, bool isMigrating, bool isNew) { VirtualAttributes attr = @ref.VirtualAttributes(); ObjectContainerBase container = trans.Container(); bool doAddIndexEntry = isNew && container.MaintainsIndices(); int dbID = 0; bool linkToDatabase = (attr != null && attr.i_database == null) ? true : !isMigrating; if (linkToDatabase) { Db4oDatabase db = ((IInternalObjectContainer)container).Identity(); if (db == null) { // can happen on early classes like Metaxxx, no problem attr = null; } else { if (attr.i_database == null) { attr.i_database = db; // TODO: Should be check for ! client instead of instanceof if (container is LocalObjectContainer) { attr.i_uuid = container.GenerateTimeStampId(); doAddIndexEntry = true; } } db = attr.i_database; if (db != null) { dbID = db.GetID(trans); } } } else { if (attr != null) { dbID = attr.i_database.GetID(trans); } } buffer.WriteInt(dbID); if (attr == null) { buffer.WriteLong(0); return; } buffer.WriteLong(attr.i_uuid); if (doAddIndexEntry) { AddIndexEntry(trans, @ref.GetID(), attr.i_uuid); } }
protected BTree NewBTree(Transaction systemTrans, int id) { ObjectContainerBase stream = systemTrans.Container(); IIndexable4 indexHandler = IndexHandler(stream); if (indexHandler == null) { return(null); } return(new BTree(systemTrans, id, new FieldIndexKeyHandler(indexHandler))); }
protected ClassMetadata(ObjectContainerBase container) { if (null == container) { throw new ArgumentNullException(); } _container = container; _index = CreateIndexStrategy(); _classIndexed = true; _fieldAccessor = new StrictFieldAccessor(); }
public override IPreparedComparison PrepareComparison(ObjectContainerBase container , object constraint) { Db4objects.Db4o.Internal.ClassMetadata classMetadata = ClassMetadata(); if (classMetadata == null) { return null; } return classMetadata.PrepareComparison(container.Transaction.Context(), constraint ); }
public static SerializedGraph Marshall(ObjectContainerBase serviceProvider, object obj) { MemoryBin memoryBin = new MemoryBin(223, GrowthStrategy()); TransportObjectContainer carrier = NewTransportObjectContainer(serviceProvider, memoryBin ); carrier.ProduceClassMetadata(carrier.Reflector().ForObject(obj)); carrier.Store(obj); int id = (int)carrier.GetID(obj); carrier.Close(); return new SerializedGraph(id, memoryBin.Data()); }
public virtual void WriteUpdate(Db4objects.Db4o.Internal.Transaction transaction, IUpdateDepth updatedepth) { ContinueSet(transaction, updatedepth); // make sure, a concurrent new, possibly triggered by objectOnNew // is written to the file // preventing recursive if (!BeginProcessing()) { return; } object obj = GetObject(); if (!ObjectCanUpdate(transaction, obj) || !IsActive() || obj == null || !ClassMetadata ().IsModified(obj)) { EndProcessing(); return; } MarshallingContext context = new MarshallingContext(transaction, this, updatedepth , false); if (context.UpdateDepth().Negative()) { EndProcessing(); return; } ObjectContainerBase container = transaction.Container(); LogEvent(container, "update", Const4.State); SetStateClean(); context.PurgeFieldIndexEntriesOnUpdate(transaction, container._handlers.ArrayType (obj)); Handlers4.Write(_class.TypeHandler(), context, obj); if (context.UpdateDepth().CanSkip(this)) { EndProcessing(); return; } Pointer4 pointer = context.AllocateSlot(); ByteArrayBuffer buffer = context.ToWriteBuffer(pointer); container.WriteUpdate(transaction, pointer, _class, container._handlers.ArrayType (obj), buffer); if (IsActive()) { SetStateClean(); } EndProcessing(); container.Callbacks().ObjectOnUpdate(transaction, this); ClassMetadata().DispatchEvent(transaction, obj, EventDispatchers.Update); }
public static IWeakReferenceSupport ForObjectContainer(ObjectContainerBase container ) { if (!Platform4.HasWeakReferences()) { return DisabledWeakReferenceSupport(); } if (!container.ConfigImpl.WeakReferences()) { return DisabledWeakReferenceSupport(); } return new EnabledWeakReferenceSupport(container); }
public override int ClassIDFromInfo(ObjectContainerBase container, ArrayInfo info ) { ClassMetadata classMetadata = container.ProduceClassMetadata(info.ReflectClass()); if (classMetadata == null) { // TODO: This one is a terrible low-frequency blunder !!! // If YapClass-ID == 99999 then we will get IGNORE back. // Discovered on adding the primitives return Const4.IgnoreId; } return classMetadata.GetID(); }
protected virtual ITypeHandler4 TypeHandlerForClass(ObjectContainerBase container , IReflectClass fieldType) { container.ShowInternalClasses(true); try { return(container.TypeHandlerForClass(Handlers4.BaseType(fieldType))); } finally { container.ShowInternalClasses(false); } }
private ObjectHeader(ObjectContainerBase container, Db4objects.Db4o.Internal.ClassMetadata classMetadata, IReadWriteBuffer reader) { int classID = reader.ReadInt(); _marshallerFamily = ReadMarshallerFamily(reader, classID); classID = NormalizeID(classID); _classMetadata = (classMetadata != null ? classMetadata : container.ClassMetadataForID (classID)); // This check has been added to cope with defragment in debug mode: SlotDefragment#setIdentity() // will trigger calling this constructor with a source db class metadata and a target db stream, // thus _classMetadata==null. There may be a better solution, since this call is just meant to // skip the object header. _headerAttributes = SlotFormat().ReadHeaderAttributes((ByteArrayBuffer)reader); }
public static SerializedGraph Marshall(ObjectContainerBase serviceProvider, object obj) { MemoryBin memoryBin = new MemoryBin(223, GrowthStrategy()); TransportObjectContainer carrier = NewTransportObjectContainer(serviceProvider, memoryBin ); carrier.ProduceClassMetadata(carrier.Reflector().ForObject(obj)); carrier.Store(obj); int id = (int)carrier.GetID(obj); carrier.Close(); return(new SerializedGraph(id, memoryBin.Data())); }
public virtual IReflectClass ReflectClassFromElementsEntry(ObjectContainerBase container , ArrayInfo info, int classID) { if (classID == 0) { return null; } ClassMetadata classMetadata = container.ClassMetadataForID(classID); if (classMetadata == null) { return null; } return ClassReflector(container.Reflector(), classMetadata, info.Primitive()); }
private static int EventCountFor(ObjectContainerBase container) { CallBackMode callbackMode = container.ConfigImpl.CallbackMode(); if (callbackMode == CallBackMode.All) { return(Count); } if (callbackMode == CallBackMode.DeleteOnly) { return(DeleteCount); } return(0); }
protected override FieldMetadata FromSpec(RawFieldSpec spec, ObjectContainerBase stream, ClassMetadata containingClass) { FieldMetadata actualField = base.FromSpec(spec, stream, containingClass); if (spec == null) { return null; } if (spec.IndexID() != 0) { actualField.InitIndex(stream.SystemTransaction(), spec.IndexID()); } return actualField; }
internal static void AddShutDownHook(ObjectContainerBase container) { lock (_shutdownStreamsLock) { if (_containersToBeShutdown == null) { _containersToBeShutdown = new List<ObjectContainerBase>(); #if !CF && !SILVERLIGHT AppDomain.CurrentDomain.ProcessExit += OnShutDown; AppDomain.CurrentDomain.DomainUnload += OnShutDown; #endif } _containersToBeShutdown.Add(container); } }
protected virtual IIndexable4 IndexHandler(ObjectContainerBase stream) { if (_reflectField == null) { return(null); } IReflectClass indexType = _reflectField.IndexType(); ITypeHandler4 classHandler = TypeHandlerForClass(stream, indexType); if (!(classHandler is IIndexable4)) { return(null); } return((IIndexable4)classHandler); }
// FIXME: needs test case public virtual void Rename(string newName) { ObjectContainerBase container = Container(); if (!container.IsClient) { _name = newName; _containingClass.SetStateDirty(); _containingClass.Write(container.SystemTransaction()); } else { Exceptions4.ThrowRuntimeException(58); } }
public override int MarshalledLength(ObjectContainerBase stream, ClassAspect aspect ) { int len = base.MarshalledLength(stream, aspect); if (!(aspect is FieldMetadata)) { return len; } FieldMetadata field = (FieldMetadata)aspect; if (!HasBTreeIndex(field)) { return len; } return len + Const4.IdLength; }
public static object Unmarshall(ObjectContainerBase serviceProvider, byte[] bytes , int id) { if (id <= 0) { return null; } MemoryBin memoryBin = new MemoryBin(bytes, GrowthStrategy()); TransportObjectContainer carrier = NewTransportObjectContainer(serviceProvider, memoryBin ); object obj = carrier.GetByID(id); carrier.Activate(carrier.Transaction, obj, new FullActivationDepth()); carrier.Close(); return obj; }
public virtual void Store(ObjectContainerBase container) { container.ShowInternalClasses(true); try { Transaction trans = container.CheckTransaction(); container.StoreAfterReplication(trans, this, container.UpdateDepthProvider().ForDepth (1), false); container.Commit(trans); } finally { container.ShowInternalClasses(false); } }
internal static void AddShutDownHook(ObjectContainerBase container) { lock (_shutdownStreamsLock) { if (_containersToBeShutdown == null) { _containersToBeShutdown = new List <ObjectContainerBase>(); #if !CF && !SILVERLIGHT AppDomain.CurrentDomain.ProcessExit += OnShutDown; AppDomain.CurrentDomain.DomainUnload += OnShutDown; #endif } _containersToBeShutdown.Add(container); } }
protected override RawFieldSpec ReadSpec(AspectType aspectType, ObjectContainerBase stream, ByteArrayBuffer reader) { RawFieldSpec spec = base.ReadSpec(aspectType, stream, reader); if (spec == null) { return null; } if (spec.IsVirtual()) { return spec; } int indexID = reader.ReadInt(); spec.IndexID(indexID); return spec; }
public override int MarshalledLength(ObjectContainerBase stream, ClassAspect aspect ) { int len = stream.StringIO().ShortLength(aspect.GetName()); if (aspect is FieldMetadata) { FieldMetadata field = (FieldMetadata)aspect; if (field.NeedsArrayAndPrimitiveInfo()) { len += 1; } if (!(field is VirtualFieldMetadata)) { len += Const4.IdLength; } } return len; }
protected override RawFieldSpec ReadSpec(AspectType aspectType, ObjectContainerBase stream, ByteArrayBuffer reader) { string name = StringHandler.ReadStringNoDebug(stream.Transaction.Context(), reader ); if (!aspectType.IsFieldMetadata()) { return new RawFieldSpec(aspectType, name); } if (name.IndexOf(Const4.VirtualFieldPrefix) == 0) { if (stream._handlers.VirtualFieldByName(name) != null) { return new RawFieldSpec(aspectType, name); } } int fieldTypeID = reader.ReadInt(); byte attribs = reader.ReadByte(); return new RawFieldSpec(aspectType, name, fieldTypeID, attribs); }
protected override void ReadIndex(ObjectContainerBase stream, ClassMetadata clazz , ByteArrayBuffer reader) { int indexID = reader.ReadInt(); if (!stream.MaintainsIndices() || !(stream is LocalObjectContainer)) { return; } if (Btree(clazz) != null) { return; } clazz.Index().Read(stream, ValidIndexId(indexID)); if (IsOldClassIndex(indexID)) { new ClassIndexesToBTrees_5_5().Convert((LocalObjectContainer)stream, indexID, Btree (clazz)); stream.SetDirtyInSystemTransaction(clazz); } }
private static IReflectMethod[] EventHandlerTableFor(ObjectContainerBase container , IReflectClass classReflector) { IReflectClass[] parameterClasses = { container._handlers.IclassObjectcontainer }; var methods = new IReflectMethod[Count]; for (var i = Count - 1; i >= 0; i--) { var method = classReflector.GetMethod(events[i], parameterClasses); if (null == method) { method = classReflector.GetMethod(ToPascalCase(events[i]), parameterClasses); } if (method != null) { methods[i] = method; } } return methods; }