////////////////////////////////////////////////////////////////////////////
public Node Merge(Node aNode)
{
if (aNode is StdNode)
{
StdNode node = (StdNode)aNode;
Node newLeft = node.left != null?Merge(node.left) : this;
return(new StdNode(node.elt, node.hashcode, newLeft, node.right));
}
else
{
ArraysNode node = (ArraysNode)aNode;
if (count > node.count) // count > node.count >= 2 => count >= 3
{
Node left = NewNode(elts, hashcodes, first, count - 1);
int idx = first + count - 1;
return(new StdNode(elts[idx], hashcodes[idx], left, node));
}
else // node.count >= count >= 2 => count >= 2
{
Node right = NewNode(node.elts, node.hashcodes, node.first + 1, node.count - 1);
return(new StdNode(node.elts[node.first], node.hashcodes[node.first], this, right));
}
}
}
internal StdNode(Obj key, Obj value, uint hashcode, Node left, Node right)
{
this.key = key;
this.value = value;
this.hashcode = hashcode;
this.size = 1 + (left != null ? left.Size() : 0) + (right != null ? right.Size() : 0);
this.left = left;
this.right = right;
if (left != null)
{
if (left is StdNode)
{
StdNode node = (StdNode)left;
Debug.Assert(
node.hashcode < hashcode || (node.hashcode == hashcode && node.key.QuickOrder(key) < 0)
);
}
else
{
ArraysNode node = (ArraysNode)left;
int last = node.first + node.count - 1;
Debug.Assert(
node.hashcodes[last] < hashcode ||
(node.hashcodes[last] == hashcode && node.keys[last].QuickOrder(key) < 0)
);
}
}
if (right != null)
{
if (right is StdNode)
{
StdNode node = (StdNode)right;
Debug.Assert(
hashcode < node.hashcode || (node.hashcode == hashcode && key.QuickOrder(node.key) < 0)
);
}
else
{
ArraysNode node = (ArraysNode)right;
int first = node.first;
Debug.Assert(
hashcode < node.hashcodes[first] ||
(node.hashcodes[first] == hashcode && key.QuickOrder(node.keys[first]) < 0)
);
}
}
}
