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











#include <s32strm.h> // RWriteStream
#include <SenXmlReader.h>
#include "senlayeredhttptransportproperties.h"
#include <SenHttpTransportProperties.h>              // property keys (constants)
#include <SenTransportProperties.h>                  // property keys (constants)
#include "senpropertieselement.h"   // private: Utils\inc
#include "senpropertiesfragment.h"  // private: Utils\inc

EXPORT_C CSenLayeredHttpTransportProperties* CSenLayeredHttpTransportProperties::NewL()
    {
    CSenLayeredHttpTransportProperties* pNew = NewLC();
    CleanupStack::Pop(); // pNew
    return pNew;
    }

EXPORT_C CSenLayeredHttpTransportProperties* CSenLayeredHttpTransportProperties::NewLC()
    {
    CSenLayeredHttpTransportProperties* pNew = new (ELeave) CSenLayeredHttpTransportProperties;
    CleanupStack::PushL(pNew);

    // omit parsing by passing zero-length descriptor
    pNew->BaseConstructL(KSenLayeredXmlPropertiesLocalname, KNullDesC8, NULL);
    return pNew;
    }

EXPORT_C CSenLayeredHttpTransportProperties* CSenLayeredHttpTransportProperties::NewL(const TDesC8& aXmlUtf8, CSenXmlReader& aParser)
    {
    CSenLayeredHttpTransportProperties* pNew = NewLC(aXmlUtf8, aParser);
    CleanupStack::Pop(); // pNew
    return pNew;
    }

EXPORT_C CSenLayeredHttpTransportProperties* CSenLayeredHttpTransportProperties::NewLC(const TDesC8& aXmlUtf8, CSenXmlReader& aParser)
    {
    CSenLayeredHttpTransportProperties* pNew = new (ELeave) CSenLayeredHttpTransportProperties;
    CleanupStack::PushL(pNew);

    // parse the XML document  descriptor into DOM fragment
    pNew->BaseConstructL(KSenLayeredXmlPropertiesLocalname, aXmlUtf8, &aParser);
    return pNew;
    }

EXPORT_C CSenLayeredHttpTransportProperties* CSenLayeredHttpTransportProperties::NewL(const CSenElement& aElement)
    {
    CSenLayeredHttpTransportProperties* pNew = NewLC(aElement);
    CleanupStack::Pop(); // pNew
    return pNew;
    }

EXPORT_C CSenLayeredHttpTransportProperties* CSenLayeredHttpTransportProperties::NewLC(const CSenElement& aElement)
    {
    CSenLayeredHttpTransportProperties* pNew = new (ELeave) CSenLayeredHttpTransportProperties;
    CleanupStack::PushL(pNew);

    // parse the XML document  descriptor into DOM fragment
    pNew->BaseConstructL(aElement);
    return pNew;
    }

// RStringPool variants:
EXPORT_C CSenLayeredHttpTransportProperties* CSenLayeredHttpTransportProperties::NewL(RStringPool& aStringPool)
    {
    CSenLayeredHttpTransportProperties* pNew = NewLC(aStringPool);
    CleanupStack::Pop(); // pNew
    return pNew;
    }

EXPORT_C CSenLayeredHttpTransportProperties* CSenLayeredHttpTransportProperties::NewLC(RStringPool& aStringPool)
    {
    CSenLayeredHttpTransportProperties* pNew = new (ELeave) CSenLayeredHttpTransportProperties;
    CleanupStack::PushL(pNew);

    // omit parsing by passing zero-length descriptor
    pNew->BaseConstructL(KSenLayeredXmlPropertiesLocalname, KNullDesC8, NULL, &aStringPool);
    return pNew;
    }

EXPORT_C CSenLayeredHttpTransportProperties* CSenLayeredHttpTransportProperties::NewL(const TDesC8& aXmlUtf8, CSenXmlReader& aParser, RStringPool& aStringPool)
    {
    CSenLayeredHttpTransportProperties* pNew = NewLC(aXmlUtf8, aParser, aStringPool);
    CleanupStack::Pop(); // pNew
    return pNew;
    }

EXPORT_C CSenLayeredHttpTransportProperties* CSenLayeredHttpTransportProperties::NewLC(const TDesC8& aXmlUtf8, CSenXmlReader& aParser, RStringPool& aStringPool)
    {
    CSenLayeredHttpTransportProperties* pNew = new (ELeave) CSenLayeredHttpTransportProperties;
    CleanupStack::PushL(pNew);

    // parse the XML document  descriptor into DOM fragment
    pNew->BaseConstructL(KSenLayeredXmlPropertiesLocalname, aXmlUtf8, &aParser, &aStringPool);
    return pNew;
    }

EXPORT_C CSenLayeredHttpTransportProperties* CSenLayeredHttpTransportProperties::NewL(const CSenElement& aElement, RStringPool& aStringPool)
    {
    CSenLayeredHttpTransportProperties* pNew = NewLC(aElement, aStringPool);
    CleanupStack::Pop(); // pNew
    return pNew;
    }

EXPORT_C CSenLayeredHttpTransportProperties* CSenLayeredHttpTransportProperties::NewLC(const CSenElement& aElement, RStringPool& aStringPool)
    {
    CSenLayeredHttpTransportProperties* pNew = new (ELeave) CSenLayeredHttpTransportProperties;
    CleanupStack::PushL(pNew);

    // parse the XML document  descriptor into DOM fragment
    pNew->BaseConstructL(aElement, &aStringPool);
    return pNew;
    }

    
void CSenLayeredHttpTransportProperties::SetReader(CSenXmlReader& aReader)
    {
    CSenLayeredTransportProperties::SetReader(aReader);
    }    
    

MSenProperties::TSenPropertiesClassType CSenLayeredHttpTransportProperties::PropertiesClassType() 
    {
    return ESenLayeredHttpTransportProperties;
    }

void CSenLayeredHttpTransportProperties::WriteToL(RWriteStream& aWriteStream)
    {
    CSenLayeredTransportProperties::WriteToL(aWriteStream);
    }

void CSenLayeredHttpTransportProperties::ReadFromL(const TDesC8& aBuffer)
    {
    CSenLayeredTransportProperties::ReadFromL(aBuffer);
    }
    
HBufC8* CSenLayeredHttpTransportProperties::AsUtf8L()
    {
    return CSenLayeredTransportProperties::AsUtf8L();
    }

HBufC8* CSenLayeredHttpTransportProperties::AsUtf8LC()
    {
    return CSenLayeredTransportProperties::AsUtf8LC();
    }
    
TBool CSenLayeredHttpTransportProperties::IsSafeToCast(TSenPropertiesClassType aClass)
    {
    if ( aClass == MSenProperties::ESenLayeredHttpTransportProperties )
        {
        return ETrue;
        }
    else
        {
        return CSenLayeredTransportProperties::IsSafeToCast( aClass );
        }
    }

TInt CSenLayeredHttpTransportProperties::SetPropertyL(const TDesC8& aName, const TDesC8& aValue)
    {
    return CSenLayeredTransportProperties::SetPropertyL(aName, aValue);
    }
    
TInt CSenLayeredHttpTransportProperties::PropertyL(const TDesC8& aName, TPtrC8& aValue)
    {
    return CSenLayeredTransportProperties::PropertyL(aName, aValue);
    }
    
TInt CSenLayeredHttpTransportProperties::PropertyL(const TDesC8& aName, MSenProperty*& aValue, TSenPropertiesLayer aLayer)
    {
    return CSenLayeredTransportProperties::PropertyL(aName, aValue, aLayer);
    }
        
TInt CSenLayeredHttpTransportProperties::PropertyL(const TDesC8& aName, MSenProperty*& aValue)
    {
    return CSenLayeredTransportProperties::PropertyL(aName, aValue);
    }

TInt CSenLayeredHttpTransportProperties::PropertiesByTypeL(const TDesC8& aType, RPointerArray<MSenProperty>& aArray)
    {
    return CSenLayeredTransportProperties::PropertiesByTypeL(aType, aArray);
    }

TInt CSenLayeredHttpTransportProperties::SetIntPropertyL(const TDesC8& aName, const TInt aValue)
    {
    return CSenLayeredTransportProperties::SetIntPropertyL(aName, aValue);
    }
    
TInt CSenLayeredHttpTransportProperties::IntPropertyL(const TDesC8& aName, TInt& aValue)
    {
    return CSenLayeredTransportProperties::IntPropertyL(aName, aValue);
    }
    
TInt CSenLayeredHttpTransportProperties::SetBoolPropertyL(const TDesC8& aName, const TBool aValue)
    {
    return CSenLayeredTransportProperties::SetBoolPropertyL(aName, aValue);
    }
    
TInt CSenLayeredHttpTransportProperties::BoolPropertyL(const TDesC8& aName, TBool& aValue)
    {
    return CSenLayeredTransportProperties::BoolPropertyL(aName, aValue);
    }   

void CSenLayeredHttpTransportProperties::WriteToL(RWriteStream& aWriteStream, TSenPropertiesLayer aLayer)
    {
    CSenLayeredTransportProperties::WriteToL(aWriteStream, aLayer);
    }

void CSenLayeredHttpTransportProperties::ReadFromL(const TDesC8& aBuffer, TSenPropertiesLayer aLayer)
    {
    CSenLayeredTransportProperties::ReadFromL(aBuffer, aLayer);
    }
    
HBufC8* CSenLayeredHttpTransportProperties::AsUtf8L(TSenPropertiesLayer aLayer)
    {
    return CSenLayeredTransportProperties::AsUtf8L(aLayer);
    }

HBufC8* CSenLayeredHttpTransportProperties::AsUtf8LC(TSenPropertiesLayer aLayer)
    {
    return CSenLayeredTransportProperties::AsUtf8LC(aLayer);
    }

TInt CSenLayeredHttpTransportProperties::ShrinkTo(TSenPropertiesLayer aLayer)
    {
    return CSenLayeredTransportProperties::ShrinkTo(aLayer);
    }
    
void CSenLayeredHttpTransportProperties::ExpandToL(TSenPropertiesLayer aLayer)
    {
    CSenLayeredTransportProperties::ExpandToL(aLayer);
    }
    
MSenLayeredProperties::TSenPropertiesLayer CSenLayeredHttpTransportProperties::TopLayer()
    {
    return CSenLayeredTransportProperties::TopLayer();
    }
    
TInt CSenLayeredHttpTransportProperties::SetPropertyL(const TDesC8& aName, const TDesC8& aValue, TSenPropertiesLayer aLayer)
    {
    return CSenLayeredTransportProperties::SetPropertyL(aName, aValue, aLayer);
    }
    
TInt CSenLayeredHttpTransportProperties::PropertyL(const TDesC8& aName,
                                                     TPtrC8& aValue,
                                                     TSenPropertiesLayer aLayer)
    {
    return CSenLayeredTransportProperties::PropertyL(aName, aValue, aLayer);
    }

TInt CSenLayeredHttpTransportProperties::SetIntPropertyL(const TDesC8& aName,
                                                            const TInt aValue,
                                                            TSenPropertiesLayer aLayer)
    {
    return CSenLayeredTransportProperties::SetIntPropertyL(aName, aValue, aLayer);
    }
    
TInt CSenLayeredHttpTransportProperties::IntPropertyL(const TDesC8& aName,
                                                           TInt& aValue,
                                                           TSenPropertiesLayer aLayer)
    {
    return CSenLayeredTransportProperties::IntPropertyL(aName, aValue, aLayer);
    }
    
TInt CSenLayeredHttpTransportProperties::SetBoolPropertyL(const TDesC8& aName,
                                                               const TBool aValue,
                                                               TSenPropertiesLayer aLayer)
    {
    return CSenLayeredTransportProperties::SetBoolPropertyL(aName, aValue, aLayer);
    }
    
TInt CSenLayeredHttpTransportProperties::BoolPropertyL(const TDesC8& aName,
                                                            TBool& aValue,
                                                            TSenPropertiesLayer aLayer)
    {
    return CSenLayeredTransportProperties::BoolPropertyL(aName, aValue, aLayer);
    }    

TInt CSenLayeredHttpTransportProperties::IapIdL(TUint32& aCurrentIapId)
    {
    return CSenLayeredTransportProperties::IapIdL(aCurrentIapId);
    }

TInt CSenLayeredHttpTransportProperties::SnapIdL(TUint32& aCurrentSnapId)
    {
    return CSenLayeredTransportProperties::SnapIdL(aCurrentSnapId);
    }

TInt CSenLayeredHttpTransportProperties::ProxyPortL(TInt& aProxyPort)
    {
    return CSenLayeredTransportProperties::ProxyPortL(aProxyPort);
    }

TInt CSenLayeredHttpTransportProperties::ProxyHostL(TPtrC8& aProxyHost)
    {
    return CSenLayeredTransportProperties::ProxyHostL(aProxyHost);
    }

TInt CSenLayeredHttpTransportProperties::ProxyUsageL(TBool& aValue)
    {
    return CSenLayeredTransportProperties::ProxyUsageL(aValue);
    }

TInt CSenLayeredHttpTransportProperties::IAPDialogL(TBool& aValue)
    {
    return CSenLayeredTransportProperties::IAPDialogL(aValue);
    }

TInt CSenLayeredHttpTransportProperties::SnapDialogL(TBool& aValue)
	{
	return CSenLayeredTransportProperties::SnapDialogL(aValue);
	}
TInt CSenLayeredHttpTransportProperties::ContentTypeL(TPtrC8& aContentType)
    {
    return PropertyL(KContentTypeLocalName, aContentType);
    }

TInt CSenLayeredHttpTransportProperties::UserAgentL(TPtrC8& aUserAgent)
    {
    return CSenLayeredTransportProperties::UserAgentL(aUserAgent);
    }

TInt CSenLayeredHttpTransportProperties::AcceptL(MSenProperty*& aAccept)
    {
    return CSenLayeredXmlProperties::PropertyL(KAcceptLocalName, aAccept);
    }

TInt CSenLayeredHttpTransportProperties::HttpMethodL(TSenHttpMethod& aMethod)
    {
    TPtrC8 method;
    TInt retVal = PropertyL(KHttpMethodLocalName, method);
    if (retVal == KErrNone)
        {
        if (method == KHttpGet)
            {
            aMethod = ESenHttpGet;
            return KErrNone;
            }
        else if (method == KHttpPost)
            {
            aMethod = ESenHttpPost;
            return KErrNone;
            }
        else if (method == KHttpPut)
            {
            aMethod = ESenHttpPut;
            return KErrNone;
            }
        else if (method == KHttpDelete)
            {
            aMethod = ESenHttpDelete;
            return KErrNone;
            }
        else
            {
            return KErrUnknown;
            }
        }
    else
        {
        return retVal;
        }
    }

TInt CSenLayeredHttpTransportProperties::HttpVersionL(TSenHttpVersion& aHttpVersion)
    {
    TPtrC8 method;
    TInt retVal = PropertyL(KHttpVersionLocalName, method);
    if (retVal == KErrNone)
        {
        if (method == KHttp10)
            {
            aHttpVersion = ESenHttp10;
            return KErrNone;
            }
        else if (method == KHttp11)
            {
            aHttpVersion = ESenHttp11;
            return KErrNone;
            }
        else
            {
            return KErrUnknown;
            }
        }
    else
        {
        return retVal;
        }
    }
    
TInt CSenLayeredHttpTransportProperties::HttpHeadersL(
                                        RPointerArray<MSenProperty>& aArray)
    {
    return PropertiesByTypeL(KHttpHeaderType, aArray);
    }

TInt CSenLayeredHttpTransportProperties::SetPropertyL(const TDesC8& aName, 
                                                      const TDesC8& aValue,
                                                      const TDesC8& aType)
    {
    return CSenLayeredTransportProperties::SetPropertyL(aName, aValue, aType);
    }

TInt CSenLayeredHttpTransportProperties::PropertyL(const TDesC8& aName, 
                                                   TPtrC8& aValue,
                                                   TPtrC8& aType)
    {
    return CSenLayeredTransportProperties::PropertyL(aName, aValue, aType);
    }
MSenProperties* CSenLayeredHttpTransportProperties::CloneL() const
    {
    CSenElement& element = ipFragment->AsElement();
    
    CSenLayeredHttpTransportProperties* pProperties = NewLC(element);
    if ( ipChildProperties )
        {
        CSenLayeredHttpTransportProperties* pChildProperties =
                                (CSenLayeredHttpTransportProperties*)ipChildProperties->CloneL();
        pProperties->ipChildProperties = pChildProperties;
        }
    
    CleanupStack::Pop(pProperties);
    return pProperties;
    }

void CSenLayeredHttpTransportProperties::BaseConstructL(const TDesC8& aLocalname, 
                                                 const TDesC8& aXml,
                                                 CSenXmlReader* aParser,
                                                 RStringPool* aStringPool)
    {
    CSenLayeredTransportProperties::BaseConstructL(aLocalname, aXml, aParser, aStringPool);
    }

void CSenLayeredHttpTransportProperties::BaseConstructL(const TDesC8& aNamespace, 
                                                 const TDesC8& aLocalname, 
                                                 const TDesC8& aXml,
                                                 CSenXmlReader* aParser,
                                                 RStringPool* aStringPool)
    {
    CSenLayeredTransportProperties::BaseConstructL(aNamespace, aLocalname, aXml, aParser, aStringPool);
    }

void CSenLayeredHttpTransportProperties::BaseConstructL(const TDesC8& aNamespace, 
                                                 const TDesC8& aLocalname, 
                                                 const TDesC8& aQualifiedName, 
                                                 const TDesC8& aXml,
                                                 CSenXmlReader* aParser,
                                                 RStringPool* aStringPool)
    {
    CSenLayeredTransportProperties::BaseConstructL(aNamespace, aLocalname, aQualifiedName, 
                                                   aXml, aParser, aStringPool);
    }

void CSenLayeredHttpTransportProperties::BaseConstructL(const CSenElement& aElement, RStringPool* aStringPool)
    {
    CSenLayeredTransportProperties::BaseConstructL(aElement, aStringPool);
    }

CSenLayeredHttpTransportProperties::CSenLayeredHttpTransportProperties()
    {
    }

CSenLayeredHttpTransportProperties::~CSenLayeredHttpTransportProperties()
    {
    }

TInt CSenLayeredHttpTransportProperties::DeviceIDL(TPtrC8& aDeviceID)
    {
    return CSenLayeredTransportProperties::DeviceIDL(aDeviceID);
    }

TInt CSenLayeredHttpTransportProperties::SoapActionL(TPtrC8& aAction)
    {
    return CSenLayeredTransportProperties::SoapActionL(aAction);
    }
TInt CSenLayeredHttpTransportProperties::DownloadFolderL(TPtrC8& aDownloadFolder)
    {
    return CSenLayeredTransportProperties::DownloadFolderL(aDownloadFolder);
    }
    
TInt CSenLayeredHttpTransportProperties::FileAttachmentL(const TDesC8& aCid, HBufC8*& aFileName)
    {
    return CSenLayeredTransportProperties::FileAttachmentL(aCid, aFileName);
    }

TInt CSenLayeredHttpTransportProperties::MwsNamespaceL(TPtrC8& aMwsNamespace)
    {
    return CSenLayeredTransportProperties::MwsNamespaceL(aMwsNamespace);
    }
// END OF FILE