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