1 /*

     2 * Copyright (c) 2002-2007 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 "sensessioncontext.h" 

    27 

    28 EXPORT_C CSenSessionContext* CSenSessionContext::NewL()

    29     {

    30     CSenSessionContext* pNew = CSenSessionContext::NewLC();

    31     CleanupStack::Pop();

    32     return pNew;

    33     }

    34 

    35 EXPORT_C CSenSessionContext* CSenSessionContext::NewLC()

    36     {

    37     CSenSessionContext* pNew = new (ELeave) CSenSessionContext();

    38     CleanupStack::PushL(pNew);

    39     pNew->BaseConstructL();

    40     return pNew;

    41     }

    42 

    43 EXPORT_C CSenSessionContext::CSenSessionContext()

    44     {

    45     }

    46 

    47 EXPORT_C CSenSessionContext::~CSenSessionContext()

    48     {

    49     }

    50        

    51 EXPORT_C void CSenSessionContext::BaseConstructL()

    52     {

    53 //    CSenContext::BaseConstructL();

    54     }

    55 

    56 // From MSenSessionContext:

    57 /*

    58 SenContext::TContextType CSenSessionContext::Type() const

    59     {

    60     return SenContext::EMessageContext;

    61     }

    62        

    63 SenContext::TContextDirection CSenSessionContext::Direction() const

    64     {

    65     return CSenContext::Direction();

    66     }

    67        

    68 TInt CSenSessionContext::Add(const TDesC8& aKey, const TDesC8& aValue)

    69     {

    70     return CSenContext::Add( aKey, aValue );

    71     }

    72        

    73 TInt CSenSessionContext::Update(const TDesC8& aKey, const TDesC8& aValue)

    74     {

    75     return CSenContext::Update( aKey, aValue );

    76     }

    77        

    78 const TDesC8* CSenSessionContext::GetDesC8L(const TDesC8& aKey)

    79     {

    80     return CSenContext::GetDesC8L( aKey );

    81     }

    82        

    83 TInt CSenSessionContext::Add(const TDesC8& aKey, TInt aValue)

    84     {

    85     return CSenContext::Add( aKey, aValue );

    86     }

    87        

    88 TInt CSenSessionContext::Update(const TDesC8& aKey, TInt aValue)

    89     {

    90     return CSenContext::Update( aKey, aValue );

    91     }

    92        

    93 const TInt* CSenSessionContext::GetIntL(const TDesC8& aKey)

    94     {

    95     return CSenContext::GetIntL( aKey );

    96     }

    97        

    98 TInt CSenSessionContext::Add(const TDesC8& aKey, CSenElement* aValue)

    99     {

   100     return CSenContext::Add( aKey, aValue );

   101     }

   102        

   103 TInt CSenSessionContext::Update(const TDesC8& aKey, CSenElement* aValue)

   104     {

   105     return CSenContext::Update( aKey, aValue );

   106     }

   107        

   108 const CSenElement* CSenSessionContext::GetSenElementL(const TDesC8& aKey)

   109     {

   110     return CSenContext::GetSenElementL( aKey );

   111     }

   112        

   113 TInt CSenSessionContext::Add(const TDesC8& aKey, TAny* aValue)

   114     {

   115     return CSenContext::Add( aKey, aValue );

   116     }

   117        

   118 TInt CSenSessionContext::Update(const TDesC8& aKey, TAny* aValue)

   119     {

   120     return CSenContext::Update( aKey, aValue );

   121     }

   122        

   123 TAny* CSenSessionContext::GetAny(const TDesC8& aKey)

   124     {

   125     return CSenContext::GetAny( aKey );

   126     }

   127        

   128 TInt CSenSessionContext::Remove(const TDesC8& aKey) 

   129     {

   130     return CSenContext::Remove(aKey);

   131     }

   132 

   133 TInt CSenSessionContext::Count() const

   134     {

   135     return CSenContext::Count();

   136     }

   137 

   138 TPtrC8 CSenSessionContext::KeyAtL(TInt aIndex)

   139     {

   140     return CSenContext::KeyAtL(aIndex);

   141     }

   142 

   143 void CSenSessionContext::Reset()

   144     {

   145     CSenContext::Reset();

   146     }

   147     

   148 CSenSoapMessage* CSenSessionContext::GetCurrentSoapMessage() // DEPRECATED: 

   149     {

   150     CSenSoapMessage* pSoapMessage = NULL;

   151     

   152     TInt index = iItems.Find( KSenCtxKeyCurrentSoapMessage );

   153     if ( index != KErrNotFound )

   154         {

   155         const CSenContextItem* pItem = iItems.ValueAt(index);

   156         pSoapMessage = &(pItem->ToSenSoapMessageL());

   157         }

   158     return pSoapMessage;

   159     }

   160     

   161 TPtrC8 CSenSessionContext::GetMessage()

   162     {

   163     TInt index = iItems.Find( KSenCtxKeyCurrentMessageAsDesc );

   164     if ( index != KErrNotFound )

   165         {

   166         const CSenContextItem* pItem = iItems.ValueAt(index);

   167         const TDesC8* desc = pItem->ToDesC8L();

   168         return *desc;

   169         }

   170     return KNullDesC8();

   171     }

   172     

   173 TInt CSenSessionContext::Add(const TDesC8& aKey, CSenSoapEnvelope* aValue)

   174     {

   175     return CSenContext::Add( aKey, aValue );    

   176     }

   177     

   178 TInt CSenSessionContext::Update(const TDesC8& aKey, CSenSoapEnvelope* aValue)

   179     {

   180     return CSenContext::Update( aKey, aValue );

   181     }

   182     

   183 const CSenSoapEnvelope* CSenSessionContext::GetSenSoapEnvelopeL(const TDesC8& aKey)

   184     {

   185     TInt index = iItems.Find( aKey );

   186     if ( index != KErrNotFound )

   187         {

   188         const CSenContextItem* pItem = iItems.ValueAt(index);

   189         const CSenSoapEnvelope* envelope = ((CSenSoapEnvelope*)&(pItem->ToSenSoapMessageL()));

   190         return envelope;

   191         }

   192     return NULL;

   193     }

   194     

   195 MSenMessage* CSenSessionContext::Message()

   196     {

   197     TInt index = iItems.Find( KSenCtxKeyMessage );

   198     if ( index != KErrNotFound )

   199         {

   200         const CSenContextItem* pItem = iItems.ValueAt(index);

   201         return ((MSenMessage*)&(pItem->ToSenMessageL()));

   202         }

   203     return NULL;

   204     }

   205     

   206 TInt CSenSessionContext::SetMessage(MSenMessage* apMessage, TBool aOwned)

   207     {

   208     TInt leaveCode(KErrNone);

   209     CSenContextItem* pItem = MessageToItem( apMessage, aOwned, leaveCode );

   210 

   211     if( leaveCode != KErrNone ) 

   212         {

   213         delete pItem; // should ALWAYS be NULL(!)

   214         return leaveCode;

   215         }

   216         

   217     TInt retCode(iItems.UpdateValue(&KSenCtxKeyMessage(), pItem));

   218     if( retCode != KErrNone && aOwned )

   219         {

   220         delete pItem; // delete the orphan item

   221         } 

   222     return retCode;

   223     }

   224     

   225     

   226 CSenChunk* CSenSessionContext::Chunk()

   227     {

   228     TInt index = iItems.Find( KSenCtxKeyChunk );

   229     if ( index != KErrNotFound )

   230         {

   231         const CSenContextItem* pItem = iItems.ValueAt(index);

   232         return ((CSenChunk*)&(pItem->ToSenChunkL()));

   233         }

   234     return NULL;

   235     }

   236     

   237 TInt CSenSessionContext::SetChunk(CSenChunk* apMsgAsChunk, TBool aOwned)

   238     {

   239     TInt leaveCode(KErrNone);

   240     

   241     CSenContextItem* pItem = NULL;

   242     if( aOwned )

   243         {

   244         TRAP( leaveCode, pItem = CSenContextItem::NewL(apMsgAsChunk); )

   245         }

   246     else // chunk is not to be owned

   247         {

   248         TRAP( leaveCode, pItem = CSenContextItem::NewL(*apMsgAsChunk); )

   249         }

   250 

   251     if( leaveCode != KErrNone ) 

   252         {

   253         delete pItem; // should ALWAYS be NULL(!)

   254         return leaveCode;

   255         }

   256         

   257     TInt retCode(iItems.UpdateValue(&KSenCtxKeyChunk(), pItem));

   258     if( retCode != KErrNone && aOwned )

   259         {

   260         delete pItem; // delete the orphan item

   261         } 

   262     return retCode;

   263     }

   264     

   265 

   266 TInt CSenSessionContext::SetProperties(MSenProperties* apProperties, TBool aOwned)

   267     {

   268     if( !apProperties )

   269         {

   270         return KErrArgument;

   271         }

   272         

   273     TInt retCode(KErrNone);

   274     if ( aOwned )

   275         {

   276         delete ipOwnedTp;

   277         ipOwnedTp = NULL;

   278         ipOwnedTp = apProperties;

   279         }

   280     else

   281         {

   282         

   283         CSenContextItem* pItem = NULL;

   284         TInt leaveCode(KErrNone);

   285 //        if( aOwned )

   286 //            {

   287 //            TRAP( leaveCode, pItem = CSenContextItem::NewL(apProperties); )

   288 //            }

   289 //        else // chunk is not to be owned

   290 //            {

   291             TRAP( leaveCode, pItem = CSenContextItem::NewL(*apProperties); )

   292 //            }

   293 

   294         if( leaveCode != KErrNone ) 

   295             {

   296             delete pItem; // should ALWAYS be NULL(!)

   297             return leaveCode;

   298             }

   299             

   300         retCode = iItems.UpdateValue(&KSenCtxKeyChunk(), pItem);

   301         if( retCode != KErrNone && aOwned )

   302             {

   303             delete pItem; // delete the orphan item

   304             } 

   305         }

   306     return retCode;

   307     }

   308 

   309 

   310 MSenProperties* CSenSessionContext::Properties()

   311     {

   312     if( ipOwnedTp )

   313         {

   314         return ipOwnedTp;

   315         }

   316     else

   317         {

   318         TInt index = iItems.Find( KSenCtxKeyMessageProperties );

   319         if ( index != KErrNotFound )

   320             {

   321             const CSenContextItem* pItem = iItems.ValueAt(index);

   322             if( pItem->Type() == MSenContextItem::EMSenProperties )

   323                 {

   324                 MSenProperties* pProperties = (MSenProperties*)pItem;

   325                 return pProperties;

   326                 }

   327             }

   328         return NULL;

   329         }

   330     }

   331 

   332 // Method for adding an "intermediate" message behind certain key; used normally to conduct final "service message"

   333 TInt CSenSessionContext::Add(const TDesC8& aKey, MSenMessage* apMessage, TBool aOwned)

   334     {

   335     if( iItems.Count() > 0 && iItems.Find(aKey) != KErrNotFound )

   336         {

   337         return KErrAlreadyExists;

   338         }

   339 

   340     TInt leaveCode(KErrNone);

   341     CSenContextItem* pItem = MessageToItem( apMessage, aOwned, leaveCode );

   342     if( leaveCode != KErrNone ) 

   343         {

   344         return leaveCode;

   345         }

   346 

   347     TInt retCode(iItems.Append(&aKey, pItem));

   348     if( retCode != KErrNone )

   349         {

   350         delete pItem;

   351         }

   352     return retCode;

   353     }

   354     

   355 // Method for updating some "intermediate" message behind certain key; used normally to conduct final "service message"    

   356 TInt CSenSessionContext::Update(const TDesC8& aKey, MSenMessage* apMessage, TBool aOwned)

   357     {

   358     TInt leaveCode(KErrNone);

   359     CSenContextItem* pItem = MessageToItem( apMessage, aOwned, leaveCode );

   360     if( leaveCode != KErrNone ) 

   361         {

   362         return leaveCode;

   363         }

   364 

   365     TInt retCode(iItems.UpdateValue(&aKey, pItem));

   366     if( retCode != KErrNone && aOwned )

   367         {

   368         delete pItem;

   369         }

   370     return retCode;    

   371     }

   372     

   373 // Method for getting "intermediate" message behind certain key; used normally to conduct final "service message"    

   374 MSenMessage* CSenSessionContext::GetMessage(const TDesC8& aKey)

   375     {

   376     TInt index = iItems.Find(aKey);

   377     if ( index != KErrNotFound )

   378         {

   379         const CSenContextItem* pItem = iItems.ValueAt(index);

   380         if(pItem)

   381             {

   382             return &pItem->ToSenMessageL();

   383             }

   384         }

   385     return NULL;    

   386     }

   387  

   388 // private helper method(s):

   389 CSenContextItem* CSenSessionContext::MessageToItem(MSenMessage* apMessage, TBool aOwned, TInt& aError)

   390     {

   391     aError = KErrNone;

   392     CSenContextItem* pItem = NULL;

   393     if( aOwned )

   394         {

   395         if( apMessage->IsSafeToCast( MSenMessage::EMessageBase ) )

   396             {

   397             CSenMessageBase* msgBase = (CSenMessageBase*) apMessage;

   398             TRAP( aError, pItem = CSenContextItem::NewL( msgBase ); )

   399             }

   400         else if ( apMessage->IsSafeToCast( MSenMessage::ESoapEnvelope2 ) )

   401             {

   402             CSenSoapEnvelope2* msgSoap2 = (CSenSoapEnvelope2*) apMessage;

   403             TRAP( aError,  pItem = CSenContextItem::NewL( msgSoap2 ); )

   404             }

   405         else 

   406             {

   407             aError = KErrNotSupported;

   408             return NULL;

   409             }

   410         }

   411     else // provided message is *not to be owned*

   412         {

   413         TRAP( aError, pItem = CSenContextItem::NewL(*apMessage); )

   414         }

   415     return pItem;        

   416     } 

   417     

   418 TInt CSenSessionContext::SetDirection( SenContext::TContextDirection aDirection )

   419     {

   420     CSenContext::SetDirection( aDirection );

   421     return KErrNone;

   422     }

   423 

   424 const CSenXmlReader* CSenSessionContext::GetParser()

   425     {

   426     return CSenContext::GetParser();

   427     }

   428 */       

   429 // End of file

   430