/*

 * 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