tree.cpp

用C语言设计的EPSON LCD控制器S1D13700驱动。

//============================================================================
//
//  TREE.CPP
//
//  Copyright (c) 2002 Epson Research and Development, Inc. 
//  All rights reserved.
//
//	The tabs in the file is formatted at 4.
//
//============================================================================


#include "datatype.h"
#include "assert.h"




Tree::Tree( void (*i_DeleteDataCallback)(void*) ) :
//
//	i_DeleteDataCallback - callback function to call when a tree node is deleted and it's Data needs to be deleted too.
//
	m_Root( NULL ),
	m_NumNodes( 0 )
{
	m_cbDeleteData = i_DeleteDataCallback;
}




Tree::~Tree( )
{
	DeleteAllNodes( );
	assert( m_NumNodes == 0 );
}




Tree::NodeIterator Tree::CreateRoot( )
{
	m_Root = new TreeNode;
	InitializeNode( m_Root );

	m_NumNodes++;
	return (NodeIterator)m_Root;
}




void Tree::CreateFirstChild( NodeIterator& io_Node )
{
	TreeNode* Node = (TreeNode*)io_Node;
	assert( m_Root != NULL );

	Node->FirstChild = new TreeNode;
	InitializeNode( Node->FirstChild );
	Node->FirstChild->Parent = Node;

	m_NumNodes++;
	io_Node = (NodeIterator)Node->FirstChild;
}




void Tree::CreateNextSibling( NodeIterator& io_Node )
{
	TreeNode* Node = (TreeNode*)io_Node;
	assert( m_Root != NULL );

	Node->NextSibling = new TreeNode;
	InitializeNode( Node->NextSibling );
	Node->NextSibling->PrevSibling = Node;
	Node->NextSibling->Parent = Node->Parent;

	m_NumNodes++;
	io_Node = (NodeIterator)Node->NextSibling;
}




void Tree::DeleteNodeAndChildren( NodeIterator i_Node )
{
	TreeNode* Node = (TreeNode*)i_Node;

	if ( Node != NULL )
	{
		TreeNode* Child = Node->FirstChild;

		while ( Child != NULL )
		{
			TreeNode* NextSibling = Child->NextSibling;
			DeleteNodeAndChildren( (NodeIterator)Child );
			Child = NextSibling;
		}
		(*m_cbDeleteData)( Node->Data );
		delete [] Node;
		m_NumNodes--;
	}
}




void Tree::DeleteAllNodes( void )
{
	while ( m_Root != NULL )
	{
		TreeNode* NextRootNode = m_Root->NextSibling;
		DeleteNodeAndChildren( (NodeIterator)m_Root );
		m_Root = NextRootNode;
	}
}




bool Tree::Root( NodeIterator& io_Node ) const
{
	io_Node = (NodeIterator)m_Root;
	return ( m_Root != NULL );
}




bool Tree::Parent( NodeIterator& io_Node ) const
{
	assert( (TreeNode*)io_Node != NULL );

	if ( ((TreeNode*)io_Node)->Parent == NULL )
		return false;
	io_Node = (NodeIterator)((TreeNode*)io_Node)->Parent;
	return true;
}




bool Tree::PrevSibling( NodeIterator& io_Node ) const
{
	assert( (TreeNode*)io_Node != NULL );

	if ( ((TreeNode*)io_Node)->PrevSibling == NULL )
		return false;
	io_Node = (NodeIterator)((TreeNode*)io_Node)->PrevSibling;
	return true;
}




bool Tree::NextSibling( NodeIterator& io_Node ) const
{
	assert( (TreeNode*)io_Node != NULL );

	if ( ((TreeNode*)io_Node)->NextSibling == NULL )
		return false;
	io_Node = (NodeIterator)((TreeNode*)io_Node)->NextSibling;
	return true;
}




bool Tree::FirstChild( NodeIterator& io_Node ) const
{
	assert( (TreeNode*)io_Node != NULL );

	if ( ((TreeNode*)io_Node)->FirstChild == NULL )
		return false;
	io_Node = (NodeIterator)((TreeNode*)io_Node)->FirstChild;
	return true;
}




bool Tree::ExistRoot( NodeIterator& io_Node ) const
{
	return ( m_Root != NULL );
}




bool Tree::ExistParent( NodeIterator& io_Node ) const
{
	assert( (TreeNode*)io_Node != NULL );
	return ( ((TreeNode*)io_Node)->Parent != NULL );
}




bool Tree::ExistPrevSibling( NodeIterator& io_Node ) const
{
	assert( (TreeNode*)io_Node != NULL );
	return ( ((TreeNode*)io_Node)->PrevSibling != NULL );
}




bool Tree::ExistNextSibling( NodeIterator& io_Node ) const
{
	assert( (TreeNode*)io_Node != NULL );
	return ( ((TreeNode*)io_Node)->NextSibling != NULL );
}




bool Tree::ExistFirstChild( NodeIterator& io_Node ) const
{
	assert( (TreeNode*)io_Node != NULL );
	return ( ((TreeNode*)io_Node)->FirstChild != NULL );
}




void* Tree::Data( NodeIterator& i_Node ) const
{
	assert( (TreeNode*)i_Node != NULL );

	return ((TreeNode*)i_Node)->Data;
}




void Tree::Data( NodeIterator& i_Node, void* i_NewData )
{
	assert( (TreeNode*)i_Node != NULL );

	((TreeNode*)i_Node)->Data = i_NewData;
}




void Tree::InitializeNode( TreeNode* i_Node )
{
	assert( i_Node != NULL );

	i_Node->Parent = NULL;
	i_Node->PrevSibling = NULL;
	i_Node->NextSibling = NULL;
	i_Node->FirstChild = NULL;
	i_Node->Data = NULL;
}