private void MigrateFreespace(IFreespaceManager oldFreespaceManager)
{
IFreespaceManager newFreespaceManager = AbstractFreespaceManager.CreateNew(this,
ConfigImpl.FreespaceSystem());
newFreespaceManager.Start(0);
SystemData().FreespaceSystem(ConfigImpl.FreespaceSystem());
InstallFreespaceManager(newFreespaceManager);
AbstractFreespaceManager.Migrate(oldFreespaceManager, newFreespaceManager);
_fileHeader.WriteVariablePart(this);
}
/// <exception cref="Db4objects.Db4o.Ext.OldFormatException"></exception>
internal virtual void ReadThis()
{
NewSystemData(AbstractFreespaceManager.FmLegacyRam, StandardIdSystemFactory.Legacy
);
BlockSizeReadFromFile(1);
_fileHeader = FileHeader.Read(this);
if (Config().GenerateCommitTimestamps().IsUnspecified())
{
Config().GenerateCommitTimestamps(_systemData.IdToTimestampIndexId() != 0);
}
CreateStringIO(_systemData.StringEncoding());
CreateIdSystem();
InitializeClassMetadataRepository();
InitalizeWeakReferenceSupport();
SetNextTimeStampId(SystemData().LastTimeStampID());
ClassCollection().SetID(_systemData.ClassCollectionID());
ClassCollection().Read(SystemTransaction());
Converter.Convert(new ConversionStage.ClassCollectionAvailableStage(this));
_fileHeader.ReadIdentity(this);
if (_config.IsReadOnly())
{
return;
}
if (!ConfigImpl.CommitRecoveryDisabled())
{
_fileHeader.CompleteInterruptedTransaction(this);
}
IFreespaceManager blockedFreespaceManager = AbstractFreespaceManager.CreateNew(this
, _systemData.FreespaceSystem());
InstallFreespaceManager(blockedFreespaceManager);
blockedFreespaceManager.Read(this, _systemData.InMemoryFreespaceSlot());
blockedFreespaceManager.Start(_systemData.BTreeFreespaceId());
_fileHeader = _fileHeader.Convert(this);
if (FreespaceMigrationRequired(blockedFreespaceManager))
{
MigrateFreespace(blockedFreespaceManager);
}
WriteHeader(true, false);
if (Converter.Convert(new ConversionStage.SystemUpStage(this)))
{
_systemData.ConverterVersion(Converter.Version);
_fileHeader.WriteVariablePart(this);
Transaction.Commit();
}
}
private bool FreespaceMigrationRequired(IFreespaceManager freespaceManager)
{
if (freespaceManager == null)
{
return(false);
}
byte readSystem = _systemData.FreespaceSystem();
byte configuredSystem = ConfigImpl.FreespaceSystem();
if (freespaceManager.SystemType() == configuredSystem)
{
return(false);
}
if (configuredSystem != 0)
{
return(true);
}
return(AbstractFreespaceManager.MigrationRequired(readSystem));
}
internal virtual void ConfigureNewFile()
{
BlockSize(ConfigImpl.BlockSize());
_fileHeader = FileHeader.NewCurrentFileHeader();
SetRegularEndAddress(_fileHeader.Length());
NewSystemData(ConfigImpl.FreespaceSystem(), ConfigImpl.IdSystemType());
SystemData().ConverterVersion(Converter.Version);
CreateStringIO(_systemData.StringEncoding());
CreateIdSystem();
InitializeClassMetadataRepository();
InitalizeWeakReferenceSupport();
GenerateNewIdentity();
AbstractFreespaceManager blockedFreespaceManager = AbstractFreespaceManager.CreateNew
(this);
InstallFreespaceManager(blockedFreespaceManager);
InitNewClassCollection();
InitializeEssentialClasses();
_fileHeader.InitNew(this);
blockedFreespaceManager.Start(0);
}
public virtual void TestMigrateTo()
{
for (int from = 0; from < fm.Length; from++)
{
for (int to = 0; to < fm.Length; to++)
{
if (to != from)
{
Clear(fm[from]);
Clear(fm[to]);
AbstractFreespaceManager.Migrate(fm[from], fm[to]);
AssertSame(fm[from], fm[to]);
fm[from].Free(new Slot(5, 10));
fm[from].Free(new Slot(100, 5));
fm[from].Free(new Slot(140, 27));
AbstractFreespaceManager.Migrate(fm[from], fm[to]);
AssertSame(fm[from], fm[to]);
}
}
}
}
