/*

* Copyright (c) 2002-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:        

*

*/

// INCLUDE FILES

#include "SenBaseElement.h"

#include "SenXmlUtils.h"

#include "senxmldebug.h"

#include "SenXmlConstants.h" // KSenColon, ++

#ifdef SYMBIAN_SECURE_ECOM 

    // for S60 2nd edition FP3 (2.8) OR newer 3rd edition platform

    #include <xml/attribute.h> // needed for RAttributeArray

#else 

    // for S60 2nd edition, up to FP2 (2.0 - 2.6)

    #include "Attribute.h" // needed for RAttributeArray

#endif

using namespace Xml;

namespace

    {

/*

    _LIT8(KColon,            ":");

    _LIT8(KLessThan,         "<");

    _LIT8(KGreaterThan,      ">");

    _LIT8(KSpace,            " ");

    _LIT8(KDblQuot,          "\"");

    _LIT8(KEqualsDblQuot,    "=\"");

    _LIT8(KSlashGreaterThan, "/>");

    _LIT8(KLessThanSlash,    "</");

    _LIT8(KSpaceXmlns,       " xmlns");

    _LIT8(KXmlns,            "xmlns");

    _LIT8(KXmlNsAttNamePlusColon,   "xmlns:"); 

*/

    const TInt KFlatBufSize          = 64;  // CBufFlat

    }

EXPORT_C CSenBaseElement* CSenBaseElement::NewL(const TDesC8& aLocalName)

    {

    CSenBaseElement* pNew = new (ELeave) CSenBaseElement;

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL(aLocalName);

    CleanupStack::Pop(); // pNew;

    return pNew;

    }

EXPORT_C CSenBaseElement* CSenBaseElement::NewL(const TDesC8& aNsUri,

                                                const TDesC8& aLocalName)

    {

    CSenBaseElement* pNew = new (ELeave) CSenBaseElement;

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL(aNsUri, aLocalName);

    CleanupStack::Pop(); // pNew;

    return pNew;

    }

EXPORT_C CSenBaseElement* CSenBaseElement::NewL(const TDesC8& aNsUri,

                                                const TDesC8& aLocalName,

                                                const TDesC8& aQName)

    {

    CSenBaseElement* pNew = new (ELeave) CSenBaseElement;

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL(aNsUri, aLocalName, aQName);

    CleanupStack::Pop(); // pNew;

    return pNew;

    }

EXPORT_C CSenBaseElement* CSenBaseElement::NewL(const TDesC8& aNsUri,

                                                const TDesC8& aLocalName,

                                                const TDesC8& aQName,

                                                const RAttributeArray& apAttrs)

    {

    CSenBaseElement* pNew = new (ELeave) CSenBaseElement;

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL(aNsUri, aLocalName, aQName, apAttrs);

    CleanupStack::Pop(); // pNew;

    return pNew;

    }

EXPORT_C CSenBaseElement* CSenBaseElement::NewL(const TDesC8& aNsUri,

                                                const TDesC8& aLocalName,

                                                const TDesC8& aQName,

                                                const RAttributeArray& apAttrs,

                                                CSenElement& aParent)

    {

    CSenBaseElement* pNew = new (ELeave) CSenBaseElement;

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL(aNsUri, aLocalName, aQName, apAttrs, aParent);

    CleanupStack::Pop(); // pNew;

    return pNew;

    }

EXPORT_C CSenBaseElement::CSenBaseElement()

: ipLocalName(NULL),

//  ipNsUri(NULL),

  ipContentBuf(NULL),

  ipParent(NULL),

  ipNamespace(NULL)

    {

    }

EXPORT_C CSenBaseElement::~CSenBaseElement()

    {

    delete ipLocalName;

//    delete ipNsUri;

    delete ipContentBuf;

    iAttrs.ResetAndDestroy();

    iElements.ResetAndDestroy();

    iNamespaces.ResetAndDestroy();

    }

EXPORT_C void CSenBaseElement::BaseConstructL(const TDesC8& aLocalName)

    {

    SenXmlUtils::LeaveOnInvalidElementNameL(aLocalName);

    ipLocalName = aLocalName.AllocL();

    }

EXPORT_C void CSenBaseElement::BaseConstructL(const TDesC8& aNsUri,

                                              const TDesC8& aLocalName)

    {

    SenXmlUtils::LeaveOnInvalidElementNameL(aLocalName);

    if(aNsUri.Length()>0)

        {

        SetNamespaceL(aNsUri);

        }

    ipLocalName = aLocalName.AllocL();

    }

EXPORT_C void CSenBaseElement::BaseConstructL(  const TDesC8& aNsUri,

                                                const TDesC8& aLocalName,

                                                const TDesC8& aQName)

    {

    SenXmlUtils::LeaveOnInvalidElementNameL(aLocalName);

    SenXmlUtils::LeaveOnInvalidElementNameL(aQName);

    ipLocalName = aLocalName.AllocL();

    TPtrC8 prefix(KNullDesC8);

    if(aQName.Length()>0)

        {

        TInt colon = aQName.Locate(':');

        if(colon>0) // Note: 0 also treated as no prefix

            {

            prefix.Set(aQName.Ptr(), colon);

            }

        }

    SetNamespaceL(prefix, aNsUri);

    }

EXPORT_C void CSenBaseElement::BaseConstructL(  const TDesC8& aNsUri,

                                                const TDesC8& aLocalName,

                                                const TDesC8& aQName,

                                                const RAttributeArray& apAttrs)

    {

    BaseConstructL(aNsUri, aLocalName, aQName);

    SetAttributesL(apAttrs);

    }

EXPORT_C void CSenBaseElement::BaseConstructL(  const TDesC8& aNsUri,

                                                const TDesC8& aLocalName,

                                                const TDesC8& aQName,

                                                const RAttributeArray& apAttrs,

                                                CSenElement& aParent    )

    {

    // parent must be set here at first line, because

    // namespace setting dependends of it(!)

    ipParent = &aParent;

    BaseConstructL(aNsUri, aLocalName, aQName);

    SetAttributesL(apAttrs);

    }

EXPORT_C void CSenBaseElement::SetAttributesL(const RAttributeArray& apAttrs)

    {

    AddAttributesL(apAttrs);

    }

EXPORT_C void CSenBaseElement::AddAttributesL(const RAttributeArray& apAttrs)

    {

    TInt count(apAttrs.Count());

    HBufC8* qName = NULL;

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

        {

        const TPtrC8 localname = apAttrs[i].Attribute().LocalName().DesC();

        const TPtrC8 prefix = apAttrs[i].Attribute().Prefix().DesC();

        const TPtrC8 value = apAttrs[i].Value().DesC();

        SenXmlUtils::BuildQNameL(prefix, localname, qName);

        CleanupStack::PushL(qName);

        HBufC8* encodedValue = NULL;

        TBool encoded = 

            SenXmlUtils::EncodeHttpCharactersL(value, encodedValue);

        if (encoded)

            {

            CleanupStack::PushL(encodedValue);

            AddAttributeL(*qName, localname, *encodedValue); 

            // note: this intentionally

            // skips the 2 param 

            // AddAttributeL() function

            CleanupStack::PopAndDestroy(); // encodedValue

            }

        else

            {

            AddAttributeL(*qName, localname, value); 

            // note: this intentionally

            // skips the 2 param 

            // AddAttributeL() function

            }

        CleanupStack::PopAndDestroy(); // qName

        }

    }

EXPORT_C const TDesC8& CSenBaseElement::AddAttributeL(const TDesC8& aQName,

                                                     const TDesC8& aLocalName,

                                                     const TDesC8& aValue)

    {

    // first we check for possible namespace declarations...

    if ( aQName == KSenXmlns || aLocalName == KSenXmlns)

        {

        // this is a default name space declaration

        SetNamespaceL(aValue);

        }

    else if (aLocalName == NsPrefix())

        {

        //we have a new declaration for the namespace of this element

        SetNamespaceL(aLocalName, aValue);

        }

    else if(aQName.Find(KSenXmlNsAttNamePlusColon) == 0)

        {

        // we have an additional namespace declaration

        AddNamespaceL(aLocalName, aValue);

        }

    else

        {

        // we have a real attribute!

        CSenBaseAttribute* pAttribute = CSenBaseAttribute::NewL(aQName,

                                                                aLocalName,

                                                                aValue);

        AddAttributeL(pAttribute);

        }

    return aValue;

    }

EXPORT_C const TDesC8& CSenBaseElement::AddAttributeL(const TDesC8& aAttrName,

                                                      const TDesC8& aValue)

    {

    // note, the aAttrName may be a qualified name or simply localname

    // strip off the possible prefix from possible qualified name:

    TPtrC8 localName = SenXmlUtils::LocalName(aAttrName);

    return AddAttributeL(aAttrName, localName, aValue);

    }

// takes the ownership of aAttribute

EXPORT_C const TDesC8& CSenBaseElement::AddAttributeL(CSenBaseAttribute* apAttribute)

    {

    CSenBaseAttribute* pOldAtt = FindAttr(apAttribute->Name());

    if(!pOldAtt)

        {

        // transfrer the ownership to this class:

#ifdef EKA2

        iAttrs.AppendL(apAttribute);

#else

        User::LeaveIfError(iAttrs.Append(apAttribute));

#endif // EKA2

        return apAttribute->Value();

        }

    else

        {

        pOldAtt->SetValueL(apAttribute->Value());

        delete apAttribute;

        apAttribute = NULL;

        return pOldAtt->Value();

        }

    }

EXPORT_C CSenBaseAttribute* CSenBaseElement::FindAttr(const TDesC8& aName)

    {

    for (TInt i = 0; i < iAttrs.Count(); i++)

        {

        if (iAttrs[i]->Name() == aName)

            {

            return iAttrs[i];

            }

        }

    return NULL;

    }

EXPORT_C TInt CSenBaseElement::IndexOfElement(const TDesC8& aNsUri,

                                              const TDesC8& aLocalName) const

    {

    for (TInt i = 0; i < iElements.Count(); i++)

        {

        CSenElement* pElement = iElements[i];

        const TDesC8& nsUri = pElement->NamespaceURI();

        const TDesC8& localName = pElement->LocalName();

        if ((nsUri == aNsUri) && (localName == aLocalName))

            {

            return i;

            }

        }

    return KErrNotFound;

    }

EXPORT_C const TDesC8& CSenBaseElement::LocalName() const

    {

    if (ipLocalName == NULL)

        {

        return KNullDesC8();

        }

    else

        {

        return *ipLocalName;

        }

    }

EXPORT_C const TDesC8& CSenBaseElement::NamespaceURI() const

    {

    if (ipNamespace)

        {

        return ipNamespace->URI();

        }

    else

        {

        return KNullDesC8();

        }

    }

EXPORT_C const TDesC8& CSenBaseElement::NsPrefix() const

    {

    if (ipNamespace == NULL)

        {

        return KNullDesC8();

        }

    else

        {

        return ipNamespace->Prefix();

        }

    }

EXPORT_C TBool CSenBaseElement::HasContent() const

    {

    if (ipContentBuf == NULL)

        {

        return EFalse;

        }

    else

        {

        return (ipContentBuf->Size() > 0);

        }

    }

EXPORT_C TPtrC8 CSenBaseElement::Content() const

    {

    if (ipContentBuf == NULL)

        {

        return KNullDesC8();

        }

    else

        {

        TPtrC8 p8 = ipContentBuf->Ptr(0);

        return p8;

        }

    }

EXPORT_C HBufC* CSenBaseElement::ContentUnicodeL() const

    {

    HBufC* pRet = SenXmlUtils::ToUnicodeLC(Content());

    CleanupStack::Pop(); // pRet;

    return pRet;

    }

EXPORT_C TPtrC8 CSenBaseElement::SetContentL(const TDesC8& aContent)

    {

    AllocContentBufL(); // content length is _OK_ to be ZERO

    ipContentBuf->ResizeL(aContent.Size());

    ipContentBuf->Write(0, aContent);

    //   TPtrC8(REINTERPRET_CAST(const TUint8*, aContent.Ptr()),

    //                                            aContent.Size()));

    // Reset stream

    iContentWriteStream.Open(*ipContentBuf);

    return Content();

    }

EXPORT_C RWriteStream& CSenBaseElement::ContentWriteStreamL()

    {

    AllocContentBufL();

    iContentWriteStream.Open(*ipContentBuf);

    return iContentWriteStream;

    }

// NOTE: assumes(!) that the namespace is same(!)

EXPORT_C RPointerArray<CSenElement>& CSenBaseElement::ElementsL()

    {

    return iElements;

    }

EXPORT_C TInt CSenBaseElement::ElementsL(

                                    RPointerArray<CSenElement>& aElementArray,

                                    const TDesC8& aNsUri,

                                    const TDesC8& aLocalName)

    {

    if (iElements.Count() == 0)

        return KErrNotFound;

    CSenElement* pElement = NULL;

    TInt count(iElements.Count());

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

        {

        pElement = iElements[i];

        if ( (aLocalName == pElement->LocalName()) &&

             (aNsUri == pElement->NamespaceURI()) )

            {

#ifdef EKA2

            aElementArray.AppendL(pElement);

#else

            User::LeaveIfError(aElementArray.Append(pElement));

#endif // EKA2

            }

        }

    return KErrNone;

    }

EXPORT_C TInt CSenBaseElement::ElementsL(

                                    RPointerArray<CSenElement>& aElementArray,

                                    const TDesC8& aLocalName)

    {

    return ElementsL(aElementArray,NamespaceURI(),aLocalName);

    }

EXPORT_C const TDesC8* CSenBaseElement::AttrValue(const TDesC8& aName)

    {

    CSenBaseAttribute* pAttr = FindAttr(aName);

    if (pAttr == NULL)

        {

        return NULL;

        }

    else

        {

        return &(pAttr->Value());

        }

    }

EXPORT_C void CSenBaseElement::AddAttrL(const TDesC8& aName,

                                        const TDesC8& aValue)

    {

    CSenBaseAttribute* pAttr = FindAttr(aName);

    if (pAttr == NULL)

        {

        }

    else

        {

        pAttr->SetValueL(aValue);

        }

    }

EXPORT_C CSenElement* CSenBaseElement::Parent()

    {

    return ipParent;

    }

EXPORT_C CSenElement* CSenBaseElement::SetParent(CSenElement* apParent)  // IOP

    {

    if (apParent && ipParent != apParent)

        {

        ipParent = apParent;

        if (!ipNamespace)

            {

            // check if there is a default namespace declared in the scope of

            // the parent

            const CSenNamespace* pParentNamespace =

                ((CSenBaseElement*) ipParent)->Namespace(KNullDesC8,ETrue);

            if (pParentNamespace && pParentNamespace->Prefix() == KNullDesC8)

                {

                ipNamespace = (CSenNamespace*)pParentNamespace;

                }

            }

        else

            {

            //check if the parent already has a namespace for this element

            // if so remove it from the local namespace table

            const CSenNamespace* pNs = ipParent->Namespace(KNullDesC8,

                                                    ipNamespace->URI());

            if (pNs && pNs != ipNamespace)

                {

                if (ipNamespace->Compare(*pNs) ||