internal long GenerateHashOffset(uint xBlock, TreeLevel xTree)
{
if (xBlock >= 0x4AF768)
{
return(Constants.STFSEnd);
}
try
{
uint result = GenerateHashBlock(xBlock, xTree);
long xReturn = BlockToOffset(result);
switch (xTree)
{
case TreeLevel.L0:
xReturn += (0x18 * (xBlock % BlockLevel[0]));
break;
case TreeLevel.L1:
xReturn += (0x18 * ((xBlock / BlockLevel[0]) % BlockLevel[0]));
break;
case TreeLevel.L2:
xReturn += (0x18 * ((xBlock / BlockLevel[1]) % BlockLevel[0]));
break;
}
return(xReturn);
}
catch { throw STFSExcepts.General; }
}
public bool IsEvenOddTree(TreeNode root)
{
if (root == null)
{
return(false);
}
Queue <TreeLevel> queue = new Queue <TreeLevel>();
TreeLevel rootTreeLevel = new TreeLevel(root, 0);
TreeLevel previousTreeLevel = rootTreeLevel;
queue.Enqueue(new TreeLevel(root, 0));
while (queue.Count != 0)
{
TreeLevel treeLevel = queue.Dequeue();
if (treeLevel.Node.left != null)
{
queue.Enqueue(new TreeLevel(treeLevel.Node.left, treeLevel.Level + 1));
}
if (treeLevel.Node.right != null)
{
queue.Enqueue(new TreeLevel(treeLevel.Node.right, treeLevel.Level + 1));
}
//Even odd value check
if (treeLevel.Level % 2 == 0 && treeLevel.Node.val % 2 == 0)
{
return(false);
}
else if (treeLevel.Level % 2 == 1 && treeLevel.Node.val % 2 == 1)
{
return(false);
}
//Check for increasing or decreasing
if (treeLevel.Level > 0 && treeLevel.Level == previousTreeLevel.Level)
{
//even Asceniding
if (treeLevel.Level % 2 == 0 && treeLevel.Node.val <= previousTreeLevel.Node.val)
{
return(false);
}
else if (treeLevel.Level % 2 == 1 && treeLevel.Node.val >= previousTreeLevel.Node.val) // Odd descending
{
return(false);
}
}
previousTreeLevel = treeLevel;
}
return(true);
}
internal uint GenerateHashBlock(uint xBlock, TreeLevel xTree)
{
if (xBlock >= 0x4AF768)
{
return(Constants.STFSEnd);
}
try
{
switch (xTree)
{
case TreeLevel.L0:
{
// Get Base Level 0 Table
uint num = (xBlock / BlockLevel[0]) * SpaceBetween[0];
// Adjusts the result for Level 1 table count
if (xBlock >= BlockLevel[0])
{
num += (((xBlock / BlockLevel[1]) + 1) << Shift);
// Adjusts for the Level 2 table
if (xBlock >= BlockLevel[1])
{
num += (uint)(1 << Shift);
}
}
return(num);
}
case TreeLevel.L1:
{
// Grab the number of Table 1 blocks
if (xBlock < BlockLevel[1])
{
return(xSpaceBetween[0]);
}
else
{
return((uint)((SpaceBetween[1] * (xBlock / BlockLevel[1])) + (1 << Shift)));
}
}
// Only one Level 2 table
case TreeLevel.L2:
return(SpaceBetween[1]);
default:
return(Constants.STFSEnd);
}
}
catch { throw STFSExcepts.General; }
}
public void Apply()
{
if (string.IsNullOrEmpty(name.Text))
{
Dialog.ShowMsg("内容不能为空");
return;
}
TreeLevel lv = TreeLevel.File;
switch (levels.SelectedIndex)
{
case 0: lv = TreeLevel.File; break;
case 1: lv = TreeLevel.Database; break;
case 2: lv = TreeLevel.Table; break;
}
KeyValue <string, string> key = dbtype.SelectedItem as KeyValue <string, string>;
CurNode = new TreeList
{
CONN_STRING = connstr.Text,
LEVEL = (!IsEdit && vm.SelectedNode == null) ? TreeLevel.File : lv,
NODE_NAME = name.Text,
SqlType = string.IsNullOrEmpty(connstr.Text) ? null : key.Key
};
if (vm.SelectedNode != null)
{
if (!IsEdit)
{
Insert(vm.TreeSource, vm.SelectedNode, CurNode);
}
else
{
Update(vm.TreeSource, vm.SelectedNode, CurNode);
}
}
else
{
vm.TreeSource.Add(CurNode);
}
}
public IList <IList <int> > LevelOrder(TreeNode root)
{
IList <IList <int> > result = new List <IList <int> >();
if (root == null)
{
return(result);
}
Queue <TreeLevel> queue = new Queue <TreeLevel>();
List <int> currentLevelList = new List <int>();
int currentLevel = 0;
queue.Enqueue(new TreeLevel(root, currentLevel));
while (queue.Count > 0)
{
TreeLevel nodeWithLevel = queue.Dequeue();
if (nodeWithLevel.Level == currentLevel)
{
currentLevelList.Add(nodeWithLevel.Node.val);
}
else
{
result.Add(currentLevelList);
currentLevelList = new List <int>();
currentLevelList.Add(nodeWithLevel.Node.val);
currentLevel = nodeWithLevel.Level;
}
if (nodeWithLevel.Node.left != null)
{
queue.Enqueue(new TreeLevel(nodeWithLevel.Node.left, nodeWithLevel.Level + 1));
}
if (nodeWithLevel.Node.right != null)
{
queue.Enqueue(new TreeLevel(nodeWithLevel.Node.right, nodeWithLevel.Level + 1));
}
}
result.Add(currentLevelList);
return(result);
}
internal long GenerateBaseOffset(uint xBlock, TreeLevel xTree)
{
try { return(BlockToOffset(GenerateHashBlock(xBlock, xTree))); }
catch { throw STFSExcepts.General; }
}
BlockRecord GetRecord(uint xBlock, TreeLevel xLevel)
{
if (xLevel == TreeLevel.LT)
return xSTFSStruct.TopRecord;
BlockRecord current = xSTFSStruct.TopRecord;
bool canswitch = (xSTFSStruct.ThisType == STFSType.Type1);
if (xSTFSStruct.xBlockCount > Constants.BlockLevel[1])
{
// Grab base position
xIO.Position = (xSTFSStruct.GenerateHashOffset(xBlock, TreeLevel.L2) + 0x14);
if (canswitch)
xIO.Position += (current.Index << 0xC);
current = new BlockRecord(xIO.ReadUInt32()); // Read new flag
if (xLevel == TreeLevel.L2)
{
// return if needed
current.ThisBlock = xBlock;
current.ThisLevel = TreeLevel.L2;
return current;
}
}
else if (xLevel == TreeLevel.L2)
return xSTFSStruct.TopRecord;
// Follows same procedure
if (xSTFSStruct.xBlockCount > Constants.BlockLevel[0])
{
xIO.Position = (xSTFSStruct.GenerateHashOffset(xBlock, TreeLevel.L1)) + 0x14;
if (canswitch)
xIO.Position += (current.Index << 0xC);
current = new BlockRecord(xIO.ReadUInt32());
if (xLevel == TreeLevel.L1)
{
current.ThisBlock = xBlock;
current.ThisLevel = TreeLevel.L1;
return current;
}
}
else if (xLevel == TreeLevel.L1)
return xSTFSStruct.TopRecord;
xIO.Position = (xSTFSStruct.GenerateHashOffset(xBlock, TreeLevel.L0)) + 0x14;
if (canswitch)
xIO.Position += (current.Index << 0xC);
current = new BlockRecord(xIO.ReadUInt32());
current.ThisBlock = xBlock;
current.ThisLevel = TreeLevel.L0;
return current;
}
/// <summary>
/// Generates a hash offset via block
/// </summary>
/// <param name="xBlock"></param>
/// <param name="xTree"></param>
/// <returns></returns>
internal long GenerateHashOffset(uint xBlock, TreeLevel xTree)
{
long xReturn = xSTFSStruct.GenerateHashOffset(xBlock, xTree);
if (xSTFSStruct.ThisType == STFSType.Type1) // Grabs the one up level block record for shifting
xReturn += (GetRecord(xBlock, (TreeLevel)((byte)xTree + 1)).Index << 0xC);
return xReturn;
}
internal long GenerateHashOffset(uint xBlock, TreeLevel xTree)
{
if (xBlock >= 0x4AF768)
return Constants.STFSEnd;
try
{
uint result = GenerateHashBlock(xBlock, xTree);
long xReturn = BlockToOffset(result);
switch (xTree)
{
case TreeLevel.L0:
xReturn += (0x18 * (xBlock % BlockLevel[0]));
break;
case TreeLevel.L1:
xReturn += (0x18 * ((xBlock / BlockLevel[0]) % BlockLevel[0]));
break;
case TreeLevel.L2:
xReturn += (0x18 * ((xBlock / BlockLevel[1]) % BlockLevel[0]));
break;
}
return xReturn;
}
catch { throw STFSExcepts.General; }
}
internal uint GenerateHashBlock(uint xBlock, TreeLevel xTree)
{
if (xBlock >= 0x4AF768)
return Constants.STFSEnd;
try
{
switch (xTree)
{
case TreeLevel.L0:
{
// Get Base Level 0 Table
uint num = (xBlock / BlockLevel[0]) * SpaceBetween[0];
// Adjusts the result for Level 1 table count
if (xBlock >= BlockLevel[0])
{
num += (((xBlock / BlockLevel[1]) + 1) << Shift);
// Adjusts for the Level 2 table
if (xBlock >= BlockLevel[1])
num += (uint)(1 << Shift);
}
return num;
}
case TreeLevel.L1:
{
// Grab the number of Table 1 blocks
if (xBlock < BlockLevel[1])
return xSpaceBetween[0];
else
return (uint)((SpaceBetween[1] * (xBlock / BlockLevel[1])) + (1 << Shift));
}
// Only one Level 2 table
case TreeLevel.L2:
return SpaceBetween[1];
default:
return Constants.STFSEnd;
}
}
catch { throw STFSExcepts.General; }
}
internal long GenerateBaseOffset(uint xBlock, TreeLevel xTree)
{
try { return BlockToOffset(GenerateHashBlock(xBlock, xTree)); }
catch { throw STFSExcepts.General; }
}
private void setLevelOfRow(TreeLevel i_level, int i_grid_row_index)
{
m_fg.Rows[i_grid_row_index].IsNode = true;
m_fg.Rows[i_grid_row_index].Node.Level = (int) i_level;
}