/*

* Copyright (c) 2002 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: 

*     Wrap any function or method call to a class and ask CAsyncWrapper class

*		to call it after certain timeout

*

*

*

*/

#ifndef __TStaticWrapper_H__

#define __TStaticWrapper_H__

// INCLUDES

#include <e32base.h>

#include <e32svr.h>

//You can use these classes to call any method or function after certain time

//All of the method and function wrappers are derived from MStaticWrapper

//##ModelId=3EBA47ED027F

class MStaticWrapper

    {

    public:

        //##ModelId=3EBA47ED028A

        virtual void CallL() = 0;

    };

//Give the function or method wrapper to this class and the timeout

//##ModelId=3EBA47ED029A

class CAsyncCall : public CActive

    {

        //##ModelId=3EBA47ED029D

        MStaticWrapper* iWrapper;

        //##ModelId=3EBA47ED02AA

        TInt iLeaveCode;

        //##ModelId=3EBA47ED02AF

        RTimer iTimer;

    public:

        //##ModelId=3EBA47ED02B9

        static CAsyncCall* NewLC()

            {

            CAsyncCall* _that = new( ELeave )CAsyncCall;

            CleanupStack::PushL( _that );

            _that->ConstructL();

            return _that;

            }

        //##ModelId=3EBA47ED02BB

        static CAsyncCall* NewL()

            {

            CAsyncCall* _that = NewLC();

            CleanupStack::Pop();

            return _that;

            }

        //##ModelId=3EBA47ED02BD

        void Start( MStaticWrapper* aWrapper, TInt aTimeout )

            {

            if ( IsActive() )

                {

                User::Leave( KErrAlreadyExists );

                }

            iWrapper = aWrapper;

            iTimer.After( iStatus, aTimeout );

            SetActive();

            }

        //##ModelId=3EBA47ED02C9

        TInt LeaveCode() const

            {

            return iLeaveCode;

            }

        //##ModelId=3EBA47ED02CB

        void Stop()

            {

            iTimer.Cancel();

            Cancel();

            }

        //##ModelId=3EBA47ED02CC

        ~CAsyncCall()

            {

            Stop();

            iTimer.Cancel();

            iTimer.Close();

            }

    protected:

        //##ModelId=3EBA47ED02CD

        CAsyncCall()

                : CActive( CActive::EPriorityStandard )

            {

            CActiveScheduler::Add( this );

            }

        //##ModelId=3EBA47ED02CE

        void ConstructL()

            {

            User::LeaveIfError( iTimer.CreateLocal() );

            }

        //##ModelId=3EBA47ED02CF

        void RunL()

            {

            if ( iWrapper )

                {

                TRAP( iLeaveCode, iWrapper->CallL() );

                }

            }

        //##ModelId=3EBA47ED02D8

        void DoCancel()

            {

            }

        //##ModelId=3EBA47ED02D9

        TInt RunError( TInt /*aError*/ )

            {

            return KErrNone;

            }

    };

//This is same as the CAsyncWrapper class but the call will be made from another thread.

//Not tested

//##ModelId=3EBA47ED02E8

class CThreadCall : public CTimer

    {

        //##ModelId=3EBA47ED02F9

        MStaticWrapper* iWrapper;

    public:

        //##ModelId=3EBA47ED02FD

        CThreadCall()

                : CTimer( CActive::EPriorityStandard )

            {

            CActiveScheduler::Add( this );

            CTimer::ConstructL();

            }

        //##ModelId=3EBA47ED02FE

        ~CThreadCall()

            {

            }

        //##ModelId=3EBA47ED02FF

        void ThreadFunc()

            {

            iWrapper->CallL();

            }

        //##ModelId=3EBA47ED0307

        static TInt CallIt( TAny* aAny )

            {

            CTrapCleanup* tc = CTrapCleanup::New();

            CThreadCall* p = ( CThreadCall* )aAny;

            TRAPD( err, p->ThreadFunc() );

            delete tc;

            return KErrNone;

            }

        //##ModelId=3EBA47ED030A

        void StartCallingThread()

            {

            RThread t;

            t.Create( _L( "WrapperCompletingThread" ), CallIt, KDefaultStackSize, 0, 10000, this );

            t.Resume();

            t.Close();

            }

        //##ModelId=3EBA47ED030B

        void RunL()

            {

            if ( iWrapper )

                {

                StartCallingThread();

                }

            }

        //##ModelId=3EBA47ED030C

        void DoCancel()

            {

            }

        //##ModelId=3EBA47ED030D

        TInt RunError( TInt /*aError*/ )

            {

            return KErrNone;

            }

        //##ModelId=3EBA47ED0317

        void Start( MStaticWrapper* aWrapper, TInt aTimeout )

            {

            iWrapper = aWrapper;

            After( aTimeout );

            }

    };

/*

Use this class to "wrap" methods with return "normal" value ( "normal" return value IS NOT reference to some object or any value that can't be copied with assignment operator)

For example:

class CHomma

	{

	TInt DoIt( TInt aValue, const TDesC& aText );

	public:

	}

CHomma h;

_LIT( KText, "Text" );

TStaticWrapper<CHomma, TInt, TInt, const TDesC&> wrap( &h, &CHomma::DoIt, 10, KText );

iAsyncWrapper->Start( &wrap, 1000000 );

CAOWait::WaitLD( 1500000 );

wrap.ReturnValue();//returns the value that was returned by DoIt call

This example will call "h.DoIt( 10, KText)" after one second

*/

//##ModelId=3EBA47ED0346

template < class C, class R, class P1 = TInt, class P2 = TInt, class P3 = TInt, class P4 = TInt, class P5 = TInt >

class TStaticWrapper : public MStaticWrapper

    {

    public:

        //##ModelId=3EBA47ED03D2

        typedef R ( C::*TFuncType1 )();

        //##ModelId=3EBA47ED03D4

        typedef R ( C::*TFuncType2 )( P1 aP1 );

        //##ModelId=3EBA47ED03E2

        typedef R ( C::*TFuncType3 )( P1 aP1, P2 aP2 );

        //##ModelId=3EBA47ED03E4

        typedef R ( C::*TFuncType4 )( P1 aP1, P2 aP2, P3 aP3 );

        //##ModelId=3EBA47EE000B

        typedef R ( C::*TFuncType5 )( P1 aP1, P2 aP2, P3 aP3, P4 aP4 );

        //##ModelId=3EBA47EE000D

        typedef R ( C::*TFuncType6 )( P1 aP1, P2 aP2, P3 aP3, P4 aP4, P5 aP5 );

        //##ModelId=3EBA47ED035A

        TStaticWrapper( C* aTestClass, TFuncType1 aFunction )

                : iTestClass( aTestClass ), iF1( aFunction )

            {

            }

        //##ModelId=3EBA47ED035D

        TStaticWrapper( C* aTestClass, TFuncType2 aFunction, P1 aP1 )

                : iTestClass( aTestClass ), iF1( NULL ), iF2( aFunction ), iP1( aP1 )

            {

            }

        //##ModelId=3EBA47ED0361

        TStaticWrapper( C* aTestClass, TFuncType3 aFunction, P1 aP1 , P2 aP2  )

                : iTestClass( aTestClass ), iF1( NULL ), iF2( NULL ), iF3( aFunction ), iP1( aP1 ), iP2( aP2 )

            {

            }

        //##ModelId=3EBA47ED0366

        TStaticWrapper( C* aTestClass, TFuncType4 aFunction, P1 aP1 , P2 aP2, P3 aP3  )

                : iTestClass( aTestClass ), iF1( NULL ), iF2( NULL ), iF3( NULL ), iF4( aFunction ), iP1( aP1 ), iP2( aP2 ), iP3( aP3 )

            {

            }

        //##ModelId=3EBA47ED036C

        TStaticWrapper( C* aTestClass, TFuncType5 aFunction, P1 aP1 , P2 aP2, P3 aP3, P4 aP4  )

                : iTestClass( aTestClass ), iF1( NULL ), iF2( NULL ), iF3( NULL ), iF4( NULL ), iF5( aFunction ), iP1( aP1 ), iP2( aP2 ), iP3( aP3 ), iP4( aP4 )

            {

            }

        //##ModelId=3EBA47ED0375

        TStaticWrapper( C* aTestClass, TFuncType6 aFunction, P1 aP1 , P2 aP2, P3 aP3, P4 aP4, P5 aP5  )

                : iTestClass( aTestClass ), iF1( NULL ), iF2( NULL ), iF3( NULL ), iF4( NULL ), iF5( NULL ), iF6( aFunction ), iP1( aP1 ), iP2( aP2 ), iP3( aP3 ), iP4( aP4 ), iP5( aP5 )

            {

            }

        //##ModelId=3EBA47ED037D

        void CallL()

            {

            if ( iF1 )

                {

                iRet = ( iTestClass->*iF1 )();

                }

            else if ( iF2 )

                {

                iRet = ( iTestClass->*iF2 )( iP1 );

                }

            else if ( iF3 )

                {

                iRet = ( iTestClass->*iF3 )( iP1, iP2 );

                }

            else if ( iF4 )

                {

                iRet = ( iTestClass->*iF4 )( iP1, iP2, iP3 );

                }

            else if ( iF5 )

                {

                iRet = ( iTestClass->*iF5 )( iP1, iP2, iP3, iP4 );

                }

            else if ( iF6 )

                {

                iRet = ( iTestClass->*iF6 )( iP1, iP2, iP3, iP4, iP5 );

                }

            }

        //##ModelId=3EBA47ED037E

        R& ReturnValue()

            {

            return iRet;

            }

    private:

        //##ModelId=3EBA47ED037F

        C* iTestClass;

        //##ModelId=3EBA47ED0384

        P1 iP1;

        //##ModelId=3EBA47ED0385

        P2 iP2;

        //##ModelId=3EBA47ED0386

        P3 iP3;

        //##ModelId=3EBA47ED0387

        P4 iP4;

        //##ModelId=3EBA47ED0388

        P5 iP5;

        //##ModelId=3EBA47ED0394

        R iRet;

        //##ModelId=3EBA47ED0396

        TFuncType1 iF1;

        //##ModelId=3EBA47ED03A4

        TFuncType2 iF2;

        //##ModelId=3EBA47ED03A9

        TFuncType3 iF3;

        //##ModelId=3EBA47ED03B4

        TFuncType4 iF4;

        //##ModelId=3EBA47ED03B9

        TFuncType5 iF5;

        //##ModelId=3EBA47ED03C4

        TFuncType6 iF6;

    };

/*

Use this class to "wrap" methods without return value

For example:

class CHomma

	{

	void DoIt( TInt aValue, const TDesC& aText );

	public:

	}

CHomma h;

_LIT( KText, "Text" );

TStaticWrapperVoid<CHomma, TInt, const TDesC&> wrap( &h, &CHomma::DoIt, 10, KText );

iAsyncWrapper->Start( &wrap, 1000000 );

CAOWait::WaitLD( 1500000 );

This example will call "h.DoIt( 10, KText)" after one second

*/

//##ModelId=3EBA47EE0077

template < class C, class P1 = TInt, class P2 = TInt, class P3 = TInt, class P4 = TInt, class P5 = TInt, class P6 = TInt, class P7 = TInt, class P8 = TInt >

class TStaticWrapperVoid : public MStaticWrapper

    {

    public:

        //##ModelId=3EBA47EE0147

        typedef void ( C::*TFuncType1 )();

        //##ModelId=3EBA47EE0153

        typedef void ( C::*TFuncType2 )( P1 aP1 );

        //##ModelId=3EBA47EE0161

        typedef void ( C::*TFuncType3 )( P1 aP1, P2 aP2 );

        //##ModelId=3EBA47EE0163

        typedef void ( C::*TFuncType4 )( P1 aP1, P2 aP2, P3 aP3 );

        //##ModelId=3EBA47EE0171

        typedef void ( C::*TFuncType5 )( P1 aP1, P2 aP2, P3 aP3, P4 aP4 );

        //##ModelId=3EBA47EE0173

        typedef void ( C::*TFuncType6 )( P1 aP1, P2 aP2, P3 aP3, P4 aP4, P5 aP5 );

        //##ModelId=3EBA47EE0182

        typedef void ( C::*TFuncType7 )( P1 aP1, P2 aP2, P3 aP3, P4 aP4, P5 aP5, P6 aP6 );

        //##ModelId=3EBA47EE0190

        typedef void ( C::*TFuncType8 )( P1 aP1, P2 aP2, P3 aP3, P4 aP4, P5 aP5, P6 aP6, P7 aP7 );

        //##ModelId=3EBA47EE0192

        typedef void ( C::*TFuncType9 )( P1 aP1, P2 aP2, P3 aP3, P4 aP4, P5 aP5, P6 aP6, P7 aP7, P8 aP8 );

        //##ModelId=3EBA47EE0092

        TStaticWrapperVoid( C* aTestClass, TFuncType1 aFunction )

                : iTestClass( aTestClass ), iF1( aFunction )

            {

            }

        //##ModelId=3EBA47EE0095

        TStaticWrapperVoid( C* aTestClass, TFuncType2 aFunction, P1 aP1 )

                : iTestClass( aTestClass ), iF1( NULL ), iF2( aFunction ), iP1( aP1 )

            {

            }

        //##ModelId=3EBA47EE0099

        TStaticWrapperVoid( C* aTestClass, TFuncType3 aFunction, P1 aP1 , P2 aP2  )

                : iTestClass( aTestClass ), iF1( NULL ), iF2( NULL ), iF3( aFunction ), iP1( aP1 ), iP2( aP2 )

            {

            }

        //##ModelId=3EBA47EE009E

        TStaticWrapperVoid( C* aTestClass, TFuncType4 aFunction, P1 aP1 , P2 aP2, P3 aP3  )

                : iTestClass( aTestClass ), iF1( NULL ), iF2( NULL ), iF3( NULL ), iF4( aFunction ), iP1( aP1 ), iP2( aP2 ), iP3( aP3 )

            {

            }

        //##ModelId=3EBA47EE00A4

        TStaticWrapperVoid( C* aTestClass, TFuncType5 aFunction, P1 aP1 , P2 aP2, P3 aP3, P4 aP4  )

                : iTestClass( aTestClass ), iF1( NULL ), iF2( NULL ), iF3( NULL ), iF4( NULL ), iF5( aFunction ), iP1( aP1 ), iP2( aP2 ), iP3( aP3 ), iP4( aP4 )

            {

            }

        //##ModelId=3EBA47EE00AC

        TStaticWrapperVoid( C* aTestClass, TFuncType6 aFunction, P1 aP1 , P2 aP2, P3 aP3, P4 aP4, P5 aP5  )

                : iTestClass( aTestClass ), iF1( NULL ), iF2( NULL ), iF3( NULL ), iF4( NULL ), iF5( NULL ), iF6( aFunction ), iP1( aP1 ), iP2( aP2 ), iP3( aP3 ), iP4( aP4 ), iP5( aP5 )

            {

            }

        //##ModelId=3EBA47EE00B5

        TStaticWrapperVoid( C* aTestClass, TFuncType7 aFunction, P1 aP1 , P2 aP2, P3 aP3, P4 aP4, P5 aP5, P6 aP6  )

                : iTestClass( aTestClass ), iF1( NULL ), iF2( NULL ), iF3( NULL ), iF4( NULL ), iF5( NULL ), iF6( NULL ), iF7( aFunction ), iP1( aP1 ), iP2( aP2 ), iP3( aP3 ), iP4( aP4 ), iP5( aP5 ), iP6( aP6 )

            {

            }

        //##ModelId=3EBA47EE00BE

        TStaticWrapperVoid( C* aTestClass, TFuncType8 aFunction, P1 aP1 , P2 aP2, P3 aP3, P4 aP4, P5 aP5, P6 aP6, P7 aP7  )

                : iTestClass( aTestClass ), iF1( NULL ), iF2( NULL ), iF3( NULL ), iF4( NULL ), iF5( NULL ), iF6( NULL ), iF7( NULL ), iF8( aFunction ), iP1( aP1 ), iP2( aP2 ), iP3( aP3 ), iP4( aP4 ), iP5( aP5 ), iP6( aP6 ), iP7( aP7 )

            {

            }

        //##ModelId=3EBA47EE00C9

        TStaticWrapperVoid( C* aTestClass, TFuncType9 aFunction, P1 aP1 , P2 aP2, P3 aP3, P4 aP4, P5 aP5, P6 aP6, P7 aP7, P8 aP8  )

                : iTestClass( aTestClass ), iF1( NULL ), iF2( NULL ), iF3( NULL ), iF4( NULL ), iF5( NULL ), iF6( NULL ), iF7( NULL ), iF8( NULL ), iF9( aFunction ), iP1( aP1 ), iP2( aP2 ), iP3( aP3 ), iP4( aP4 ), iP5( aP5 ), iP6( aP6 ), iP7( aP7 ), iP8( aP8 )

            {

            }

        //##ModelId=3EBA47EE00D5

        void CallL()

            {

            if ( iF1 )

                {

                ( iTestClass->*iF1 )();

                }

            else if ( iF2 )

                {

                ( iTestClass->*iF2 )( iP1 );

                }

            else if ( iF3 )

                {

                ( iTestClass->*iF3 )( iP1, iP2 );

                }

            else if ( iF4 )

                {

                ( iTestClass->*iF4 )( iP1, iP2, iP3 );

                }

            else if ( iF5 )

                {

                ( iTestClass->*iF5 )( iP1, iP2, iP3, iP4 );

                }

            else if ( iF6 )

                {

                ( iTestClass->*iF6 )( iP1, iP2, iP3, iP4, iP5 );

                }

            else if ( iF7 )

                {

                ( iTestClass->*iF7 )( iP1, iP2, iP3, iP4, iP5, iP6 );

                }

            else if ( iF8 )

                {

                ( iTestClass->*iF8 )( iP1, iP2, iP3, iP4, iP5, iP6, iP7 );

                }

            else if ( iF9 )

                {

                ( iTestClass->*iF9 )( iP1, iP2, iP3, iP4, iP5, iP6, iP7, iP8 );

                }

            }

    private:

        //##ModelId=3EBA47EE00D6

        C* iTestClass;

        //##ModelId=3EBA47EE00D7

        P1 iP1;

        //##ModelId=3EBA47EE00D8

        P2 iP2;

        //##ModelId=3EBA47EE00D9

        P3 iP3;

        //##ModelId=3EBA47EE00DA

        P4 iP4;

        //##ModelId=3EBA47EE00E4

        P5 iP5;

        //##ModelId=3EBA47EE00E5

        P6 iP6;

        //##ModelId=3EBA47EE00E6

        P7 iP7;

        //##ModelId=3EBA47EE00E7

        P8 iP8;

        //##ModelId=3EBA47EE00F5

        TFuncType1 iF1;

        //##ModelId=3EBA47EE0105

        TFuncType2 iF2;

        //##ModelId=3EBA47EE010A

        TFuncType3 iF3;

        //##ModelId=3EBA47EE0114

        TFuncType4 iF4;

        //##ModelId=3EBA47EE0119

        TFuncType5 iF5;

        //##ModelId=3EBA47EE0124

        TFuncType6 iF6;

        //##ModelId=3EBA47EE0129

        TFuncType7 iF7;

        //##ModelId=3EBA47EE0133

        TFuncType8 iF8;

        //##ModelId=3EBA47EE0143

        TFuncType9 iF9;

    };

/*

Use this class to "wrap" methods that return a reference or any value that can't be copied with assignment operator

For example:

class CHomma

	{

	const TDesC& DoIt( TInt aValue, const TDesC& aText );

	public:

	}

CHomma h;

_LIT( KText, "Text" );

TStaticWrapper<CHomma, const TDesC&, const TDesC, TInt, const TDesC&> wrap( &h, &CHomma::DoIt, 10, KText );

iAsyncWrapper->Start( &wrap, 1000000 );

CAOWait::WaitLD( 1500000 );