StiTreeNode.cxx

#include <assert.h>
#include "StiTreeNode.h"
#include "Factory.h"


//______________________________________________________________________________
StiTreeNode::StiTreeNode()
{
        reset();
}
//______________________________________________________________________________
void StiTreeNode::reset()
{
  parent = 0; children[0]=0; children[1]=0;
}
//______________________________________________________________________________  
//______________________________________________________________________________
void StiTreeNode::remove(int childIndex) 
{
  StiTreeNode *node =0;
  if (childIndex>=0)    { //remove children
    node =children[childIndex];children[childIndex]=0;
    if (!childIndex)    {children[0]=children[1]; children[1]=0;}
    if (!node)                  return;
    if (node->parent!=this)     return;
    node->remove(0);
    
  } else                {//remove parent
    node = parent; parent=0;
    if (!node)                  return;
    node->remove(0);
    node->remove(0);
    node->remove(-1);
  }
  node->reset();
  BFactory::Free(node);
}
//______________________________________________________________________________
StiTreeNode *StiTreeNode::disconnect(int all) 
{
  StiTreeNode *node =0;
  node = parent; parent=0;
  if (!node)                    return 0;
  assert(node->children[0]==this);
  assert(!children[1]);
  node->children[0]=0;
  if (all) return node;
  node->children[0]=children[0];
  if (children[0]) children[0]->parent=node;
  children[0]=0; 
  return node;
}

//______________________________________________________________________________
//______________________________________________________________________________
void StiTreeNode::setParent(StiTreeNode *  newParent) 
{
    parent = newParent;
}

//______________________________________________________________________________
//______________________________________________________________________________
StiTreeNode *  StiTreeNode::getParent() const
{
  return parent;
}

StiTreeNode *  StiTreeNode::getChildAt(int index) const
{
  return children[index];
}

//______________________________________________________________________________
//______________________________________________________________________________
int StiTreeNode::getChildCount() const
{
  int n=0; 
  if(children[0]) n++;
  if(children[1]) n++;
  return n;
}

//______________________________________________________________________________
// node's tree.  Returns 0 if this node is the last node of the
// traversal.  This is an inefficient way to traverse the entire tree; use
// an enumeration, instead.
//
// @see #preorderEnumeration
// @return      the node that follows this node in a preorder traversal, or
//              0 if this node is last
//______________________________________________________________________________
StiTreeNode *  StiTreeNode::getNextNode() const
{
  return children[0];
}


//______________________________________________________________________________// 
//Returns the node that precedes this node in a preorder traversal of
// this node's tree.  Returns 0 if this node is the first node of the
// traveral -- the root of the tree.  This is an inefficient way to
// traverse the entire tree; use an enumeration, instead.
//
// @see #preorderEnumeration
// @return      the node that precedes this node in a preorder traversal, or
//              0 if this node is the first
//______________________________________________________________________________
StiTreeNode *  StiTreeNode::getPrevNode() const
{
    return parent;
}
//______________________________________________________________________________
const StiTreeNode& StiTreeNode::operator=(const StiTreeNode& node)  
{
  reset();
  parent = node.parent; 
  return *this;
}
//______________________________________________________________________________
void StiTreeNode::add(StiTreeNode *  newChild,int direction)
{
  if (direction==0) {
    assert(!children[1]);
    children[1]=children[0];
    children[0]=newChild;
    newChild->setParent(this);

  } else {

    assert(!getParent());
    setParent(newChild);
    newChild->children[0]=this;
    newChild->children[1]=0;
  }
}
//______________________________________________________________________________
StiTreeNode *StiTreeNode::getLastNode() const
{
  const StiTreeNode *node = this;
  const StiTreeNode *next = 0;
  while ((next = node->getNextNode())) {
    node=next;
    assert(node!=this);
  }
  return (StiTreeNode*)node;
}
//______________________________________________________________________________
StiTreeNode *StiTreeNode::getFirstNode()  const
{
  const StiTreeNode *node = this;
  const StiTreeNode *back = 0;
  while ((back = node->getPrevNode())) {
    node=back;
    assert(node!=this);
  }
  return (StiTreeNode*)node;
}
//______________________________________________________________________________
void StiTreeNode::cutTail(int direction)  
{
   direction = (direction)? -1:0;
   remove(direction);
}
//______________________________________________________________________________
void  StiTreeNode::remove(StiTreeNode **fstNode,StiTreeNode **lstNode)
{
   assert(!children[1]);
   StiTreeNode **kLeft = (parent     )? &parent->children[0]:fstNode;
   StiTreeNode **kRite = (children[0])? &children[0]->parent:lstNode;
   *kLeft = children[0];
   *kRite = parent;
}