/*

* Copyright (c) 2005 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:   XDM Engine document node

*

*/

// INCLUDE FILES

#include "XdmEngine.h"

#include "XdmDocument.h"

#include "XdmNodeFactory.h"

#include "XdmDocumentNode.h"

#include "XdmNodeAttribute.h"

//XML Escape codes

_LIT8( KXmlBracketOpenEsc,                             "<");

_LIT8( KXmlBracketCloseEsc,                            ">");

_LIT8( KXmlAmpersandEsc,                               "&");

// ----------------------------------------------------------

// CXdmDocumentNode::CXdmDocumentNode

// 

// ----------------------------------------------------------

//

EXPORT_C CXdmDocumentNode::CXdmDocumentNode( CXdmEngine& aXdmEngine,

                                             MXdmNodeFactory& aNodeFactory ) :

                                             iPosition( KErrNotFound ),

                                             iEmptyNode( EFalse ),

                                             iXdmEngine( aXdmEngine ),

                                             iNodeFactory( aNodeFactory )                                           

    {

    }

// ----------------------------------------------------------

// CXdmDocumentNode::CXdmDocumentNode

// 

// ----------------------------------------------------------

//

EXPORT_C CXdmDocumentNode::CXdmDocumentNode( CXdmEngine& aXdmEngine,

                                             MXdmNodeFactory& aNodeFactory,

                                             CXdmDocumentNode* aParentNode ) :

                                             iEmptyNode( EFalse ),

                                             iXdmEngine( aXdmEngine ),

                                             iNodeFactory( aNodeFactory ),

                                             iParentNode( aParentNode )

    {   

    }

// ----------------------------------------------------------

// CXdmDocumentNode::CXdmDocumentNode

// 

// ----------------------------------------------------------

//

EXPORT_C CXdmDocumentNode::CXdmDocumentNode( const TBool aLeafNode,

                                             CXdmEngine& aXdmEngine,

                                             MXdmNodeFactory& aNodeFactory,

                                             CXdmDocumentNode* aParentNode ) :

                                             iLeafNode( aLeafNode ),

                                             iEmptyNode( EFalse ),

                                             iXdmEngine( aXdmEngine ),

                                             iNodeFactory( aNodeFactory ),

                                             iParentNode( aParentNode )

    {

    }

// ----------------------------------------------------------

// CXdmDocumentNode::ConstructL

// 

// ----------------------------------------------------------

//

EXPORT_C void CXdmDocumentNode::BaseConstructL( const TDesC& aNodeName )

    {

    delete iNodeName;

    iNodeName = NULL;

    iNodeName = HBufC::NewL( aNodeName.Length() );

    iNodeName->Des().Copy( aNodeName );

    }

// ----------------------------------------------------------

// CXdmDocumentNode::CopyConstructL

// 

// ----------------------------------------------------------

//

EXPORT_C void CXdmDocumentNode::CopyConstructL( const CXdmDocumentNode& aAnotherNode,

		                                        const CXdmDocumentNode& aParentNode )

    {

    #ifdef _DEBUG

        iXdmEngine.WriteToLog( _L8( "CXdmDocumentNode::CopyConstructL()" ) );

    #endif

    if( aAnotherNode.ElementType() != EXdmElementAttribute )

        {

        ConstructChildrenL( aAnotherNode );

        ConstructAttributesL( aAnotherNode );

        }

    iLeafNode = aAnotherNode.IsLeafNode();

    iEmptyNode = aAnotherNode.IsEmptyNode();

    if( iLeafNode )

        {

        iLeafContent = HBufC8::New( aAnotherNode.LeafNodeContent().Length() );

        iLeafContent->Des().Copy( aAnotherNode.LeafNodeContent() );

        }

    iParentNode = CONST_CAST( CXdmDocumentNode*, &aParentNode ); 

    }

// ----------------------------------------------------------

// CXdmDocumentNode::ConstructAttributesL

// 

// ----------------------------------------------------------

//

void CXdmDocumentNode::ConstructAttributesL( const CXdmDocumentNode& aAnotherNode )

    {

    #ifdef _DEBUG

        iXdmEngine.WriteToLog( _L8( "CXdmDocumentNode::CopyConstructL()" ) );

    #endif

    TInt attrCount = aAnotherNode.AttributeCount();

    for( TInt i = 0;i < attrCount;i++ )

        {

        TPtrC name = aAnotherNode.Attribute( i )->NodeName();

        TPtrC value = aAnotherNode.Attribute( i )->AttributeValue();

        CXdmNodeAttribute* attribute = iNodeFactory.AttributeL( name );

        CleanupStack::PushL( attribute );

        attribute->SetAttributeValueL( value );

        User::LeaveIfError( iAttributes.Append( attribute ) );

        CleanupStack::Pop();  //attribute

        }

    }

// ----------------------------------------------------------

// CXdmDocumentNode::ConstructChildrenL

// 

// ----------------------------------------------------------

//

void CXdmDocumentNode::ConstructChildrenL( const CXdmDocumentNode& aAnotherNode )

    {

    #ifdef _DEBUG

        iXdmEngine.WriteToLog( _L8( "CXdmDocumentNode::ConstructChildrenL()" ) );

    #endif

    TInt childCount = aAnotherNode.NodeCount();

    for( TInt i = 0;i < childCount;i++ )

        {

        CXdmDocumentNode* node = aAnotherNode.ChileNode( i );

        CXdmDocumentNode* copy = iNodeFactory.ChileNodeL( node );

        CleanupStack::PushL( copy );

        User::LeaveIfError( iChildren.Append( copy ) );

        CleanupStack::Pop();  //copy

        }

    }

// ----------------------------------------------------

// CXdmDocumentNode::~CXdmDocumentNode

// 

// ----------------------------------------------------

//

EXPORT_C CXdmDocumentNode::~CXdmDocumentNode()

    {

    #ifdef _DEBUG

        iXdmEngine.WriteToLog( _L8( "CXdmDocumentNode::~CXdmDocumentNode()" ) );

    #endif

    delete iNextNode;

    iNextNode = NULL;

    delete iLeafContent;

    delete iNodeName;

    iChildren.ResetAndDestroy();

    iChildren.Close();

    iAttributes.ResetAndDestroy();

    iAttributes.Close();

    }

// ----------------------------------------------------

// CXdmDocumentNode::CreateChileNodeL

// 

// ----------------------------------------------------

//

EXPORT_C CXdmDocumentNode* CXdmDocumentNode::CreateChileNodeL()

    {

    /*#ifdef _DEBUG

        iXdmEngine.WriteToLog( _L8( "CXdmDocumentNode::CreateChileNodeL()" ) );

    #endif*/

    __ASSERT_ALWAYS( !iEmptyNode, User::Panic( _L( "CXdmDocumentNode" ), ENodeNotEmpty ) );

    CXdmDocumentNode* node = iNodeFactory.ChileNodeL();

    CleanupStack::PushL( node );

    User::LeaveIfError( iChildren.Append( node ) );

    CleanupStack::Pop();  //node

    return node;

    }

// ----------------------------------------------------

// CXdmDocumentNode::CreateChileNodeL

// 

// ----------------------------------------------------

//

EXPORT_C CXdmDocumentNode* CXdmDocumentNode::CreateChileNodeL( const TDesC& aChildName )

    {

    /*#ifdef _DEBUG

        iXdmEngine.WriteToLog( _L8( "CXdmDocumentNode::CreateChileNodeL() - Name: %S" ), &aChildName );

    #endif*/

    __ASSERT_ALWAYS( !iEmptyNode, User::Panic( _L( "CXdmDocumentNode" ), ENodeNotEmpty ) );

    CXdmDocumentNode* node = iNodeFactory.ChileNodeL( aChildName );

    CleanupStack::PushL( node );

    User::LeaveIfError( iChildren.Append( node ) );

    CleanupStack::Pop();  //node

    return node;

    }

// ----------------------------------------------------

// CXdmDocumentNode::SetLeafNode

// 

// ----------------------------------------------------

//

EXPORT_C void CXdmDocumentNode::SetLeafNode( const TBool aIsLeafNode )

    {

    iLeafNode = aIsLeafNode;

    }

// ----------------------------------------------------

// CXdmDocumentNode::IsLeafNode

// 

// ----------------------------------------------------

//

EXPORT_C TBool CXdmDocumentNode::IsLeafNode() const

    {

    return iLeafNode;

    }

// ----------------------------------------------------

// CXdmDocumentNode::SetEmptyNode

// 

// ----------------------------------------------------

//

EXPORT_C void CXdmDocumentNode::SetEmptyNode( const TBool aIsEmptyNode )

    {

    //Do nothing if the state is not being changed

    if( aIsEmptyNode != iEmptyNode )

        {    

        if( aIsEmptyNode )

            {

            if( !iEmptyNode )

                {

                TInt count = iChildren.Count();

                if( count > 0 )

                    iChildren.ResetAndDestroy();

                }

            }

        iEmptyNode = aIsEmptyNode;

        }

    }

// ----------------------------------------------------

// CXdmDocumentNode::IsEmptyNode

// 

// ----------------------------------------------------

//

EXPORT_C TBool CXdmDocumentNode::IsEmptyNode() const

    {

    return iEmptyNode;

    }

// ----------------------------------------------------

// CXdmDocumentNode::CreateAttributeL

// 

// ----------------------------------------------------

//

EXPORT_C CXdmNodeAttribute* CXdmDocumentNode::CreateAttributeL()

    {

    /*#ifdef _DEBUG

        iXdmEngine.WriteToLog( _L8( "CXdmDocumentNode::CreateAttributeL()" ) );

    #endif*/

    CXdmDocumentNode* node = iNodeFactory.AttributeL();

    CleanupStack::PushL( node );

    User::LeaveIfError( iAttributes.Append( ( CXdmNodeAttribute* )node ) );

    CleanupStack::Pop();  //node

    return ( CXdmNodeAttribute* )node;

    }

// ----------------------------------------------------

// CXdmDocumentNode::CreateAttributeL

// 

// ----------------------------------------------------

//

EXPORT_C CXdmNodeAttribute* CXdmDocumentNode::CreateAttributeL( const TDesC& aAttributeName )

    {

    /*#ifdef _DEBUG

        iXdmEngine.WriteToLog( _L8( "CXdmDocumentNode::CreateAttributeL() - Name: %S" ), &aAttributeName );

    #endif*/

    CXdmDocumentNode* node = iNodeFactory.AttributeL( aAttributeName );

    CleanupStack::PushL( node );

    User::LeaveIfError( iAttributes.Append( ( CXdmNodeAttribute* )node ) );

    CleanupStack::Pop();  //node

    return ( CXdmNodeAttribute* )node;

    }

// ----------------------------------------------------

// CXdmDocumentNode::SetLeafNodeContentL

// 

// ----------------------------------------------------

//

EXPORT_C void CXdmDocumentNode::SetLeafNodeContentL( const TDesC& aLeafContent )

    {

    /*#ifdef _DEBUG

        iXdmEngine.WriteToLog( _L8( "CXdmDocumentNode::SetLeafNodeContentL( 16 ) - Content: %S" ),

                                &aLeafContent );

    #endif*/

    if( iLeafNode )

        {

        delete iLeafContent;

        iLeafContent = NULL;

        iLeafContent = CXdmEngine::ConvertToUTF8L( aLeafContent );

        }

    else

        User::Leave( KErrGeneral );

    }

// ----------------------------------------------------

// CXdmDocumentNode::SetLeafNodeContentL

// 

// ----------------------------------------------------

//

EXPORT_C void CXdmDocumentNode::SetLeafNodeContentL( const TDesC8& aLeafContent )

    {

    /*#ifdef _DEBUG

        iXdmEngine.WriteToLog( _L8( "CXdmDocumentNode::SetLeafNodeContentL( 8 ) - Content: %S" ),

                                &aLeafContent );

    #endif*/

    if( iLeafNode )

        {

        delete iLeafContent;

        iLeafContent = NULL;

        iLeafContent = HBufC8::NewL( aLeafContent.Length() );

        iLeafContent->Des().Copy( aLeafContent );

        }

    else

        User::Leave( KErrGeneral );

    }

// ----------------------------------------------------

// CXdmDocumentNode::ElementData

// 

// ----------------------------------------------------

//

EXPORT_C HBufC8* CXdmDocumentNode::ElementDataLC() const

    {

    /*#ifdef _DEBUG

        iXdmEngine.WriteToLog( _L8( "CXdmDocumentNode::ElementDataLC()" ) );

    #endif*/

    TInt position = 0;

    CBufFlat* buffer = CBufFlat::NewL( 48 );

    CleanupStack::PushL( buffer );

    buffer->InsertL( position, EightBitNodeNameLC()->Des() );

    CleanupStack::PopAndDestroy();   //EightBitNodeNameLC()

    position = position + NodeName().Length();

    TInt attributeCount = iAttributes.Count();

    if( attributeCount > 0 )

        {

        for( TInt i = 0;i < attributeCount;i++ )

            {

            buffer->InsertL( position, KGeneralSpace );

            position = position + KGeneralSpace().Length();

            CXdmNodeAttribute* attribute = iAttributes[i];

            TPtrC8 name( attribute->EightBitNodeNameLC()->Des() );

            buffer->InsertL( position, name );

            position = position + name.Length();

            buffer->InsertL( position, KGeneralEqualsAndQuotes );

            position = position + KGeneralEqualsAndQuotes().Length();

            TPtrC8 value( attribute->EscapedValueLC()->Des() );

            buffer->InsertL( position, value );

            position = position + value.Length();

            buffer->InsertL( position, KGeneralQuotes );

            position = position + KGeneralQuotes().Length();

            CleanupStack::PopAndDestroy( 2 );  //EscapedValueLC(),

                                               //EightBitNodeNameLC()

            }

        }

    HBufC8* ret = HBufC8::NewL( buffer->Size() );

    TPtr8 pointer( ret->Des() );

    buffer->Read( 0, pointer, buffer->Size() );

    CleanupStack::PopAndDestroy();  //buffer

    CleanupStack::PushL( ret );

    return ret;

    }

// ----------------------------------------------------------

// CXdmNodeAttribute::NodeCount

// 

// ----------------------------------------------------------

//

EXPORT_C TInt CXdmDocumentNode::NodeCount() const

    {

    return iNextNode ? 1 : iChildren.Count();

    }

// ----------------------------------------------------------

// CXdmNodeAttribute::NodeCount

// 

// ----------------------------------------------------------

//

EXPORT_C TInt CXdmDocumentNode::AttributeCount() const

    {

    return iAttributes.Count();

    }

// ----------------------------------------------------------

// CXdmDocumentNode::Parent

// 

// ----------------------------------------------------------

//

EXPORT_C CXdmDocumentNode* CXdmDocumentNode::ChileNode( const TInt aPosition ) const

    {

    /*#ifdef _DEBUG

        iXdmEngine.WriteToLog( _L8( "CXdmDocumentNode::ChileNode() - Position: %d" ), aPosition );

    #endif*/

    if( iNextNode )

        return iNextNode;

    else

        {   

        TInt count = NodeCount();

        if( count > 0 && aPosition >= 0 && aPosition < count )

            return iChildren[aPosition];

        else return NULL;

        }

    }

// ----------------------------------------------------------

// CXdmDocumentNode::Attribute

// 

// ----------------------------------------------------------

//

EXPORT_C CXdmNodeAttribute* CXdmDocumentNode::Attribute( const TInt aPosition ) const

    {

    /*#ifdef _DEBUG

        iXdmEngine.WriteToLog( _L8( "CXdmDocumentNode::Attribute() - Position: %d" ), aPosition );

    #endif*/

    TInt count = iAttributes.Count();

    if( count > 0 && aPosition >= 0 && aPosition < count )

        return iAttributes[aPosition];

    else return NULL;

    }

// ----------------------------------------------------------

// CXdmDocumentNode::Attribute

// 

// ----------------------------------------------------------

//

EXPORT_C CXdmNodeAttribute* CXdmDocumentNode::Attribute( const TDesC& aAttributeName ) const

    {

    /*#ifdef _DEBUG

        iXdmEngine.WriteToLog( _L8( "CXdmDocumentNode::Attribute() - Name: %S" ), &aAttributeName );

    #endif*/

    TInt count = iAttributes.Count();

    if( count > 0 )

        {

        TBool found = EFalse;

        CXdmNodeAttribute* target = NULL;

        for( TInt i = 0;!found && i < count;i++ )

            {

            if( iAttributes[i]->NodeName().Compare( aAttributeName ) == 0 )

                {

                target = iAttributes[i];

                found = ETrue;

                }

            }

        return target;

        }

    else return NULL;

    }

// ----------------------------------------------------------

// CXdmDocumentNode::Parent

// 

// ----------------------------------------------------------

//

EXPORT_C TPtrC8 CXdmDocumentNode::LeafNodeContent() const

    {

    return iLeafNode && iLeafContent != NULL ? iLeafContent->Des() : TPtrC8();

    }

// ----------------------------------------------------------

// CXdmDocumentNode::Parent

// 

// ----------------------------------------------------------

//

EXPORT_C HBufC8* CXdmDocumentNode::EscapeLeafNodeContentLC() const

    {

    return iLeafNode && iLeafContent != NULL ? EscapeDescLC( iLeafContent->Des() ) : NULL;

    }

// ----------------------------------------------------------

// CXdmDocumentNode::SetNextNode

// 

// ----------------------------------------------------------

//

EXPORT_C TPtrC CXdmDocumentNode::NodeName() const

    {

    return iNodeName != NULL ? iNodeName->Des() : TPtrC();

    }

// ----------------------------------------------------------

// CXdmDocumentNode::SetNextNode

// 

// ----------------------------------------------------------

//

EXPORT_C HBufC8* CXdmDocumentNode::EightBitNodeNameLC() const

    {

    HBufC8* eightBit = CXdmEngine::ConvertToUTF8L( iNodeName->Des() );

    CleanupStack::PushL( eightBit );

    return eightBit;

    }

// ----------------------------------------------------------

// CXdmDocumentNode::SetNextNode

// 

// ----------------------------------------------------------