--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/webservices/wsframework/src/senapplicationcontext.cpp Thu Jan 07 16:19:19 2010 +0200
@@ -0,0 +1,506 @@
+/*
+* Copyright (c) 2002-2007 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 FILES
+#include "senapplicationcontext.h"
+#include "senservercontext.h"
+#include "senclientcontext.h"
+#include "SenServiceConnection.h" // KErrSenInternal
+
+EXPORT_C CSenApplicationContext* CSenApplicationContext::NewL(TSecureId aSecureId,
+ CSenServerContext& aServerContext)
+ {
+ CSenApplicationContext* pNew = CSenApplicationContext::NewLC(aSecureId, aServerContext);
+ CleanupStack::Pop();
+ return pNew;
+ }
+
+EXPORT_C CSenApplicationContext* CSenApplicationContext::NewLC(TSecureId aSecureId,
+ CSenServerContext& aServerContext)
+ {
+ CSenApplicationContext* pNew = new (ELeave) CSenApplicationContext(aSecureId, aServerContext);
+ CleanupStack::PushL(pNew);
+ pNew->BaseConstructL();
+ return pNew;
+ }
+
+EXPORT_C CSenApplicationContext::CSenApplicationContext(TSecureId aSecureId,
+ CSenServerContext& aServerContext)
+: iSecureId(aSecureId),
+ iServerContext(aServerContext),
+ iClients(ETrue, ETrue)
+ {
+ }
+
+EXPORT_C CSenApplicationContext::~CSenApplicationContext()
+ {
+ }
+
+EXPORT_C void CSenApplicationContext::BaseConstructL()
+ {
+// CSenContext::BaseConstructL();
+ }
+
+CSenServerContext& CSenApplicationContext::ServerContext() const
+ {
+ return iServerContext;
+ }
+
+TSecureId CSenApplicationContext::SecureId() const
+ {
+ return iSecureId;
+ }
+
+CSenClientContext& CSenApplicationContext::OpenClientContextL(TInt aClientId)
+ {
+ CSenClientContext* pCtx = NULL;
+ // Check if requested client context already exists, held by this server context
+ TInt index = iClients.Find( aClientId );
+ if ( index == KErrNotFound )
+ {
+ // New client context needs to be created
+ pCtx = CSenClientContext::NewLC(aClientId, *this );
+ TInt* pClientId = new (ELeave) TInt(aClientId);
+ TInt err = iClients.Append( pClientId, pCtx );
+ if( err )
+ {
+ // Append failed: cleanup and leave
+ delete pClientId; // de-alloc this orphan
+ CleanupStack::PopAndDestroy( pCtx );
+ User::Leave( err );
+ }
+ else
+ {
+ // Remove the new context from cleanup stack,
+ // it is now owned by this application context
+ CleanupStack::Pop( pCtx );
+ }
+ }
+ else
+ {
+ // Return the existing client context
+ pCtx = (CSenClientContext*)iClients.ValueAt( index );
+ if( !pCtx )
+ {
+ // Should NOT occur: map failed => leave with internal error code
+ User::Leave( KErrSenInternal );
+ }
+ }
+ return *pCtx;
+ }
+
+TInt CSenApplicationContext::CloseClientContext(const CSenClientContext& aCtx)
+ {
+ TInt retVal(KErrNotFound);
+ if ( aCtx.iSessions.Count() == 0 )
+ {
+ // Note: RemoveByKey returns KErrNotFound or index of removed item(!)
+ retVal = iClients.RemoveByKey( aCtx.ClientId() );
+ if( retVal != KErrNotFound )
+ {
+ retVal = KErrNone;
+ }
+ }
+ else
+ {
+ retVal = KErrInUse;
+ }
+ return retVal;
+ }
+
+// From MSenApplicationContext:
+/*
+SenContext::TContextType CSenApplicationContext::Type() const
+ {
+ return SenContext::EMessageContext;
+ }
+
+SenContext::TContextDirection CSenApplicationContext::Direction() const
+ {
+ return CSenContext::Direction();
+ }
+
+TInt CSenApplicationContext::Add(const TDesC8& aKey, const TDesC8& aValue)
+ {
+ return CSenContext::Add( aKey, aValue );
+ }
+
+TInt CSenApplicationContext::Update(const TDesC8& aKey, const TDesC8& aValue)
+ {
+ return CSenContext::Update( aKey, aValue );
+ }
+
+const TDesC8* CSenApplicationContext::GetDesC8L(const TDesC8& aKey)
+ {
+ return CSenContext::GetDesC8L( aKey );
+ }
+
+TInt CSenApplicationContext::Add(const TDesC8& aKey, TInt aValue)
+ {
+ return CSenContext::Add( aKey, aValue );
+ }
+
+TInt CSenApplicationContext::Update(const TDesC8& aKey, TInt aValue)
+ {
+ return CSenContext::Update( aKey, aValue );
+ }
+
+const TInt* CSenApplicationContext::GetIntL(const TDesC8& aKey)
+ {
+ return CSenContext::GetIntL( aKey );
+ }
+
+TInt CSenApplicationContext::Add(const TDesC8& aKey, CSenElement* aValue)
+ {
+ return CSenContext::Add( aKey, aValue );
+ }
+
+TInt CSenApplicationContext::Update(const TDesC8& aKey, CSenElement* aValue)
+ {
+ return CSenContext::Update( aKey, aValue );
+ }
+
+const CSenElement* CSenApplicationContext::GetSenElementL(const TDesC8& aKey)
+ {
+ return CSenContext::GetSenElementL( aKey );
+ }
+
+TInt CSenApplicationContext::Add(const TDesC8& aKey, TAny* aValue)
+ {
+ return CSenContext::Add( aKey, aValue );
+ }
+
+TInt CSenApplicationContext::Update(const TDesC8& aKey, TAny* aValue)
+ {
+ return CSenContext::Update( aKey, aValue );
+ }
+
+TAny* CSenApplicationContext::GetAny(const TDesC8& aKey)
+ {
+ return CSenContext::GetAny( aKey );
+ }
+
+TInt CSenApplicationContext::Remove(const TDesC8& aKey)
+ {
+ return CSenContext::Remove(aKey);
+ }
+
+TInt CSenApplicationContext::Count() const
+ {
+ return CSenContext::Count();
+ }
+
+TPtrC8 CSenApplicationContext::KeyAtL(TInt aIndex)
+ {
+ return CSenContext::KeyAtL(aIndex);
+ }
+
+void CSenApplicationContext::Reset()
+ {
+ CSenContext::Reset();
+ }
+
+CSenSoapMessage* CSenApplicationContext::GetCurrentSoapMessage() // DEPRECATED:
+ {
+ CSenSoapMessage* pSoapMessage = NULL;
+
+ TInt index = iItems.Find( KSenCtxKeyCurrentSoapMessage );
+ if ( index != KErrNotFound )
+ {
+ const CSenContextItem* pItem = iItems.ValueAt(index);
+ pSoapMessage = &(pItem->ToSenSoapMessageL());
+ }
+ return pSoapMessage;
+ }
+
+TPtrC8 CSenApplicationContext::GetMessage()
+ {
+ TInt index = iItems.Find( KSenCtxKeyCurrentMessageAsDesc );
+ if ( index != KErrNotFound )
+ {
+ const CSenContextItem* pItem = iItems.ValueAt(index);
+ const TDesC8* desc = pItem->ToDesC8L();
+ return *desc;
+ }
+ return KNullDesC8();
+ }
+
+TInt CSenApplicationContext::Add(const TDesC8& aKey, CSenSoapEnvelope* aValue)
+ {
+ return CSenContext::Add( aKey, aValue );
+ }
+
+TInt CSenApplicationContext::Update(const TDesC8& aKey, CSenSoapEnvelope* aValue)
+ {
+ return CSenContext::Update( aKey, aValue );
+ }
+
+const CSenSoapEnvelope* CSenApplicationContext::GetSenSoapEnvelopeL(const TDesC8& aKey)
+ {
+ TInt index = iItems.Find( aKey );
+ if ( index != KErrNotFound )
+ {
+ const CSenContextItem* pItem = iItems.ValueAt(index);
+ const CSenSoapEnvelope* envelope = ((CSenSoapEnvelope*)&(pItem->ToSenSoapMessageL()));
+ return envelope;
+ }
+ return NULL;
+ }
+
+MSenMessage* CSenApplicationContext::Message()
+ {
+ TInt index = iItems.Find( KSenCtxKeyMessage );
+ if ( index != KErrNotFound )
+ {
+ const CSenContextItem* pItem = iItems.ValueAt(index);
+ return ((MSenMessage*)&(pItem->ToSenMessageL()));
+ }
+ return NULL;
+ }
+
+TInt CSenApplicationContext::SetMessage(MSenMessage* apMessage, TBool aOwned)
+ {
+ TInt leaveCode(KErrNone);
+ CSenContextItem* pItem = MessageToItem( apMessage, aOwned, leaveCode );
+
+ if( leaveCode != KErrNone )
+ {
+ delete pItem; // should ALWAYS be NULL(!)
+ return leaveCode;
+ }
+
+ TInt retCode(iItems.UpdateValue(&KSenCtxKeyMessage(), pItem));
+ if( retCode != KErrNone && aOwned )
+ {
+ delete pItem; // delete the orphan item
+ }
+ return retCode;
+ }
+
+
+CSenChunk* CSenApplicationContext::Chunk()
+ {
+ TInt index = iItems.Find( KSenCtxKeyChunk );
+ if ( index != KErrNotFound )
+ {
+ const CSenContextItem* pItem = iItems.ValueAt(index);
+ return ((CSenChunk*)&(pItem->ToSenChunkL()));
+ }
+ return NULL;
+ }
+
+TInt CSenApplicationContext::SetChunk(CSenChunk* apMsgAsChunk, TBool aOwned)
+ {
+ TInt leaveCode(KErrNone);
+
+ CSenContextItem* pItem = NULL;
+ if( aOwned )
+ {
+ TRAP( leaveCode, pItem = CSenContextItem::NewL(apMsgAsChunk); )
+ }
+ else // chunk is not to be owned
+ {
+ TRAP( leaveCode, pItem = CSenContextItem::NewL(*apMsgAsChunk); )
+ }
+
+ if( leaveCode != KErrNone )
+ {
+ delete pItem; // should ALWAYS be NULL(!)
+ return leaveCode;
+ }
+
+ TInt retCode(iItems.UpdateValue(&KSenCtxKeyChunk(), pItem));
+ if( retCode != KErrNone && aOwned )
+ {
+ delete pItem; // delete the orphan item
+ }
+ return retCode;
+ }
+
+
+TInt CSenApplicationContext::SetProperties(MSenProperties* apProperties, TBool aOwned)
+ {
+ if( !apProperties )
+ {
+ return KErrArgument;
+ }
+
+ TInt retCode(KErrNone);
+ if ( aOwned )
+ {
+ delete ipOwnedTp;
+ ipOwnedTp = NULL;
+ ipOwnedTp = apProperties;
+ }
+ else
+ {
+
+ CSenContextItem* pItem = NULL;
+ TInt leaveCode(KErrNone);
+// if( aOwned )
+// {
+// TRAP( leaveCode, pItem = CSenContextItem::NewL(apProperties); )
+// }
+// else // chunk is not to be owned
+// {
+ TRAP( leaveCode, pItem = CSenContextItem::NewL(*apProperties); )
+// }
+
+ if( leaveCode != KErrNone )
+ {
+ delete pItem; // should ALWAYS be NULL(!)
+ return leaveCode;
+ }
+
+ retCode = iItems.UpdateValue(&KSenCtxKeyChunk(), pItem);
+ if( retCode != KErrNone && aOwned )
+ {
+ delete pItem; // delete the orphan item
+ }
+ }
+ return retCode;
+ }
+
+
+MSenProperties* CSenApplicationContext::Properties()
+ {
+ if( ipOwnedTp )
+ {
+ return ipOwnedTp;
+ }
+ else
+ {
+ TInt index = iItems.Find( KSenCtxKeyMessageProperties );
+ if ( index != KErrNotFound )
+ {
+ const CSenContextItem* pItem = iItems.ValueAt(index);
+ if( pItem->Type() == MSenContextItem::EMSenProperties )
+ {
+ MSenProperties* pProperties = (MSenProperties*)pItem;
+ return pProperties;
+ }
+ }
+ return NULL;
+ }
+ }
+
+// Method for adding an "intermediate" message behind certain key; used normally to conduct final "service message"
+TInt CSenApplicationContext::Add(const TDesC8& aKey, MSenMessage* apMessage, TBool aOwned)
+ {
+ if( iItems.Count() > 0 && iItems.Find(aKey) != KErrNotFound )
+ {
+ return KErrAlreadyExists;
+ }
+
+ TInt leaveCode(KErrNone);
+ CSenContextItem* pItem = MessageToItem( apMessage, aOwned, leaveCode );
+ if( leaveCode != KErrNone )
+ {
+ return leaveCode;
+ }
+
+ TInt retCode(iItems.Append(&aKey, pItem));
+ if( retCode != KErrNone )
+ {
+ delete pItem;
+ }
+ return retCode;
+ }
+
+// Method for updating some "intermediate" message behind certain key; used normally to conduct final "service message"
+TInt CSenApplicationContext::Update(const TDesC8& aKey, MSenMessage* apMessage, TBool aOwned)
+ {
+ TInt leaveCode(KErrNone);
+ CSenContextItem* pItem = MessageToItem( apMessage, aOwned, leaveCode );
+ if( leaveCode != KErrNone )
+ {
+ return leaveCode;
+ }
+
+ TInt retCode(iItems.UpdateValue(&aKey, pItem));
+ if( retCode != KErrNone && aOwned )
+ {
+ delete pItem;
+ }
+ return retCode;
+ }
+
+// Method for getting "intermediate" message behind certain key; used normally to conduct final "service message"
+MSenMessage* CSenApplicationContext::GetMessage(const TDesC8& aKey)
+ {
+ TInt index = iItems.Find(aKey);
+ if ( index != KErrNotFound )
+ {
+ const CSenContextItem* pItem = iItems.ValueAt(index);
+ if(pItem)
+ {
+ return &pItem->ToSenMessageL();
+ }
+ }
+ return NULL;
+ }
+
+// private helper method(s):
+CSenContextItem* CSenApplicationContext::MessageToItem(MSenMessage* apMessage, TBool aOwned, TInt& aError)
+ {
+ aError = KErrNone;
+ CSenContextItem* pItem = NULL;
+ if( aOwned )
+ {
+ if( apMessage->IsSafeToCast( MSenMessage::EMessageBase ) )
+ {
+ CSenMessageBase* msgBase = (CSenMessageBase*) apMessage;
+ TRAP( aError, pItem = CSenContextItem::NewL( msgBase ); )
+ }
+ else if ( apMessage->IsSafeToCast( MSenMessage::ESoapEnvelope2 ) )
+ {
+ CSenSoapEnvelope2* msgSoap2 = (CSenSoapEnvelope2*) apMessage;
+ TRAP( aError, pItem = CSenContextItem::NewL( msgSoap2 ); )
+ }
+ else
+ {
+ aError = KErrNotSupported;
+ return NULL;
+ }
+ }
+ else // provided message is *not to be owned*
+ {
+ TRAP( aError, pItem = CSenContextItem::NewL(*apMessage); )
+ }
+ return pItem;
+ }
+
+TInt CSenApplicationContext::SetDirection( SenContext::TContextDirection aDirection )
+ {
+ CSenContext::SetDirection( aDirection );
+ return KErrNone;
+ }
+
+const CSenXmlReader* CSenApplicationContext::GetParser()
+ {
+ return CSenContext::GetParser();
+ }
+*/
+// End of file
+