/*

 * 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:  Primary datatype for the entire Document Object Model.

 *

 */

// INCLUDE FILES

#include    "xndomnode.h"

#include    "xndomattribute.h"

#include    "xndomproperty.h"

#include    "xndomlist.h"

#include    "xndomstringpool.h"

// LOCAL CONSTANTS AND MACROS

const TInt KNotDefined = -1;

_LIT8( KIdAttr, "id" );

_LIT8( KRefAttr, "ref" );

const TInt KPropertyListGranularity = 8;

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

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

// CXnDomNode::CXnDomNode

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CXnDomNode::CXnDomNode(CXnDomStringPool& aStringPool) :

    iStringPool(aStringPool), iNodeId(KNotDefined)

    {

    }

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

// CXnDomNode::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CXnDomNode::ConstructL(const TDesC8& aName, const TDesC8& aNS)

    {

    iNameRef = iStringPool.AddStringL(aName);

    iNSRef = iStringPool.AddStringL(aNS);

    iChildList = CXnDomList::NewL(CXnDomList::ENodeList, iStringPool);

    iAttributeList

            = CXnDomList::NewL(CXnDomList::EAttributeList, iStringPool);

    iPropertyList = CXnDomList::NewL(CXnDomList::EPropertyList, iStringPool,

            KPropertyListGranularity);

    }

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

// CXnDomNode::NewL

// Two-phased constructor.

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

//

CXnDomNode* CXnDomNode::NewL(const TDesC8& aName, const TDesC8& aNS,

        CXnDomStringPool& aStringPool)

    {

    CXnDomNode* self = new (ELeave) CXnDomNode(aStringPool);

    CleanupStack::PushL(self);

    self->ConstructL(aName, aNS);

    CleanupStack::Pop(self);

    return self;

    }

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

// CXnDomNode::NewL

// Two-phased stream constructor.

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

//

CXnDomNode* CXnDomNode::NewL(RReadStream& aStream,

        CXnDomStringPool& aStringPool)

    {

    CXnDomNode* self = new (ELeave) CXnDomNode(aStringPool);

    CleanupStack::PushL(self);

    aStream >> *self;

    CleanupStack::Pop(self);

    return self;

    }

// Destructor

CXnDomNode::~CXnDomNode()

    {

    delete iChildList;

    delete iAttributeList;

    delete iPropertyList;

    delete iPCData;

    }

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

// CXnDomNode::CloneL

// Clones this node and it's child nodes. This is a recursive function.

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

//

EXPORT_C CXnDomNode* CXnDomNode::CloneL(CXnDomStringPool& aStringPool)

    {

    const TDesC8& name = iStringPool.String(iNameRef);

    const TDesC8& ns = iStringPool.String(iNSRef);

    CXnDomNode* clone = CXnDomNode::NewL(name, ns, aStringPool);

    CleanupStack::PushL(clone);

    if (iPCData)

        {

        clone->AppendPCDataL(*iPCData);

        }

    clone->iNodeId = iNodeId;

    clone->iRefNode = iRefNode;

    TInt childCount(iChildList->Length());

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

        {

        CXnDomNode* childClone =

                static_cast<CXnDomNode*> (iChildList->Item(i))->CloneL(

                        aStringPool);

        CleanupStack::PushL(childClone);

        childClone->iParentNode = clone;

        clone->iChildList->AddItemL(childClone);

        CleanupStack::Pop(childClone);

        }

    TInt attrCount(iAttributeList->Length());

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

        {

        CXnDomAttribute

                * attrClone =

                        static_cast<CXnDomAttribute*> (iAttributeList->Item(j))->CloneL(

                                aStringPool);

        CleanupStack::PushL(attrClone);

        clone->iAttributeList->AddItemL(attrClone);

        CleanupStack::Pop(attrClone);

        }

    TInt propertyCount(iPropertyList->Length());

    for (TInt k = 0; k < propertyCount; k++)

        {

        CXnDomProperty

                * propClone =

                        static_cast<CXnDomProperty*> (iPropertyList->Item(k))->CloneL(

                                aStringPool);

        CleanupStack::PushL(propClone);

        clone->iPropertyList->AddItemL(propClone);

        CleanupStack::Pop(propClone);

        }

    CleanupStack::Pop(clone);

    return clone;

    }

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

// CXnDomNode::CloneWithoutKidsL

// Clones only this node. This is a recursive function.

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

//

EXPORT_C CXnDomNode* CXnDomNode::CloneWithoutKidsL(

        CXnDomStringPool& aStringPool)

    {

    const TDesC8& name = iStringPool.String(iNameRef);

    const TDesC8& ns = iStringPool.String(iNSRef);

    CXnDomNode* clone = CXnDomNode::NewL(name, ns, aStringPool);

    CleanupStack::PushL(clone);

    if (iPCData)

        {

        clone->AppendPCDataL(*iPCData);

        }

    clone->iNodeId = iNodeId;

    clone->iRefNode = iRefNode;

    TInt attrCount(iAttributeList->Length());

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

        {

        CXnDomAttribute

                * attrClone =

                        static_cast<CXnDomAttribute*> (iAttributeList->Item(j))->CloneL(

                                aStringPool);

        CleanupStack::PushL(attrClone);

        clone->iAttributeList->AddItemL(attrClone);

        CleanupStack::Pop(attrClone);

        }

    TInt propertyCount(iPropertyList->Length());

    for (TInt k = 0; k < propertyCount; k++)

        {

        CXnDomProperty

                * propClone =

                        static_cast<CXnDomProperty*> (iPropertyList->Item(k))->CloneL(

                                aStringPool);

        CleanupStack::PushL(propClone);

        clone->iPropertyList->AddItemL(propClone);

        CleanupStack::Pop(propClone);

        }

    CleanupStack::Pop(clone);

    return clone;

    }

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

// CXnDomNode::CreateRefNodeL

// Recursive function to create referer nodes.

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

//

EXPORT_C CXnDomNode* CXnDomNode::CreateRefNodeL()

    {

    const TDesC8& name = iStringPool.String(iNameRef);

    const TDesC8& ns = iStringPool.String(iNSRef);

    CXnDomNode* ref = CXnDomNode::NewL(name, ns, iStringPool);

    CleanupStack::PushL(ref);

    ref->iRefNode = ETrue;

    TInt childCount(iChildList->Length());

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

        {

        CXnDomNode

                * childRef =

                        static_cast<CXnDomNode*> (iChildList->Item(i))->CreateRefNodeL();

        CleanupStack::PushL(childRef);

        childRef->iParentNode = ref;

        ref->iChildList->AddItemL(childRef);

        CleanupStack::Pop(childRef);

        }

    CXnDomAttribute* attr = NULL;

    if (!iRefNode)

        {

        attr = static_cast<CXnDomAttribute*> (iAttributeList->FindByName(

                KIdAttr));

        }

    else

        {

        attr = static_cast<CXnDomAttribute*> (iAttributeList->FindByName(

                KRefAttr));

        }

    if (attr)

        {

        CXnDomAttribute* newAttr = CXnDomAttribute::NewL(KRefAttr,

                iStringPool);

        CleanupStack::PushL(newAttr);

        newAttr->SetValueL(attr->Value());

        ref->iAttributeList->AddItemL(newAttr);

        CleanupStack::Pop(newAttr);

        }

    else

        {

        //referred node don't have an id or ref, thats not ok.

        User::Leave(KErrArgument);

        }

    CleanupStack::Pop(ref);

    return ref;

    }

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

// CXnDomNode::Name

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

//

EXPORT_C const TDesC8& CXnDomNode::Name()

    {

    return iStringPool.String(iNameRef);

    }

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

// CXnDomNode::Namespace

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

//

EXPORT_C const TDesC8& CXnDomNode::Namespace()

    {

    return iStringPool.String(iNSRef);

    }

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

// CXnDomNode::AttributeList

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

//

EXPORT_C CXnDomList& CXnDomNode::AttributeList() const

    {

    return *iAttributeList;

    }

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

// CXnDomNode::PropertyList

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

//

EXPORT_C CXnDomList& CXnDomNode::PropertyList()

    {

    return *iPropertyList;

    }

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

// CXnDomNode::SetParent

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

//

EXPORT_C void CXnDomNode::SetParent(CXnDomNode* aParent)

    {

    iParentNode = aParent;

    }

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

// CXnDomNode::Parent

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

//

EXPORT_C CXnDomNode* CXnDomNode::Parent() const

    {

    return iParentNode;

    }

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

// CXnDomNode::AddChildL

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

//

EXPORT_C void CXnDomNode::AddChildL(CXnDomNode* aNode)

    {

    aNode->SetParent(this);

    iChildList->AddItemL(aNode);

    }

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

// CXnDomNode::AddChildL

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

//

EXPORT_C void CXnDomNode::AddChildL(CXnDomNode* aNode, TInt aIndex)

    {

    aNode->SetParent(this);

    iChildList->AddItemL(aNode, aIndex);

    }

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

// CXnDomNode::DeleteChild

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

//

EXPORT_C void CXnDomNode::DeleteChild(CXnDomNode* aNode)

    {

    iChildList->DeleteItem(aNode);

    }

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

// CXnDomNode::ReplaceChildL

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

//

EXPORT_C void CXnDomNode::ReplaceChildL(CXnDomNode* aNode,

        CXnDomNode* aNewNode)

    {

    CXnDomNode* swapChild = NULL;

    CXnDomList& childList = aNode->ChildNodes();

    TInt childCount(childList.Length());

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

        {

        swapChild = static_cast<CXnDomNode*> (childList.Item(i));

        aNewNode->AddChildL(swapChild); //Let the new node adopt the child

        childList.RemoveItem(swapChild); //Remove it from the orginal parent

        }

    iChildList->DeleteItem(aNode); // Delete the old child

    aNewNode->SetParent(this); //Set new child

    iChildList->AddItemL(aNewNode);

    }

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

// CXnDomNode::ChildNodes

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

//   

EXPORT_C CXnDomList& CXnDomNode::ChildNodes()

    {

    return *iChildList;

    }

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

// CXnDomNode::SetNodeId

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

//   

EXPORT_C void CXnDomNode::SetNodeId(const TInt aNodeId)

    {

    iNodeId = aNodeId;

    }

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

// CXnDomNode::NodeId

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

//   

EXPORT_C TInt CXnDomNode::NodeId() const

    {

    return iNodeId;

    }

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

// CXnDomNode::ItemIndex

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

//   

EXPORT_C TInt CXnDomNode::ItemIndex(const MXnDomListItem& aItem) const

    {

    return iChildList->ItemIndex(aItem);

    }

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

// CXnDomNode::AppendPCDataL

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

//   

EXPORT_C void CXnDomNode::AppendPCDataL(const TDesC8& aPCData)

    {

    if (iPCData)

        {

        iPCData = iPCData->ReAllocL(iPCData->Length() + aPCData.Length());

        iPCData->Des().Append(aPCData);

        }

    else

        {

        iPCData = aPCData.AllocL();

        }

    }

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

// CXnDomNode::PCData

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

//  

EXPORT_C const TDesC8& CXnDomNode::PCData()

    {

    if (iPCData)

        {

        return *iPCData;

        }

    return KNullDesC8;

    }

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

// CXnDomNode::SetPCDataL

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

//  

EXPORT_C void CXnDomNode::SetPCDataL(const TDesC8& aPCData)

    {

    if (iPCData)

        {

        delete iPCData;

        iPCData = NULL;

        }

    iPCData = aPCData.AllocL();

    }

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

// CXnDomNode::ContentType

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

//   

EXPORT_C const TContentType& CXnDomNode::ContentType()

    {

    return iContentType;

    }

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

// CXnDomNode::SetContentType

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

//   

EXPORT_C void CXnDomNode::SetContentType(const TContentType& aContentType)

    {

    iContentType = aContentType;

    }

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

// CXnDomNode::StringPool

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

//        

EXPORT_C CXnDomStringPool& CXnDomNode::StringPool() const

    {

    return iStringPool;

    }

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

// CXnDomNode::SetRefNode

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

//        

EXPORT_C void CXnDomNode::SetRefNode(TBool aRefNode)

    {

    iRefNode = aRefNode;

    }

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

// CXnDomNode::IsRefNode

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

//        

EXPORT_C TBool CXnDomNode::IsRefNode() const

    {

    return iRefNode;

    }

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

// CXnDomNode::Size

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

//

TInt CXnDomNode::Size() const

    {

    TInt size(0);

    size += sizeof(TInt16); //iNameRef

    size += sizeof(TInt16); //iNSRef

    size += sizeof(TBool); //iRefNode

    if (iPCData)

        {

        size += sizeof(TInt8);

        size += sizeof(TInt16);

        size += iPCData->Size();

        size++;

        }

    else

        {

        size += sizeof(TInt8);

        }

    size += sizeof(TInt32); //For nodeId

    size += iAttributeList->Size();

    size += iPropertyList->Size();

    size += iChildList->Size();

    return size;

    }

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

// CXnDomNode::ExternalizeL

// NOTE: This function is not implemented yet!

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