/*

* 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:      

*

*/

// INCLUDE FILES

#include "SenXmlElement.h"

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

#include "SenXmlUtils.h"

#include "senxmldebug.h"

#ifdef SYMBIAN_SECURE_ECOM 

    // for 2.8, 3.0 or newer:

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

#else // for 2.6 or older

    #include "Attribute.h"

#endif

using namespace Xml;

namespace

    {

//    _LIT8(KColon,            ":");

//    _LIT8(KLessThan,         "<");

//    _LIT8(KGreaterThan,      ">");

//    _LIT8(KSpace,            " ");

//    _LIT8(KDblQuot,          "\"");

//    _LIT8(KEqualsDblQuot,    "=\"");

//    _LIT8(KSlashGreaterThan, "/>");

//    _LIT8(KSenLessThanSlash,    "</");

//    _LIT8(KSpaceXmlns,       " xmlns");

//    _LIT8(KXmlns,            "xmlns");

//    _LIT8(KXmlNsAttNamePlusColon, "xmlns:"); 

    const TInt KFlatBufSize        = 64;

    }

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

    {

    CSenXmlElement* pNew = new (ELeave) CSenXmlElement;

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL(aLocalName);

    CleanupStack::Pop(); // pNew;

    return pNew;

    }

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

                                                const TDesC8& aLocalName)

    {

    CSenXmlElement* pNew = new (ELeave) CSenXmlElement;

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL(aNsUri, aLocalName);

    CleanupStack::Pop(); // pNew;

    return pNew;

    }

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

                                                const TDesC8& aLocalName,

                                                const TDesC8& aQName)

    {

    CSenXmlElement* pNew = new (ELeave) CSenXmlElement;

    CleanupStack::PushL(pNew);

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

    CleanupStack::Pop(); // pNew;

    return pNew;

    }

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

                                                const TDesC8& aLocalName,

                                                const TDesC8& aQName,

                                                const RAttributeArray& apAttrs)

    {

    CSenXmlElement* pNew = new (ELeave) CSenXmlElement;

    CleanupStack::PushL(pNew);

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

    CleanupStack::Pop(); // pNew;

    return pNew;

    }

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

                                                const TDesC8& aLocalName,

                                                const TDesC8& aQName,

                                                const RAttributeArray& apAttrs,

                                                CSenElement& aParent)

    {

    CSenXmlElement* pNew = new (ELeave) CSenXmlElement;

    CleanupStack::PushL(pNew);

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

    CleanupStack::Pop(); // pNew;

    return pNew;

    }

EXPORT_C CSenXmlElement::CSenXmlElement()

: ipLocalName(NULL),

  ipContentBuf(NULL),

  ipParent(NULL),

  ipNamespace(NULL)

    {

    }

EXPORT_C CSenXmlElement::~CSenXmlElement()

    {

    if(ipContentWriteStream)

        {

        ipContentWriteStream->Close();

        delete ipContentWriteStream;

        ipContentWriteStream = NULL;

        }

    if(ipAttrs)

        {

        ipAttrs->ResetAndDestroy();

        delete ipAttrs;

        ipAttrs = NULL; // not required

        }

    if(ipElements)

        {

        ipElements->ResetAndDestroy();

        delete ipElements;

        ipElements = NULL; // not required

        }

    if(ipNamespaces)

        {

        ipNamespaces->ResetAndDestroy();

        delete ipNamespaces;

        ipNamespaces = NULL; // not required

        }

    delete ipLocalName;

    ipLocalName = NULL; // not required

    delete ipContentBuf;

    ipContentBuf = NULL; // not required

    }

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

    {

    SenXmlUtils::LeaveOnInvalidElementNameL(aLocalName);

    ipLocalName = aLocalName.AllocL();

    }

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

                                              const TDesC8& aLocalName)

    {

    SenXmlUtils::LeaveOnInvalidElementNameL(aLocalName);

    if(aNsUri.Length()>0)

        {

        SetNamespaceL(aNsUri);

        }

    ipLocalName = aLocalName.AllocL();

    }

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

                                                const TDesC8& aLocalName,

                                                const TDesC8& aQName)

    {

    SenXmlUtils::LeaveOnInvalidElementNameL(aLocalName);

    SenXmlUtils::LeaveOnInvalidElementNameL(aQName);

    ipLocalName = aLocalName.AllocL();

    TPtrC8 ptrPrefix(KNullDesC8);

    if (aQName.Length() > 0 )

        {

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

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

            {

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

            }

        }

    SetNamespaceL(ptrPrefix, aNsUri);

    }

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

                                                const TDesC8& aLocalName,

                                                const TDesC8& aQName,

                                                const RAttributeArray& apAttrs)

    {

    BaseConstructL(aNsUri, aLocalName, aQName);

    SetAttributesL(apAttrs);

    }

EXPORT_C void CSenXmlElement::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 CSenXmlElement::SetAttributesL(const RAttributeArray& apAttrs)

    {

    AddAttributesL(apAttrs);

    }

EXPORT_C void CSenXmlElement::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& CSenXmlElement::AddAttributeL(const TDesC8& aQName,

                                                     const TDesC8& aLocalName,

                                                     const TDesC8& aValue)

    {

    const TDesC8& nsPrefix = NsPrefix();

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

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

        {

            if(nsPrefix.Length() > 0)

                {

                // we have an additional namespace declaration

                AddNamespaceL(KNullDesC8(), aValue);

                }

            else

                {

                // 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& CSenXmlElement::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& CSenXmlElement::AddAttributeL(

                                                CSenBaseAttribute* apAttribute)

    {

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

    // if attribute array is not yet allocated, instantiate here

    if(!ipAttrs)

        {

        ipAttrs = new (ELeave) RPointerArray<CSenBaseAttribute>;

        }

    if(!pOldAtt)

        {

        // transfrer the ownership to this class:

        ipAttrs->Append(apAttribute);

        return apAttribute->Value();

        }

    else

        {

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

        delete apAttribute;

        apAttribute = NULL;

        return pOldAtt->Value();

        }

    }

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

    {

    if(ipAttrs)

        {

        TInt count(ipAttrs->Count());

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

            {

            CSenBaseAttribute* pAttribute = (*ipAttrs)[i];

            if(pAttribute->Name() == aName)

                {

                return pAttribute;

                }

            }

        }

    return NULL;

    }

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

                                              const TDesC8& aLocalName) const

    {

    if(ipElements)

        {

        TInt count(ipElements->Count());

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

            {

            CSenElement* pElement = (*ipElements)[i];

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

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

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

                {

                return i;

                }

            }

        }

    return KErrNotFound;

    }

EXPORT_C const TDesC8& CSenXmlElement::LocalName() const

    {

    if (ipLocalName == NULL)

        {

        return KNullDesC8();

        }

    else

        {

        return *ipLocalName;

        }

    }

EXPORT_C const TDesC8& CSenXmlElement::NamespaceURI() const

    {

    if (ipNamespace)

        {

        return ipNamespace->URI();

        }

    else

        {

        return KNullDesC8();

        }

    }

EXPORT_C const TDesC8& CSenXmlElement::NsPrefix() const

    {

    if (!ipNamespace)

        {

        return KNullDesC8();

        }

    else

        {

        return ipNamespace->Prefix();

        }

    }

EXPORT_C TBool CSenXmlElement::HasContent() const

    {

    if (!ipContentBuf)

        {

        return EFalse;

        }

    else

        {

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

        }

    }

EXPORT_C TPtrC8 CSenXmlElement::Content() const

    {

    if (!ipContentBuf)

        {

        return KNullDesC8();

        }

    else

        {

        TPtrC8 p8 = ipContentBuf->Ptr(0);

        return p8;

        }

    }

EXPORT_C HBufC* CSenXmlElement::ContentUnicodeL() const

    {

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

    CleanupStack::Pop(); // pRet;

    return pRet;

    }

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

    {

    AllocContentBufL(); 

	if(ipContentBuf)

		{

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

		ipContentBuf->Write(0,

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

                                                aContent.Size())

        );

		if(ipContentWriteStream)

			{

			// Reset stream

			ipContentWriteStream->Open(*ipContentBuf);

			}

		}

    return Content();

    }

EXPORT_C RWriteStream& CSenXmlElement::ContentWriteStreamL()

    {

    AllocContentBufL();

    // Allocate stream

    if(!ipContentWriteStream)

        {

        ipContentWriteStream = new (ELeave) RBufWriteStream;

        }

    ipContentWriteStream->Open(*ipContentBuf);

    return *ipContentWriteStream;

    }

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

// Optimization 

// RPointerArray<CSenElement>* or NULL if no elements have been added!

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

    {

    if(!ipElements)

        {

        ipElements = new (ELeave) RPointerArray<CSenElement>;

        }

    return *ipElements;

    }

EXPORT_C TInt CSenXmlElement::ElementsL(

                                    RPointerArray<CSenElement>& aElementArray,

                                    const TDesC8& aNsUri,

                                    const TDesC8& aLocalName)

    {

    TInt retVal(KErrNotFound);

    if(ipElements) // return KErrNotFound, if zero elements have been added

        {

        TInt count(ipElements->Count());

        if (count > 0) // return KErrNotFound, if owned array is empty

            {

            CSenElement* pElement = NULL;

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

                {

                pElement = (*ipElements)[i];

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

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

                    {

                    aElementArray.Append(pElement);

                    }

                }

            retVal = KErrNone;

            }

        }

    return retVal;

    }