C++ Template class BST

#include "Debug.hpp"

namespace esc
{
    template < typename TComparable, typename TValue >
    SearchTree< TComparable, TValue >::SearchTree( void )
        : mNodeCount( 0 ),
          mRoot( NULL )
    {}

    template < typename TComparable, typename TValue >
    SearchTree< TComparable, TValue >::~SearchTree( void )
    {
        if ( mRoot ) delete mRoot;
    }

    template < typename TComparable, typename TValue >
    TValue SearchTree< TComparable, TValue >::find( const TComparable& k )
    {
        if ( !mRoot )
        {
            Debug::Log::info( "Tree empty, called from SearchTree::find( const TComparable& k ). Bailing out." );
            return;
        }

        Node* traverser = mRoot;

        while( traverser != NULL )
        {
            if ( k < traverser->Key )
            {
                if ( traverser->mLeftChild )
                {
                    traverser = traverser->mLeftChild;
                    continue;
                }
                else
                {
                    return false; //node doesn't exist
                }
            }
            else if ( k > traverser->Key )
            {
                if( traverser->mRightChild )
                {
                    traverser = traverser->mRightChild;
                    continue;
                }
                else
                {
                    return false; //node doesn't exist
                }
            }
            else // nodes are equal
            {
                return *( traverser->Value );
            }
        }
    }

    template < typename TComparable, typename TValue >
    void SearchTree< TComparable, TValue >::insert( const TComparable& k, const TValue& v )
    {
        if ( !mRoot )
        {
            mRoot = new Node;
            mRoot->Key = k;
            mRoot->Value = v;

            return;
        }

        Node* traverser = mRoot;

        while( traverser != NULL )
        {
            if ( k < traverser->Key )
            {
                if ( traverser->mLeftChild )
                {
                    traverser = traverser->mLeftChild;

                    continue;
                }

                //left child doesn't exist, thus, create it: we have found our new position.

                traverser->mLeftChild = new Node;
                traverser->mLeftChild->Key = k;
                traverser->mLeftChild->Value = v;
            }
            else if ( k > traverser->Key )
            {
                if( traverser->mRightChild )
                {
                    traverser = traverser->mRightChild;

                    continue;
                }

                //right child doesn't exist, thus, create it: we have found our new position.

                traverser->mRightChild = new Node;
                traverser->mRightChild->Key = k;
                traverser->mLeftChild->Value = v;
            }
            else //is equal to
            {
                return;
            }
        }
    }

    template < typename TComparable, typename TValue >
    void SearchTree< TComparable, TValue >::insert( const Iterator& pIter )
    {

    }

    template < typename TComparable, typename TValue >
    typename SearchTree< TComparable, TValue >::Iterator SearchTree< TComparable, TValue >::begin( TreeIterator::IteratorFocus f ) const
    {
        typename SearchTree< TComparable, TValue >::Iterator ret( 0, f );
        return ret;
    }

    template < typename TComparable, typename TValue >
    typename SearchTree< TComparable, TValue >::Iterator SearchTree< TComparable, TValue >::end( TreeIterator::IteratorFocus f ) const
    {
        return typename SearchTree< TComparable, TValue >::Iterator( mNodeCount, f );
    }

    /************************/
    /* SearchTree::Iterator */
    /************************/

    template < typename TComparable, typename TValue >
    SearchTree< TComparable, TValue >::Iterator::Iterator( void )
        : mIterPosition( 0 ),
          mCurrentNode( NULL ),
          mFocus( Leftmost ),
    {}

    template < typename TComparable, typename TValue >
    SearchTree< TComparable, TValue >::Iterator::Iterator( int32_t position, IteratorFocus focus )
        : mIterPosition( position ),
          mCurrentNode( NULL ),
          mFocus( focus )
    {}

    template < typename TComparable, typename TValue >
    SearchTree< TComparable, TValue >::Iterator::~Iterator( void )
    {}

    template < typename TComparable, typename TValue >
    bool SearchTree< TComparable, TValue >::Iterator::isLeafNode( const Node*& n )
    {
        return ( n->mLeftChild == NULL && n->mRightChild == NULL );
    }

    template < typename TComparable, typename TValue >
    bool SearchTree< TComparable, TValue >::Iterator::isInternalNode( const Node*& n )
    {
        return ( n->mLeftChild != NULL && n->mRightChild != NULL );
    }

    template < typename TComparable, typename TValue >
    int32_t SearchTree< TComparable, TValue >::Iterator::operator++( void )
    {
        static int32_t numStepsLeft = 0;
        static int32_t numStepsRight = 0;

        if ( numStepsLeft != numStepsRight )
        {
            if ( numStepsLeft > numStepsRight )
            {
                mCurrentNode = mCurrentNode->mRightChild;
                ++numStepsRight;
            }
            else
            {
                mCurrentNode = mCurrentNode->mLeftChild;
                ++numStepsLeft;
            }
        }
        else
        {
            switch ( mFocus )
            {
            case Rightmost:
                mCurrentNode = mCurrentNode->mRightChild;
                break;
            case Leftmost:
                mCurrentNode = mCurrentNode->mLeftChild;
                break;
            }
        }


        return ++mIterPosition;
    }

    template < typename TComparable, typename TValue >
    bool SearchTree< TComparable, TValue >::Iterator::operator==( const Iterator& pIter )
    {
        return ( pIter.getCurrent() == mCurrentNode ) && ( pIter.getPosition() == mIterPosition );
    }

    template < typename TComparable, typename TValue >
    bool SearchTree< TComparable, TValue >::Iterator::operator!=( const Iterator& pIter )
    {
        return ( pIter.getCurrent() != mCurrentNode ) && ( pIter.getPosition() != mIterPosition );
    }

    template < typename TComparable, typename TValue >
    bool SearchTree< TComparable, TValue >::Iterator::inOrderTraverse( Node* n )
    {
        if ( n != NULL && isInternalNode( n ) )
        {
            inOrderTraverse( n->mLeftChild );
            inOrderTraverse( n->mRightChild );
        }
    }

    template < typename TComparable, typename TValue >
    TValue SearchTree< TComparable, TValue >::Iterator::treeSearch( Node* n, const TComparable& k )
    {
        if ( n != NULL )
        {
            if ( n == NULL )
            {
                return NULL;
            }
            else if ( k == n->Key )
            {
                return n->Value;
            }
            else if ( k < n->Key )
            {
                return treeSearch( n->mLeftChild, k );
            }
            else
            {
                return treeSearch( n->mRightChild, k );
            }
        }
    }




}