// GuestTree.C

#include <stddef.h>
#include "IOStuff.h"
#include "GuestTree.h"

struct TreeNode {
    GuestInfo data;
    NodePtr lLink; // left child
    NodePtr rLink; // right child

    // constructor
    TreeNode( const GuestInfo & g,
	      NodePtr l, NodePtr r);
};

TreeNode::TreeNode( const GuestInfo & g,
                    NodePtr leftPtr,
                    NodePtr rightPtr )
 : data(g),
   lLink(leftPtr), rLink(rightPtr)
{}

GuestTree::GuestTree()
{
  rootPtr = NULL;
}

GuestTree::GuestTree(const GuestTree& gt)
{
  cerr << "GuestTree copy constructor called" << endl;
}

GuestTree::~GuestTree()
{
  delete rootPtr;
}


GuestTree& GuestTree::operator = (
		   const GuestTree & gt)
{
  cerr << "GuestTree assignment operator called" << endl;
  return (*this);
}

Boolean GuestTree::IsEmpty() const
{
    return (rootPtr == NULL);
}

void GuestTree::BuildRoot(
              const GuestInfo & g)
{
  rootPtr = new TreeNode(g, NULL, NULL);
}

NodePtr GuestTree::Root() const
{
  return rootPtr;
}

void GuestTree::SetRoot(NodePtr ptr)
{
  rootPtr = ptr;
}

void AppendLeft( NodePtr ptr,
                 const GuestInfo & g )
{
    ptr->lLink = new TreeNode(
			g, NULL, NULL);
}

void AppendRight( NodePtr ptr,
                  const GuestInfo & g )
{
  ptr->rLink = new TreeNode(
			 g, NULL, NULL);
}

GuestInfo Data( NodePtr ptr )
{
  return ptr->data;
}

void Store( NodePtr ptr,
            const GuestInfo & g )
{
  ptr->data = g;
}

NodePtr LChild( NodePtr ptr )
{
  return (ptr==NULL) ? NULL : ptr->lLink;
}

NodePtr RChild( NodePtr ptr )
{
  return (ptr==NULL) ? NULL : ptr->rLink;
}

void SetLeft(NodePtr ptr,
		      NodePtr p)
{
  ptr->lLink = p;
}

void SetRight(NodePtr ptr,
		      NodePtr p)
{
  ptr->rLink = p;
}

Boolean IsLeaf( NodePtr ptr )
{
  return (ptr->lLink == NULL
	  && ptr->rLink == NULL);
}

void DeleteLeaf( NodePtr& ptr )
  // POST: *ptr deallocated
{
  delete ptr;
  ptr = NULL;
}

void PrintInOrder( NodePtr ptr )
{
  if (ptr != NULL) {
    PrintInOrder(LChild(ptr));
    GuestInfo temp = ptr->data;
    cout << temp;
    PrintInOrder(RChild(ptr));
  }
}