diff -r 000000000000 -r 62f9d29f7211 webservices/wsutils/src/senvtcptransportproperties.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/webservices/wsutils/src/senvtcptransportproperties.cpp Thu Jan 07 16:19:19 2010 +0200 @@ -0,0 +1,456 @@ +/* +* 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 // RWriteStream +#include +#include "senvtcptransportproperties.h" +#include "senpropertiesfragment.h" +#include "MSenProperty.h" +#include + +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 ); + } + +TInt CSenVtcpTransportProperties::OnewayMessageOnOffL( TBool& aOnewayMessageOnOff ) + { + return CSenTransportProperties::OnewayMessageOnOffL( aOnewayMessageOnOff ); + } + +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 ); + } + +TInt CSenVtcpTransportProperties::SetMaxTimeToLiveL(TInt aMaxTTL) + { + return CSenTransportProperties::SetMaxTimeToLiveL( aMaxTTL ); + } + +TInt CSenVtcpTransportProperties::MaxTimeToLiveL(TInt& aMaxTTL) + { + return CSenTransportProperties::MaxTimeToLiveL( aMaxTTL ); + } + +TInt CSenVtcpTransportProperties::SetMinTimeToLiveL(TInt aMinTTL) + { + return CSenTransportProperties::SetMinTimeToLiveL( aMinTTL ); + } + +TInt CSenVtcpTransportProperties::MinTimeToLiveL(TInt& aMinTTL) + { + return CSenTransportProperties::MinTimeToLiveL( aMinTTL ); + } + +TInt CSenVtcpTransportProperties::SetMaxRetryTTLL(TInt aMaxRetryTTL) + { + return SetIntPropertyL( KSenConnectionRetryMaxTTL, aMaxRetryTTL ); + } + +TInt CSenVtcpTransportProperties::MaxRetryTTLL(TInt& aMaxRetryTTL) + { + return IntPropertyL( KSenConnectionRetryMaxTTL, aMaxRetryTTL ); + } + +TInt CSenVtcpTransportProperties::SetMinRetryTTLL(TInt aMinRetryTTL) + { + return SetIntPropertyL( KSenConnectionRetryMinTTL, aMinRetryTTL ); + } + +TInt CSenVtcpTransportProperties:: MinRetryTTLL(TInt& aMinRetryTTL) + { + return IntPropertyL( KSenConnectionRetryMinTTL, aMinRetryTTL ); + } + +TInt CSenVtcpTransportProperties::SetRetryDeltaTimeoutL(TInt aTimeout) + { + return SetIntPropertyL( KSenConnectionRetryDelta, aTimeout ); + } + +TInt CSenVtcpTransportProperties::RetryDeltaTimeoutL(TInt& aTimeout) + { + return IntPropertyL( KSenConnectionRetryDelta, aTimeout ); + } + + + + +// END OF FILE + +