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);
}
protected override void ReadIndex(ObjectContainerBase stream, ClassMetadata clazz
, ByteArrayBuffer reader)
{
var indexID = reader.ReadInt();
if (indexID == 0)
{
return;
}
clazz.Index().Read(stream, indexID);
}
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)
{
}
public _IVisitor4_385(_IVisitor4_374 _enclosing, ObjectContainerBase stream, string
fieldName, ByRef idsNew)
{
this._enclosing = _enclosing;
this.stream = stream;
this.fieldName = fieldName;
this.idsNew = idsNew;
}
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);
public _IVisitor4_374(QQueryBase _enclosing, Collection4 executionPath, ObjectContainerBase
stream, IdListQueryResult result)
{
this._enclosing = _enclosing;
this.executionPath = executionPath;
this.stream = stream;
this.result = result;
}
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);
}
