diff -r 000000000000 -r dfb7c4ff071f datacommsserver/esockserver/inc/ss_cmetaextensioncontainer.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/datacommsserver/esockserver/inc/ss_cmetaextensioncontainer.h Thu Dec 17 09:22:25 2009 +0200 @@ -0,0 +1,272 @@ +// Copyright (c) 2005-2009 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: +// ss_cmetaextensioncontainer.h +// + +/** +@file +@prototype +@internalTechnology +*/ + +#ifndef SYMBIAN_SS_CMETAEXTENSIONCONTAINER +#define SYMBIAN_SS_CMETAEXTENSIONCONTAINER + +#include + +#ifdef MEC_UNITTEST +// If this file is being built for the unit test we use a simpler +// base class that doesn't use the comms transport and async deletion. +// Functionally CMecUnitTestRefCountOwnerBase is the same as CRefCountOwnerBase +#include "mecunittestrefcountowner.h" + +class TMetaExtensionContainerSpy; + +#else +// !MEC_UNITTEST +#include + +#endif +// MEC_UNITTEST + +namespace ESock +{ +// Forward declarations - see +class RMetaExtensionContainer; +class RMetaExtensionContainerC; + + + +/** +Base class for implementations of containers holding the meta extensions. +The lifetime of itself and any extensions it owned by it are ref counted. +Extensions owned by the CMetaExtensionContainerImplBase must have been +created on the same heap as the container. +@prototype +@internalTechnology +*/ +NONSHARABLE_CLASS(CMetaExtensionContainerImplBase) : public CRefCountOwnerBase + { +#ifdef MEC_UNITTEST + friend class ::TMetaExtensionContainerSpy; +#endif + +public: + /** + @prototype + @internalTechnology + */ + enum TMetaExtensionContainerType + { + EMetaExtensionContainer, + EMetaExtensionContainerArray, + }; + + /** + Finds the extension specified within the container + @param aTypeId The STypeId of the meta extension to find + @return A pointer to the meta extension or NULL if it wasn't found + */ + virtual const Meta::SMetaData* FindExtension(const Meta::STypeId& aTypeId) const = 0; + + /** + Finds the extension specified within the container + @param aTypeId The STypeId of the meta extension to find + @return A reference to the meta extension + @exception KErrNotFound is thrown if the meta extension was not present in the container + */ + const Meta::SMetaData& FindExtensionL(const Meta::STypeId& aTypeId) const; + + inline TMetaExtensionContainerType Type() const; + +protected: + CMetaExtensionContainerImplBase(TMetaExtensionContainerType aType) + : CRefCountOwnerBase(NULL), iType(aType) + { + Open(); // Open the first reference + } + + virtual void DeletePtr(); + + ~CMetaExtensionContainerImplBase() + { + } + +private: + TMetaExtensionContainerType iType; + }; + + + +/** +An implementation of an appendable container of meta extensions. This implementation can not +be created and used directly. Use RMetaExtensionContainer instead. +@prototype +@internalTechnology +*/ +NONSHARABLE_CLASS(CMetaExtensionContainer) : public CMetaExtensionContainerImplBase + { + friend class RMetaExtensionContainer; + friend class RMetaExtensionContainerC; +#ifdef MEC_UNITTEST + friend class ::TMetaExtensionContainerSpy; +#endif + +public: + /** + Finds the extension specified within the container + @param aTypeId The STypeId of the meta extension to find + @return A pointer to the meta extension or NULL if it wasn't found + */ + virtual const Meta::SMetaData* FindExtension(const Meta::STypeId& aTypeId) const; + + /** + Adds a meta extension to the container, which will take ownership on success. + @param aExtension The meta extension to add + @return KErrAlreadyExists If a meta extension of the same type is in the container + KErrNone If the meta extension was added successfully + Other system-wide error codes + */ + TInt AppendExtension(const Meta::SMetaData* aExtension); + + /** + Adds a meta extension to the container, which will take ownership on success. + @param aExtension The meta extension to add + @exception Leaves with KErrAlreadyExists If a meta extension of the same type is in the container, + or other system-wide error codes + */ + void AppendExtensionL(const Meta::SMetaData* aExtension); + + /** + Identifies obsolete containers in the chain and closes references to them + */ + void Compact(); + +protected: + /** + From CRefCountOwnerBase. Use to release any resources owned by the implementation. + It is called just before the object is deleted. Always call the DeletePtr in the base + class from your implementation. + */ + virtual void DeletePtr(); + +private: + // Never deleted directly + ~CMetaExtensionContainer(); + CMetaExtensionContainer(); + + // Only RMetaExtensionContainer/RMetaExtensionContainerC may create this class + static CMetaExtensionContainer* NewLC(const CMetaExtensionContainerImplBase* aBaseContainer); + void ConstructL(const CMetaExtensionContainerImplBase* aBaseContainer); + + /** + Retrieves the base meta extension container + @return A pointer to the base meta extension container, or NULL if it is a root base container + */ + const CMetaExtensionContainerImplBase* BaseContainer() const; + + /** + Sets the base container for branched meta extension containers + Can only be set once and should be set during construction. + The refcount on the base container will be incremented and owned by this CMetaExtensionContainerImplBase. + @param aBaseContainer The base meta extension container + */ + void SetBaseContainer(const CMetaExtensionContainerImplBase* aBaseContainer); + + /** + Remove the base container from the chain + */ + void RemoveBaseContainer(); + + /** + Find the specified extension by searching only this container + @param aTypeId The STypeId of the meta extension to find + @return A pointer to the meta extension or NULL if it wasn't found + */ + const Meta::SMetaData* FindExtensionInThisContainer(const Meta::STypeId& aTypeId) const; + +private: + const CMetaExtensionContainerImplBase* iBaseContainer; + mutable RPointerArray iExtensions; + }; + + + +/** +An implementation of a container of meta extension containers. This implementation can not +be created and used directly. RMetaExtensionContainer will create this implementation during +a call to AppendContainerL. +@prototype +@internalTechnology +*/ +NONSHARABLE_CLASS(CMetaExtensionContainerArray) : public CMetaExtensionContainerImplBase + { + friend class RMetaExtensionContainer; + friend class RMetaExtensionContainerC; +#ifdef MEC_UNITTEST + friend class ::TMetaExtensionContainerSpy; +#endif + +public: + /** + Finds the extension specified within the container + @param aTypeId The STypeId of the meta extension to find + @return A pointer to the meta extension or NULL if it wasn't found + */ + virtual const Meta::SMetaData* FindExtension(const Meta::STypeId& aTypeId) const; + + /** + Appends a container to the list of container implementations. + @aBaseContainer Appends an existing container. Extensions in aBaseContainer container will override + any extensions of the same type already present in the container this method is called on. + @return KErrNone on success + KErrAlreadyExists if the container is already in the array + or any other system-wide error code. + */ + TInt AppendContainer(const CMetaExtensionContainerImplBase& aContainer); + +protected: + /** + From CRefCountOwnerBase. Use to release any resources owned by the implementation. + It is called just before the object is deleted. Always call the DeletePtr in the base + class from your implementation. + */ + virtual void DeletePtr(); + +private: + // Never deleted directly + ~CMetaExtensionContainerArray(); + CMetaExtensionContainerArray(); + + // Only RMetaExtensionContainer/RMetaExtensionContainerC may create this class + static CMetaExtensionContainerArray* NewLC(const CMetaExtensionContainerImplBase* aBaseContainer); + void ConstructL(const CMetaExtensionContainerImplBase* aBaseContainer); + +private: + mutable RPointerArray iContainers; + }; + + + +inline CMetaExtensionContainerImplBase::TMetaExtensionContainerType CMetaExtensionContainerImplBase::Type() const + { + return iType; + } + +} // namespace ESock + + +#endif +// SYMBIAN_SS_CMETAEXTENSIONCONTAINER +