/// <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 void UseSlot(Db4objects.Db4o.Internal.Slots.Slot slot)
{
_address = slot.Address();
_offset = 0;
if (slot.Length() > _buffer.Length)
{
_buffer = new byte[slot.Length()];
}
_length = slot.Length();
}
private long IdSystemUsage()
{
IIdSystem idSystem = _db.IdSystem();
long usage = 0;
while (idSystem is BTreeIdSystem)
{
IIdSystem parentIdSystem = ((IIdSystem)FieldValue(idSystem, "_parentIdSystem"));
usage += BTreeUsage(_db.SystemTransaction(), parentIdSystem, (BTree)FieldValue(idSystem
, "_bTree"), _slots);
PersistentIntegerArray persistentState = (PersistentIntegerArray)FieldValue(idSystem
, "_persistentState");
int persistentStateId = persistentState.GetID();
Db4objects.Db4o.Internal.Slots.Slot persistentStateSlot = parentIdSystem.CommittedSlot
(persistentStateId);
_slots.Add(persistentStateSlot);
usage += persistentStateSlot.Length();
idSystem = parentIdSystem;
}
if (idSystem is InMemoryIdSystem)
{
Db4objects.Db4o.Internal.Slots.Slot idSystemSlot = ((Db4objects.Db4o.Internal.Slots.Slot
)FieldValue(idSystem, "_slot"));
usage += idSystemSlot.Length();
_slots.Add(idSystemSlot);
}
return(usage);
}
public void Apply(object idSlot)
{
Db4objects.Db4o.Internal.Slots.Slot slot = ((Db4objects.Db4o.Internal.Slots.Slot)
((Pair)idSlot).second);
usage.value += slot.Length();
this._enclosing._slots.Add(slot);
}
public override void Write(ByteArrayBuffer writer)
{
if (SlotModified())
{
writer.WriteInt(_key);
writer.WriteInt(_newSlot.Address());
writer.WriteInt(_newSlot.Length());
}
}
public virtual void TestIndexMarshalling()
{
ByteArrayBuffer reader = new ByteArrayBuffer(2 * Const4.IntLength);
Slot original = new Slot(unchecked((int)(0xdb)), unchecked((int)(0x40)));
StringHandler().WriteIndexEntry(Context(), reader, original);
reader._offset = 0;
Slot retrieved = (Slot)StringHandler().ReadIndexEntry(Context(), reader);
Assert.AreEqual(original.Address(), retrieved.Address());
Assert.AreEqual(original.Length(), retrieved.Length());
}
public virtual Tree Free(LocalObjectContainer file, Tree treeRoot, Slot
slot)
{
file.Free(_slot.Address(), _slot.Length());
if (RemoveReferenceIsLast())
{
if (treeRoot != null)
{
return(treeRoot.RemoveNode(this));
}
}
PointTo(slot);
return(treeRoot);
}
private long ClassMetadataUsage()
{
Db4objects.Db4o.Internal.Slots.Slot classRepositorySlot = Slot(_db.ClassCollection
().GetID());
_slots.Add(classRepositorySlot);
long usage = classRepositorySlot.Length();
IEnumerator classIdIter = _db.ClassCollection().Ids();
while (classIdIter.MoveNext())
{
int curClassId = (((int)classIdIter.Current));
Db4objects.Db4o.Internal.Slots.Slot classSlot = Slot(curClassId);
_slots.Add(classSlot);
usage += classSlot.Length();
}
return(usage);
}
private static long BTreeUsage(Transaction transaction, IIdSystem idSystem, BTree
btree, ISlotMap slotMap)
{
IEnumerator nodeIter = btree.AllNodeIds(transaction);
Db4objects.Db4o.Internal.Slots.Slot btreeSlot = idSystem.CommittedSlot(btree.GetID
());
slotMap.Add(btreeSlot);
long usage = btreeSlot.Length();
while (nodeIter.MoveNext())
{
int curNodeId = ((int)nodeIter.Current);
Db4objects.Db4o.Internal.Slots.Slot slot = idSystem.CommittedSlot(curNodeId);
slotMap.Add(slot);
usage += slot.Length();
}
return(usage);
}
public StatefulBuffer(Transaction trans, Slot
slot) : this(trans, slot.Address(), slot.Length())
{
}
public Slot ToNonBlockedLength(Slot slot)
{
return new Slot(slot.Address(), BlocksToBytes(slot.Length()));
}
public IdSlotMapping(int id, Slot slot) : this(id,
slot.Address(), slot.Length())
{
}
private bool SlotLongEnoughForLog(int slotChangeCount, Slot slot)
{
return slot != null && slot.Length() >= TransactionLogSlotLength(slotChangeCount);
}
public virtual void WritePointer(int id, Slot slot)
{
if (DTrace.enabled)
{
DTrace.WritePointer.Log(id);
DTrace.WritePointer.LogLength(slot);
}
_pointerIo.Seek(0);
_pointerIo.WriteInt(slot.Address());
_pointerIo.WriteInt(slot.Length());
WriteBytes(_pointerIo, id, 0);
}
private void WriteSlot(ByteArrayBuffer buffer, Slot slot, bool writeZero)
{
if (writeZero || slot == null)
{
buffer.WriteInt(0);
buffer.WriteInt(0);
return;
}
buffer.WriteInt(slot.Address());
buffer.WriteInt(slot.Length());
}
private void ZeroFile(BlockAwareBin io, Slot slot)
{
if (io == null)
{
return;
}
byte[] zeroBytes = new byte[1024];
int left = slot.Length();
int offset = 0;
while (left > zeroBytes.Length)
{
io.BlockWrite(slot.Address(), offset, zeroBytes, zeroBytes.Length);
offset += zeroBytes.Length;
left -= zeroBytes.Length;
}
if (left > 0)
{
io.BlockWrite(slot.Address(), offset, zeroBytes, left);
}
}
public override void Free(Slot slot)
{
if (!IsStarted())
{
return;
}
if (IsDelegating())
{
_delegate.Free(slot);
return;
}
try
{
BeginDelegation();
if (DTrace.enabled)
{
DTrace.FreespacemanagerBtreeFree.LogLength(slot.Address(), slot.Length());
}
Slot[] remove = new Slot[2];
Slot newFreeSlot = slot;
BTreePointer pointer = SearchBTree(_slotsByAddress, slot, SearchTarget.Lowest);
BTreePointer previousPointer = pointer != null ? pointer.Previous() : _slotsByAddress
.LastPointer(Transaction());
if (previousPointer != null)
{
Slot previousSlot = (Slot)previousPointer.Key();
if (previousSlot.IsDirectlyPreceding(newFreeSlot))
{
remove[0] = previousSlot;
newFreeSlot = previousSlot.Append(newFreeSlot);
}
}
if (pointer != null)
{
Slot nextSlot = (Slot)pointer.Key();
if (newFreeSlot.IsDirectlyPreceding(nextSlot))
{
remove[1] = nextSlot;
newFreeSlot = newFreeSlot.Append(nextSlot);
}
}
for (int i = 0; i < remove.Length; i++)
{
if (remove[i] != null)
{
RemoveSlot(remove[i]);
}
}
if (!CanDiscard(newFreeSlot.Length()))
{
AddSlot(newFreeSlot);
}
SlotFreed(slot);
}
finally
{
EndDelegation();
}
}
// do nothing
// reading happens in start( )
private void RemoveSlot(Slot slot)
{
_slotsByLength.Remove(Transaction(), slot);
_slotsByAddress.Remove(Transaction(), slot);
_listener.SlotRemoved(slot.Length());
}
public virtual void LogLength(long id, Slot slot)
{
if (enabled)
{
if (slot == null)
{
return;
}
LogLength(id, slot.Address(), slot.Length());
}
}
public void UseSlot(Slot slot)
{
_address = slot.Address();
_offset = 0;
if (slot.Length() > _buffer.Length)
{
_buffer = new byte[slot.Length()];
}
_length = slot.Length();
}
public virtual void OverwriteDeletedBlockedSlot(Slot slot)
{
OverwriteDeletedBytes(slot.Address(), _blockConverter.BlocksToBytes(slot.Length()
));
}
public virtual StatefulBuffer ReadStatefulBufferBySlot(Transaction trans, int id,
Slot slot)
{
if (Slot.IsNull(slot))
{
return null;
}
if (DTrace.enabled)
{
DTrace.ReadSlot.LogLength(slot.Address(), slot.Length());
}
StatefulBuffer buffer = CreateStatefulBuffer(trans, slot.Address(), slot.Length()
);
buffer.SetID(id);
buffer.ReadEncrypt(this, slot.Address());
return buffer;
}
public virtual ByteArrayBuffer ReadBufferBySlot(Slot slot)
{
if (Slot.IsNull(slot))
{
return null;
}
if (DTrace.enabled)
{
DTrace.ReadSlot.LogLength(slot.Address(), slot.Length());
}
ByteArrayBuffer buffer = new ByteArrayBuffer(slot.Length());
buffer.ReadEncrypt(this, slot.Address());
return buffer;
}
public virtual void Free(Slot slot)
{
if (slot.IsNull())
{
return;
}
// TODO: This should really be an IllegalArgumentException but old database files
// with index-based FreespaceManagers appear to deliver zeroed slots.
// throw new IllegalArgumentException();
if (_freespaceManager == null)
{
// Can happen on early free before freespacemanager
// is up, during conversion.
return;
}
if (DTrace.enabled)
{
DTrace.FileFree.LogLength(slot.Address(), slot.Length());
}
_freespaceManager.Free(slot);
}
public StatefulBuffer(Db4objects.Db4o.Internal.Transaction trans, Db4objects.Db4o.Internal.Slots.Slot
slot) : this(trans, slot.Address(), slot.Length())
{
}
public override void MapId(int id, Slot slot)
{
_slotTree.Add(Trans(), new IdSlotMapping(id, slot.Address(), slot.Length()));
if (_commitFrequency > 0)
{
_slotInsertCount++;
if (_commitFrequency == _slotInsertCount)
{
_slotTree.Commit(Trans());
_slotInsertCount = 0;
}
}
}
public virtual int Length()
{
return(_slot.Length());
}
private void WriteThis(Slot reservedSlot)
{
// We need a little dance here to keep filling free slots
// with X bytes. The FreespaceManager would do it immediately
// upon the free call, but then our CrashSimulatingTestCase
// fails because we have the Xses in the file before flushing.
Slot xByteSlot = null;
int slotLength = SlotLength();
if (reservedSlot.Length() >= slotLength)
{
_slot = reservedSlot;
reservedSlot = null;
}
else
{
_slot = AllocateSlot(true, slotLength);
}
ByteArrayBuffer buffer = new ByteArrayBuffer(_slot.Length());
buffer.WriteInt(_childId);
_idGenerator.Write(buffer);
TreeInt.Write(buffer, _ids);
_container.WriteBytes(buffer, _slot.Address(), 0);
_container.SystemData().IdSystemSlot(_slot);
IRunnable commitHook = _container.CommitHook();
_container.SyncFiles(commitHook);
FreeSlot(reservedSlot);
}
// do nothing
public override void Free(Slot slot)
{
int address = slot.Address();
if (address <= 0)
{
throw new ArgumentException();
}
int length = slot.Length();
if (DTrace.enabled)
{
DTrace.FreespacemanagerRamFree.LogLength(address, length);
}
_finder._key = address;
FreeSlotNode sizeNode;
FreeSlotNode addressnode = (FreeSlotNode)Tree.FindSmaller(_freeByAddress, _finder
);
if ((addressnode != null) && ((addressnode._key + addressnode._peer._key) == address
))
{
sizeNode = addressnode._peer;
RemoveFromFreeBySize(sizeNode);
sizeNode._key += length;
FreeSlotNode secondAddressNode = (FreeSlotNode)Tree.FindGreaterOrEqual(_freeByAddress
, _finder);
if ((secondAddressNode != null) && (address + length == secondAddressNode._key))
{
sizeNode._key += secondAddressNode._peer._key;
RemoveFromBothTrees(secondAddressNode._peer);
}
sizeNode.RemoveChildren();
AddToFreeBySize(sizeNode);
}
else
{
addressnode = (FreeSlotNode)Tree.FindGreaterOrEqual(_freeByAddress, _finder);
if ((addressnode != null) && (address + length == addressnode._key))
{
sizeNode = addressnode._peer;
RemoveFromBothTrees(sizeNode);
sizeNode._key += length;
addressnode._key = address;
addressnode.RemoveChildren();
sizeNode.RemoveChildren();
_freeByAddress = Tree.Add(_freeByAddress, addressnode);
AddToFreeBySize(sizeNode);
}
else
{
if (CanDiscard(length))
{
return;
}
AddFreeSlotNodes(address, length);
}
}
SlotFreed(slot);
}
private void AddSlot(Slot slot)
{
_slotsByLength.Add(Transaction(), slot);
_slotsByAddress.Add(Transaction(), slot);
_listener.SlotAdded(slot.Length());
}