/*

* 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