public override void WriteFixedPart(LocalObjectContainer file, bool startFileLockingThread
, bool shuttingDown, StatefulBuffer writer, int blockSize)
{
var systemData = file.SystemData();
writer.Append(Signature);
writer.WriteByte(Version());
writer.WriteInt((int) TimeToWrite(_timerFileLock.OpenTime(), shuttingDown));
writer.WriteLong(TimeToWrite(_timerFileLock.OpenTime(), shuttingDown));
writer.WriteLong(TimeToWrite(Runtime.CurrentTimeMillis(), shuttingDown));
writer.WriteInt(blockSize);
writer.WriteInt(systemData.ClassCollectionID());
writer.WriteByte(systemData.IdSystemType());
writer.WriteInt(((FileHeaderVariablePart2) _variablePart).Address());
writer.WriteInt(((FileHeaderVariablePart2) _variablePart).Length());
writer.WriteInt(_transactionPointerAddress);
writer.Write();
if (shuttingDown)
{
WriteVariablePart(file, true);
}
else
{
file.SyncFiles();
}
if (startFileLockingThread)
{
file.ThreadPool().Start("db4o lock thread", _timerFileLock);
}
}
/// <exception cref="Db4objects.Db4o.Ext.Db4oIOException"></exception>
public override sealed void InitNew(LocalObjectContainer file)
{
NewTimerFileLock(file);
OldEncryptionOff(file);
_variablePart = CreateVariablePart(file);
WriteVariablePart(file);
}
public static IIdSystem NewInstance(LocalObjectContainer localContainer)
{
var systemData = localContainer.SystemData();
var idSystemType = systemData.IdSystemType();
switch (idSystemType)
{
case Legacy:
{
return new PointerBasedIdSystem(localContainer);
}
case PointerBased:
{
return new PointerBasedIdSystem(localContainer);
}
case StackedBtree:
{
var inMemoryIdSystem = new InMemoryIdSystem(localContainer);
var bTreeIdSystem = new BTreeIdSystem(localContainer, inMemoryIdSystem);
systemData.FreespaceIdSystem(bTreeIdSystem.FreespaceIdSystem());
return new BTreeIdSystem(localContainer, bTreeIdSystem);
}
case SingleBtree:
{
var smallInMemoryIdSystem = new InMemoryIdSystem(localContainer);
var smallBTreeIdSystem = new BTreeIdSystem(localContainer, smallInMemoryIdSystem
);
systemData.FreespaceIdSystem(smallBTreeIdSystem.FreespaceIdSystem());
return smallBTreeIdSystem;
}
case InMemory:
{
return new InMemoryIdSystem(localContainer);
}
case Custom:
{
var customIdSystemFactory = localContainer.ConfigImpl.CustomIdSystemFactory
();
if (customIdSystemFactory == null)
{
throw new Db4oFatalException(
"Custom IdSystem configured but no factory was found. See IdSystemConfiguration#useCustomSystem()"
);
}
return customIdSystemFactory.NewInstance(localContainer);
}
default:
{
return new PointerBasedIdSystem(localContainer);
break;
}
}
}
public BTreeFreespaceManager(LocalObjectContainer file, IProcedure4 slotFreedCallback
, int discardLimit, int remainderSizeLimit) : base(slotFreedCallback, discardLimit
, remainderSizeLimit)
{
_file = file;
_delegate = new InMemoryFreespaceManager(slotFreedCallback, discardLimit, remainderSizeLimit
);
_idSystem = file.SystemData().FreespaceIdSystem();
}
public SodaQueryComparator(LocalObjectContainer container, ClassMetadata extent,
Ordering[] orderings)
{
_container = container;
_transaction = ((LocalTransaction) _container.Transaction);
_extentType = extent;
_orderings = orderings;
ResolveFieldPaths(orderings);
}
/// <exception cref="Db4objects.Db4o.Internal.FieldIndexException"></exception>
protected virtual void RebuildIndexForObject(LocalObjectContainer container, int
objectId)
{
var writer = container.ReadStatefulBufferById(container.SystemTransaction
(), objectId);
if (writer != null)
{
RebuildIndexForWriter(container, writer, objectId);
}
}
public virtual bool RebuildIndexForClass(LocalObjectContainer container, ClassMetadata
classMetadata)
{
var ids = classMetadata.GetIDs();
for (var i = 0; i < ids.Length; i++)
{
RebuildIndexForObject(container, (int) ids[i]);
}
return ids.Length > 0;
}
private TransactionLogHandler NewTransactionLogHandler(LocalObjectContainer container
)
{
var fileBased = container.Config().FileBasedTransactionLog() && container is IoAdaptedObjectContainer;
if (!fileBased)
{
return new EmbeddedTransactionLogHandler(container);
}
var fileName = ((IoAdaptedObjectContainer) container).FileName();
return new FileBasedTransactionLogHandler(container, fileName);
}
public FileHeaderVariablePart1(LocalObjectContainer container, int id) : base(container
)
{
// The variable part format is:
// (int) converter version
// (byte) freespace system used
// (int) freespace address
// (int) identity ID
// (long) versionGenerator
// (int) uuid index ID
_id = id;
}
public override sealed void WriteVariablePart(LocalObjectContainer file, bool shuttingDown
)
{
if (!IsInitalized())
{
return;
}
var commitHook = Commit(shuttingDown);
file.SyncFiles();
commitHook.Run();
file.SyncFiles();
}
private void RebuildUUIDIndex(LocalObjectContainer file)
{
var uuid = file.UUIDIndex();
var i = file.ClassCollection().Iterator();
while (i.MoveNext())
{
var clazz = i.CurrentClass();
if (clazz.GenerateUUIDs())
{
uuid.RebuildIndexForClass(file, clazz);
}
}
}
private void BuildCommitTimestampIndex(LocalObjectContainer container)
{
versionFieldMetadata = container.Handlers.Indexes()._version;
var i = container.ClassCollection().Iterator();
while (i.MoveNext())
{
var clazz = i.CurrentClass();
if (clazz.HasVersionField() && !clazz.IsStruct())
{
RebuildIndexForClass(container, clazz);
}
}
}
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 static FileHeader DetectFileHeader(LocalObjectContainer file, ByteArrayBuffer
reader)
{
for (var i = 0; i < AvailableFileHeaders.Length; i++)
{
reader.Seek(0);
var result = AvailableFileHeaders[i].NewOnSignatureMatch(file, reader);
if (result != null)
{
return result;
}
}
return null;
}
/// <exception cref="Db4objects.Db4o.Ext.OldFormatException"></exception>
public static FileHeader Read(LocalObjectContainer file)
{
var reader = PrepareFileHeaderReader(file);
var header = DetectFileHeader(file, reader);
if (header == null)
{
Exceptions4.ThrowRuntimeException(Messages.IncompatibleFormat
, file.ToString());
}
else
{
header.Read(file, reader);
}
return header;
}
public virtual void Convert(LocalObjectContainer container, int classIndexId, BTree
bTree)
{
var trans = container.SystemTransaction();
var reader = container.ReadBufferById(trans, classIndexId);
if (reader == null)
{
return;
}
var entries = reader.ReadInt();
for (var i = 0; i < entries; i++)
{
bTree.Add(trans, reader.ReadInt());
}
}
protected override void Read(LocalObjectContainer file, ByteArrayBuffer reader)
{
NewTimerFileLock(file);
OldEncryptionOff(file);
CheckThreadFileLock(file, reader);
reader.Seek(TransactionPointerOffset);
file.SystemData().TransactionPointer1(reader.ReadInt());
file.SystemData().TransactionPointer2(reader.ReadInt());
reader.Seek(BlocksizeOffset);
file.BlockSizeReadFromFile(reader.ReadInt());
var systemData = file.SystemData();
systemData.ClassCollectionID(reader.ReadInt());
reader.ReadInt();
// was freespace ID, can no longer be read
_variablePart = CreateVariablePart(file);
var variablePartId = reader.ReadInt();
_variablePart.Read(variablePartId, 0);
}
public FileHeaderVariablePart2(LocalObjectContainer container, int address, int length
) : base(container)
{
// The variable part format is:
// (long) checksum
// (int) address of InMemoryIdSystem slot
// (int) length of InMemoryIdSystem slot
// (int) address of InMemoryFreespace
// (int) length of InMemoryFreespace
// (int) BTreeFreespace id
// (int) converter version
// (int) uuid index ID
// (int) identity ID
// (long) versionGenerator
// (byte) freespace system used
_address = address;
_length = length;
}
public BTreeIdSystem(LocalObjectContainer container, IStackableIdSystem parentIdSystem
, int maxValidId)
{
_container = container;
_parentIdSystem = parentIdSystem;
_transactionalIdSystem = container.NewTransactionalIdSystem(null, new _IClosure4_40
(parentIdSystem));
var persistentArrayId = parentIdSystem.ChildId();
if (persistentArrayId == 0)
{
InitializeNew();
}
else
{
InitializeExisting(persistentArrayId);
}
_idGenerator = new SequentialIdGenerator(new _IFunction4_52(this), IdGeneratorValue
(), _container.Handlers.LowestValidId(), maxValidId);
}
protected virtual void RebuildIndexForWriter(LocalObjectContainer container, StatefulBuffer
buffer, int objectId)
{
var objectHeader = new ObjectHeader(container, buffer);
var context = new ObjectIdContextImpl(container.SystemTransaction
(), buffer, objectHeader, objectId);
var classMetadata = context.ClassMetadata();
if (classMetadata.IsStruct())
{
// We don't keep version information for structs.
return;
}
if (classMetadata.SeekToField(container.SystemTransaction(), buffer, versionFieldMetadata
) != HandlerVersion.Invalid)
{
var version = ((long) versionFieldMetadata.Read(context));
if (version != 0)
{
var t = (LocalTransaction) container.SystemTransaction();
t.CommitTimestampSupport().Put(container.SystemTransaction(), objectId, version);
}
}
}
protected override void Read(LocalObjectContainer container, ByteArrayBuffer reader
)
{
NewTimerFileLock(container);
OldEncryptionOff(container);
CheckThreadFileLock(container, reader);
reader.Seek(BlocksizeOffset);
container.BlockSizeReadFromFile(reader.ReadInt());
var systemData = container.SystemData();
systemData.ClassCollectionID(reader.ReadInt());
container.SystemData().IdSystemType(reader.ReadByte());
_variablePart = CreateVariablePart(container);
var variablePartAddress = reader.ReadInt();
var variablePartLength = reader.ReadInt();
_variablePart.Read(variablePartAddress, variablePartLength);
_transactionPointerAddress = reader.ReadInt();
if (_transactionPointerAddress != 0)
{
var buffer = new ByteArrayBuffer(TransactionPointerLength);
buffer.Read(container, _transactionPointerAddress, 0);
systemData.TransactionPointer1(buffer.ReadInt());
systemData.TransactionPointer2(buffer.ReadInt());
}
}
protected abstract FileHeader NewOnSignatureMatch(LocalObjectContainer file, ByteArrayBuffer
reader);
public SodaQueryComparator(LocalObjectContainer container, Type extentType, SodaQueryComparator.Ordering
[] orderings) : this(container, container.ProduceClassMetadata(container.Reflector
().ForClass(extentType)), orderings)
{
}
public static bool LockedByOtherSession(LocalObjectContainer container, long lastAccessTime
)
{
return(container.NeedsLockFileThread() && (lastAccessTime != 0));
}
/// <exception cref="Db4objects.Db4o.Ext.Db4oIOException"></exception> public abstract void InitNew(LocalObjectContainer file);
protected abstract void Read(LocalObjectContainer file, ByteArrayBuffer reader);
public virtual void WriteVariablePart(LocalObjectContainer file)
{
WriteVariablePart(file, false);
}
public MockIdSystem(LocalObjectContainer container) : base(container)
{
}
protected TransactionLogHandler(LocalObjectContainer container)
{
_container = container;
}
public ObjectServerImpl(LocalObjectContainer container, IServerConfiguration serverConfig
, int port) : this(container, (ServerConfigurationImpl)serverConfig, (port < 0 ?
0 : port), port == 0)
{
}
public static ObjectHeader ScrollBufferToContent
(LocalObjectContainer container, ByteArrayBuffer buffer)
{
return new ObjectHeader(container, buffer);
}
public SodaQueryComparator(LocalObjectContainer container, Type extentType, Ordering
[] orderings) : this(container, container.ProduceClassMetadata(container.Reflector
().ForClass(extentType)), orderings)
{
}
/// <exception cref="Db4objects.Db4o.Ext.Db4oIOException"></exception>
public override void CheckIfOtherSessionAlive(LocalObjectContainer container, int
address, int offset, long lastAccessTime)
{
}
public abstract FileHeaderVariablePart CreateVariablePart(LocalObjectContainer file
);
protected override FileHeader NewOnSignatureMatch(LocalObjectContainer file, ByteArrayBuffer
reader)
{
if (SignatureMatches(reader, Signature, Version()))
{
return CreateNew();
}
return null;
}
public override void Read(LocalObjectContainer container, Slot slot)
{
}
public FileBasedTransactionLogHandler(LocalObjectContainer container, string fileName
) : base(container)
{
_fileName = fileName;
}
protected virtual void NewTimerFileLock(LocalObjectContainer file)
{
_timerFileLock = TimerFileLock.ForFile(file);
_timerFileLock.SetAddresses(0, OpenTimeOffset, AccessTimeOffset);
}
public FileHeaderVariablePart2(LocalObjectContainer container) : this(container,
0, 0)
{
}
public SystemUpStage(LocalObjectContainer file) : base(file)
{
}
// TODO: freespaceID should not be passed here, it should be taken from SystemData
public abstract void WriteFixedPart(LocalObjectContainer file, bool startFileLockingThread
, bool shuttingDown, StatefulBuffer writer, int blockSize);
protected ConversionStage(LocalObjectContainer file)
{
_file = file;
}
public abstract void WriteVariablePart(LocalObjectContainer file, bool shuttingDown
);
internal static long BTreeUsage(LocalObjectContainer db, BTree btree, ISlotMap slotMap
)
{
return(BTreeUsage(db.SystemTransaction(), db.IdSystem(), btree, slotMap));
}
public abstract void ReadIdentity(LocalObjectContainer container);
protected abstract void Backup(LocalObjectContainer origDb, string backupPath);
public abstract void CompleteInterruptedTransaction(LocalObjectContainer container
);
public DelegatingIdSystem(LocalObjectContainer container)
{
_delegate = new InMemoryIdSystem(container);
}
protected FileHeaderVariablePart(LocalObjectContainer container)
{
_container = container;
}
/// <param name="file"></param>
private void FreeOldUUIDMetaIndex(LocalObjectContainer file)
{
}
public _IRunnable_351(ObjectServerImpl _enclosing, LocalObjectContainer threadContainer
)
{
this._enclosing = _enclosing;
this.threadContainer = threadContainer;
}
protected virtual void OldEncryptionOff(LocalObjectContainer file)
{
file._handlers.OldEncryptionOff();
}
protected override void Backup(LocalObjectContainer origDb, string backupPath)
{
origDb.Backup(BackupStorage(), backupPath);
}
public EmbeddedTransactionLogHandler(LocalObjectContainer container) : base(container
)
{
}
public PointerBasedIdSystem(LocalObjectContainer container)
{
_container = container;
_transactionLogHandler = NewTransactionLogHandler(container);
}
public virtual void Write(LocalObjectContainer container)
{
}
public IIdSystem NewInstance(LocalObjectContainer container)
{
return(new MockIdSystem(container));
}
public virtual void Read(LocalObjectContainer container, Slot slot)
{
}
public FileHeaderVariablePart3(LocalObjectContainer container) : base(container)
{
}
public ClassCollectionAvailableStage(LocalObjectContainer file) : base(file)
{
}
