diff -r 000000000000 -r 2c201484c85f cryptoservices/filebasedcertificateandkeystores/source/generic/server/FSRunPackage.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/cryptoservices/filebasedcertificateandkeystores/source/generic/server/FSRunPackage.h Wed Jul 08 11:25:26 2009 +0100 @@ -0,0 +1,307 @@ +/* +* 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 the License "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: +* +*/ + + + + + + +/** + @file + @internalTechnology +*/ + +#ifndef _FSRUNPACKAGE_H +#define _FSRUNPACKAGE_H + +#include + +// Disable WINS warning for symbol being too long (especially for template +// instantiations) +#ifdef __WINS__ +#pragma warning(disable : 4786) +#endif + +// The CRunPackage class allows a CActive derived object to "callback" +// a member function with given parameters when the RunL function is called. +// +// It packages up the function call and the parameters into an object. +// This saves you on having to have all these different member variables +// to store parameters in an async call. +// +// The way this works is to create a member CRunPackage contained in +// your class. Your RunL would simply be +// +// if (iRunPackage) +// { +// iRunPackage->ExecuteL(); +// } +// +// And you set your iRunPackage by doing +// iRunPackage = CRunPackage2<....>(this, function, param1, param2); +// +// In addition, CRunPackage encapsulates transient variables allocated on +// the heap which must be destroyed when the CRunPackage object is destroyed. +// +// These objects can be added by calling the AddDeleteOnly, AddCloseDelete, +// and AddReleaseOnly methods. When CRunPackage is destroyed, these objects +// will be deleted. +class CRunPackage : public CBase + { +private: + // Private classes derived from CBase whose destructors release transient + // resources when the RunPackage is destroyed + template + class CDeleteOnly : public CBase + { + public: + CDeleteOnly(T* aPtr) : iPtr(aPtr) {} + ~CDeleteOnly() { delete iPtr; } + + private: + T* iPtr; + }; + + // Close and delete an object - this is required for pointers to R classes + template + class CCloseDelete : public CBase + { + public: + CCloseDelete(T* aPtr) : iPtr(aPtr) {} + ~CCloseDelete() + { + iPtr->Close(); + delete iPtr; + } + + private: + T* iPtr; + }; + + // Release an object + template + class CReleaseOnly : public CBase + { + public: + CReleaseOnly(T* aPtr) : iPtr(aPtr) {} + ~CReleaseOnly() { iPtr->Release(); } + + private: + T* iPtr; + }; + +public: + // when the destructor is invoked, if there is an iDeleteAction, its + // destructor will be invoked + virtual ~CRunPackage(); + virtual void ExecuteL() = 0; + + // Operations to add delete operations + template + TInt AddDeleteOnly(T* aPtr) + { + return AddDeleteAction(new CDeleteOnly(aPtr)); + } + + // adds a pointer which is to be closed and deleted + template + TInt AddCloseDelete(T* aPtr) + { + return AddDeleteAction(new CCloseDelete(aPtr)); + } + + // adds a pointer which is to be released + template + TInt AddReleaseOnly(T* aPtr) + { + return AddDeleteAction(new CReleaseOnly(aPtr)); + } + +private: + // Adds a deleted action + TInt AddDeleteAction(CBase* aAction); + +private: + RPointerArray iDeleteActions; + }; + +// Implementation of RunPackage where callback takes no parameters +template +class CRunPackage0 : public CRunPackage + { +public: + typedef void (T::*TRunFn)(); + + CRunPackage0(T& aParent, TRunFn aRunFn) + : iParent(aParent), iRunFn(aRunFn) {} + + void ExecuteL() + { + (iParent.*iRunFn)(); + } + +private: + T& iParent; + TRunFn iRunFn; + }; + + +// implementation which takes one parameter +template +class CRunPackage1 : public CRunPackage + { +public: + typedef void (T::*TRunFn)(P1); + + CRunPackage1(T& aParent, TRunFn aRunFn, P1 aP1) + : iParent(aParent), iRunFn(aRunFn), iP1(aP1) {} + + void ExecuteL() + { + (iParent.*iRunFn)(iP1); + } + +private: + T& iParent; + TRunFn iRunFn; + P1 iP1; + }; + +// implementation which takes two parameters +template +class CRunPackage2 : public CRunPackage + { +public: + typedef void (T::*TRunFn)(P1, P2); + + CRunPackage2(T& aParent, TRunFn aRunFn, P1 aP1, P2 aP2) + : iParent(aParent), iRunFn(aRunFn), iP1(aP1), iP2(aP2) {} + + void ExecuteL() + { + (iParent.*iRunFn)(iP1, iP2); + } + +private: + T& iParent; + TRunFn iRunFn; + P1 iP1; + P2 iP2; + }; + +// implementation which takes three parameters +template +class CRunPackage3 : public CRunPackage + { +public: + typedef void (T::*TRunFn)(P1, P2, P3); + + CRunPackage3(T& aParent, TRunFn aRunFn, P1 aP1, P2 aP2, P3 aP3) + : iParent(aParent), iRunFn(aRunFn), iP1(aP1), iP2(aP2), iP3(aP3) {} + + void ExecuteL() + { + (iParent.*iRunFn)(iP1, iP2, iP3); + } + +private: + T& iParent; + TRunFn iRunFn; + P1 iP1; + P2 iP2; + P3 iP3; + }; + +// implementation which takes four parameters +template +class CRunPackage4 : public CRunPackage + { +public: + typedef void (T::*TRunFn)(P1, P2, P3, P4); + + CRunPackage4(T& aParent, TRunFn aRunFn, P1 aP1, P2 aP2, P3 aP3, P4 aP4) + : iParent(aParent), iRunFn(aRunFn), iP1(aP1), iP2(aP2), iP3(aP3), iP4(aP4) {} + + void ExecuteL() + { + (iParent.*iRunFn)(iP1, iP2, iP3, iP4); + } + +private: + T& iParent; + TRunFn iRunFn; + P1 iP1; + P2 iP2; + P3 iP3; + P4 iP4; + }; + +// implementation which takes four parameters +template +class CRunPackage5 : public CRunPackage + { +public: + typedef void (T::*TRunFn)(P1, P2, P3, P4, P5); + + CRunPackage5(T& aParent, TRunFn aRunFn, P1 aP1, P2 aP2, P3 aP3, P4 aP4, P5 aP5) + : iParent(aParent), iRunFn(aRunFn), iP1(aP1), iP2(aP2), iP3(aP3), + iP4(aP4), iP5(aP5) {} + + void ExecuteL() + { + (iParent.*iRunFn)(iP1, iP2, iP3, iP4, iP5); + } + +private: + T& iParent; + TRunFn iRunFn; + P1 iP1; + P2 iP2; + P3 iP3; + P4 iP4; + P5 iP5; + }; + +// implementation which takes four parameters +template +class CRunPackage6 : public CRunPackage + { +public: + typedef void (T::*TRunFn)(P1, P2, P3, P4, P5, P6); + + CRunPackage6(T& aParent, TRunFn aRunFn, P1 aP1, P2 aP2, P3 aP3, P4 aP4, P5 aP5, P6 aP6) + : iParent(aParent), iRunFn(aRunFn), iP1(aP1), iP2(aP2), iP3(aP3), + iP4(aP4), iP5(aP5), iP6(aP6) {} + + void ExecuteL() + { + (iParent.*iRunFn)(iP1, iP2, iP3, iP4, iP5, iP6); + } + +private: + T& iParent; + TRunFn iRunFn; + P1 iP1; + P2 iP2; + P3 iP3; + P4 iP4; + P5 iP5; + P6 iP6; + }; + + +#endif