/*

* 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 <flogger.h>

#include "SenXmlElement.h" // header to optimized version of SenBaseElement

#include "SenBaseFragment.h"

#include "SenXmlConstants.h"

#include "SenXmlUtils.h"

#ifdef SYMBIAN_SECURE_ECOM 

    // for 2.8, 3.0 or newer:

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

#else // for 2.6 or olde

    #include "Attribute.h"

#endif

using namespace Xml;

namespace

    {

    const TInt KFlatBufSize = 128;

    }

// ***************************************************************************

// Fragment class state constants are as following (declared in derivants):

// KStateNotSet                     = -1;

// KStateIgnore                     =  0; // even ones ignore(0),

// KStateSave                       =  1; // and odd ones save(1)

// KStateResume                     =  2;

// KStateParsingFramework           =  4;

// KStateParsingSoapFault           =  5;  // odd, save

// KStateParsingServiceDescription  =  6;

// KStateParsingResourceOffering    =  11; // odd, save

// KStateParsingCredentials         =  12;

// KStateParsingService             =  13; // odd state, saves content

// KStateParsingPwTransforms        =  14;

// KStateParsingSoapHeader          =  20; // ignore state (even num)

// KStateParsingSoapBody            =  40; // ignore state (even num)

// KStateParsingSingleCredential    =  122;

// KStateParsingProviderPolicy      =  1222;

EXPORT_C CSenBaseFragment* CSenBaseFragment::NewL( const CSenElement& aElement )

    {

    CSenBaseFragment* pNew = new (ELeave) CSenBaseFragment;

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL(aElement);

    CleanupStack::Pop(); // pNew;

    return pNew;

    }

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

    {

    CSenBaseFragment* pNew = new (ELeave) CSenBaseFragment;

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL(aLocalName);

    CleanupStack::Pop(); // pNew;

    return pNew;

    }

EXPORT_C CSenBaseFragment* CSenBaseFragment::NewL(

    const TDesC8& aNsUri,

    const TDesC8& aLocalName

    )

    {

    CSenBaseFragment* pNew = new (ELeave) CSenBaseFragment;

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL(aNsUri, aLocalName);

    CleanupStack::Pop(); // pNew;

    return pNew;

    }

EXPORT_C CSenBaseFragment* CSenBaseFragment::NewL(

    const TDesC8& aNsUri,

    const TDesC8& aLocalName,

    const TDesC8& aQName,

    const RAttributeArray& aAttrs

    )

    {

    CSenBaseFragment* pNew = new (ELeave) CSenBaseFragment;

    CleanupStack::PushL(pNew);

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

    CleanupStack::Pop(); // pNew;

    return pNew;

    }

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

                                                   const TDesC8& aLocalName,

                                                   const TDesC8& aQName,

                                                   const RAttributeArray& aAttrs,

                                                   CSenElement& aParent )

    {

    CSenBaseFragment* pNew = new (ELeave) CSenBaseFragment;

    CleanupStack::PushL(pNew);

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

    CleanupStack::Pop(); // pNew;

    return pNew;

    }

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

                                                   const TDesC8& aLocalName,

                                                   const TDesC8& aQName )

    {

    CSenBaseFragment* pNew = new (ELeave) CSenBaseFragment;

    CleanupStack::PushL(pNew);

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

    CleanupStack::Pop(); // pNew;

    return pNew;

    }

EXPORT_C CSenBaseFragment::~CSenBaseFragment()

    {

    if(iElementOwned)

        {

        delete ipElement;

        }

    delete ipDelegate;

    if(ipContentWithNamespaces)

        {

        ipContentWithNamespaces->Reset();

        }

    iNamespaces.Reset(); // not owned

    iPrefixes.ResetAndDestroy(); // owned copies from parsed values..

    }

EXPORT_C CSenBaseFragment::CSenBaseFragment()

: iState(KStateIgnore),

  ipElement(NULL),

  iXmlReader(NULL),

  ipOwner(NULL),

  ipDelegate(NULL),

  ipContentWithNamespaces(NULL),

  hasContentWriteStream(EFalse),

  iElementOwned(ETrue)

    {

    }

EXPORT_C void CSenBaseFragment::BaseConstructL( const CSenElement& aElement )

    {

    ipElement = CSenXmlElement::NewL(aElement.LocalName());

    ipElement->CopyFromL((CSenElement&)aElement);

    }

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

    {

    ipElement = CSenXmlElement::NewL(aLocalName);

    }

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

                                                const TDesC8& aLocalName )

    {

    ipElement = CSenXmlElement::NewL(aNsUri, aLocalName);

    }

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

                                                const TDesC8& aLocalName,

                                                const TDesC8& aQName,

                                                const RAttributeArray& aAttrs )

    {

    ipElement = CSenXmlElement::NewL(aNsUri, aLocalName, aQName, aAttrs);

    }

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

                                                const TDesC8& aLocalName,

                                                const TDesC8& aQName,

                                                const RAttributeArray& aAttrs,

                                                CSenElement& aParent )

    {

    // this transfers the ipElement ownership to the parent(!)

    ipElement = CSenXmlElement::NewL(aNsUri, aLocalName, aQName, aAttrs, aParent);

    }

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

                                                const TDesC8& aLocalName,

                                                const TDesC8& aQName )

    {

    ipElement = CSenXmlElement::NewL(aNsUri, aLocalName, aQName);

    }

// Leaves the the fragment without initialized ipElement

EXPORT_C void CSenBaseFragment::BaseConstructL( CSenXmlReader& aReader )

    {

    iXmlReader = &aReader;

    }

EXPORT_C CSenElement& CSenBaseFragment::AsElement()

    {

    __ASSERT_ALWAYS(ipElement != NULL, User::Panic(KSenXmlPanic, EFragmentElementNotInitialized));

    return *ipElement;

    }

EXPORT_C CSenElement* CSenBaseFragment::ExtractElement()

    {

    CSenElement* pElement = ipElement;

    ipElement = NULL;

    return pElement;

    }

EXPORT_C CSenXmlReader* CSenBaseFragment::Reader()

    {

    return iXmlReader;

    }

EXPORT_C void CSenBaseFragment::SetReader( CSenXmlReader& aReader )

    {

    iXmlReader = &aReader;

    }

EXPORT_C TInt CSenBaseFragment::BuildFrom( const TDesC8& aBuf )

    {

    TRAPD(err, ParseL(aBuf));

    return err;

    }

EXPORT_C void CSenBaseFragment::ParseL( const TDesC8& aBuf )

    {

    iState = KStateIgnore;

    if(!iXmlReader)

        {

        User::Leave(KErrSenXmlReaderNotSet);

        }

    iXmlReader->SetContentHandler(*this);

    iXmlReader->ParseL(aBuf);

    }

EXPORT_C void CSenBaseFragment::DelegateParsingL(MSenFragment& aDelegate)

    {

    // Delegate parsing to a new Fragment, until we encounter 

    // the end of an element with the given qualified name

    aDelegate.SetOwner(*this);

    if(!iXmlReader)

        {

        User::Leave(KErrSenXmlReaderNotSet);

        }

    aDelegate.ParseWithL(*iXmlReader);

    }

EXPORT_C void CSenBaseFragment::DelegateParsingL( const TDesC8& aNsUri,

                                                  const TDesC8& aLocalName,

                                                  const TDesC8& aQName,

                                                  const RAttributeArray& aAttrs )

    {

    // Delegate parsing to a new Fragment, until we encounter the end of an

    // element with the given qualified name

    __ASSERT_ALWAYS( ipDelegate == NULL, User::Panic(KSenXmlPanic, EDelegatedFragmentAlreadySet) );

    ipDelegate = CSenBaseFragment::NewL(aNsUri, aLocalName, aQName);

    ipDelegate->SetAttributesL(aAttrs);

    DelegateParsingL(*ipDelegate);

    }

EXPORT_C void CSenBaseFragment::ParseWithL(CSenXmlReader& aReader)

    {

    iXmlReader = &aReader;

    iState = KStateSave;

    iXmlReader->SetContentHandler(*this);

    }

EXPORT_C void CSenBaseFragment::SetOwner(MSenFragment& aFragment)

    {

    ipOwner = &aFragment;

    AsElement().SetParent(&aFragment.AsElement());

    }

EXPORT_C void CSenBaseFragment::ResumeParsingFromL( const TDesC8& aNsUri,

                                                    const TDesC8& aLocalName,

                                                    const TDesC8& aQName )

    {

    if(!iXmlReader)

        {

        User::Leave(KErrSenXmlReaderNotSet);

        }

    // listen to content handler

    iXmlReader->SetContentHandler(*this);

    // Destroy delegate

    if (ipDelegate)

        {

        CSenElement* pElement = ipDelegate->ExtractElement();

        CleanupStack::PushL(pElement); // IOP

        ipElement->AddElementL(*pElement);

        CleanupStack::Pop(); // pElement;

        delete ipDelegate; // free memory

        ipDelegate = NULL;

        }

    TInt currentState = KStateNotSet; // == -1

    if(ipElement)

        {

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

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

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

            {

            currentState = iState;

            // Before calling EndElementL, which may execute

            // unpredictable amount of code in derivants, the

            // the state must be set to "ignore"

            iState = KStateResume;

            }

        }

    EndElementL(aNsUri, aLocalName, aQName); // 2004-07-17

    // now check if current state was to be preserved

    if(currentState!=KStateNotSet) // IOP

        {

        // restore the state preserved prior to

        // "set ignore for endelement" -case

        iState = currentState;

        }

    }

EXPORT_C void CSenBaseFragment::StartElementL( const TDesC8& aNsUri,

                                               const TDesC8& aLocalName,

                                               const TDesC8& aQName,

                                               const RAttributeArray& aAttrs )

    {

    // 2004-09-10: check & alloc moved out

    // from KStateIgnore case code segment below (where in Java)

    if(!ipElement)

        {

        ipElement = CSenXmlElement::NewL( aNsUri, aLocalName, aQName );

        }

    // we can assume, that ipElement is not NULL

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

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

    if(iState == KStateIgnore)

        {

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

            {

            iState = KStateSave;

            SetAttributesL(aAttrs);

            }

        }

    else if((iState & KStateSave) == KStateSave)

        {

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

            {

            // start a new BaseFragment otherwise we loose

            // track of nested elements with the same name

            DelegateParsingL(aNsUri, aLocalName, aQName, aAttrs);

            }

        else

            {

            WriteStartElementL(aNsUri, aLocalName, aQName, aAttrs);

            }

        }

    }

EXPORT_C void CSenBaseFragment::EndElementL( const TDesC8& aNsUri,

                                             const TDesC8& aLocalName,

                                             const TDesC8& aQName )

    {

    AllocContentSaverL();

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

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

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

        {

        if(iState != KStateResume && ipOwner)

            {

            ipOwner->ResumeParsingFromL(aNsUri, aLocalName, aQName);

            return; // This is mandatory, since ResumeParsingFromL 

                    // de-allocates delegate fragment!

            }

        iState = KStateIgnore;

        }

    if((iState & KStateSave) == KStateSave)

        {

        WriteEndElementL(aNsUri, aLocalName, aQName);

        }

    }

// Closely the same as the code in Java ref-impl's BaseElement.append()

EXPORT_C void CSenBaseFragment::CharactersL( const TDesC8& aChars,

                                             TInt /*aStart*/,

                                             TInt /*aLength*/ )

    {

    if((iState & KStateSave) == KStateSave)

        {

        AllocContentSaverL(); // get iWs if it is NULL

        HBufC8* pCharsCopy = NULL;

        if (SenXmlUtils::EncodeHttpCharactersL(aChars, pCharsCopy))

            {

            CleanupStack::PushL(pCharsCopy);

            iWs.WriteL(*pCharsCopy);

            CleanupStack::PopAndDestroy(); // pCharsCopy

            }

        else

            {

            iWs.WriteL(aChars);

            }

        }

    }

EXPORT_C void CSenBaseFragment::SetAttributesL( const RAttributeArray& aAttrs )

    {

    SaveNamespacesL(aAttrs, ETrue);

    // Otherwise ignore attributes, these are up to the subclass to deal with.

    }

EXPORT_C void CSenBaseFragment::AllocContentSaverL()

    {

    if(!hasContentWriteStream)

        {

        iWs = ipElement->ContentWriteStreamL();

        hasContentWriteStream = ETrue;

        }

    }

EXPORT_C TInt CSenBaseFragment::StartDocument()

    {

    return 1;

    }

EXPORT_C TInt CSenBaseFragment::EndDocument()

    {

    if ( hasContentWriteStream )

        {

        hasContentWriteStream = EFalse;

        iWs.Close();

        }

    if (ipElement) ((CSenXmlElement*)ipElement)->Compress();

    return 1;

    }

EXPORT_C TInt CSenBaseFragment::StartElement( const TDesC8& aNsUri,

                                              const TDesC8& aLocalName,

                                              const TDesC8& aQName,

                                              const RAttributeArray& aAttrs )

    {

    TRAPD(err, StartElementL(aNsUri, aLocalName, aQName, aAttrs));

    return (err == KErrNone);

    }

EXPORT_C TInt CSenBaseFragment::EndElement( const TDesC8& aNsUri,

                                            const TDesC8& aLocalName,

                                            const TDesC8& aQName )

    {

    TRAPD(err, EndElementL(aNsUri, aLocalName, aQName));

    return (err == KErrNone);

    }

EXPORT_C TInt CSenBaseFragment::Characters( const TDesC8& aChars,

                                            const TInt aStart,

                                            const TInt aLength)

    {

    TRAPD(err, CharactersL(aChars, aStart, aLength));

    return (err == KErrNone);

    }

EXPORT_C void CSenBaseFragment::ResetContentL()

    {

    AsElement().SetContentL(KNullDesC8);

    // iPrefixes.Reset();   // contents not owned, clearing is enough // 2005-09-26: wouldn't this leak memory?

    iPrefixes.ResetAndDestroy(); // owned copies from parsed values..

    iNamespaces.Reset(); // contents not owned, clearing is enough

    }

EXPORT_C TPtrC8 CSenBaseFragment::Content()

    {

    TPtrC8 retVal;

    TRAPD(err, retVal.Set(ContentL());)

    if (err != KErrNone)

        {

        retVal.Set(KNullDesC8);

        }

    return retVal;

    }

TPtrC8 CSenBaseFragment::ContentL()

    {

    TPtrC8 content = AsElement().Content();

    TInt nsCount(iNamespaces.Count());

    if(nsCount>0)

        {

        TInt i = content.Locate('>');

        if( i > -1 )

            {

            if(!ipContentWithNamespaces)

                {

                ipContentWithNamespaces = CBufFlat::NewL(KFlatBufSize);

                }

            else

                {

                ipContentWithNamespaces->Reset(); //discard the old data in buf

                }

            i--; // make sure we are before a possible "/>"

            TInt cut = i;

            RBufWriteStream ws;

            CleanupClosePushL(ws);

            ws.Open(*ipContentWithNamespaces);