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; }
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); }
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 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); }
/// <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(); }