/*
* 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 "senvtcptransportproperties.h"
#include "senpropertiesfragment.h"
#include "MSenProperty.h"
#include <SenXmlUtils.h>

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

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

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

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

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

    // parse the XML document  descriptor into DOM fragment
    pNew->BaseConstructL(KSenXmlPropertiesLocalname,
                         aXmlUtf8,
                         &aParser);
    return pNew;
    }
    
EXPORT_C CSenVtcpTransportProperties* CSenVtcpTransportProperties::NewL(const CSenElement& aElement)
    {
    CSenVtcpTransportProperties* pNew = NewLC(aElement);
    CleanupStack::Pop(); // pNew
    return pNew;
    }

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

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

void CSenVtcpTransportProperties::SetReader(CSenXmlReader& aReader)
    {
    CSenTransportProperties::SetReader(aReader);
    } 

MSenProperties::TSenPropertiesClassType CSenVtcpTransportProperties::PropertiesClassType() 
    {
    return ESenVtcpTransportProperties;
    }

void CSenVtcpTransportProperties::WriteToL(RWriteStream& aWriteStream)
    {
    CSenTransportProperties::WriteToL(aWriteStream);
    }
    
void CSenVtcpTransportProperties::ReadFromL(const TDesC8& aBuffer)
    {
    CSenTransportProperties::ReadFromL(aBuffer);
    }    

HBufC8* CSenVtcpTransportProperties::AsUtf8L()
    {
    return CSenTransportProperties::AsUtf8L();
    }

HBufC8* CSenVtcpTransportProperties::AsUtf8LC()
    {
    return CSenTransportProperties::AsUtf8LC();
    }
    
TBool CSenVtcpTransportProperties::IsSafeToCast(TSenPropertiesClassType aClass)
    {
    if ( aClass == MSenProperties::ESenVtcpTransportProperties )
        {
        return ETrue;
        }
    else
        {
        return CSenTransportProperties::IsSafeToCast(aClass);
        }
    }      

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

TInt CSenVtcpTransportProperties::PropertyL(const TDesC8& aName,
                                            TPtrC8& aValue,
                                            TPtrC8& aType)
    {
    return CSenTransportProperties::PropertyL(aName, aValue, aType);
    }

    
TInt CSenVtcpTransportProperties::SetPropertyL(const TDesC8& aName,
                                               const TDesC8& aValue)
    {
    return CSenTransportProperties::SetPropertyL(aName, aValue);
    }
    
TInt CSenVtcpTransportProperties::PropertyL(const TDesC8& aName,
                                            TPtrC8& aValue)
    {
    return CSenTransportProperties::PropertyL(aName, aValue);
    }
    
TInt CSenVtcpTransportProperties::SetIntPropertyL(const TDesC8& aName,
                                                  const TInt aValue)
    {
    return CSenTransportProperties::SetIntPropertyL(aName, aValue);
    }

TInt CSenVtcpTransportProperties::IntPropertyL(const TDesC8& aName,
                                               TInt& aValue)
    {
    return CSenTransportProperties::IntPropertyL(aName, aValue);
    }

TInt CSenVtcpTransportProperties::SetBoolPropertyL(const TDesC8& aName,
                                                   const TBool aValue)
    {
    return CSenTransportProperties::SetBoolPropertyL(aName, aValue);
    }

TInt CSenVtcpTransportProperties::BoolPropertyL(const TDesC8& aName,
                                                TBool& aValue)
    {
    return CSenTransportProperties::BoolPropertyL(aName, aValue);
    }  

CSenVtcpTransportProperties::~CSenVtcpTransportProperties()
    {
    }

void CSenVtcpTransportProperties::BaseConstructL(const TDesC8& aLocalname, 
                                                 const TDesC8& aXml,
                                                 CSenXmlReader* aParser)
    {
    CSenTransportProperties::BaseConstructL(aLocalname, aXml, aParser);
    }

void CSenVtcpTransportProperties::BaseConstructL(const CSenElement& aElement)
    {
    CSenTransportProperties::BaseConstructL(aElement);
    }

CSenVtcpTransportProperties::CSenVtcpTransportProperties()
    {
    }

TInt CSenVtcpTransportProperties::DeviceLCIDL(TPtrC8& aDeviceLCID)
    {
    return PropertyL(KDeviceLCIDLocalName, aDeviceLCID);
    }

void CSenVtcpTransportProperties::SetDeviceLCIDL(const TDesC8& aDeviceLCID)
    {
    SetPropertyL(KDeviceLCIDLocalName, aDeviceLCID);
    }

TInt CSenVtcpTransportProperties::ConnectionBoundL(TBool& aConnectionBound)
    {
    return BoolPropertyL(KConnectionBoundLocalName, aConnectionBound);
    }

void CSenVtcpTransportProperties::SetConnectionBoundL(const TBool& aConnectionBound)
    {
    SetBoolPropertyL(KConnectionBoundLocalName, aConnectionBound);
    }

TInt CSenVtcpTransportProperties::ConnectionTimeOutL(TInt& aConnectionTimeOut)
    {
    return IntPropertyL(KConnectionTimeOutLocalName, aConnectionTimeOut);
    }

void CSenVtcpTransportProperties::SetConnectionTimeOutL(const TInt& aConnectionTimeOut)
    {
    SetIntPropertyL(KConnectionTimeOutLocalName, aConnectionTimeOut);
    }
    
//override
TInt CSenVtcpTransportProperties::IapIdL(TUint32& aCurrentIapId)
    {
    return CSenTransportProperties::IapIdL(aCurrentIapId);
    }

void CSenVtcpTransportProperties::SetIapIdL(TUint32 aIapId)
    {
    CSenTransportProperties::SetIapIdL(aIapId);
    }

void CSenVtcpTransportProperties::SetSnapIdL(TUint32 aSnapId)
{
    CSenTransportProperties::SetSnapIdL(aSnapId);
}

TInt CSenVtcpTransportProperties::SnapIdL(TUint32& aCurrentSnapId)
{
    return CSenTransportProperties::SnapIdL(aCurrentSnapId);
}

TInt CSenVtcpTransportProperties::ProxyPortL(TInt& aProxyPort)
    {
    return CSenTransportProperties::ProxyPortL(aProxyPort);
    }

void CSenVtcpTransportProperties::SetProxyPortL(TInt aProxyPort)
    {
    CSenTransportProperties::SetProxyPortL(aProxyPort);
    }

TInt CSenVtcpTransportProperties::ProxyHostL(TPtrC8& aProxyHost)
    {
    return CSenTransportProperties::ProxyHostL(aProxyHost);
    }

void CSenVtcpTransportProperties::SetProxyHostL(const TDesC8& aProxyHost)
    {
    CSenTransportProperties::SetProxyHostL(aProxyHost);
    }

TInt CSenVtcpTransportProperties::ProxyUsageL(TBool& aValue)
    {
    return CSenTransportProperties::ProxyUsageL(aValue);
    }

void CSenVtcpTransportProperties::SetProxyUsageL(TBool aProxyUsage)
    {
    CSenTransportProperties::SetProxyUsageL(aProxyUsage);
    }
    
TInt CSenVtcpTransportProperties::SecureDialogL(TBool& aValue)
    {
    return CSenTransportProperties::SecureDialogL(aValue);
    }

void CSenVtcpTransportProperties::SetSecureDialogL(TBool aSecureDialog)
    {
    CSenTransportProperties::SetSecureDialogL(aSecureDialog);
    }

TInt CSenVtcpTransportProperties::UserAgentL(TPtrC8& aUserAgent)
    {
    return CSenTransportProperties::UserAgentL(aUserAgent);
    }

void CSenVtcpTransportProperties::SetUserAgentL(const TDesC8& aUserAgent)
    {
    CSenTransportProperties::SetUserAgentL(aUserAgent);
    }


TInt CSenVtcpTransportProperties::DeviceIDL(TPtrC8& aDeviceID)
    {
    return CSenTransportProperties::DeviceIDL(aDeviceID);
    }

void CSenVtcpTransportProperties::SetDeviceIDL(const TDesC8& aDeviceID)
    {
    CSenTransportProperties::SetDeviceIDL(aDeviceID);
    }    

TInt CSenVtcpTransportProperties::SoapActionL(TPtrC8& aAction)
    {
    return CSenTransportProperties::SoapActionL(aAction);
    }

void CSenVtcpTransportProperties::SetSoapActionL(const TDesC8& aAction)
    {
    CSenTransportProperties::SetSoapActionL(aAction);
    }

void CSenVtcpTransportProperties::ApplyBindingL(TSOAPVersion aSoapVersion)
    {
    CSenTransportProperties::ApplyBindingL(aSoapVersion);
    }

TInt CSenVtcpTransportProperties::DownloadFolderL(TPtrC8& aDownloadFolder)
    {
    return CSenTransportProperties::DownloadFolderL(aDownloadFolder);
    }

void CSenVtcpTransportProperties::SetDownloadFolderL(const TDesC8& aDownloadFolder)
    {
    CSenTransportProperties::SetDownloadFolderL(aDownloadFolder);
    }      

TInt CSenVtcpTransportProperties::FileAttachmentL(const TDesC8& aCid, HBufC8*& aFileName)
    {
    return CSenTransportProperties::FileAttachmentL(aCid, aFileName);
    }

TInt CSenVtcpTransportProperties::SetFileAttachmentL(const TDesC8& aCid, const TDesC8& aFileName)
    {
    return CSenTransportProperties::SetFileAttachmentL(aCid, aFileName);
    }
    
MSenProperties* CSenVtcpTransportProperties::CloneL() const
    {
    CSenElement& element = ipFragment->AsElement();
    
    CSenVtcpTransportProperties* pProperties = NewLC(element);
    CleanupStack::Pop(pProperties);
    return pProperties;
    }
        
TInt CSenVtcpTransportProperties::MwsNamespaceL( TPtrC8& aMwsNamespace )
    {
    return CSenTransportProperties::MwsNamespaceL(aMwsNamespace);
    }

void CSenVtcpTransportProperties::SetMwsNamespaceL( const TDesC8& aMwsNamespace )
    {
    CSenTransportProperties::SetMwsNamespaceL(aMwsNamespace);
    }      

TInt CSenVtcpTransportProperties::MessageIdL( TPtrC8& aMessageId )
    {
    return CSenTransportProperties::MessageIdL( aMessageId );
    }      

void CSenVtcpTransportProperties::SetMessageIdL( const TDesC8& aMessageId )
    {
    CSenTransportProperties::SetMessageIdL( aMessageId );
    }
    
EXPORT_C TInt CSenVtcpTransportProperties::OnewayMessageOnOffL( TBool& aOnewayMessageOnOff )
    {
    return CSenTransportProperties::OnewayMessageOnOffL( aOnewayMessageOnOff );
    }

EXPORT_C void CSenVtcpTransportProperties::SetOnewayMessageOnOffL( TBool aOnewayMessageOnOff )
    {
    CSenTransportProperties::SetOnewayMessageOnOffL( aOnewayMessageOnOff );
    }
    
TInt CSenVtcpTransportProperties::HeartbeatL(TInt& aHeartbeat) 
    { 
    return CSenTransportProperties::HeartbeatL( aHeartbeat ); 
    }
    
TInt CSenVtcpTransportProperties::SetHeartbeatL(TInt aHeartbeat) 
    { 
    return CSenTransportProperties::SetHeartbeatL( aHeartbeat ); 
    }
    
EXPORT_C TInt CSenVtcpTransportProperties::SetMaxTimeToLiveL(TInt aMaxTTL) 
    { 
    return CSenTransportProperties::SetMaxTimeToLiveL( aMaxTTL ); 
    }

EXPORT_C TInt CSenVtcpTransportProperties::MaxTimeToLiveL(TInt& aMaxTTL) 
    { 
    return CSenTransportProperties::MaxTimeToLiveL( aMaxTTL ); 
    }

EXPORT_C TInt CSenVtcpTransportProperties::SetMinTimeToLiveL(TInt aMinTTL) 
    { 
    return CSenTransportProperties::SetMinTimeToLiveL( aMinTTL ); 
    }

EXPORT_C TInt CSenVtcpTransportProperties::MinTimeToLiveL(TInt& aMinTTL) 
    { 
    return CSenTransportProperties::MinTimeToLiveL( aMinTTL ); 
    }
    
EXPORT_C TInt CSenVtcpTransportProperties::SetMaxRetryTTLL(TInt aMaxRetryTTL)
	{ 
	return SetIntPropertyL( KSenConnectionRetryMaxTTL, aMaxRetryTTL );
	}
	
EXPORT_C TInt CSenVtcpTransportProperties::MaxRetryTTLL(TInt& aMaxRetryTTL)
	{ 
	return IntPropertyL( KSenConnectionRetryMaxTTL, aMaxRetryTTL ); 
	}

EXPORT_C TInt CSenVtcpTransportProperties::SetMinRetryTTLL(TInt aMinRetryTTL)
	{ 
	return SetIntPropertyL( KSenConnectionRetryMinTTL, aMinRetryTTL );
	}
	
EXPORT_C TInt CSenVtcpTransportProperties:: MinRetryTTLL(TInt& aMinRetryTTL)
	{ 
	return IntPropertyL( KSenConnectionRetryMinTTL, aMinRetryTTL ); 
	}
	
EXPORT_C TInt CSenVtcpTransportProperties::SetRetryDeltaTimeoutL(TInt aTimeout)
	{ 
	return SetIntPropertyL( KSenConnectionRetryDelta, aTimeout );
	}
	
EXPORT_C TInt CSenVtcpTransportProperties::RetryDeltaTimeoutL(TInt& aTimeout)
	{ 
	return IntPropertyL( KSenConnectionRetryDelta, aTimeout ); 
	}


          

// END OF FILE