1 /*

     2 * Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:         

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 

    22 

    23 

    24 

    25 

    26 

    27 

    28 #include <s32strm.h> // RWriteStream

    29 #include <SenXmlReader.h>

    30 #include "senlayeredvtcptransportproperties.h"

    31 #include "senvtcptransportproperties.h"              // property keys (constants)

    32 #include <SenTransportProperties.h>

    33 #include "senpropertieselement.h"   // private: Utils\inc

    34 #include "senpropertiesfragment.h"  // private: Utils\inc

    35 

    36 EXPORT_C CSenLayeredVtcpTransportProperties* CSenLayeredVtcpTransportProperties::NewL()

    37     {

    38     CSenLayeredVtcpTransportProperties* pNew = NewLC();

    39     CleanupStack::Pop(); // pNew

    40     return pNew;

    41     }

    42 

    43 EXPORT_C CSenLayeredVtcpTransportProperties* CSenLayeredVtcpTransportProperties::NewLC()

    44     {

    45     CSenLayeredVtcpTransportProperties* pNew = new (ELeave) CSenLayeredVtcpTransportProperties;

    46     CleanupStack::PushL(pNew);

    47 

    48     // omit parsing by passing zero-length descriptor

    49     pNew->BaseConstructL(KSenLayeredXmlPropertiesLocalname, KNullDesC8, NULL);

    50     return pNew;

    51     }

    52 

    53 EXPORT_C CSenLayeredVtcpTransportProperties* CSenLayeredVtcpTransportProperties::NewL(const CSenElement& aElement)

    54     {

    55     CSenLayeredVtcpTransportProperties* pNew = NewLC(aElement);

    56     CleanupStack::Pop(); // pNew

    57     return pNew;

    58     }

    59 

    60 EXPORT_C CSenLayeredVtcpTransportProperties* CSenLayeredVtcpTransportProperties::NewLC(const CSenElement& aElement)

    61     {

    62     CSenLayeredVtcpTransportProperties* pNew = new (ELeave) CSenLayeredVtcpTransportProperties;

    63     CleanupStack::PushL(pNew);

    64 

    65     // parse the XML document  descriptor into DOM fragment

    66     pNew->BaseConstructL(aElement);

    67     return pNew;

    68     }

    69         

    70 void CSenLayeredVtcpTransportProperties::SetReader(CSenXmlReader& aReader)

    71     {

    72     CSenLayeredTransportProperties::SetReader(aReader);

    73     }    

    74     

    75 

    76 MSenProperties::TSenPropertiesClassType CSenLayeredVtcpTransportProperties::PropertiesClassType() 

    77     {

    78     return ESenLayeredVtcpTransportProperties;

    79     }

    80 

    81 void CSenLayeredVtcpTransportProperties::WriteToL(RWriteStream& aWriteStream)

    82     {

    83     CSenLayeredTransportProperties::WriteToL(aWriteStream);

    84     }

    85 

    86 void CSenLayeredVtcpTransportProperties::ReadFromL(const TDesC8& aBuffer)

    87     {

    88     CSenLayeredTransportProperties::ReadFromL(aBuffer);

    89     }

    90     

    91 HBufC8* CSenLayeredVtcpTransportProperties::AsUtf8L()

    92     {

    93     return CSenLayeredTransportProperties::AsUtf8L();

    94     }

    95 

    96 HBufC8* CSenLayeredVtcpTransportProperties::AsUtf8LC()

    97     {

    98     return CSenLayeredTransportProperties::AsUtf8LC();

    99     }

   100 

   101 TBool CSenLayeredVtcpTransportProperties::IsSafeToCast(TSenPropertiesClassType aClass)

   102     {

   103     if ( aClass == MSenProperties::ESenLayeredVtcpTransportProperties )

   104         {

   105         return ETrue;

   106         }

   107     else

   108         {

   109         return CSenLayeredTransportProperties::IsSafeToCast( aClass );

   110         }

   111     }

   112 

   113 TInt CSenLayeredVtcpTransportProperties::SetPropertyL(const TDesC8& aName, const TDesC8& aValue)

   114     {

   115     return CSenLayeredTransportProperties::SetPropertyL(aName, aValue);

   116     }

   117     

   118 TInt CSenLayeredVtcpTransportProperties::PropertyL(const TDesC8& aName, TPtrC8& aValue)

   119     {

   120     return CSenLayeredTransportProperties::PropertyL(aName, aValue);

   121     }

   122     

   123 TInt CSenLayeredVtcpTransportProperties::PropertyL(const TDesC8& aName, MSenProperty*& aValue, TSenPropertiesLayer aLayer)

   124     {

   125     return CSenLayeredTransportProperties::PropertyL(aName, aValue, aLayer);

   126     }

   127         

   128 TInt CSenLayeredVtcpTransportProperties::PropertyL(const TDesC8& aName, MSenProperty*& aValue)

   129     {

   130     return CSenLayeredTransportProperties::PropertyL(aName, aValue);

   131     }

   132 

   133 TInt CSenLayeredVtcpTransportProperties::PropertiesByTypeL(const TDesC8& aType, RPointerArray<MSenProperty>& aArray)

   134     {

   135     return CSenLayeredTransportProperties::PropertiesByTypeL(aType, aArray);

   136     }

   137 

   138 TInt CSenLayeredVtcpTransportProperties::SetIntPropertyL(const TDesC8& aName, const TInt aValue)

   139     {

   140     return CSenLayeredTransportProperties::SetIntPropertyL(aName, aValue);

   141     }

   142     

   143 TInt CSenLayeredVtcpTransportProperties::IntPropertyL(const TDesC8& aName, TInt& aValue)

   144     {

   145     return CSenLayeredTransportProperties::IntPropertyL(aName, aValue);

   146     }

   147     

   148 TInt CSenLayeredVtcpTransportProperties::SetBoolPropertyL(const TDesC8& aName, const TBool aValue)

   149     {

   150     return CSenLayeredTransportProperties::SetBoolPropertyL(aName, aValue);

   151     }

   152     

   153 TInt CSenLayeredVtcpTransportProperties::BoolPropertyL(const TDesC8& aName, TBool& aValue)

   154     {

   155     return CSenLayeredTransportProperties::BoolPropertyL(aName, aValue);

   156     }   

   157 

   158 void CSenLayeredVtcpTransportProperties::WriteToL(RWriteStream& aWriteStream, TSenPropertiesLayer aLayer)

   159     {

   160     CSenLayeredTransportProperties::WriteToL(aWriteStream, aLayer);

   161     }

   162 

   163 void CSenLayeredVtcpTransportProperties::ReadFromL(const TDesC8& aBuffer, TSenPropertiesLayer aLayer)

   164     {

   165     CSenLayeredTransportProperties::ReadFromL(aBuffer, aLayer);

   166     }

   167     

   168 HBufC8* CSenLayeredVtcpTransportProperties::AsUtf8L(TSenPropertiesLayer aLayer)

   169     {

   170     return CSenLayeredTransportProperties::AsUtf8L(aLayer);

   171     }

   172 

   173 HBufC8* CSenLayeredVtcpTransportProperties::AsUtf8LC(TSenPropertiesLayer aLayer)

   174     {

   175     return CSenLayeredTransportProperties::AsUtf8LC(aLayer);

   176     }

   177 

   178 TInt CSenLayeredVtcpTransportProperties::ShrinkTo(TSenPropertiesLayer aLayer)

   179     {

   180     return CSenLayeredTransportProperties::ShrinkTo(aLayer);

   181     }

   182     

   183 void CSenLayeredVtcpTransportProperties::ExpandToL(TSenPropertiesLayer aLayer)

   184     {

   185     CSenLayeredTransportProperties::ExpandToL(aLayer);

   186     }

   187     

   188 MSenLayeredProperties::TSenPropertiesLayer CSenLayeredVtcpTransportProperties::TopLayer()

   189     {

   190     return CSenLayeredTransportProperties::TopLayer();

   191     }

   192     

   193 TInt CSenLayeredVtcpTransportProperties::SetPropertyL(const TDesC8& aName, const TDesC8& aValue, TSenPropertiesLayer aLayer)

   194     {

   195     return CSenLayeredTransportProperties::SetPropertyL(aName, aValue, aLayer);

   196     }

   197     

   198 TInt CSenLayeredVtcpTransportProperties::PropertyL(const TDesC8& aName,

   199                                                      TPtrC8& aValue,

   200                                                      TSenPropertiesLayer aLayer)

   201     {

   202     return CSenLayeredTransportProperties::PropertyL(aName, aValue, aLayer);

   203     }

   204 

   205 TInt CSenLayeredVtcpTransportProperties::SetIntPropertyL(const TDesC8& aName,

   206                                                             const TInt aValue,

   207                                                             TSenPropertiesLayer aLayer)

   208     {

   209     return CSenLayeredTransportProperties::SetIntPropertyL(aName, aValue, aLayer);

   210     }

   211     

   212 TInt CSenLayeredVtcpTransportProperties::IntPropertyL(const TDesC8& aName,

   213                                                            TInt& aValue,

   214                                                            TSenPropertiesLayer aLayer)

   215     {

   216     return CSenLayeredTransportProperties::IntPropertyL(aName, aValue, aLayer);

   217     }

   218     

   219 TInt CSenLayeredVtcpTransportProperties::SetBoolPropertyL(const TDesC8& aName,

   220                                                                const TBool aValue,

   221                                                                TSenPropertiesLayer aLayer)

   222     {

   223     return CSenLayeredTransportProperties::SetBoolPropertyL(aName, aValue, aLayer);

   224     }

   225     

   226 TInt CSenLayeredVtcpTransportProperties::BoolPropertyL(const TDesC8& aName,

   227                                                             TBool& aValue,

   228                                                             TSenPropertiesLayer aLayer)

   229     {

   230     return CSenLayeredTransportProperties::BoolPropertyL(aName, aValue, aLayer);

   231     }    

   232 

   233 TInt CSenLayeredVtcpTransportProperties::IapIdL(TUint32& aCurrentIapId)

   234     {

   235     return CSenLayeredTransportProperties::IapIdL(aCurrentIapId);

   236     }

   237 

   238  TInt CSenLayeredVtcpTransportProperties::SnapIdL(TUint32& aCurrentSnapId)

   239  	{

   240 	return CSenLayeredTransportProperties::SnapIdL(aCurrentSnapId); 	

   241  	}

   242 TInt CSenLayeredVtcpTransportProperties::ProxyPortL(TInt& aProxyPort)

   243     {

   244     return CSenLayeredTransportProperties::ProxyPortL(aProxyPort);

   245     }

   246 

   247 TInt CSenLayeredVtcpTransportProperties::ProxyHostL(TPtrC8& aProxyHost)

   248     {

   249     return CSenLayeredTransportProperties::ProxyHostL(aProxyHost);

   250     }

   251 

   252 TInt CSenLayeredVtcpTransportProperties::ProxyUsageL(TBool& aValue)

   253     {

   254     return CSenLayeredTransportProperties::ProxyUsageL(aValue);

   255     }

   256 

   257 TInt CSenLayeredVtcpTransportProperties::UserAgentL(TPtrC8& aUserAgent)

   258     {

   259     return CSenLayeredTransportProperties::UserAgentL(aUserAgent);

   260     }

   261 

   262 TInt CSenLayeredVtcpTransportProperties::SetPropertyL(const TDesC8& aName, 

   263                                                       const TDesC8& aValue,

   264                                                       const TDesC8& aType)

   265     {

   266     return CSenLayeredTransportProperties::SetPropertyL(aName, aValue, aType);

   267     }

   268 

   269 TInt CSenLayeredVtcpTransportProperties::PropertyL(const TDesC8& aName, 

   270                                                    TPtrC8& aValue,

   271                                                    TPtrC8& aType)

   272     {

   273     return CSenLayeredTransportProperties::PropertyL(aName, aValue, aType);

   274     }

   275 

   276 TInt CSenLayeredVtcpTransportProperties::SoapActionL(TPtrC8& aAction)

   277     {

   278     return CSenLayeredTransportProperties::SoapActionL(aAction);

   279     }

   280 

   281 TInt CSenLayeredVtcpTransportProperties::DeviceIDL(TPtrC8& aDeviceID)

   282     {

   283     return CSenLayeredTransportProperties::DeviceIDL(aDeviceID);

   284     }

   285 

   286 TInt CSenLayeredVtcpTransportProperties::DeviceLCIDL(TPtrC8& aDeviceLCID)

   287     {

   288     return PropertyL(KDeviceLCIDLocalName, aDeviceLCID);    

   289     }

   290 

   291 TInt CSenLayeredVtcpTransportProperties::ConnectionBoundL(TBool& aConnectionBound)

   292     {

   293     return BoolPropertyL(KConnectionBoundLocalName, aConnectionBound);    

   294     }

   295 

   296 TInt CSenLayeredVtcpTransportProperties::ConnectionTimeOutL(TInt& aConnectionTimeOut)

   297     {

   298     return IntPropertyL(KConnectionTimeOutLocalName, aConnectionTimeOut);    

   299     }

   300 TInt CSenLayeredVtcpTransportProperties::DownloadFolderL(TPtrC8& aDownloadFolder)

   301     {

   302     return CSenLayeredTransportProperties::DownloadFolderL(aDownloadFolder);

   303     }

   304 

   305 TInt CSenLayeredVtcpTransportProperties::FileAttachmentL(const TDesC8& aCid, HBufC8*& aFileName)

   306     {

   307     return CSenLayeredTransportProperties::FileAttachmentL(aCid, aFileName);

   308     }

   309 

   310 CSenLayeredVtcpTransportProperties::CSenLayeredVtcpTransportProperties()

   311     {

   312     }

   313 

   314 CSenLayeredVtcpTransportProperties::~CSenLayeredVtcpTransportProperties()

   315     {

   316     }

   317 

   318 MSenProperties* CSenLayeredVtcpTransportProperties::CloneL() const

   319     {

   320     CSenElement& element = ipFragment->AsElement();

   321     

   322     CSenLayeredVtcpTransportProperties* pProperties = NewLC(element);

   323     if ( ipChildProperties )

   324         {

   325         CSenLayeredVtcpTransportProperties* pChildProperties =

   326                                 (CSenLayeredVtcpTransportProperties*)ipChildProperties->CloneL();

   327         pProperties->ipChildProperties = pChildProperties;

   328         }

   329     

   330     CleanupStack::Pop(pProperties);

   331     return pProperties;

   332     }

   333 

   334 TInt CSenLayeredVtcpTransportProperties::MwsNamespaceL(TPtrC8& aMwsNamespace)

   335     {

   336     return CSenLayeredTransportProperties::MwsNamespaceL(aMwsNamespace);

   337     }

   338 

   339 // END OF FILE

   340 

   341