Comments and suggestions?

[JamesSchumacher]

I have tested this and debugged it, I have found no problems that I can see at the moment. Can any of you see any POTENTIAL problems with the below code?


template <typename NodeType> bool Tree<NodeType>::Add(NodeType * pNode,const IComparer<NodeType> * pComparer)
{
if (pNode != 0 && pComparer != 0)
{
if (m_pRootNode != 0)
{
bool bAdded = false;
bool bLessNode = false;

long nCompareValue = pComparer->Compare(*pNode,*m_pRootNode);

if (nCompareValue == 0)
{
m_pRootNode->EqualList.Add(pNode);
bAdded = true;
}
else
{
NodeType * pCurrentNode = 0;
NodeType * pParentNode = 0;

if (nCompareValue < 0)
{
bLessNode = true;
pCurrentNode = static_cast<NodeType *>(m_pRootNode->LessTreeNode);
}
else if (nCompareValue > 0)
{
bLessNode = false;
pCurrentNode = static_cast<NodeType *>(m_pRootNode->GreaterTreeNode);
}

pParentNode = m_pRootNode;

while (pCurrentNode != 0)
{
nCompareValue = pComparer->Compare(*pNode,*pCurrentNode);

if (nCompareValue == 0)
{
pCurrentNode->EqualList.Add(pNode);
bAdded = true;
break;
}
else if (nCompareValue < 0)
{
bLessNode = true;
}
else if (nCompareValue > 0)
{
bLessNode = false;
}

pParentNode = pCurrentNode;

if (bLessNode == true)
{
pCurrentNode = static_cast<NodeType *>(pParentNode->LessTreeNode);
}
else
{
pCurrentNode = static_cast<NodeType *>(pParentNode->GreaterTreeNode);
}

if (pCurrentNode == 0)
{
break;
}
}

if (bAdded == false)
{
if (bLessNode == true)
{
pParentNode->LessTreeNode = pNode;
pNode->ParentTreeNode = pParentNode;
pNode->TreeNextNode = pParentNode->TreeNextNode;

if (pParentNode->TreeNextNode != 0)
{
pParentNode->TreeNextNode->TreePriorNode = pNode;
}

pParentNode->TreeNextNode = pNode;
pNode->TreePriorNode = pParentNode;
}
else
{
pParentNode->GreaterTreeNode = pNode;
pNode->ParentTreeNode = pParentNode;
pNode->TreePriorNode = pParentNode->TreePriorNode;

if (pParentNode->TreePriorNode != 0)
{
pParentNode->TreePriorNode->TreeNextNode = pNode;
}

pParentNode->TreePriorNode = pNode;
pNode->TreeNextNode = pParentNode;
}

if (pNode->TreePriorNode == 0)
{
m_pHighNode = pNode;
}

if (pNode->TreeNextNode == 0)
{
m_pLowNode = pNode;
}

bAdded = true;
}
}

return bAdded;
}
else
{
pNode->ParentTreeNode = 0;
pNode->LessTreeNode = 0;
pNode->GreaterTreeNode = 0;
pNode->TreePriorNode = 0;
pNode->TreeNextNode = 0;

m_pRootNode = pNode;
m_pHighNode = pNode;
m_pLowNode = pNode;

m_dwNodeCount = 1;

return true;
}
}
else
{
return false;
}
}