public void NextRow(object keyValue, IHierarchyObj owner)
{
try
{
BTreeNodeValue value = default(BTreeNodeValue);
int num = default(int);
int childIndex = default(int);
if (!this.m_root.SearchAndInsert(keyValue, this.m_nodes, owner, out value, out num, out childIndex))
{
int count = this.m_nodes.Count;
this.m_nodes.Add(this.m_root);
this.m_root = new BTreeNode(owner);
this.m_root.SetFirstChild(this.m_nodes, count);
this.m_root.Tuples.Add(new BTreeNodeTuple(value, childIndex), this.m_nodes);
}
}
catch (ReportProcessingException_SpatialTypeComparisonError)
{
throw new ReportProcessingException(owner.RegisterComparisonError("SortExpression"));
}
catch (ReportProcessingException_ComparisonError)
{
throw new ReportProcessingException(owner.RegisterComparisonError("SortExpression"));
}
}
public bool SearchAndInsert(object keyValue, ScalableList <BTreeNode> nodes, IHierarchyObj owner, out BTreeNodeValue newSiblingValue, out int newSiblingIndex, out int globalNewSiblingIndex)
{
int num = -1;
int i;
for (i = 1; i < this.m_tuples.Count; i++)
{
BTreeNodeTuple bTreeNodeTuple = this.m_tuples[i];
num = bTreeNodeTuple.Value.CompareTo(keyValue, owner.OdpContext);
if (num >= 0)
{
break;
}
}
if (num == 0)
{
this.m_tuples[i].Value.AddRow(owner);
}
else
{
int childIndex = this.m_tuples[i - 1].ChildIndex;
if (childIndex == -1)
{
return(this.InsertBTreeNode(nodes, this.CreateBTreeNode(keyValue, owner), i, -1, owner, out newSiblingValue, out newSiblingIndex, out globalNewSiblingIndex));
}
BTreeNode bTreeNode = default(BTreeNode);
using (nodes.GetAndPin(childIndex, out bTreeNode))
{
BTreeNodeValue nodeValueToInsert = default(BTreeNodeValue);
int nodeIndexToInsert = default(int);
int globalNodeIndexToInsert = default(int);
if (!bTreeNode.SearchAndInsert(keyValue, nodes, owner, out nodeValueToInsert, out nodeIndexToInsert, out globalNodeIndexToInsert))
{
return(this.InsertBTreeNode(nodes, nodeValueToInsert, nodeIndexToInsert, globalNodeIndexToInsert, owner, out newSiblingValue, out newSiblingIndex, out globalNewSiblingIndex));
}
}
}
newSiblingValue = null;
newSiblingIndex = -1;
globalNewSiblingIndex = -1;
return(true);
}
void IPersistable.Deserialize(IntermediateFormatReader reader)
{
reader.RegisterDeclaration(BTreeNodeTuple.m_declaration);
while (reader.NextMember())
{
switch (reader.CurrentMember.MemberName)
{
case MemberName.Value:
this.m_value = (BTreeNodeValue)reader.ReadRIFObject();
break;
case MemberName.Child:
this.m_childIndex = reader.ReadInt32();
break;
default:
Global.Tracer.Assert(false);
break;
}
}
}
private bool InsertBTreeNode(ScalableList <BTreeNode> nodes, BTreeNodeValue nodeValueToInsert, int nodeIndexToInsert, int globalNodeIndexToInsert, IHierarchyObj owner, out BTreeNodeValue newSiblingValue, out int newSiblingIndex, out int globalNewSibingIndex)
{
if (3 > this.m_tuples.Count)
{
this.m_tuples.Insert(nodeIndexToInsert, new BTreeNodeTuple(nodeValueToInsert, globalNodeIndexToInsert), nodes);
newSiblingValue = null;
newSiblingIndex = -1;
globalNewSibingIndex = -1;
return(true);
}
int num = 2;
BTreeNode bTreeNode = new BTreeNode(owner);
BTreeNodeValue bTreeNodeValue;
if (num < nodeIndexToInsert)
{
bTreeNodeValue = this.m_tuples[num].Value;
bTreeNode.SetFirstChild(nodes, this.m_tuples[num].ChildIndex);
for (int i = num + 1; i < ((this.m_tuples.Count <= nodeIndexToInsert) ? this.m_tuples.Count : nodeIndexToInsert); i++)
{
bTreeNode.m_tuples.Add(this.m_tuples[i], nodes);
}
bTreeNode.m_tuples.Add(new BTreeNodeTuple(nodeValueToInsert, globalNodeIndexToInsert), nodes);
for (int j = nodeIndexToInsert; j < this.m_tuples.Count; j++)
{
bTreeNode.m_tuples.Add(this.m_tuples[j], nodes);
}
int count = this.m_tuples.Count;
for (int k = num; k < count; k++)
{
this.m_tuples.RemoveAtEnd();
}
}
else if (num > nodeIndexToInsert)
{
bTreeNodeValue = this.m_tuples[num - 1].Value;
bTreeNode.SetFirstChild(nodes, this.m_tuples[num - 1].ChildIndex);
for (int l = num; l < this.m_tuples.Count; l++)
{
bTreeNode.m_tuples.Add(this.m_tuples[l], nodes);
}
int count2 = this.m_tuples.Count;
for (int m = num - 1; m < count2; m++)
{
this.m_tuples.RemoveAtEnd();
}
this.m_tuples.Insert(nodeIndexToInsert, new BTreeNodeTuple(nodeValueToInsert, globalNodeIndexToInsert), nodes);
}
else
{
bTreeNodeValue = nodeValueToInsert;
bTreeNode.SetFirstChild(nodes, globalNodeIndexToInsert);
for (int n = num; n < this.m_tuples.Count; n++)
{
bTreeNode.m_tuples.Add(this.m_tuples[n], nodes);
}
int count3 = this.m_tuples.Count;
for (int num2 = num; num2 < count3; num2++)
{
this.m_tuples.RemoveAtEnd();
}
}
newSiblingValue = bTreeNodeValue;
newSiblingIndex = this.m_indexInParent + 1;
globalNewSibingIndex = nodes.Count;
nodes.Add(bTreeNode);
return(false);
}
public BTreeNodeTuple(BTreeNodeValue value, int childIndex)
{
this.m_value = value;
this.m_childIndex = childIndex;
}
