public static void InsertFile(IndexNode node, Stream stream, Engine engine)
{
DataUnit dataPage = null;
byte[] buffer = new byte[0xff8L];
uint totalBytes = 0;
int read = 0;
int dataPerPage = 0xff8;
while ((read = stream.Read(buffer, 0, dataPerPage)) > 0)
{
totalBytes += (uint) read;
if (dataPage == null)
{
dataPage = engine.GetPageData(node.DataPageID);
}
else
{
dataPage = GetNewDataPage(dataPage, engine);
}
if (!dataPage.IsEmpty)
{
throw new FileDBException("Page {0} is not empty", new object[] { dataPage.UnitID });
}
Array.Copy(buffer, dataPage.DataBlock, read);
dataPage.IsEmpty = false;
dataPage.DataBlockLength = (short) read;
}
if (dataPage.NextUnitID != uint.MaxValue)
{
engine.Header.FreeDataPageID = dataPage.NextUnitID;
dataPage.NextUnitID = uint.MaxValue;
}
UnitFactory.WriteToFile(dataPage, engine.Writer);
node.FileLength = totalBytes;
}
private void Connect(string fileName, FileAccess fileAccess)
{
if (!File.Exists(fileName))
{
CreateEmptyFile(fileName);
}
FileAccess fa = ((fileAccess == FileAccess.Write) || (fileAccess == FileAccess.ReadWrite)) ? FileAccess.ReadWrite : FileAccess.Read;
this._fileStream = new FileStream(fileName, FileMode.Open, fa, FileShare.ReadWrite, 0x1000, FileOptions.None);
this._engine = new Engine(this._fileStream);
}
private static IndexNode BinaryInsertNode(IndexLink baseLink, IndexNode baseNode, EntryInfo entry, Engine engine)
{
IndexUnit pageIndex = engine.GetFreeIndexPage();
IndexNode newNode = pageIndex.Nodes[pageIndex.NodeIndex];
baseLink.PageID = pageIndex.UnitID;
baseLink.Index = pageIndex.NodeIndex;
newNode.UpdateFromEntry(entry);
newNode.DataPageID = DataFactory.GetStartDataPageID(engine);
if (pageIndex.UnitID != baseNode.IndexPage.UnitID)
{
engine.CacheIndexPage.AddPage(baseNode.IndexPage, true);
}
engine.CacheIndexPage.AddPage(pageIndex, true);
return newNode;
}
public static uint GetStartDataPageID(Engine engine)
{
if (engine.Header.FreeDataPageID != uint.MaxValue)
{
DataUnit startPage = UnitFactory.GetDataPage(engine.Header.FreeDataPageID, engine.Reader, true);
engine.Header.FreeDataPageID = startPage.NextUnitID;
if (engine.Header.FreeDataPageID == uint.MaxValue)
{
engine.Header.LastFreeDataPageID = uint.MaxValue;
}
return startPage.UnitID;
}
Header header = engine.Header;
header.LastPageID++;
return engine.Header.LastPageID;
}
public static DataUnit GetNewDataPage(DataUnit basePage, Engine engine)
{
if (basePage.NextUnitID != uint.MaxValue)
{
UnitFactory.WriteToFile(basePage, engine.Writer);
DataUnit dataPage = UnitFactory.GetDataPage(basePage.NextUnitID, engine.Reader, false);
engine.Header.FreeDataPageID = dataPage.NextUnitID;
if (engine.Header.FreeDataPageID == uint.MaxValue)
{
engine.Header.LastFreeDataPageID = uint.MaxValue;
}
return dataPage;
}
Header header = engine.Header;
uint pageID = ++header.LastPageID;
DataUnit newPage = new DataUnit(pageID);
basePage.NextUnitID = newPage.UnitID;
UnitFactory.WriteToFile(basePage, engine.Writer);
return newPage;
}
public static IndexNode BinaryInsert(EntryInfo target, IndexNode baseNode, Engine engine)
{
int dif = baseNode.ID.CompareTo(target.ID);
if (dif == 1)
{
if (baseNode.Right.IsEmpty)
{
return BinaryInsertNode(baseNode.Right, baseNode, target, engine);
}
return BinaryInsert(target, GetChildIndexNode(baseNode.Right, engine), engine);
}
if (dif != -1)
{
throw new FileDBException("Same GUID?!?");
}
if (baseNode.Left.IsEmpty)
{
return BinaryInsertNode(baseNode.Left, baseNode, target, engine);
}
return BinaryInsert(target, GetChildIndexNode(baseNode.Left, engine), engine);
}
public static IndexNode BinarySearch(Guid target, IndexNode baseNode, Engine engine)
{
int dif = baseNode.ID.CompareTo(target);
if (dif == 1)
{
if (baseNode.Right.IsEmpty)
{
return null;
}
return BinarySearch(target, GetChildIndexNode(baseNode.Right, engine), engine);
}
if (dif != -1)
{
return baseNode;
}
if (baseNode.Left.IsEmpty)
{
return null;
}
return BinarySearch(target, GetChildIndexNode(baseNode.Left, engine), engine);
}
public static void MarkAsEmpty(uint firstPageID, Engine engine)
{
DataUnit dataPage = UnitFactory.GetDataPage(firstPageID, engine.Reader, true);
uint lastPageID = uint.MaxValue;
bool cont = true;
while (cont)
{
dataPage.IsEmpty = true;
UnitFactory.WriteToFile(dataPage, engine.Writer);
if (dataPage.NextUnitID != uint.MaxValue)
{
lastPageID = dataPage.NextUnitID;
dataPage = UnitFactory.GetDataPage(lastPageID, engine.Reader, true);
}
else
{
cont = false;
}
}
if (engine.Header.FreeDataPageID == uint.MaxValue)
{
engine.Header.FreeDataPageID = firstPageID;
engine.Header.LastFreeDataPageID = (lastPageID == uint.MaxValue) ? firstPageID : lastPageID;
}
else
{
DataUnit lastPage = UnitFactory.GetDataPage(engine.Header.LastFreeDataPageID, engine.Reader, true);
if ((lastPage.NextUnitID != uint.MaxValue) || !lastPage.IsEmpty)
{
throw new FileDBException("The page is not empty");
}
lastPage.NextUnitID = firstPageID;
UnitFactory.WriteToFile(lastPage, engine.Writer);
engine.Header.LastFreeDataPageID = (lastPageID == uint.MaxValue) ? firstPageID : lastPageID;
}
}
public static void ReadFile(IndexNode node, Stream stream, Engine engine)
{
DataUnit dataPage = UnitFactory.GetDataPage(node.DataPageID, engine.Reader, false);
while (dataPage != null)
{
stream.Write(dataPage.DataBlock, 0, dataPage.DataBlockLength);
if (dataPage.NextUnitID == uint.MaxValue)
{
dataPage = null;
}
else
{
dataPage = UnitFactory.GetDataPage(dataPage.NextUnitID, engine.Reader, false);
}
}
}
internal DebugFile(Engine engine)
{
this._engine = engine;
}
public static IndexNode GetRootIndexNode(Engine engine)
{
return engine.CacheIndexPage.GetPage(engine.Header.IndexRootPageID).Nodes[0];
}
private static IndexNode GetChildIndexNode(IndexLink link, Engine engine)
{
return engine.CacheIndexPage.GetPage(link.PageID).Nodes[link.Index];
}
