public void add(int weight, T key)
{
NestedNode node = new NestedNode();
node.weight = weight;
node.key = key;
allNodes.Add(node);
int size = allNodes.Count;
int current = size - 1;
int parentIndex = (current - 1) / 2;
nodePosition[node.key] = current;
while (parentIndex >= 0)
{
NestedNode parentNode = allNodes[parentIndex];
NestedNode currentNode = allNodes[current];
if (parentNode.weight > currentNode.weight)
{
swap(parentNode, currentNode);
updatePositionOnMap(parentNode.key, currentNode.key, parentIndex, current);
current = parentIndex;
parentIndex = (parentIndex - 1) / 2;
}
else
{
break;
}
}
}
private void swap(NestedNode parentNode, NestedNode currentNode)
{
int weight = parentNode.weight;
T data = parentNode.key;
parentNode.key = currentNode.key;
parentNode.weight = currentNode.weight;
currentNode.key = data;
currentNode.weight = weight;
}
public NestedNode extractMinNode()
{
int size = allNodes.Count - 1;
NestedNode minNode = new NestedNode();
minNode.key = allNodes[0].key;
minNode.weight = allNodes[0].weight;
int lastNodeWeight = allNodes[size].weight;
allNodes[0].weight = lastNodeWeight;
allNodes[0].key = allNodes[size].key;
nodePosition.Remove(minNode.key);
nodePosition.Remove(allNodes[0].key);
nodePosition.Add(allNodes[0].key, 0);
allNodes.Remove(allNodes[size]);
int currentIndex = 0;
size--;
while (true)
{
int left = 2 * currentIndex + 1;
int right = 2 * currentIndex + 2;
if (left > size)
{
break;
}
if (right > size)
{
right = left;
}
int smallerIndex = allNodes[left].weight <= allNodes[right].weight ? left : right;
if (allNodes[currentIndex].weight > allNodes[smallerIndex].weight)
{
swap(allNodes[currentIndex], allNodes[smallerIndex]);
updatePositionOnMap(allNodes[currentIndex].key, allNodes[smallerIndex].key, currentIndex,
smallerIndex);
currentIndex = smallerIndex;
}
else
{
break;
}
}
return(minNode);
}
} // end _VerifyParamsAndBuildFullTypeName()
public override bool Matches(DbgTemplateNode other)
{
// Special typename wildcard:
if (IsEitherNameSingleTypeWildcard(other.FullName, FullName))
{
return(true);
}
if (!other.IsTemplate)
{
return(false);
}
DbgTemplate dtOther = (DbgTemplate)other;
// TODO: PS Wildcard? Regex?
if (0 != Util.Strcmp_OI(dtOther.TemplateName, TemplateName))
{
return(false);
}
for (int i = 0; i < dtOther.Parameters.Count; i++)
{
if (i >= Parameters.Count)
{
return(false);
}
// Special typename wildcard:
if (IsMultiMatchWildcard(dtOther.Parameters[i]))
{
if (i != (dtOther.Parameters.Count - 1))
{
Util.Fail("Not reachable."); // construction of such now disallowed.
throw new ArgumentException(Util.Sprintf("The '{0}' placeholder can only come last in a template parameter list.",
c_MultiTypeWildcard),
"other");
}
break;
}
// Special typename wildcard:
if (IsMultiMatchWildcard(Parameters[i]))
{
if (i != (Parameters.Count - 1))
{
throw new ArgumentException(Util.Sprintf("The '{0}' placeholder can only come last in a template parameter list.",
c_MultiTypeWildcard),
"this");
}
break;
}
if (!Parameters[i].Matches(dtOther.Parameters[i]))
{
return(false);
}
}
if ((null == NestedNode) != (null == dtOther.NestedNode))
{
// One has a nested node, and the other doesn't.
return(false);
}
if (null != NestedNode)
{
return(NestedNode.Matches(dtOther.NestedNode));
}
else
{
return(true);
}
} // end Matches()
public T extractMin()
{
NestedNode node = extractMinNode();
return(node.key);
}
