public virtual ObjectReference Reference()
{
HardObjectReference hardRef = _transaction.Container().GetHardObjectReferenceById
(_transaction, _id);
return(hardRef._reference);
}
public virtual void CaptureQueryResultConfig()
{
Config4Impl config = _trans.Container().Config();
_evaluationMode = config.EvaluationMode();
_prefetchDepth = config.PrefetchDepth();
_prefetchCount = config.PrefetchObjectCount();
}
internal virtual bool Attach(QQuery query, string a_field)
{
Db4objects.Db4o.Internal.Query.Processor.QCon qcon = this;
ClassMetadata yc = GetYapClass();
bool[] foundField = new bool[] { false };
ForEachChildField(a_field, new _IVisitor4_101(foundField, query));
if (foundField[0])
{
return(true);
}
QField qf = null;
if (yc == null || yc.HoldsAnyClass())
{
int[] count = new int[] { 0 };
FieldMetadata[] yfs = new FieldMetadata[] { null };
i_trans.Container().ClassCollection().AttachQueryNode(a_field, new _IVisitor4_119
(yfs, count));
if (count[0] == 0)
{
return(false);
}
if (count[0] == 1)
{
qf = yfs[0].QField(i_trans);
}
else
{
qf = new QField(i_trans, a_field, null, 0, 0);
}
}
else
{
if (yc.IsTranslated())
{
i_trans.Container()._handlers.DiagnosticProcessor().DescendIntoTranslator(yc, a_field
);
}
FieldMetadata yf = yc.FieldMetadataForName(a_field);
if (yf != null)
{
qf = yf.QField(i_trans);
}
if (qf == null)
{
qf = new QField(i_trans, a_field, null, 0, 0);
}
}
QConPath qcp = new QConPath(i_trans, qcon, qf);
query.AddConstraint(qcp);
qcon.AddConstraint(qcp);
return(true);
}
public static Db4objects.Db4o.Internal.Marshall.CollectIdContext ForID(Transaction
transaction, IdObjectCollector collector, int id)
{
StatefulBuffer reader = transaction.Container().ReadStatefulBufferById(transaction
, id);
if (reader == null)
{
return null;
}
ObjectHeader oh = new ObjectHeader(transaction.Container(), reader);
return new Db4objects.Db4o.Internal.Marshall.CollectIdContext(transaction, collector
, oh, reader);
}
internal QConClass(Transaction a_trans, QCon a_parent, QField a_field, IReflectClass
claxx) : base(a_trans, a_parent, a_field, null)
{
// C/S
if (claxx != null)
{
_classMetadata = a_trans.Container().ProduceClassMetadata(claxx);
if (claxx.Equals(a_trans.Container()._handlers.IclassObject))
{
_classMetadata = (ClassMetadata)_classMetadata.TypeHandler();
}
}
_claxx = claxx;
}
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();
}
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);
}
public virtual Db4objects.Db4o.Internal.VirtualAttributes VirtualAttributes(Db4objects.Db4o.Internal.Transaction
trans, bool lastCommitted)
{
if (trans == null)
{
return(_virtualAttributes);
}
lock (trans.Container().Lock())
{
if (_virtualAttributes == null)
{
if (_class.HasVirtualAttributes())
{
_virtualAttributes = new Db4objects.Db4o.Internal.VirtualAttributes();
_class.ReadVirtualAttributes(trans, this, lastCommitted);
}
}
else
{
if (!_virtualAttributes.SuppliesUUID())
{
if (_class.HasVirtualAttributes())
{
_class.ReadVirtualAttributes(trans, this, lastCommitted);
}
}
}
return(_virtualAttributes);
}
}
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;
}
internal QConClass(Transaction trans, QCon parent, QField field, IReflectClass claxx
) : base(trans, parent, field, null)
{
// C/S
if (claxx != null)
{
ObjectContainerBase container = trans.Container();
_classMetadata = container.ClassMetadataForReflectClass(claxx);
if (_classMetadata == null)
{
// could be an aliased class, try to resolve.
string className = claxx.GetName();
string aliasRunTimeName = container.Config().ResolveAliasStoredName(className);
if (!className.Equals(aliasRunTimeName))
{
_classMetadata = container.ClassMetadataForName(aliasRunTimeName);
}
}
if (claxx.Equals(container._handlers.IclassObject))
{
_classMetadata = (ClassMetadata)_classMetadata.TypeHandler();
}
}
_claxx = claxx;
}
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();
}
private void EnsureIndex(Transaction transaction)
{
if (null == transaction)
{
throw new ArgumentNullException();
}
if (null != base.GetIndex(transaction))
{
return;
}
LocalObjectContainer file = ((LocalObjectContainer)transaction.Container());
SystemData sd = file.SystemData();
if (sd == null)
{
// too early, in new file, try again later.
return;
}
InitIndex(transaction, sd.UuidIndexId());
if (sd.UuidIndexId() == 0)
{
sd.UuidIndexId(base.GetIndex(transaction).GetID());
file.GetFileHeader().WriteVariablePart(file);
}
}
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 virtual void SetTransaction(Transaction trans)
{
if (trans != null)
{
_trans = trans;
_stream = trans.Container();
}
}
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 void ObjectOnNew(Db4objects.Db4o.Internal.Transaction transaction, object
obj)
{
ObjectContainerBase container = transaction.Container();
container.Callbacks().ObjectOnNew(transaction, this);
_class.DispatchEvent(transaction, obj, EventDispatchers.New);
}
protected virtual bool ObjectCanUpdate(Transaction transaction
, object obj)
{
var container = transaction.Container();
return(container.Callbacks().ObjectCanUpdate(transaction, this) && _class.DispatchEvent
(transaction, obj, EventDispatchers.CanUpdate));
}
public virtual void Activate(Transaction ta, object obj,
IActivationDepth depth)
{
var container = ta.Container();
ActivateInternal(container.ActivationContextFor(ta, obj, depth));
container.ActivatePending(ta);
}
public static StatefulBuffer Marshall(Transaction ta, object obj)
{
SerializedGraph serialized = Marshall(ta.Container(), obj);
StatefulBuffer buffer = new StatefulBuffer(ta, serialized.Length());
buffer.Append(serialized._bytes);
buffer.UseSlot(serialized._id, 0, serialized.Length());
return buffer;
}
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));
}
private void ObjectOnNew(Transaction transaction, object
obj)
{
var container = transaction.Container();
container.Callbacks().ObjectOnNew(transaction, this);
_class.DispatchEvent(transaction, obj, EventDispatchers.New);
}
public static StatefulBuffer Marshall(Transaction ta, object obj)
{
SerializedGraph serialized = Marshall(ta.Container(), obj);
StatefulBuffer buffer = new StatefulBuffer(ta, serialized.Length());
buffer.Append(serialized._bytes);
buffer.UseSlot(serialized._id, 0, serialized.Length());
return(buffer);
}
protected override ByteArrayBuffer ReadBufferById(Transaction trans)
{
var slot = IdSystem(trans).CurrentSlot(GetID());
if (DTrace.enabled)
{
DTrace.SlotRead.LogLength(GetID(), slot);
}
return ((LocalObjectContainer) trans.Container()).ReadBufferBySlot(slot);
}
protected override ByteArrayBuffer ReadBufferById(Transaction trans)
{
Slot slot = IdSystem(trans).CurrentSlot(GetID());
if (DTrace.enabled)
{
DTrace.SlotRead.LogLength(GetID(), slot);
}
return(((LocalObjectContainer)trans.Container()).ReadBufferBySlot(slot));
}
public void InitOnUp(Transaction systemTrans)
{
_classMetadataCreationDepth++;
systemTrans.Container().ShowInternalClasses(true);
try
{
IEnumerator i = _classes.GetEnumerator();
while (i.MoveNext())
{
((ClassMetadata)i.Current).InitOnUp(systemTrans);
}
}
finally
{
systemTrans.Container().ShowInternalClasses(false);
_classMetadataCreationDepth--;
}
InitClassMetadataOnUp();
}
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);
}
}
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 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)));
}
public static Db4objects.Db4o.Internal.HardObjectReference PeekPersisted(Transaction
trans, int id, int depth)
{
object obj = trans.Container().PeekPersisted(trans, id, ActivationDepthProvider(trans
).ActivationDepth(depth, ActivationMode.Peek), true);
if (obj == null)
{
return null;
}
ObjectReference @ref = trans.ReferenceForId(id);
return new Db4objects.Db4o.Internal.HardObjectReference(@ref, obj);
}
public virtual void InitIndex(Transaction systemTrans, int id)
{
if (_index != null)
{
throw new InvalidOperationException();
}
if (systemTrans.Container().IsClient)
{
return;
}
_index = NewBTree(systemTrans, id);
}
internal void Store(Db4objects.Db4o.Internal.Transaction trans, Db4objects.Db4o.Internal.ClassMetadata
classMetadata, object obj)
{
_object = obj;
_class = classMetadata;
int id = trans.Container().IdForNewUserObject(trans);
SetID(id);
// will be ended in continueset()
BeginProcessing();
BitTrue(Const4.Continue);
}
/// <exception cref="Db4objects.Db4o.Ext.Db4oIOException"></exception>
public Db4objects.Db4o.Internal.ByteArrayBuffer ReadEmbeddedObject(Transaction trans
)
{
int address = ReadInt();
int length = ReadInt();
if (address == 0)
{
return(null);
}
return(trans.Container().DecryptedBufferByAddress(address, length));
}
/// <exception cref="Db4objects.Db4o.Ext.Db4oIOException"></exception>
public ByteArrayBuffer ReadEmbeddedObject(Transaction trans
)
{
var address = ReadInt();
var length = ReadInt();
if (address == 0)
{
return(null);
}
return(trans.Container().DecryptedBufferByAddress(address, length));
}
public virtual RawClassSpec ReadSpec(Transaction trans, ByteArrayBuffer reader)
{
byte[] nameBytes = ReadName(trans, reader);
string className = trans.Container().StringIO().Read(nameBytes);
ReadMetaClassID(reader);
// skip
int ancestorID = reader.ReadInt();
reader.IncrementOffset(Const4.IntLength);
// index ID
int numFields = reader.ReadInt();
return new RawClassSpec(className, ancestorID, numFields);
}
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 virtual void Store(Transaction trans)
{
ObjectContainerBase container = trans.Container();
container.ShowInternalClasses(true);
try
{
container.StoreAfterReplication(trans, this, container.UpdateDepthProvider().ForDepth
(int.MaxValue), false);
}
finally
{
container.ShowInternalClasses(false);
}
}
public static Db4objects.Db4o.Internal.HardObjectReference PeekPersisted(Transaction
trans, int id, int depth)
{
object obj = trans.Container().PeekPersisted(trans, id, ActivationDepthProvider(trans
).ActivationDepth(depth, ActivationMode.Peek), true);
if (obj == null)
{
return(null);
}
ObjectReference @ref = trans.ReferenceForId(id);
return(new Db4objects.Db4o.Internal.HardObjectReference(@ref, obj));
}
private void WriteToFile(Transaction trans, ByteArrayBuffer writer, Slot slot)
{
if (DTrace.enabled)
{
DTrace.PersistentbaseWrite.Log(GetID());
}
LocalObjectContainer container = (LocalObjectContainer)trans.Container();
WriteThis(trans, writer);
container.WriteEncrypt(writer, slot.Address(), 0);
if (IsActive())
{
SetStateClean();
}
}
internal override void Marshall(Transaction trans, ObjectReference @ref, IWriteBuffer
buffer, bool isMigrating, bool isNew)
{
VirtualAttributes attr = @ref.VirtualAttributes();
if (!isMigrating)
{
attr.i_version = trans.Container().GenerateTimeStampId();
}
if (attr == null)
{
buffer.WriteLong(0);
}
else
{
buffer.WriteLong(attr.i_version);
}
}
private void AssociateYapClass(Transaction a_trans, object a_object)
{
if (a_object == null)
{
}
else
{
//It seems that we need not result the following field
//i_object = null;
//i_comparator = Null.INSTANCE;
//i_classMetadata = null;
// FIXME: Setting the YapClass to null will prevent index use
// If the field is typed we can guess the right one with the
// following line. However this does break some SODA test cases.
// Revisit!
// if(i_field != null){
// i_classMetadata = i_field.getYapClass();
// }
_classMetadata = a_trans.Container().ProduceClassMetadata(a_trans.Reflector().ForObject
(a_object));
if (_classMetadata != null)
{
i_object = _classMetadata.GetComparableObject(a_object);
if (a_object != i_object)
{
i_attributeProvider = _classMetadata.Config().QueryAttributeProvider();
_classMetadata = a_trans.Container().ProduceClassMetadata(a_trans.Reflector().ForObject
(i_object));
}
if (_classMetadata != null)
{
_classMetadata.CollectConstraints(a_trans, this, i_object, new _IVisitor4_84(this
));
}
else
{
AssociateYapClass(a_trans, null);
}
}
else
{
AssociateYapClass(a_trans, null);
}
}
}
protected HardObjectReference GetHardObjectReferenceById(Transaction transaction,
int parentId, byte[] signature)
{
HardObjectReference hardRef = transaction.Container().GetHardObjectReferenceById(
transaction, parentId);
if (hardRef._reference == null)
{
return(null);
}
VirtualAttributes vad = hardRef._reference.VirtualAttributes(transaction, false);
if (!Arrays4.Equals(signature, vad.i_database.i_signature))
{
return(null);
}
return(hardRef);
}
internal override void Marshall(Transaction trans, ObjectReference @ref, IWriteBuffer
buffer, bool isMigrating, bool isNew)
{
VirtualAttributes attr = @ref.VirtualAttributes();
if (!isMigrating)
{
attr.i_version = trans.Container().GenerateTimeStampId();
}
if (attr == null)
{
buffer.WriteLong(0);
}
else
{
buffer.WriteLong(attr.i_version);
}
}
public virtual void Deactivate(Transaction trans, IActivationDepth
depth)
{
if (!depth.RequiresActivation())
{
return;
}
var obj = GetObject();
if (obj == null)
{
return;
}
var container = trans.Container();
LogActivation(container, "deactivate");
SetStateDeactivated();
_class.Deactivate(trans, this, depth);
}
public virtual void Deactivate(Db4objects.Db4o.Internal.Transaction trans, IActivationDepth
depth)
{
if (!depth.RequiresActivation())
{
return;
}
object obj = GetObject();
if (obj == null)
{
return;
}
ObjectContainerBase container = trans.Container();
LogActivation(container, "deactivate");
SetStateDeactivated();
_class.Deactivate(trans, this, depth);
}
/// <summary>gets the db4o ID, and may cache it for performance reasons.</summary>
/// <remarks>gets the db4o ID, and may cache it for performance reasons.</remarks>
/// <returns>the db4o ID for the ObjectContainer</returns>
public virtual int GetID(Transaction trans)
{
ObjectContainerBase stream = trans.Container();
if (stream != i_stream)
{
i_stream = stream;
i_id = Bind(trans);
}
return i_id;
}
public virtual Db4objects.Db4o.CS.Internal.Messages.MsgD GetWriterForSingleObject
(Transaction trans, object obj)
{
SerializedGraph serialized = Serializer.Marshall(trans.Container(), obj);
Db4objects.Db4o.CS.Internal.Messages.MsgD msg = GetWriterForLength(trans, serialized
.MarshalledLength());
serialized.Write(msg._payLoad);
return msg;
}
internal override void Unmarshall(Transaction trans)
{
if (i_trans != null)
{
return;
}
base.Unmarshall(trans);
if (i_object == null)
{
_preparedComparison = Null.Instance;
}
if (i_classMetadataID != 0)
{
_classMetadata = trans.Container().ClassMetadataForID(i_classMetadataID);
}
if (i_field != null)
{
i_field.Unmarshall(trans);
}
if (i_objectID > 0)
{
object obj = trans.Container().TryGetByID(trans, i_objectID);
if (obj != null)
{
i_object = obj;
}
}
}
public virtual void WriteShortString(Transaction trans, string a_string)
{
trans.Container()._handlers._stringHandler.WriteShort(trans, a_string, this);
}
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 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;
}
private bool ObjectCanDeactivate(Transaction transaction, IObjectInfo objectInfo)
{
var container = transaction.Container();
return container.Callbacks().ObjectCanDeactivate(transaction, objectInfo) && DispatchEvent
(transaction, objectInfo.GetObject(), EventDispatchers.CanDeactivate);
}
public byte[] ReadName(Transaction trans, ByteArrayBuffer reader)
{
return ReadName(trans.Container().StringIO(), reader);
}
public void InitOnUp(Transaction systemTrans)
{
_classMetadataCreationDepth++;
systemTrans.Container().ShowInternalClasses(true);
try
{
IEnumerator i = _classes.GetEnumerator();
while (i.MoveNext())
{
((ClassMetadata)i.Current).InitOnUp(systemTrans);
}
}
finally
{
systemTrans.Container().ShowInternalClasses(false);
_classMetadataCreationDepth--;
}
InitClassMetadataOnUp();
}
/// <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 int StoreAndGetId(Transaction trans)
{
ObjectContainerBase stream = trans.Container();
stream.ShowInternalClasses(true);
try
{
stream.Store2(trans, this, stream.UpdateDepthProvider().ForDepth(2), false);
return stream.GetID(trans, this);
}
finally
{
stream.ShowInternalClasses(false);
}
}
internal virtual void Unmarshall(Transaction a_trans)
{
if (i_classMetadataID != 0)
{
ClassMetadata yc = a_trans.Container().ClassMetadataForID(i_classMetadataID);
_fieldMetadata = (FieldMetadata)yc._aspects[_fieldHandle];
}
}
/// <exception cref="Db4objects.Db4o.Ext.Db4oIOException"></exception>
public Db4objects.Db4o.Internal.ByteArrayBuffer ReadEmbeddedObject(Transaction trans
)
{
int address = ReadInt();
int length = ReadInt();
if (address == 0)
{
return null;
}
return trans.Container().DecryptedBufferByAddress(address, length);
}
private static Config4Impl Config(Transaction trans)
{
if (null == trans)
{
throw new ArgumentNullException();
}
return trans.Container().ConfigImpl;
}
public override object InitialValueFor(Transaction transaction)
{
Config4Impl config = transaction.Container().Config();
return CacheFactory.NewLRUIntCache(config.PrefetchSlotCacheSize());
}
internal virtual ObjectContainerBase Container(Transaction trans)
{
return trans.Container();
}
