diff -r 000000000000 -r 62f9d29f7211 webservices/wsframework/src/senapplicationcontext.cpp --- /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 +