/*
* Copyright (c) 2005,2006 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  Depth iterator walks the dom tree using depth first principle.
*
*/



// INCLUDE FILES
#include    "hspsdomdepthiterator.h"
#include    "hspsdomlist.h"
#include    "hspsdomnode.h"

// ============================ LOCAL FUNCTIONS ===============================
 

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// ChspsDomDepthIterator::ChspsDomDepthIterator
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
ChspsDomDepthIterator::ChspsDomDepthIterator( ChspsDomNode& aRootNode  ):
    iFirst(&aRootNode), iCurrent(&aRootNode)
    {
    }

// -----------------------------------------------------------------------------
// ChspsDomDepthIterator::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void ChspsDomDepthIterator::ConstructL()
    {
    }

// -----------------------------------------------------------------------------
// ChspsDomDepthIterator::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C ChspsDomDepthIterator* ChspsDomDepthIterator::NewL( ChspsDomNode& aRootNode )
    {
    ChspsDomDepthIterator* self = new( ELeave ) ChspsDomDepthIterator( aRootNode );
    
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );

    return self;
    }

    
// Destructor
EXPORT_C ChspsDomDepthIterator::~ChspsDomDepthIterator()
    {
    iDepthLevel.Close();
    }

// -----------------------------------------------------------------------------
// ChspsDomDepthIterator::First
// -----------------------------------------------------------------------------
//
EXPORT_C ChspsDomNode* ChspsDomDepthIterator::First()
    {
    return iFirst;
    }
    
// -----------------------------------------------------------------------------
// ChspsDomDepthIterator::Next
// -----------------------------------------------------------------------------
//
EXPORT_C ChspsDomNode* ChspsDomDepthIterator::NextL()
    {
    ChspsDomNode* sibling = NULL; 
    ChspsDomNode* firstChild = NULL;     
    
    //Initialise iCurrent if the whole tree has been walked through 
    if (!iCurrent) 
        {
        iCurrent = iFirst;
        }
        
    firstChild = static_cast<ChspsDomNode*>( iCurrent->ChildNodes().First() );
        
    // Current node has childs left
    if (firstChild)
        {
        //Keep count of depth level
        PushL( *iCurrent );
        iCurrent = firstChild;
        }
    else //If current node has siblings left
        {
        sibling = NextSibling(*iCurrent);
        if(sibling)
            {
            iCurrent = sibling;    
            }
        else //Current node don't have any childs or siblings left
            {
            // Reverse the tree by moving up in hierarchy
            // Move up one level in hierarchy and check if siblings exists or we are in a 
            // root level
            TBool stop( EFalse );
            while( !stop && iDepthLevel.Count() )  
                {
                iCurrent = Pop();                   //Reach the previous level
                sibling = NextSibling( *iCurrent ); //Check if siblings exist
                if ( sibling && iDepthLevel.Count() )
                    {
                    iCurrent = sibling;
                    stop = ETrue;
                    }
                else                                //We didn't find any siblings
                    {
                    iCurrent = NULL;
                    }
                }    
            }
        }
    return iCurrent;
    }

// -----------------------------------------------------------------------------
// NextSibling Find next sibling.
// Returns NULL if there is no siblings left or there is no parent i.e this is a
// root node
// Returns: ChspsDomNode* Pointer to the node or NULL
//          
// -----------------------------------------------------------------------------
//

EXPORT_C ChspsDomNode* ChspsDomDepthIterator::NextSibling( ChspsDomNode& aNode )
    {
    ChspsDomNode* left = NULL;
    ChspsDomNode* parent = aNode.Parent();
    if ( parent )
        {
        ChspsDomList& nodeList = parent->ChildNodes();
        TInt currentIndex( nodeList.ItemIndex( aNode ) );
        TInt nextIndex( ++currentIndex );
        TInt length( nodeList.Length() );
        if ( nextIndex < length )  
            {
            left = static_cast<ChspsDomNode*>( nodeList.Item( nextIndex ) );
            }
        }
    return left;     
    }

// -----------------------------------------------------------------------------
// ChspsDomDepthIterator::PushL
// -----------------------------------------------------------------------------
//
void ChspsDomDepthIterator::PushL( ChspsDomNode& aNode )
    {
    iDepthLevel.AppendL( &aNode );
    }

// -----------------------------------------------------------------------------
// ChspsDomDepthIterator::Pop
// -----------------------------------------------------------------------------
//
ChspsDomNode* ChspsDomDepthIterator::Pop()
    {
    ChspsDomNode* pop = NULL;
    TInt count( iDepthLevel.Count() );
    if ( count )
        {
        pop = iDepthLevel[ count-1 ];
        iDepthLevel.Remove( count-1 );
        }
    return pop;    
    }
    
//  End of File