--- /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 <e32base.h>
+
+// 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 T>
+ 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 T>
+ class CCloseDelete : public CBase
+ {
+ public:
+ CCloseDelete(T* aPtr) : iPtr(aPtr) {}
+ ~CCloseDelete()
+ {
+ iPtr->Close();
+ delete iPtr;
+ }
+
+ private:
+ T* iPtr;
+ };
+
+ // Release an object
+ template <class T>
+ 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 <class T>
+ TInt AddDeleteOnly(T* aPtr)
+ {
+ return AddDeleteAction(new CDeleteOnly<T>(aPtr));
+ }
+
+ // adds a pointer which is to be closed and deleted
+ template <class T>
+ TInt AddCloseDelete(T* aPtr)
+ {
+ return AddDeleteAction(new CCloseDelete<T>(aPtr));
+ }
+
+ // adds a pointer which is to be released
+ template <class T>
+ TInt AddReleaseOnly(T* aPtr)
+ {
+ return AddDeleteAction(new CReleaseOnly<T>(aPtr));
+ }
+
+private:
+ // Adds a deleted action
+ TInt AddDeleteAction(CBase* aAction);
+
+private:
+ RPointerArray<CBase> iDeleteActions;
+ };
+
+// Implementation of RunPackage where callback takes no parameters
+template <class T>
+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 T, class P1>
+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 T, class P1, class P2>
+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 T, class P1, class P2, class P3>
+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 T, class P1, class P2, class P3, class P4>
+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 T, class P1, class P2, class P3, class P4, class P5>
+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 T, class P1, class P2, class P3, class P4, class P5, class P6>
+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