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; var classMetadata = container.ClassMetadataForID(classID); if (classMetadata != null) { return ClassReflector(container.Reflector(), classMetadata, info.Primitive()); } return null; }
public _IProcedure4_108(ClassMarshaller _enclosing, IntByRef len, ObjectContainerBase stream) { this._enclosing = _enclosing; this.len = len; this.stream = stream; }
internal void Poll(ObjectContainerBase objectContainer) { List4 remove = null; lock (this){ System.Collections.IEnumerator i = new Iterator4Impl(_list); _list = null; while (i.MoveNext()) { WeakReferenceHandler refHandler = (WeakReferenceHandler)i.Current; if (refHandler.IsAlive) { _list = new List4(_list, refHandler); } else { remove = new List4(remove, refHandler.ObjectReference); } } } System.Collections.IEnumerator j = new Iterator4Impl(remove); while (j.MoveNext()) { lock (objectContainer.Lock()) { if (objectContainer.IsClosed()) { return; } objectContainer.RemoveFromAllReferenceSystems(j.Current); } } }
public static int Main() { IExtContainer e = null; ObjectContainerBase b = null; return(e == b ? 0 : 1); }
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; var classMetadata = container.ClassMetadataForID(classID); if (classMetadata != null) { return(ClassReflector(container.Reflector(), classMetadata, info.Primitive())); } return(null); }
private static void AssertNameRead(ObjectContainerBase localObjectContainer, string originalName, string newName) { var originalBytes = localObjectContainer.StringIO().Write(originalName); var updatedClassNameBytes = Platform4.UpdateClassName(originalBytes); Assert.AreEqual(newName, localObjectContainer.StringIO().Read(updatedClassNameBytes)); }
public virtual object Lock() { ObjectContainerBase stream = Stream(); stream.CheckClosed(); return(stream.Lock()); }
/// <summary>make sure this Db4oDatabase is stored.</summary> /// <remarks>make sure this Db4oDatabase is stored. Return the ID.</remarks> public virtual int Bind(Transaction trans) { ObjectContainerBase stream = trans.Container(); Db4objects.Db4o.Ext.Db4oDatabase stored = (Db4objects.Db4o.Ext.Db4oDatabase)stream .Db4oTypeStored(trans, this); if (stored == null) { return(StoreAndGetId(trans)); } if (stored == this) { return(stream.GetID(trans, this)); } if (i_uuid == 0) { i_uuid = stored.i_uuid; } stream.ShowInternalClasses(true); try { int id = stream.GetID(trans, stored); stream.Bind(trans, this, id); return(id); } finally { stream.ShowInternalClasses(false); } }
private void ReadBTreeIndex(ObjectContainerBase stream, int indexId) { if (!stream.IsClient && _btreeIndex == null) { CreateBTreeIndex(stream, indexId); } }
public override void WriteUpdate(Transaction transaction, IUpdateDepth updatedepth ) { if (!this._firstUpdate) { base.WriteUpdate(transaction, updatedepth); return; } this._firstUpdate = false; ObjectContainerBase container = transaction.Container(); this.SetStateClean(); MarshallingContext context = new MarshallingContext(transaction, this, updatedepth , false); Handlers4.Write(this.ClassMetadata().TypeHandler(), context, this.GetObject()); int length = this.Container().BlockConverter().BlockAlignedBytes(context.MarshalledLength ()); Slot slot = context.AllocateNewSlot(length); Pointer4 pointer = new Pointer4(this.GetID(), slot); ByteArrayBuffer buffer = context.ToWriteBuffer(pointer); container.WriteUpdate(transaction, pointer, this.ClassMetadata(), ArrayType.None, buffer); if (this.IsActive()) { this.SetStateClean(); } }
public static ReplicationRecord QueryForReplicationRecord(ObjectContainerBase container, Transaction trans, Db4oDatabase younger, Db4oDatabase older) { container.ShowInternalClasses(true); try { var q = container.Query(trans); q.Constrain(typeof(ReplicationRecord)); q.Descend("_youngerPeer").Constrain(younger).Identity(); q.Descend("_olderPeer").Constrain(older).Identity(); var objectSet = q.Execute(); if (objectSet.HasNext()) { var replicationRecord = (ReplicationRecord )objectSet.Next(); container.Activate(replicationRecord, int.MaxValue); return(replicationRecord); } return(null); } finally { container.ShowInternalClasses(false); } }
internal void Poll(ObjectContainerBase objectContainer) { List4 remove = null; lock(this){ System.Collections.IEnumerator i = new Iterator4Impl(_list); _list = null; while(i.MoveNext()){ WeakReferenceHandler refHandler = (WeakReferenceHandler)i.Current; if(refHandler.IsAlive){ _list = new List4(_list, refHandler); }else{ remove = new List4(remove, refHandler.ObjectReference); } } } System.Collections.IEnumerator j = new Iterator4Impl(remove); while (j.MoveNext()) { lock (objectContainer.Lock()) { if (objectContainer.IsClosed()) { return; } objectContainer.RemoveFromAllReferenceSystems(j.Current); } } }
protected override void ReadIndex(ObjectContainerBase stream, ClassMetadata clazz , ByteArrayBuffer reader) { int indexID = reader.ReadInt(); clazz.Index().Read(stream, -indexID); }
public override Db4objects.Db4o.Internal.ClassMetadata ClassMetadata() { if (_classMetadata != null) { return(_classMetadata); } Read(); if (_bytes == null) { return(null); } Seek(0); ObjectContainerBase stream = Container(); ObjectHeader objectHeader = new ObjectHeader(stream, _bytes); _classMetadata = objectHeader.ClassMetadata(); if (_classMetadata != null) { if (stream._handlers.IclassCompare.IsAssignableFrom(_classMetadata.ClassReflector ())) { ReadThis(false); } } return(_classMetadata); }
private Db4objects.Db4o.Ext.Db4oDatabase Query(Transaction trans, bool constrainByUUID ) { ObjectContainerBase stream = trans.Container(); IQuery q = stream.Query(trans); q.Constrain(GetType()); if (constrainByUUID) { q.Descend(CreationtimeField).Constrain(i_uuid); } IObjectSet objectSet = q.Execute(); while (objectSet.HasNext()) { Db4objects.Db4o.Ext.Db4oDatabase storedDatabase = (Db4objects.Db4o.Ext.Db4oDatabase )objectSet.Next(); stream.Activate(null, storedDatabase, new FixedActivationDepth(4)); if (storedDatabase.Equals(this)) { return(storedDatabase); } } return(null); }
public sealed override FieldMetadata Read(ObjectContainerBase stream, ClassMetadata containingClass, ByteArrayBuffer reader) { RawFieldSpec spec = ReadSpec(stream, reader); return(FromSpec(spec, stream, containingClass)); }
protected override void AnalyzeDimensions(ObjectContainerBase container, object obj , ArrayInfo info) { int[] dim = ArrayReflector(container).Dimensions(obj); ((MultidimensionalArrayInfo)info).Dimensions(dim); info.ElementCount(ElementCount(dim)); }
public _IVisitor4_385(_IVisitor4_374 _enclosing, ObjectContainerBase stream, string fieldName, ByRef idsNew) { this._enclosing = _enclosing; this.stream = stream; this.fieldName = fieldName; this.idsNew = idsNew; }
public _IVisitor4_374(QQueryBase _enclosing, Collection4 executionPath, ObjectContainerBase stream, IdListQueryResult result) { this._enclosing = _enclosing; this.executionPath = executionPath; this.stream = stream; this.result = result; }
private void StoreModifiedObjects() { ObjectContainerBase container = _transaction.Container(); container.StoreAll(_transaction, _modified.ValuesIterator(), container.UpdateDepthProvider ().Unspecified(new _IModifiedObjectQuery_132(this))); _transaction.ProcessDeletes(); }
public AscendingQueryExecutor(Transaction trans, IdListQueryResult result, Collection4 executionPath) { _trans = trans; _container = _trans.Container(); _result = result; _executionPath = executionPath; }
public virtual void SetTransaction(Transaction trans) { if (trans != null) { _trans = trans; _stream = trans.Container(); } }
private void CreateBTreeIndex(ObjectContainerBase stream, int btreeID) { if (stream.IsClient) { return; } _btreeIndex = ((LocalObjectContainer)stream).CreateBTreeClassIndex(btreeID); _btreeIndex.SetRemoveListener(new _IVisitor4_61(this)); }
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) { var classMetadata = container.ProduceClassMetadata(info.ReflectClass()); if (classMetadata == null) { return 0; } return classMetadata.GetID(); }
public static Db4objects.Drs.Db4o.ReplicationRecord BeginReplication(Transaction transA, Transaction transB) { ObjectContainerBase peerA = transA.Container(); ObjectContainerBase peerB = transB.Container(); Db4oDatabase dbA = ((IInternalObjectContainer)peerA).Identity(); Db4oDatabase dbB = ((IInternalObjectContainer)peerB).Identity(); dbB.Bind(transA); dbA.Bind(transB); Db4oDatabase younger = null; Db4oDatabase older = null; if (dbA.IsOlderThan(dbB)) { younger = dbB; older = dbA; } else { younger = dbA; older = dbB; } Db4objects.Drs.Db4o.ReplicationRecord rrA = QueryForReplicationRecord(peerA, transA , younger, older); Db4objects.Drs.Db4o.ReplicationRecord rrB = QueryForReplicationRecord(peerB, transB , younger, older); if (rrA == null) { if (rrB == null) { return(new Db4objects.Drs.Db4o.ReplicationRecord(younger, older)); } rrB.Store(peerA); return(rrB); } if (rrB == null) { rrA.Store(peerB); return(rrA); } if (rrA != rrB) { peerB.ShowInternalClasses(true); try { int id = peerB.GetID(transB, rrB); peerB.Bind(transB, rrA, id); } finally { peerB.ShowInternalClasses(false); } } return(rrA); }
protected override void ReadIndex(ObjectContainerBase stream, ClassMetadata clazz , ByteArrayBuffer reader) { var indexID = reader.ReadInt(); if (indexID == 0) { return; } clazz.Index().Read(stream, indexID); }
private static ClassMetadata DetectElementTypeErasingNullables(ObjectContainerBase container, IEnumerable collection) { Type elementType = ElementTypeOf(collection); if (IsNullableInstance(elementType)) { return(container.ClassMetadataForReflectClass(container.Handlers.IclassObject)); } return(container.ProduceClassMetadata(container.Reflector().ForClass(elementType))); }
public virtual int MarshalledLength(ObjectContainerBase stream, ClassMetadata clazz ) { var len = new IntByRef(stream.StringIO().ShortLength(clazz.NameToWrite()) + Const4.ObjectLength + (Const4.IntLength * 2) + (Const4.IdLength)); len.value += clazz.Index().OwnLength(); clazz.TraverseDeclaredAspects(new _IProcedure4_108(this, len, stream)); return(len.value); }
public virtual int ClassIDFromInfo(ObjectContainerBase container, ArrayInfo info) { ClassMetadata classMetadata = container.ProduceClassMetadata(info.ReflectClass()); if (classMetadata == null) { return(0); } return(classMetadata.GetID()); }
public object ActivatedObject(int id) { ObjectContainerBase stream = Stream(); object ret = stream.GetActivatedObjectFromCache(_transaction, id); if (ret != null) { return(ret); } return(stream.ReadActivatedObjectNotInCache(_transaction, id)); }
private ClassAspect[] ReadAspects(ObjectContainerBase stream, ByteArrayBuffer reader , ClassMetadata clazz) { ClassAspect[] aspects = new ClassAspect[reader.ReadInt()]; for (int i = 0; i < aspects.Length; i++) { aspects[i] = _family._field.Read(stream, clazz, reader); aspects[i].SetHandle(i); } return(aspects); }
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 )); }
private void ReadThis(bool a_activate) { Read(); ObjectContainerBase container = Transaction().Container(); _member = container.TryGetByID(Transaction(), _key); if (_member != null && (a_activate || _member is ICompare)) { container.Activate(Transaction(), _member); CheckInstanceOfCompare(); } }
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 ) { var 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(); }
public void Read(ObjectContainerBase stream, ClassMetadata clazz, ByteArrayBuffer reader) { clazz.SetAncestor(stream.ClassMetadataForID(reader.ReadInt())); // if(clazz.callConstructor()){ // // The logic further down checks the ancestor YapClass, whether // // or not it is allowed, not to call constructors. The ancestor // // YapClass may possibly have not been loaded yet. // clazz.createConstructor(true); // } clazz.CheckType(); ReadIndex(stream, clazz, reader); clazz._aspects = ReadAspects(stream, reader, clazz); }
protected override FieldMetadata FromSpec(RawFieldSpec spec, ObjectContainerBase stream, ClassMetadata containingClass) { var actualField = base.FromSpec(spec, stream, containingClass); if (spec == null) { return null; } if (spec.IndexID() != 0) { actualField.InitIndex(stream.SystemTransaction(), spec.IndexID()); } return actualField; }
public virtual IReflectClass ReflectClassFromElementsEntry(ObjectContainerBase container , ArrayInfo info, int classID) { if (classID == 0) { return null; } var classMetadata = container.ClassMetadataForID(classID); if (classMetadata == null) { return null; } return ClassReflector(container.Reflector(), classMetadata, info.Primitive()); }
public override int MarshalledLength(ObjectContainerBase stream, ClassAspect aspect ) { var len = base.MarshalledLength(stream, aspect); if (!(aspect is FieldMetadata)) { return len; } var field = (FieldMetadata) aspect; if (!HasBTreeIndex(field)) { return len; } return len + Const4.IdLength; }
protected override RawFieldSpec ReadSpec(AspectType aspectType, ObjectContainerBase stream, ByteArrayBuffer reader) { var spec = base.ReadSpec(aspectType, stream, reader); if (spec == null) { return null; } if (spec.IsVirtual()) { return spec; } var indexID = reader.ReadInt(); spec.IndexID(indexID); return spec; }
private ObjectHeader(ObjectContainerBase container, ClassMetadata classMetadata, IReadWriteBuffer reader) { var 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 override int MarshalledLength(ObjectContainerBase stream, ClassAspect aspect ) { var len = stream.StringIO().ShortLength(aspect.GetName()); if (aspect is FieldMetadata) { var 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) { var 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); } } var fieldTypeID = reader.ReadInt(); var attribs = reader.ReadByte(); return new RawFieldSpec(aspectType, name, fieldTypeID, attribs); }
protected override void ReadIndex(ObjectContainerBase stream, ClassMetadata clazz , ByteArrayBuffer reader) { var 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); } }
protected virtual FieldMetadata FromSpec(RawFieldSpec spec, ObjectContainerBase stream , ClassMetadata containingClass) { if (spec == null) { return null; } var name = spec.Name(); if (spec.IsVirtualField()) { return stream._handlers.VirtualFieldByName(name); } if (spec.IsTranslator()) { return new TranslatedAspect(containingClass, name); } if (spec.IsField()) { return new FieldMetadata(containingClass, name, spec.FieldTypeID(), spec.IsPrimitive (), spec.IsArray(), spec.IsNArray()); } return new UnknownTypeHandlerAspect(containingClass, name); }
public ObjectHeader(ObjectContainerBase container, IReadWriteBuffer reader) : this (container, null, reader) { }
internal EnabledWeakReferenceSupport(ObjectContainerBase container) { _container = container; _queue = Platform4.CreateReferenceQueue(); }
protected abstract RawFieldSpec ReadSpec(AspectType aspectType, ObjectContainerBase stream, ByteArrayBuffer reader);
public OpenTypeHandler0(ObjectContainerBase container) : base(container) { }
public abstract int MarshalledLength(ObjectContainerBase arg1, ClassAspect arg2);
protected override void AnalyzeDimensions(ObjectContainerBase container, object obj , ArrayInfo info) { var dim = ArrayReflector(container).Dimensions(obj); ((MultidimensionalArrayInfo) info).Dimensions(dim); info.ElementCount(ElementCount(dim)); }
public abstract void Read(ObjectContainerBase arg1, int arg2);
public abstract void Initialize(ObjectContainerBase arg1);
internal virtual IPreparedComparison PrepareComparison(ObjectContainerBase container , object constraint) { var context = container.Transaction.Context(); if (_fieldMetadata != null) { return _fieldMetadata.PrepareComparison(context, constraint); } if (_classMetadata != null) { return _classMetadata.PrepareComparison(context, constraint); } IReflector reflector = container.Reflector(); ClassMetadata classMetadata = null; if (_bytes != null) { classMetadata = container.ProduceClassMetadata(reflector.ForObject(constraint)); } else { if (_member != null) { classMetadata = container.ClassMetadataForReflectClass(reflector.ForObject(_member )); } } if (classMetadata != null) { if (_member != null && _member.GetType().IsArray) { var arrayElementTypehandler = classMetadata.TypeHandler(); if (reflector.Array().IsNDimensional(MemberClass())) { var mah = new MultidimensionalArrayHandler(arrayElementTypehandler , false); return mah.PrepareComparison(context, _member); } var ya = new ArrayHandler(arrayElementTypehandler, false); return ya.PrepareComparison(context, _member); } return classMetadata.PrepareComparison(context, constraint); } return null; }
public abstract FieldMetadata Read(ObjectContainerBase arg1, ClassMetadata arg2, ByteArrayBuffer arg3);
// required for reflection cloning public override sealed IEnumerator AllElements(ObjectContainerBase container, object array) { return AllElementsMultidimensional(ArrayReflector(container), array); }