/*

* 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 <s32strm.h> // RWriteStream

#include <SenXmlReader.h>

#include "SenHttpTransportProperties.h"

namespace

    {

    _LIT8(KIapIdLocalName, "IapId"); 

    _LIT8(KProxyHostLocalName, "ProxyHost"); 

    _LIT8(KProxyPortLocalName, "ProxyPort"); 

    }

EXPORT_C CSenHttpTransportProperties* CSenHttpTransportProperties::NewL()

    {

    CSenHttpTransportProperties* pNew = NewLC();

    CleanupStack::Pop(); // pNew

    return pNew;

    }

EXPORT_C CSenHttpTransportProperties* CSenHttpTransportProperties::NewLC()

    {

    CSenHttpTransportProperties* pNew = new (ELeave) CSenHttpTransportProperties;

    CleanupStack::PushL(pNew);

    // omit parsing by passing zero-length descriptor

    pNew->BaseConstructL(KSenXmlPropertiesLocalname,

                         KNullDesC8,

                         NULL);

    return pNew;

    }

EXPORT_C CSenHttpTransportProperties* CSenHttpTransportProperties::NewL(const TDesC8& aXmlUtf8,

                                                               CSenXmlReader& aParser)

    {

    CSenHttpTransportProperties* pNew = NewLC(aXmlUtf8, aParser);

    CleanupStack::Pop(); // pNew

    return pNew;

    }

EXPORT_C CSenHttpTransportProperties* CSenHttpTransportProperties::NewLC(const TDesC8& aXmlUtf8,

                                                                CSenXmlReader& aParser)

    {

    CSenHttpTransportProperties* pNew = new (ELeave) CSenHttpTransportProperties;

    CleanupStack::PushL(pNew);

    // parse the XML document  descriptor into DOM fragment

    pNew->BaseConstructL(KSenXmlPropertiesLocalname,

                         aXmlUtf8,

                         &aParser);

    return pNew;

    }

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

    {

    CSenHttpTransportProperties* pNew = NewLC(aElement);

    CleanupStack::Pop(); // pNew

    return pNew;

    }

EXPORT_C CSenHttpTransportProperties* CSenHttpTransportProperties::NewLC(const CSenElement& aElement)

    {

    CSenHttpTransportProperties* pNew = new (ELeave) CSenHttpTransportProperties;

    CleanupStack::PushL(pNew);

    // parse the XML document  descriptor into DOM fragment

    pNew->BaseConstructL(aElement);

    return pNew;

    }

/**

* Get an integer identifying properties class type.

* All subclasses MUST return use unique integer value.

* @return unique TInt identifying this properties class type

*/

TInt CSenHttpTransportProperties::PropertiesClassType() 

    { 

    return KSenPropertiesClassTypeSenHttpTransportProperties; 

    }

/**

* Writes this properties object as descriptor into a stream.

* UTF-8 charset encoding will be used.

* @since Series60

* @param aWriteStream The stream to write to.

*/

void CSenHttpTransportProperties::WriteToL(RWriteStream& aWriteStream)

    {

    CSenTransportProperties::WriteAsXMLToL(aWriteStream);

    /*

    WriteAsXMLToL(aWriteStream);

    */

    }

/**

* Get these properties as UTF-8 charset encoded descriptor.

* @since Series60

* @return a pointer to UTF-8 encoded descriptor. 

* Caller takes ownership.

*/

HBufC8* CSenHttpTransportProperties::AsUtf8L()

    {

    return CSenTransportProperties::AsUtf8L();

    /*

    return AsXmlL();

    */

    }

/**

* Get these properties as UTF-8 charset encoded descriptor.

* @since Series60

* @return a pointer to UTF-8 encoded descriptor, which is

* has been left on cleanup stack.

* Caller takes ownership.

*/

HBufC8* CSenHttpTransportProperties::AsUtf8LC()

    {

    return CSenTransportProperties::AsUtf8LC();

    /*

    HBufC8* pAsXml = AsXmlL();

    CleanupStack::PushL(pAsXml);

    return pAsXml;

    */

    }

/**

* Destructor.

*/

CSenHttpTransportProperties::~CSenHttpTransportProperties()

    {

    }

/**

* Constructs this fragment. Subclasses should call this

* function in their corresponding 2nd phase constructor.

*

* @param aLocalname is used as XML localname for this instance

* @param aXml is the XML document to be parsed into this DOM tree

* this properties instance represents.

* Parsing is omitted iff descriptor is zero-length: KNullDesC8.

*/

void CSenHttpTransportProperties::BaseConstructL(const TDesC8& aLocalname, 

                                                 const TDesC8& aXml,

                                                 CSenXmlReader* aParser)

    {

    CSenTransportProperties::BaseConstructL(aLocalname, aXml, aParser);

    }

/**

* Constructs this fragment. Subclasses should call this

* function in their corresponding 2nd phase constructor.

*

* @param aNamespace is the XML namespace

* @param aLocalname is the XML localname

* @param aXml is the XML document to be parsed into this DOM tree

* this properties instance represents.

* Parsing is omitted iff descriptor is zero-length: KNullDesC8.

*/

void CSenHttpTransportProperties::BaseConstructL(const TDesC8& aNamespace, 

                                                 const TDesC8& aLocalname, 

                                                 const TDesC8& aXml,

                                                 CSenXmlReader* aParser)

    {

    CSenTransportProperties::BaseConstructL(aNamespace, aLocalname, aXml, aParser);

    }

/**

* Constructs this fragment. Subclasses should call this

* function in their corresponding 2nd phase constructor.

*

* @param aNamespace is the XML namespace

* @param aLocalname is the XML localname

* @param aLocalname is the XML qualified name

* @param aXml is the XML document to be parsed into this DOM tree

* this properties instance represents.

* Parsing is omitted iff descriptor is zero-length: KNullDesC8.

*/

void CSenHttpTransportProperties::BaseConstructL(const TDesC8& aNamespace, 

                                                 const TDesC8& aLocalname, 

                                                 const TDesC8& aQualifiedName, 

                                                 const TDesC8& aXml,

                                                 CSenXmlReader* aParser)

    {

    CSenTransportProperties::BaseConstructL(aNamespace, aLocalname, aQualifiedName, aXml, aParser);

    }

/**

* 2nd phase constructor:

*/

void CSenHttpTransportProperties::BaseConstructL(const CSenElement& aElement)

    {

    CSenTransportProperties::BaseConstructL(aElement);

    }

CSenHttpTransportProperties::CSenHttpTransportProperties()

    {

    }

// First versions of real HTTP spesific transport methods:

EXPORT_C TInt CSenHttpTransportProperties::IapId(TUint32& aCurrentIapId)

    {

    CSenElement* pIapIdElement = AsElement().Element(KIapIdLocalName);

    if(pIapIdElement && pIapIdElement->HasContent())

        {

        TPtrC8 content = pIapIdElement->Content();

        TLex8 lex(content);

        TInt retVal = lex.Val(aCurrentIapId, EDecimal);

        return retVal;

        }

    return KErrNotFound;

    }

EXPORT_C void CSenHttpTransportProperties::SetIapIdL(TUint32 aIapId)

    {

    CSenElement* pIapIdElement = AsElement().Element(KIapIdLocalName);

    if(!pIapIdElement)

        {

        pIapIdElement = &(AsElement().AddElementL(KIapIdLocalName));

        }

    TBuf8<128> buf;

    buf.AppendFormat(_L8("%u"), aIapId);

    pIapIdElement->SetContentL(buf);

    }

EXPORT_C TInt CSenHttpTransportProperties::ProxyPort()

    {

    CSenElement* pProxyPortElement = AsElement().Element(KProxyPortLocalName);

    if(pProxyPortElement && pProxyPortElement->HasContent())

        {

        TPtrC8 content = pProxyPortElement->Content();

        TLex8 lex(content);

        TUint proxyPort(0);

        TInt retVal = lex.Val(proxyPort, EDecimal);

        if(retVal==KErrNone)

            {

            return (TInt)proxyPort;

            }

        else

            {

            return retVal;

            }

        }

    return KErrNotFound;

    }

EXPORT_C void CSenHttpTransportProperties::SetProxyPortL(TInt aProxyPort)

    {

    CSenElement* pProxyPortElement = AsElement().Element(KProxyPortLocalName);

    if(!pProxyPortElement)

        {

        pProxyPortElement = &(AsElement().AddElementL(KProxyPortLocalName));

        }

    TBuf8<128> buf;

    buf.AppendFormat(_L8("%u"), aProxyPort);

    pProxyPortElement->SetContentL(buf);

    }

EXPORT_C TPtrC8 CSenHttpTransportProperties::ProxyHost()

    {

    CSenElement* pProxyHostElement = AsElement().Element(KProxyHostLocalName);

    if(pProxyHostElement && pProxyHostElement->HasContent())

        {

        return pProxyHostElement->Content();

        }

    else return KNullDesC8();

    }

EXPORT_C void CSenHttpTransportProperties::SetProxyHostL(const TDesC8& aProxyHost)

    {

    CSenElement* pProxyHostElement = AsElement().Element(KProxyHostLocalName);

    if(!pProxyHostElement)

        {

        pProxyHostElement = &(AsElement().AddElementL(KProxyHostLocalName));

        }

    pProxyHostElement->SetContentL(aProxyHost);

    }

// END OF FILEŽ