1 /*

     2 * Copyright (c) 2002-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 // INCLUDE FILES

    26 #include "sencontextitem.h" 

    27 

    28 

    29 #include "msencoreservicemanager.h"     // internal: Core\inc

    30 #include "msenremotehostlet.h"

    31 

    32 #include "SenXmlElement.h"              // Xml\inc

    33 #include "SenXmlReader.h"               // Xml\inc

    34 #include "senwsdescription.h"   // ServiceDescription\inc

    35 #include "SenHttpTransportProperties.h" // Utils\inc

    36 #include "senlayeredhttptransportproperties.h"

    37 

    38 #include "senmessagebase.h"

    39 #include "SenSoapMessage2.h"

    40 #include "senatomentry.h"

    41 #include "SenSoapMessage.h"

    42 

    43 #include "MSenMessage.h"

    44 

    45 #include "senchunk.h"

    46 

    47 // From MSenContextItem:

    48 MSenContextItem::TClass CSenContextItem::Type() const

    49     { 

    50     return MSenContextItem::EContextItem; 

    51     }

    52 

    53 CSenContextItem::CSenContextItem(TAny* apData, MSenContextItem::TData aType, TInt* apFlags)

    54 : ipData(apData), iType(aType), ipFlags(apFlags) 

    55 // NOTE: currently only "flag" is ownership: **if ipFlags == NULL, data is owned**

    56     {

    57     }

    58 

    59 EXPORT_C CSenContextItem::~CSenContextItem()

    60     {

    61     if(ipFlags == NULL)

    62         {

    63         // Destroy the owned data

    64         switch(iType)

    65             {

    66             case ETDesC8:

    67                 {

    68                 TDesC8* p = (TDesC8*) ipData;

    69                 delete p; 

    70                 ipData = NULL;

    71                 }

    72                 break;

    73             case ETInt:

    74                 {

    75                 TInt* p = (TInt*) ipData;

    76                 delete p; 

    77                 ipData = NULL;

    78                 }

    79                 break;

    80             case ETUint:

    81                 {

    82                 TUint* p = (TUint*) ipData;

    83                 delete p; 

    84                 ipData = NULL;

    85                 }

    86                 break;

    87             case EMSenProperties:

    88                 {

    89                 MSenProperties* pM = (MSenProperties*) ipData;

    90                 MSenProperties::TSenPropertiesClassType t = pM->PropertiesClassType();

    91                 if( t == MSenProperties::ESenXmlProperties           ||

    92                     t == MSenProperties::ESenTransportProperties     ||

    93                     t == MSenProperties::ESenHttpTransportProperties ||

    94                     t == MSenProperties::ESenVtcpTransportProperties )

    95                     {

    96                     CSenXmlProperties* p = (CSenXmlProperties*)ipData; 

    97                     delete p;

    98                     ipData = NULL;

    99                     }

   100                 else if( t == MSenProperties::ESenLayeredXmlProperties          ||

   101                          t == MSenProperties::ESenLayeredTransportProperties     ||

   102                          t == MSenProperties::ESenLayeredHttpTransportProperties ||

   103                          t == MSenProperties::ESenLayeredVtcpTransportProperties )

   104                     {

   105                     CSenLayeredXmlProperties* p = (CSenLayeredXmlProperties*)ipData; 

   106                     delete p;

   107                     ipData = NULL;

   108                     }

   109                 }

   110             case ECSenWSDescription:

   111                 {

   112                 CSenWSDescription* p = (CSenWSDescription*) ipData;

   113                 delete p;

   114                 ipData = NULL;

   115                 }

   116                 break;

   117             case ECSenXmlReader:

   118                 {

   119                 CSenXmlReader* p = (CSenXmlReader*) ipData;

   120                 delete p;

   121                 ipData = NULL;

   122                 }

   123                 break;

   124             case ECSenElement:

   125                 {

   126                 CSenElement* p = (CSenElement*) ipData;

   127                 delete p;

   128                 ipData = NULL;

   129                 }

   130                 break;

   131             case ECSenSoapMessage:

   132                     {

   133                     CSenSoapEnvelope* p = (CSenSoapEnvelope*) ipData;

   134                     delete p;

   135                     ipData = NULL;

   136                     }

   137                 break;

   138             case ECSenSoapEnvelope2:

   139                     {

   140                     CSenSoapEnvelope2* p = (CSenSoapEnvelope2*) ipData;

   141                     delete p;

   142                     ipData = NULL;

   143                     }

   144                 break;

   145             case ECSenAtomMessage:

   146                     {

   147                     CSenAtomEntry* p = (CSenAtomEntry*) ipData;

   148                     delete p;

   149                     ipData = NULL;

   150                     }

   151                 break;

   152             case ECSenMessageBase:

   153                     {

   154                     CSenMessageBase* p = (CSenMessageBase*) ipData;

   155                     delete p;

   156                     ipData = NULL;

   157                     }

   158                 break;

   159             case ETAny: // delete void* is not defined(!)

   160             case EMSenCoreServiceManager:

   161             case EMSenRemoteServiceConsumer:

   162             case EMSenRemoteHostlet:

   163             case EMSenMessage:

   164             default:

   165                 {

   166                 #ifdef _SENDEBUG

   167                 User::Panic(KErrUnknown, _LIT("~SenCtxItem"));

   168                 #endif

   169                 }

   170             }

   171         }

   172     else delete ipFlags; // onlyg ipFlags were owned..

   173     }

   174 

   175 EXPORT_C CSenContextItem* CSenContextItem::NewL(TAny* apNotOwned)

   176     { 

   177     CSenContextItem* pNew = CSenContextItem::NewLC(apNotOwned);

   178     CleanupStack::Pop(pNew);

   179     return pNew;

   180     }

   181 

   182 EXPORT_C CSenContextItem* CSenContextItem::NewLC(TAny* apNotOwned)

   183     { 

   184     CSenContextItem* pNew = 

   185         new (ELeave) CSenContextItem(apNotOwned, MSenContextItem::ETAny, new (ELeave) TInt(1)); // not owned

   186     CleanupStack::PushL(pNew);

   187     return pNew;

   188     }

   189 

   190 

   191 /*

   192 EXPORT_C CSenContextItem* CSenContextItem::NewL(TAny* apValue, TBool aIsOwnedOrNot)

   193     { 

   194     CSenContextItem* pNew = CSenContextItem::NewLC(apValue, aIsOwnedOrNot);

   195     // REMOVED, REASON: if owned: deleting of void* pointer is undefined => 

   196     CleanupStack::Pop(pNew);

   197     return pNew;

   198     }

   199 

   200 EXPORT_C CSenContextItem* CSenContextItem::NewLC(TAny* apValue, TBool aIsOwnedOrNot)

   201     { 

   202     CSenContextItem* pNew = 

   203         new (ELeave) CSenContextItem(apValue, MSenContextItem::ETAny, aIsOwnedOrNot?NULL:(new (ELeave) TInt(1)));

   204     CleanupStack::PushL(pNew);

   205     return pNew;

   206     }

   207 */

   208 

   209 EXPORT_C CSenContextItem* CSenContextItem::NewL(const TDesC8& aRefToValue)

   210     { 

   211     CSenContextItem* pNew = CSenContextItem::NewLC(aRefToValue);

   212     CleanupStack::Pop(pNew);

   213     return pNew;

   214     }

   215 

   216 EXPORT_C CSenContextItem* CSenContextItem::NewLC(const TDesC8& aRefToValue)

   217     {

   218     CSenContextItem* pNew = 

   219         new (ELeave) CSenContextItem(&(TDesC8&)aRefToValue, MSenContextItem::ETDesC8, new (ELeave) TInt(1)); // not owned

   220     CleanupStack::PushL(pNew);

   221     return pNew;

   222     }

   223 

   224 EXPORT_C CSenContextItem* CSenContextItem::NewL(TDesC8* apOwned)

   225     { 

   226     CSenContextItem* pNew = CSenContextItem::NewLC(apOwned);

   227     CleanupStack::Pop(pNew);

   228     return pNew;

   229     }

   230 

   231 EXPORT_C CSenContextItem* CSenContextItem::NewLC(TDesC8* apOwned)

   232     { 

   233     CSenContextItem* pNew = 

   234         new (ELeave) CSenContextItem(apOwned, MSenContextItem::ETDesC8, NULL);

   235     CleanupStack::PushL(pNew);

   236     return pNew;

   237     }

   238 

   239 EXPORT_C CSenContextItem* CSenContextItem::NewL(const TInt apValue)

   240     { 

   241     CSenContextItem* pNew = CSenContextItem::NewLC(apValue);

   242     CleanupStack::Pop(pNew);

   243     return pNew;

   244     }

   245 

   246 EXPORT_C CSenContextItem* CSenContextItem::NewLC(const TInt apValue)

   247     { 

   248     CSenContextItem* pNew = 

   249         new (ELeave) CSenContextItem(new (ELeave) TInt(apValue), MSenContextItem::ETInt, NULL);

   250     CleanupStack::PushL(pNew);

   251     return pNew;

   252     }

   253 

   254 

   255 EXPORT_C CSenContextItem* CSenContextItem::NewL(TInt* apOwned)

   256     { 

   257     CSenContextItem* pNew = CSenContextItem::NewLC(apOwned);

   258     CleanupStack::Pop(pNew);

   259     return pNew;

   260     }

   261 

   262 EXPORT_C CSenContextItem* CSenContextItem::NewLC(TInt* apOwned)

   263     { 

   264     CSenContextItem* pNew = 

   265         new (ELeave) CSenContextItem(apOwned, MSenContextItem::ETInt, NULL);

   266     CleanupStack::PushL(pNew);

   267     return pNew;

   268     }

   269 

   270 

   271 EXPORT_C CSenContextItem* CSenContextItem::NewL(const TUint aValue)

   272     { 

   273     CSenContextItem* pNew = CSenContextItem::NewLC(aValue);

   274     CleanupStack::Pop(pNew);

   275     return pNew;

   276     }

   277 

   278 EXPORT_C CSenContextItem* CSenContextItem::NewLC(const TUint aValue)

   279     { 

   280     CSenContextItem* pNew = 

   281         new (ELeave) CSenContextItem(new (ELeave) TUint(aValue), MSenContextItem::ETUint, NULL);

   282     CleanupStack::PushL(pNew);

   283     return pNew;

   284     }

   285 

   286 EXPORT_C CSenContextItem* CSenContextItem::NewL(TUint* apOwned)

   287     {

   288     CSenContextItem* pNew = CSenContextItem::NewLC(apOwned);

   289     CleanupStack::Pop(pNew);

   290     return pNew;

   291     }

   292 

   293 EXPORT_C CSenContextItem* CSenContextItem::NewLC(TUint* apOwned)

   294     { 

   295     CSenContextItem* pNew = 

   296         new (ELeave) CSenContextItem(apOwned, MSenContextItem::ETInt, NULL);

   297     CleanupStack::PushL(pNew);

   298     return pNew;

   299     }

   300 

   301 EXPORT_C CSenContextItem* CSenContextItem::NewL(MSenCoreServiceManager& aValue)

   302     { 

   303     CSenContextItem* pNew = CSenContextItem::NewLC(aValue);

   304     CleanupStack::Pop(pNew);

   305     return pNew;

   306     }

   307 

   308 EXPORT_C CSenContextItem* CSenContextItem::NewLC(MSenCoreServiceManager& aValue)

   309     { 

   310     CSenContextItem* pNew = 

   311         new (ELeave) CSenContextItem(&aValue, MSenContextItem::EMSenCoreServiceManager, new (ELeave) TInt(1));

   312     CleanupStack::PushL(pNew);

   313     return pNew;

   314     }

   315 

   316 EXPORT_C CSenContextItem* CSenContextItem::NewL(MSenRemoteServiceConsumer& aValue)

   317     { 

   318     CSenContextItem* pNew = CSenContextItem::NewLC(aValue);

   319     CleanupStack::Pop(pNew);

   320     return pNew;

   321     }

   322 

   323 EXPORT_C CSenContextItem* CSenContextItem::NewLC(MSenRemoteServiceConsumer& aValue)

   324     { 

   325     CSenContextItem* pNew = 

   326         new (ELeave) CSenContextItem(&aValue, MSenContextItem::EMSenRemoteServiceConsumer, new (ELeave) TInt(1));

   327     CleanupStack::PushL(pNew);

   328     return pNew;

   329     }

   330 

   331 EXPORT_C CSenContextItem* CSenContextItem::NewL(MSenRemoteHostlet& aValue)

   332     { 

   333     CSenContextItem* pNew = CSenContextItem::NewLC(aValue);

   334     CleanupStack::Pop(pNew);

   335     return pNew;

   336     }

   337 

   338 EXPORT_C CSenContextItem* CSenContextItem::NewLC(MSenRemoteHostlet& aValue)

   339     {

   340     CSenContextItem* pNew = 

   341         new (ELeave) CSenContextItem(&aValue, MSenContextItem::EMSenRemoteHostlet, new (ELeave) TInt(1));

   342     CleanupStack::PushL(pNew);

   343     return pNew;

   344     }

   345 

   346 EXPORT_C CSenContextItem* CSenContextItem::NewL(CSenWSDescription& aValue)

   347     { 

   348     CSenContextItem* pNew = CSenContextItem::NewLC(aValue);

   349     CleanupStack::Pop(pNew);

   350     return pNew;

   351     }

   352 

   353 EXPORT_C CSenContextItem* CSenContextItem::NewLC(CSenWSDescription& aValue)

   354     { 

   355     CSenContextItem* pNew = 

   356         new (ELeave) CSenContextItem(&aValue, MSenContextItem::ECSenWSDescription, new (ELeave) TInt(1));

   357     CleanupStack::PushL(pNew);

   358     return pNew;

   359     }

   360 

   361 EXPORT_C CSenContextItem* CSenContextItem::NewL(CSenWSDescription* apOwned)

   362     { 

   363     CSenContextItem* pNew = CSenContextItem::NewLC(apOwned);

   364     CleanupStack::Pop(pNew);

   365     return pNew;

   366     }

   367 

   368 EXPORT_C CSenContextItem* CSenContextItem::NewLC(CSenWSDescription* apOwned)

   369     { 

   370     CSenContextItem* pNew = 

   371         new (ELeave) CSenContextItem(apOwned, MSenContextItem::ECSenWSDescription, NULL);

   372     CleanupStack::PushL(pNew);

   373     return pNew;

   374     }

   375 

   376 

   377 EXPORT_C CSenContextItem* CSenContextItem::NewL(CSenChunk& aValue)

   378     { 

   379     CSenContextItem* pNew = CSenContextItem::NewLC(aValue);

   380     CleanupStack::Pop(pNew);

   381     return pNew;

   382     }

   383 

   384 EXPORT_C CSenContextItem* CSenContextItem::NewLC(CSenChunk& aValue)

   385     { 

   386     CSenContextItem* pNew = 

   387         new (ELeave) CSenContextItem(&aValue, MSenContextItem::ECSenChunk, new (ELeave) TInt(1));

   388     CleanupStack::PushL(pNew);

   389     return pNew;

   390     }

   391 

   392 EXPORT_C CSenContextItem* CSenContextItem::NewL(CSenChunk* apOwned)

   393     { 

   394     CSenContextItem* pNew = CSenContextItem::NewLC(apOwned);

   395     CleanupStack::Pop(pNew);

   396     return pNew;

   397     }

   398 

   399 EXPORT_C CSenContextItem* CSenContextItem::NewLC(CSenChunk* apOwned)

   400     { 

   401     CSenContextItem* pNew = 

   402         new (ELeave) CSenContextItem(apOwned, MSenContextItem::ECSenChunk, NULL);

   403     CleanupStack::PushL(pNew);

   404     return pNew;

   405     }

   406 

   407 

   408 

   409 

   410 EXPORT_C CSenContextItem* CSenContextItem::NewL(CSenElement& aValue)

   411     { 

   412     CSenContextItem* pNew = CSenContextItem::NewLC(aValue);

   413     CleanupStack::Pop(pNew);

   414     return pNew;

   415     }

   416 

   417 EXPORT_C CSenContextItem* CSenContextItem::NewLC(CSenElement& aValue)

   418     { 

   419     CSenContextItem* pNew = 

   420         new (ELeave) CSenContextItem(&aValue, MSenContextItem::ECSenElement, new (ELeave) TInt(1));

   421     CleanupStack::PushL(pNew);

   422     return pNew;

   423     }

   424 

   425 EXPORT_C CSenContextItem* CSenContextItem::NewL(CSenElement* apOwned)

   426     { 

   427     CSenContextItem* pNew = CSenContextItem::NewLC(apOwned);

   428     CleanupStack::Pop(pNew);

   429     return pNew;

   430     }

   431 

   432 EXPORT_C CSenContextItem* CSenContextItem::NewLC(CSenElement* apOwned)

   433     { 

   434     CSenContextItem* pNew = 

   435         new (ELeave) CSenContextItem(apOwned, MSenContextItem::ECSenElement, NULL);

   436     CleanupStack::PushL(pNew);

   437     return pNew;

   438     }

   439 

   440 

   441 

   442 EXPORT_C CSenContextItem* CSenContextItem::NewL(CSenSoapMessage& aValue)

   443     { 

   444     CSenContextItem* pNew = CSenContextItem::NewLC(aValue);

   445     CleanupStack::Pop(pNew);

   446     return pNew;

   447     }

   448 

   449 EXPORT_C CSenContextItem* CSenContextItem::NewLC(CSenSoapMessage& aValue)

   450     { 

   451     CSenContextItem* pNew = 

   452         new (ELeave) CSenContextItem(&aValue, MSenContextItem::ECSenSoapMessage, new (ELeave) TInt(1));

   453     CleanupStack::PushL(pNew);

   454     return pNew;

   455     }

   456 

   457 EXPORT_C CSenContextItem* CSenContextItem::NewL(MSenMessage& aValue)

   458     { 

   459     CSenContextItem* pNew = CSenContextItem::NewLC(aValue);

   460     CleanupStack::Pop(pNew);

   461     return pNew;

   462     }

   463 

   464 EXPORT_C CSenContextItem* CSenContextItem::NewLC(MSenMessage& aValue)

   465     { 

   466     CSenContextItem* pNew = 

   467         new (ELeave) CSenContextItem(&aValue, MSenContextItem::EMSenMessage, new (ELeave) TInt(1));

   468     CleanupStack::PushL(pNew);

   469     return pNew;

   470     }

   471 

   472 

   473 EXPORT_C CSenContextItem* CSenContextItem::NewL(CSenSoapMessage* apOwned)

   474     { 

   475     CSenContextItem* pNew = CSenContextItem::NewLC(apOwned);

   476     CleanupStack::Pop(pNew);

   477     return pNew;

   478     }

   479 

   480 EXPORT_C CSenContextItem* CSenContextItem::NewLC(CSenSoapMessage* apOwned)

   481     { 

   482     CSenContextItem* pNew = 

   483         new (ELeave) CSenContextItem(apOwned, MSenContextItem::ECSenSoapMessage, NULL);

   484     CleanupStack::PushL(pNew);

   485     return pNew;

   486     }

   487     

   488 EXPORT_C CSenContextItem* CSenContextItem::NewL(CSenSoapEnvelope2* apOwned)

   489     { 

   490     CSenContextItem* pNew = CSenContextItem::NewLC(apOwned);

   491     CleanupStack::Pop(pNew);

   492     return pNew;

   493     }

   494 

   495 EXPORT_C CSenContextItem* CSenContextItem::NewLC(CSenSoapEnvelope2* apOwned)

   496     { 

   497     CSenContextItem* pNew = 

   498         new (ELeave) CSenContextItem(apOwned, MSenContextItem::ECSenSoapEnvelope2, NULL);

   499     CleanupStack::PushL(pNew);

   500     return pNew;

   501     }    

   502 EXPORT_C CSenContextItem* CSenContextItem::NewLC(CSenAtomEntry* apOwned)

   503     { 

   504     CSenContextItem* pNew = 

   505         new (ELeave) CSenContextItem(apOwned, MSenContextItem::ECSenAtomMessage, NULL);

   506     CleanupStack::PushL(pNew);

   507     return pNew;

   508     }    

   509 EXPORT_C CSenContextItem* CSenContextItem::NewL(CSenAtomEntry* apOwned)

   510     { 

   511     CSenContextItem* pNew = CSenContextItem::NewLC(apOwned);

   512     CleanupStack::Pop(pNew);

   513     return pNew;

   514     }    

   515 

   516 EXPORT_C CSenContextItem* CSenContextItem::NewL(CSenMessageBase* apOwned)

   517     { 

   518     CSenContextItem* pNew = CSenContextItem::NewLC(apOwned);

   519     CleanupStack::Pop(pNew);

   520     return pNew;

   521     }

   522 

   523 EXPORT_C CSenContextItem* CSenContextItem::NewLC(CSenMessageBase* apOwned)

   524     { 

   525     CSenContextItem* pNew = new (ELeave) CSenContextItem(apOwned, MSenContextItem::ECSenMessageBase, NULL);

   526     CleanupStack::PushL(pNew);

   527     return pNew;

   528     }  

   529 

   530 EXPORT_C CSenContextItem* CSenContextItem::NewL(CSenXmlReader& aValue)

   531     { 

   532     CSenContextItem* pNew = CSenContextItem::NewLC(aValue);

   533     CleanupStack::Pop(pNew);

   534     return pNew;

   535     }

   536 

   537 EXPORT_C CSenContextItem* CSenContextItem::NewLC(CSenXmlReader& aValue)

   538     { 

   539     CSenContextItem* pNew = 

   540         new (ELeave) CSenContextItem(&aValue, MSenContextItem::ECSenXmlReader, new (ELeave) TInt(1));

   541     CleanupStack::PushL(pNew);

   542     return pNew;

   543     }

   544 

   545 EXPORT_C CSenContextItem* CSenContextItem::NewL(CSenXmlReader* apOwned)

   546     { 

   547     CSenContextItem* pNew = CSenContextItem::NewLC(apOwned);

   548     CleanupStack::Pop(pNew);

   549     return pNew;

   550     }

   551 

   552 EXPORT_C CSenContextItem* CSenContextItem::NewLC(CSenXmlReader* apOwned)

   553     { 

   554     CSenContextItem* pNew = 

   555         new (ELeave) CSenContextItem(apOwned, MSenContextItem::ECSenXmlReader, NULL);

   556     CleanupStack::PushL(pNew);

   557     return pNew;

   558     }

   559 

   560 EXPORT_C CSenContextItem* CSenContextItem::NewL(MSenProperties& aValue)

   561     { 

   562     CSenContextItem* pNew = CSenContextItem::NewLC(aValue);

   563     CleanupStack::Pop(pNew);

   564     return pNew;

   565     }

   566 

   567 EXPORT_C CSenContextItem* CSenContextItem::NewLC(MSenProperties& aValue)

   568     { 

   569     CSenContextItem* pNew = 

   570         new (ELeave) CSenContextItem(&aValue, MSenContextItem::EMSenProperties, new (ELeave) TInt(1));

   571     CleanupStack::PushL(pNew);

   572     return pNew;

   573     }

   574 

   575 EXPORT_C CSenContextItem* CSenContextItem::NewL(CSenXmlProperties* apOwned)

   576     { 

   577     CSenContextItem* pNew = CSenContextItem::NewLC(apOwned);

   578     CleanupStack::Pop(pNew);

   579     return pNew;

   580     }

   581 

   582 EXPORT_C CSenContextItem* CSenContextItem::NewLC(CSenXmlProperties* apOwned)

   583     { 

   584     CSenContextItem* pNew = 

   585         new (ELeave) CSenContextItem(apOwned, MSenContextItem::EMSenProperties, NULL);

   586     CleanupStack::PushL(pNew);

   587     return pNew;

   588     }

   589 

   590 EXPORT_C CSenContextItem* CSenContextItem::NewL(CSenLayeredXmlProperties* apOwned)

   591     { 

   592     CSenContextItem* pNew = CSenContextItem::NewLC(apOwned);

   593     CleanupStack::Pop(pNew);

   594     return pNew;

   595     }

   596 

   597 EXPORT_C CSenContextItem* CSenContextItem::NewLC(CSenLayeredXmlProperties* apOwned)

   598     { 

   599     CSenContextItem* pNew = 

   600         new (ELeave) CSenContextItem(apOwned, MSenContextItem::EMSenProperties, NULL);

   601     CleanupStack::PushL(pNew);

   602     return pNew;

   603     }

   604 

   605 // New methods:

   606 TAny* CSenContextItem::ToAnyL() const

   607     { 

   608     if( iType != MSenContextItem::ETAny )

   609         {

   610         User::Leave( KErrSenCtxItemTypeMismatch );

   611         }

   612     return ipData; 

   613     }

   614 

   615 TPtrC8 CSenContextItem::ToPtrC8L() const

   616     { 

   617     if( iType != MSenContextItem::ETDesC8 )

   618         {

   619         User::Leave( KErrSenCtxItemTypeMismatch );

   620         }

   621     

   622     return *((TDesC8*)ipData); 

   623     }

   624 

   625 const TDesC8* CSenContextItem::ToDesC8L() const

   626     { 

   627     if( iType != MSenContextItem::ETDesC8 )

   628         {

   629         User::Leave( KErrSenCtxItemTypeMismatch );

   630         }

   631     

   632     return (TDesC8*)ipData;

   633     }

   634 

   635 

   636 const TInt* CSenContextItem::ToIntL() const

   637     { 

   638     if( iType != MSenContextItem::ETInt )

   639         {

   640         User::Leave( KErrSenCtxItemTypeMismatch );

   641         }

   642     return (TInt*)ipData; 

   643     }

   644 

   645 const TUint* CSenContextItem::ToUintL() const

   646     { 

   647     if( iType != MSenContextItem::ETInt )

   648         {

   649         User::Leave( KErrSenCtxItemTypeMismatch );

   650         }

   651     return (TUint*)ipData; 

   652     }

   653 

   654 MSenCoreServiceManager& CSenContextItem::ToSenCoreL() const

   655     { 

   656     if( iType != MSenContextItem::EMSenCoreServiceManager )

   657         {

   658         User::Leave( KErrSenCtxItemTypeMismatch );

   659         }

   660     return *((MSenCoreServiceManager*)ipData); 

   661     }

   662     

   663 MSenRemoteServiceConsumer& CSenContextItem::ToSenRemoteConsumerL() const

   664     { 

   665     if( iType != MSenContextItem::EMSenRemoteServiceConsumer )

   666         {

   667         User::Leave( KErrSenCtxItemTypeMismatch );

   668         }

   669     return *((MSenRemoteServiceConsumer*)ipData); 

   670     }

   671 

   672 MSenRemoteHostlet& CSenContextItem::ToSenRemoteHostletL() const

   673     { 

   674     if( iType != MSenContextItem::EMSenRemoteHostlet )

   675         {

   676         User::Leave( KErrSenCtxItemTypeMismatch );

   677         }

   678     return *((MSenRemoteHostlet*)ipData); 

   679     }

   680 

   681 CSenWSDescription& CSenContextItem::ToSenServiceDescriptionL() const

   682     { 

   683     if(ipData)

   684         {

   685         if( iType == MSenContextItem::ECSenWSDescription )

   686             {

   687             CSenWSDescription* pDesc = (CSenWSDescription*) ipData;

   688             if( pDesc->HasSuperClass( MSenServiceDescription::EWSDescription ) )

   689                 {

   690                 return *((CSenWSDescription*)ipData); 

   691                 }

   692             else if ( pDesc->DescriptionClassType() == MSenServiceDescription::EWSDescription )

   693                 {

   694                 return *((CSenWSDescription*)ipData); 

   695                 }

   696             }

   697         }

   698     User::Leave( KErrSenCtxItemTypeMismatch );

   699     return *((CSenWSDescription*)ipData); 

   700     }

   701 

   702 CSenServiceSession& CSenContextItem::ToSenServiceSessionL() const

   703     { 

   704     if(ipData) 

   705         {

   706         if( iType == MSenContextItem::ECSenWSDescription )

   707             {

   708             CSenWSDescription* pDesc = (CSenWSDescription*) ipData;

   709             if( pDesc->HasSuperClass( MSenServiceDescription::EServiceSession ) )

   710                 {

   711                 return *((CSenServiceSession*)ipData); 

   712                 }

   713             else if ( pDesc->DescriptionClassType() == MSenServiceDescription::EServiceSession )

   714                 {

   715                 return *((CSenServiceSession*)ipData);

   716                 }

   717             }

   718         }

   719     User::Leave( KErrSenCtxItemTypeMismatch );

   720     return *((CSenServiceSession*)ipData); 

   721     }

   722 

   723 CSenXmlProperties& CSenContextItem::ToSenXmlPropertiesL() const

   724     { 

   725     if(ipData)

   726         {

   727         if( iType == MSenContextItem::EMSenProperties )

   728             {

   729             MSenProperties* pProp = (MSenProperties*) ipData;

   730             MSenProperties::TSenPropertiesClassType t = pProp->PropertiesClassType();

   731             if( t == MSenProperties::ESenXmlProperties           ||

   732                 t == MSenProperties::ESenTransportProperties     ||

   733                 t == MSenProperties::ESenHttpTransportProperties ||

   734                 t == MSenProperties::ESenVtcpTransportProperties )

   735                 {

   736                 return *((CSenXmlProperties*)ipData); 

   737                 }

   738             }

   739         }

   740     User::Leave( KErrSenCtxItemTypeMismatch );

   741     return *((CSenXmlProperties*)ipData); 

   742     }

   743 

   744 CSenLayeredXmlProperties& CSenContextItem::ToSenLayeredXmlPropertiesL() const

   745     { 

   746     if(ipData) 

   747         {

   748         if( iType == MSenContextItem::EMSenProperties )

   749             {

   750             MSenProperties* pProp = (MSenProperties*) ipData;

   751             MSenProperties::TSenPropertiesClassType t = pProp->PropertiesClassType();

   752             if( t == MSenProperties::ESenLayeredXmlProperties           ||

   753                 t == MSenProperties::ESenLayeredTransportProperties     ||

   754                 t == MSenProperties::ESenLayeredHttpTransportProperties ||

   755                 t == MSenProperties::ESenLayeredVtcpTransportProperties )

   756                 {

   757                 return *((CSenLayeredXmlProperties*)ipData); 

   758                 }

   759             }

   760         }

   761     User::Leave( KErrSenCtxItemTypeMismatch );

   762     return *((CSenLayeredXmlProperties*)ipData); 

   763     }

   764     

   765 MSenMessage& CSenContextItem::ToSenMessageL() const

   766     {

   767     if(ipData)

   768         {

   769         if( iType == MSenContextItem::EMSenMessage )

   770             {

   771             return *((MSenMessage*)ipData); 

   772             }

   773         else if (iType == MSenContextItem::ECSenSoapEnvelope2)

   774             {

   775             return *((CSenSoapEnvelope2*)ipData); 

   776             }

   777         else if (iType == MSenContextItem::ECSenAtomMessage)

   778             {

   779             return *((CSenAtomEntry*)ipData); 

   780             }

   781         }

   782     User::Leave( KErrSenCtxItemTypeMismatch );

   783     return *((MSenMessage*)ipData); 

   784     }

   785 

   786 CSenSoapMessage& CSenContextItem::ToSenSoapMessageL() const

   787     {

   788     if(ipData)

   789         {

   790         if( iType == MSenContextItem::ECSenSoapMessage )

   791             {

   792             return *((CSenSoapMessage*)ipData); 

   793             }

   794         }

   795     User::Leave( KErrSenCtxItemTypeMismatch );

   796     return *((CSenSoapMessage*)ipData); 

   797     }

   798     

   799 

   800 CSenChunk& CSenContextItem::ToSenChunkL() const

   801     { 

   802     if( iType != MSenContextItem::ECSenChunk )

   803         {

   804         User::Leave( KErrSenCtxItemTypeMismatch );

   805         }

   806     return *((CSenChunk*)ipData); 

   807     }

   808 

   809 

   810 CSenElement& CSenContextItem::ToSenElementL() const

   811     { 

   812     if( iType != MSenContextItem::ECSenElement )

   813         {

   814         User::Leave( KErrSenCtxItemTypeMismatch );

   815         }

   816     return *((CSenElement*)ipData); 

   817     }

   818 

   819 CSenXmlReader& CSenContextItem::ToSenXmlReaderL() const

   820     { 

   821     if( iType != MSenContextItem::ECSenXmlReader )

   822         {

   823         User::Leave( KErrSenCtxItemTypeMismatch );

   824         }

   825     return *((CSenXmlReader*)ipData); 

   826     }

   827 // End of File

   828