diff -r 000000000000 -r 62f9d29f7211 webservices/wsframework/inc/sencontextitem.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/webservices/wsframework/inc/sencontextitem.h Thu Jan 07 16:19:19 2010 +0200 @@ -0,0 +1,736 @@ +/* +* Copyright (c) 2002-2005 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: Header declaration +* +*/ + + + + + + + + +#ifndef SEN_CONTEXT_ITEM_H +#define SEN_CONTEXT_ITEM_H + +// INCLUDES +#include +#include // for RCriticalSection + +#include "senwsdescription.h" + +#include "msencontextitem.h" // internal Framework\inc +#include "msencontext.h" + +// FORWARD DECLARE +class MSenCoreServiceManager; +class MSenRemoteServiceConsumer; +class MSenRemoteHostlet; +class MSenWSDescription; +class CSenWSDescription; +class CSenIdentityProvider; +class CSenWSPattern; +class CSenServiceSession; +class CSenWebServiceSession; +class CSenBasicWebServiceSession; +class CIdWSFServiceSession; +class CIdWsfServiceInstance; +class CSenCoreServiceConsumer; +class CSenSenInternalServiceConsumer; +class CIdWsfAuthenticationServiceClient; +class CIdWsfDiscoveryServiceClient; +class CSenRestServiceSession; +class CWSStarServiceSession; +class CWSStarSTSClient; + +class CSenChunk; +class CSenElement; +class CSenMessageBase; +class CSenSoapEnvelope2; +class MSenMessage; +class CSenSoapEnvelope; +class CSenAtomEntry; +class CSenSoapMessage; +class CSenXmlReader; +class MSenProperties; +class CSenXmlProperties; +class CSenTransportProperties; +class CSenHttpTransportProperties; +class CSenVtcpTransportProperties; +class CSenLayeredXmlProperties; +class CSenLayeredTransportProperties; +class CSenLayeredHttpTransportProperties; +class CSenLayeredVtcpTransportProperties; + +using namespace SenContext; + +// CLASS DECLARATION + +/** +* Class for wrapping objects so that they can be moved in +* and out of context a context using +* +* Sub-classing actual Service Providers have to implement MSenContextItem +* interface. +* +*/ +class CSenContextItem : public CBase, public MSenContextItem + { + public: + + // Constructors and destructor + /** + * Two-phased constructor, data type is TContextItemDataType::ETAny + * @param apValue is the data to be stored + * @param aIsOwnedOrNot determines whether the value is owned + * @return pointer to new context item + */ + IMPORT_C static CSenContextItem* NewL(TAny* apNotOwned); + /** + * Two-phased constructor, data type is TContextItemDataType::ETAny + * @param apOwned is owned + * @param aIsOwnedOrNot determines whether the value is owned + * @return pointer to new context item + * which is also left on cleanup stack. + */ + IMPORT_C static CSenContextItem* NewLC(TAny* apNotOwned); + + /** + * Two-phased constructor, data type is TContextItemDataType::ETDesC8 + * @param aRefToValue is copied (alloc) + * @return pointer to new context item + */ + IMPORT_C static CSenContextItem* NewL(const TDesC8& aRefToValue); + /** + * Two-phased constructor, data type is TContextItemDataType::ETDesC8 + * @param aRefToValue is copied (alloc) + * @return pointer to new context item + * which is also left on cleanup stack. + */ + IMPORT_C static CSenContextItem* NewLC(const TDesC8& aRefToValue); + + /** + * Two-phased constructor, data type is TContextItemDataType::ETDesC8 + * @param apOwned is owned + * @return pointer to new context item + */ + IMPORT_C static CSenContextItem* NewL(TDesC8* apOwned); + /** + * Two-phased constructor, data type is TContextItemDataType::ETDesC8 + * @param apOwned is owned + * @return pointer to new context item + * which is also left on cleanup stack. + */ + IMPORT_C static CSenContextItem* NewLC(TDesC8* apOwned); + + + /** + * Two-phased constructor, data type is TContextItemDataType::ETInt + * @param apValue is copied (alloc) + * @return pointer to new context item + */ + IMPORT_C static CSenContextItem* NewL(const TInt apValue); + /** + * Two-phased constructor, data type is TContextItemDataType::ETInt + * @param apValue is copied (alloc) + * @return pointer to new context item + * which is also left on cleanup stack. + */ + IMPORT_C static CSenContextItem* NewLC(const TInt apValue); + + + /** + * Two-phased constructor, data type is TContextItemDataType::ETInt + * @param apOwned is owned + * @return pointer to new context item + */ + IMPORT_C static CSenContextItem* NewL(TInt* apOwned); + /** + * Two-phased constructor, data type is TContextItemDataType::ETInt + * @param apOwned is owned + * @return pointer to new context item + * which is also left on cleanup stack. + */ + IMPORT_C static CSenContextItem* NewLC(TInt* apOwned); + + + /** + * Two-phased constructor, data type is TContextItemDataType::ETUint + * @param aValue is copied (alloc) + * @return pointer to new context item + */ + IMPORT_C static CSenContextItem* NewL(const TUint aValue); + /** + * Two-phased constructor, data type is TContextItemDataType::ETUint + * @param aValue is copied (alloc) + * @return pointer to new context item + * which is also left on cleanup stack. + */ + IMPORT_C static CSenContextItem* NewLC(const TUint aValue); + + /** + * Two-phased constructor, data type is TContextItemDataType::ETUint + * @param apOwned is owned + * @return pointer to new context item + */ + IMPORT_C static CSenContextItem* NewL(TUint* apOwned); + /** + * Two-phased constructor, data type is TContextItemDataType::ETUint + * @param apOwned is owned + * @return pointer to new context item + * which is also left on cleanup stack. + */ + IMPORT_C static CSenContextItem* NewLC(TUint* apOwned); + + + /** + * Two-phased constructor, data type is TContextItemDataType::EMSenCoreServiceManager + * @param aValue is referenced (not owned) + * @return pointer to new context item + */ + IMPORT_C static CSenContextItem* NewL(MSenCoreServiceManager& aValue); + /** + * Two-phased constructor, data type is TContextItemDataType::EMSenCoreServiceManager + * @param aValue is referenced (not owned) + * @return pointer to new context item + * which is also left on cleanup stack. + */ + IMPORT_C static CSenContextItem* NewLC(MSenCoreServiceManager& aValue); + + + + + /** + * Two-phased constructor, data type is TContextItemDataType::EMSenRemoteServiceConsumer + * @param aValue is referenced (not owned) + * @return pointer to new context item + */ + IMPORT_C static CSenContextItem* NewL(MSenRemoteServiceConsumer& aValue); + /** + * Two-phased constructor, data type is TContextItemDataType::EMSenRemoteServiceConsumer + * @param aValue is referenced (not owned) + * @return pointer to new context item + * which is also left on cleanup stack. + */ + IMPORT_C static CSenContextItem* NewLC(MSenRemoteServiceConsumer& aValue); + + + /** + * Two-phased constructor, data type is TContextItemDataType::EMSenRemoteHostlet + * @param aValue is referenced (not owned) + * @return pointer to new context item + */ + IMPORT_C static CSenContextItem* NewL(MSenRemoteHostlet& aValue); + /** + * Two-phased constructor, data type is TContextItemDataType::EMSenRemoteHostlet + * @param aValue is referenced (not owned) + * @return pointer to new context item + * which is also left on cleanup stack. + */ + IMPORT_C static CSenContextItem* NewLC(MSenRemoteHostlet& aValue); + + + /** + * Two-phased constructor, data type is TContextItemDataType::ECSenWSDescription + * @param aValue is referenced (not owned) + * @return pointer to new context item + */ + IMPORT_C static CSenContextItem* NewL(CSenWSDescription& aValue); + /** + * Two-phased constructor, data type is TContextItemDataType::ECSenWSDescription + * @param aValue is referenced owned (not owned) + * @return pointer to new context item + * which is also left on cleanup stack. + */ + IMPORT_C static CSenContextItem* NewLC(CSenWSDescription& aValue); + + /** + * Two-phased constructor, data type is TContextItemDataType::EMSenServiceDescription + * @param apOwned is owned + * @return pointer to new context item + */ + IMPORT_C static CSenContextItem* NewL(CSenWSDescription* apOwned); + /** + * Two-phased constructor, data type is TContextItemDataType::EMSenServiceDescription + * @param apOwned is owned + * @return pointer to new context item + * which is also left on cleanup stack. + */ + IMPORT_C static CSenContextItem* NewLC(CSenWSDescription* apOwned); + + + /** + * Two-phased constructor, data type is TContextItemDataType::ECSenChunk + * @param aValue is referenced (not owned) + * @return pointer to new context item + */ + IMPORT_C static CSenContextItem* NewL(CSenChunk& aValue); + /** + * Two-phased constructor, data type is TContextItemDataType::ECSenChunk + * @param aValue is referenced owned (not owned) + * @return pointer to new context item + * which is also left on cleanup stack. + */ + IMPORT_C static CSenContextItem* NewLC(CSenChunk& aValue); + + /** + * Two-phased constructor, data type is TContextItemDataType::ECSenChunk + * @param apOwned is owned + * @return pointer to new context item + */ + IMPORT_C static CSenContextItem* NewL(CSenChunk* apOwned); + /** + * Two-phased constructor, data type is TContextItemDataType::ECSenChunk + * @param apOwned is owned + * @return pointer to new context item + * which is also left on cleanup stack. + */ + IMPORT_C static CSenContextItem* NewLC(CSenChunk* apOwned); + + + /** + * Two-phased constructor, data type is TContextItemDataType::ECSenXmlElement + * @param aValue is referenced (not owned) + * @return pointer to new context item + */ + IMPORT_C static CSenContextItem* NewL(CSenElement& aValue); + /** + * Two-phased constructor, data type is TContextItemDataType::ECSenXmlElement + * @param aValue is referenced owned (not owned) + * @return pointer to new context item + * which is also left on cleanup stack. + */ + IMPORT_C static CSenContextItem* NewLC(CSenElement& aValue); + + /** + * Two-phased constructor, data type is TContextItemDataType::ECSenXmlElement + * @param apOwned is owned + * @return pointer to new context item + */ + IMPORT_C static CSenContextItem* NewL(CSenElement* apOwned); + /** + * Two-phased constructor, data type is TContextItemDataType::ECSenXmlElement + * @param apOwned is owned + * @return pointer to new context item + * which is also left on cleanup stack. + */ + IMPORT_C static CSenContextItem* NewLC(CSenElement* apOwned); + + + /** + * Two-phased constructor, data type is TContextItemDataType::ECSenXmlElement + * @param aValue is referenced (not owned) + * @return pointer to new context item + */ + IMPORT_C static CSenContextItem* NewL(CSenXmlReader& aValue); + /** + * Two-phased constructor, data type is TContextItemDataType::ECSenXmlReader + * @param aValue is referenced owned (not owned) + * @return pointer to new context item + * which is also left on cleanup stack. + */ + IMPORT_C static CSenContextItem* NewLC(CSenXmlReader& aValue); + + /** + * Two-phased constructor, data type is TContextItemDataType::ECSenXmlReader + * @param apOwned is owned + * @return pointer to new context item + */ + IMPORT_C static CSenContextItem* NewL(CSenXmlReader* apOwned); + /** + * Two-phased constructor, data type is TContextItemDataType::ECSenXmlReader + * @param apOwned is owned + * @return pointer to new context item + * which is also left on cleanup stack. + */ + IMPORT_C static CSenContextItem* NewLC(CSenXmlReader* apOwned); + + + /** + * Two-phased constructor, data type is TContextItemDataType::EMSenProperties + * @param aValue is referenced (not owned) + * @return pointer to new context item + */ + IMPORT_C static CSenContextItem* NewL(MSenProperties& aValue); + /** + * Two-phased constructor, data type is TContextItemDataType::EMSenProperties + * @param aValue is referenced owned (not owned) + * @return pointer to new context item + * which is also left on cleanup stack. + */ + IMPORT_C static CSenContextItem* NewLC(MSenProperties& aValue); + + /** + * Two-phased constructor, data type is TContextItemDataType::EMSenProperties + * @param apOwned is owned + * @return pointer to new context item + */ + IMPORT_C static CSenContextItem* NewL(CSenXmlProperties* apOwned); + /** + * Two-phased constructor, data type is TContextItemDataType::EMSenProperties + * @param apOwned is owned + * @return pointer to new context item + * which is also left on cleanup stack. + */ + IMPORT_C static CSenContextItem* NewLC(CSenXmlProperties* apOwned); + + /** + * Two-phased constructor, data type is TContextItemDataType::EMSenProperties + * @param apOwned is owned + * @return pointer to new context item + */ + IMPORT_C static CSenContextItem* NewL(CSenLayeredXmlProperties* apOwned); + /** + * Two-phased constructor, data type is TContextItemDataType::EMSenProperties + * @param apOwned is owned + * @return pointer to new context item + * which is also left on cleanup stack. + */ + IMPORT_C static CSenContextItem* NewLC(CSenLayeredXmlProperties* apOwned); + + + /** + * Two-phased constructor, data type is TContextItemDataType::EMSenMessage + * @param aValue is referenced (not owned) + * @return pointer to new context item + */ + IMPORT_C static CSenContextItem* NewL(MSenMessage& aValue); + /** + * Two-phased constructor, data type is TContextItemDataType::EMSenMessage + * @param aValue is referenced owned (not owned) + * @return pointer to new context item + * which is also left on cleanup stack. + */ + IMPORT_C static CSenContextItem* NewLC(MSenMessage& aValue); + + /** + * Two-phased constructor, data type is TContextItemDataType::ECSenSoapEnvelope2 + * @param apOwned is owned + * @return pointer to new context item + */ + IMPORT_C static CSenContextItem* NewL(CSenSoapEnvelope2* apOwned); + /** + * Two-phased constructor, data type is TContextItemDataType::ECSenSoapEnvelope2 + * @param apOwned is owned + * @return pointer to new context item + * which is also left on cleanup stack. + */ + IMPORT_C static CSenContextItem* NewLC(CSenSoapEnvelope2* apOwned); + + /** + * Two-phased constructor, data type is TContextItemDataType::CSenAtomEntry + * @param apOwned is owned + * @return pointer to new context item + * which is also left on cleanup stack. + */ + IMPORT_C static CSenContextItem* NewLC(CSenAtomEntry* apOwned); + /** + * Two-phased constructor, data type is TContextItemDataType::CSenAtomEntry + * @param apOwned is owned + * @return pointer to new context item + * which is also left on cleanup stack. + */ + IMPORT_C static CSenContextItem* NewL(CSenAtomEntry* apOwned); + + + + + /** + * Two-phased constructor, data type is TContextItemDataType::ECSenMessageBase + * @param apOwned is owned + * @return pointer to new context item + */ + IMPORT_C static CSenContextItem* NewL(CSenMessageBase* apOwned); + /** + * Two-phased constructor, data type is TContextItemDataType::ECSenMessageBase + * @param apOwned is owned + * @return pointer to new context item + * which is also left on cleanup stack. + */ + IMPORT_C static CSenContextItem* NewLC(CSenMessageBase* apOwned); + + + /** + * Two-phased constructor, data type is TContextItemDataType::ECSenXmlElement + * @param aValue is referenced (not owned) + * @return pointer to new context item + */ + IMPORT_C static CSenContextItem* NewL(CSenSoapMessage& aValue); + /** + * Two-phased constructor, data type is TContextItemDataType::ECSenXmlElement + * @param aValue is referenced owned (not owned) + * @return pointer to new context item + * which is also left on cleanup stack. + */ + IMPORT_C static CSenContextItem* NewLC(CSenSoapMessage& aValue); + + /** + * Two-phased constructor, data type is TContextItemDataType::ECSenXmlElement + * @param apOwned is owned + * @return pointer to new context item + */ + IMPORT_C static CSenContextItem* NewL(CSenSoapMessage* apOwned); + /** + * Two-phased constructor, data type is TContextItemDataType::ECSenXmlElement + * @param apOwned is owned + * @return pointer to new context item + * which is also left on cleanup stack. + */ + IMPORT_C static CSenContextItem* NewLC(CSenSoapMessage* apOwned); + + + // From MSenContextItem: + + /* + * Method for resolving real C-class type (implemenation class). + * Inherited from MSenContextItem. + * @return the type of this class (EContextItem) + */ + virtual MSenContextItem::TClass Type() const; + + + // New methods: + + /** + * + * Returns the pointer to the data that is wrapped inside this item. + * @return pointer to wrapped data, but only if this context item + * was constructed with TAny -argument. In case that this item knows + * the data type of the object (!=TAny), method will leave. + * Supported data type(s): + * TAny (root) -- TContextItemDataType::ETAny + * Leave codes: + * KErrSenContextItemCastMismatch if owned/referenced data type mismatches + */ + virtual TAny* ToAnyL() const; + + /** + * Returns the 8-bit descriptor that is wrapped inside this item. + * @return 8-bit descriptor, but only if this context item was constructed + * to hold such data. In case that this item holds some object of different + * type instead, the method will leave. + * Supported data type(s): + * TDesC8 (root) -- TContextItemDataType::ETDesC8 + * Leave codes: + * KErrSenContextItemCastMismatch if owned/referenced data type mismatches + */ + virtual TPtrC8 ToPtrC8L() const; + + + /** + * Returns the 8-bit descriptor that is wrapped inside this item. + * @return 8-bit descriptor, but only if this context item was constructed + * to hold such data. In case that this item holds some object of different + * type instead, the method will leave. + * Supported data type(s): + * TDesC8 (root) -- TContextItemDataType::ETDesC8 + * Leave codes: + * KErrSenContextItemCastMismatch if owned/referenced data type mismatches + */ + virtual const TDesC8* ToDesC8L() const; + + /** + * Returns the signed integer descriptor that is wrapped inside this item. + * @return integer, but only if this context item was constructed + * to hold such data. In case that this item holds some object of different + * type instead, the method will leave. + * Supported data type(s): + * TInt -- TContextItemDataType::ETInt + * Leave codes: + * KErrSenContextItemCastMismatch if owned/referenced data type mismatches + */ + virtual const TInt* ToIntL() const; + + /** + * Returns the unsigned integer descriptor that is wrapped inside this item. + * @return integer, but only if this context item was constructed + * to hold such data. In case that this item holds some object of different + * type instead, the method will leave. + * Supported data type(s): + * TUint -- TContextItemDataType::ETUint + * Leave codes: + * KErrSenContextItemCastMismatch if owned/referenced data type mismatches + */ + virtual const TUint* ToUintL() const; + + /** + * Returns MSenCoreServiceManager that is wrapped inside this item. + * @return core, but only if this context item was constructed + * to hold such data. In case that this item holds some object of different + * type instead, the method will leave. + * Supported data type(s): + * MSenCoreServiceManager -- TContextItemDataType::EMSenCoreServiceManager + * Leave codes: + * KErrSenContextItemCastMismatch if owned/referenced data type mismatches + */ + virtual MSenCoreServiceManager& ToSenCoreL() const; + + /** + * Returns MSenRemoteServiceConsumer that is wrapped inside this item. + * @return consumer, but only if this context item was constructed + * to hold such data. In case that this item holds some object of different + * type instead, the method will leave. + * Supported data type(s): + * MSenRemoteServiceConsumer -- TContextItemDataType::EMSenRemoteServiceConsumer + * Leave codes: + * KErrSenContextItemCastMismatch if owned/referenced data type mismatches + */ + virtual MSenRemoteServiceConsumer& ToSenRemoteConsumerL() const; + + /** + * Returns MSenRemoteHostlet that is wrapped inside this item. + * @return hostlet, but only if this context item was constructed + * to hold such data. In case that this item holds some object of different + * type instead, the method will leave. + * Supported data type(s): + * MSenRemoteHostlet (root) -- TContextItemDataType::EMSenRemoteHostlet + * Leave codes: + * KErrSenContextItemCastMismatch if owned/referenced data type mismatches + */ + virtual MSenRemoteHostlet& ToSenRemoteHostletL() const; + + /** + * Returns CSenWSDescription that is wrapped inside this item. + * @return XML service description, but only if this context item was constructed + * to hold such data. In case that this item holds some object of different + * type instead, the method will leave. + * Supported data type(s): + * CSenWSDescription (root) -- TContextItemDataType::EMSenServiceDescription + * Leave codes: + * KErrSenContextItemCastMismatch if owned/referenced data type mismatches + */ + virtual CSenWSDescription& ToSenServiceDescriptionL() const; + + /** + * Returns CSenServiceSession that is wrapped inside this item. + * @return session, but only if this context item was constructed + * to hold such data. In case that this item holds some object of different + * type instead, the method will leave. + * Supported data type(s): + * CSenServiceSession -- TContextItemDataType::EMSenServiceDescription + * Leave codes: + * KErrSenContextItemCastMismatch if owned/referenced data type mismatches + */ + virtual CSenServiceSession& ToSenServiceSessionL() const; + + /** + * Returns properties object that is wrapped inside this item. + * @return XML properties, but only if this context item was constructed + * to hold such data. In case that this item holds some object of different + * type instead, the method will leave. + * Supported data type(s): + * CSenXmlProperties (root) -- TContextItemDataType::EMSenProperties + * Leave codes: + * KErrSenContextItemCastMismatch if owned/referenced data type mismatches + */ + virtual CSenXmlProperties& ToSenXmlPropertiesL() const; + + /** + * Returns layered properties object that is wrapped inside this item. + * @return layered XML properties, but only if this context item was constructed + * to hold such data. In case that this item holds some object of different + * type instead, the method will leave. + * Supported data type(s): + * CSenLayeredXmlProperties (root) -- TContextItemDataType::EMSenProperties + * Leave codes: + * KErrSenContextItemCastMismatch if owned/referenced data type mismatches + */ + virtual CSenLayeredXmlProperties& ToSenLayeredXmlPropertiesL() const; + + /** + * Returns the XML element that is wrapped inside this item. + * @return XML element, but only if this context item was constructed + * to hold such data. In case that this item holds some object of different + * type instead, the method will leave. + * Supported data type(s): + * CSenElement (root) -- TContextItemDataType::ECSenElement + * Leave codes: + * KErrSenContextItemCastMismatch if owned/referenced data type mismatches + */ + virtual CSenElement& ToSenElementL() const; + + /** + * Returns the SOAP message that is wrapped inside this item. + * @return SOAP message, but only if this context item was constructed + * to hold such data. In case that this item holds some object of different + * type instead, the method will leave. + * Supported data type(s): + * CSenElement (root) -- TContextItemDataType::ECSenSoapEnvelope + * Leave codes: + * KErrSenContextItemCastMismatch if owned/referenced data type mismatches + */ + virtual CSenSoapMessage& ToSenSoapMessageL() const; + + /** + * Returns the message that is wrapped inside this item. + * @return message, but only if this context item was constructed + * to hold such data. In case that this item holds some object of different + * type instead, the method will leave. + * Supported data type(s): + * CSenElement (root) -- TContextItemDataType::EMSenMessage + * Leave codes: + * KErrSenContextItemCastMismatch if owned/referenced data type mismatches + */ + virtual MSenMessage& ToSenMessageL() const; + + + /** + * Returns the chunk that is wrapped inside this item. + * @return message, but only if this context item was constructed + * to hold such data. In case that this item holds some object of different + * type instead, the method will leave. + * Supported data type(s): + * CSenElement (root) -- TContextItemDataType::ECSenChunk + * Leave codes: + * KErrSenContextItemCastMismatch if owned/referenced data type mismatches + */ + virtual CSenChunk& ToSenChunkL() const; + + /** + * Returns the XML element that is wrapped inside this item. + * @return XML element, but only if this context item was constructed + * to hold such data. In case that this item holds some object of different + * type instead, the method will leave. + * Supported data type(s): + * CSenXmlReader -- TContextItemDataType::ECSenXmlReader + * Leave codes: + * KErrSenContextItemCastMismatch if owned/referenced data type mismatches + */ + virtual CSenXmlReader& ToSenXmlReaderL() const; + + /** + * Function: ~CSenContextItem + * + * Description: Destroy the object + */ + IMPORT_C virtual ~CSenContextItem(); + + private: + + CSenContextItem(TAny* apData, MSenContextItem::TData aType, TInt* apFlags); + + + private: // Data + + // This pointer holds the actual data wrapped by this context item:´ + TAny* ipData; + // This member specifies the item class-type: + MSenContextItem::TData iType; + // This pointer holds information about data; whether it is owned or not, etc. + TInt* ipFlags; + }; +#endif // SEN_CONTEXT_ITEM_H + +// End of File