// Copyright (c) 2007-2009 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:

// generic framework node states templates and helper macros

// 

//

/**

 @file

 @publishedPartner

 @released

*/

#ifndef SYMBIAN_MM_STATES_H

#define SYMBIAN_MM_STATES_H

#include <elements/sm_core.h>

#include <elements/mm_context.h>

#include <elements/mm_log.h>

#include <elements/mm_activities.h> //for AContextStore, logging only

#include <elements/nm_signatures.h>

#ifdef _DEBUG

// Panic category for "absolutely impossible!" vanilla ASSERT()-type panics from this module

// (if it could happen through user error then you should give it an explicit, documented, category + code)

_LIT(KSpecAssert_ElemMeshMachStaH, "ElemMeshMachStaH");

#endif

//-=========================================================

//

// MACROS

//

//-=========================================================

#define DECLARE_SMELEMENT_HEADER(element, base, intf, context) \

NONSHARABLE_CLASS(element) : public base \

	{ \

public:	\

	explicit element(context& aContext) : \

	    base(aContext) {} \

	NETSM_DECLARE_CTR(intf)

#define EXPORT_DECLARE_SMELEMENT_HEADER(element, base, intf, context) \

class element : public base \

	{ \

public:	\

	explicit element(context& aContext) : \

	    base(aContext) {} \

	EXPORT_NETSM_DECLARE_CTR(intf) \

#define DECLARE_SMELEMENT_FOOTER(element) \

	}; \

#define DEFINE_SMELEMENT(element, intf, context) \

	NETSM_DEFINE_CTR(element, intf, context) \

#define EXPORT_DEFINE_SMELEMENT(element, intf, context) \

	EXPORT_NETSM_DEFINE_CTR(element, intf, context) \

#define DECLARE_AGGREGATED_TRANSITION2(Name, T1, T2) \

typedef MeshMachine::TAggregatedTransition<T1, T2, TContext> Name;

#define DECLARE_AGGREGATED_TRANSITION3(Name, T1, T2, T3) \

DECLARE_AGGREGATED_TRANSITION2(Name##Name__TR3, T1, T2) \

DECLARE_AGGREGATED_TRANSITION2(Name, Name##Name__TR3, T3)

#define DECLARE_AGGREGATED_TRANSITION4(Name, T1, T2, T3, T4) \

DECLARE_AGGREGATED_TRANSITION3(Name##Name__TR4, T1, T2, T3) \

DECLARE_AGGREGATED_TRANSITION2(Name, Name##Name__TR4, T4)

#define DECLARE_AGGREGATED_TRANSITION5(Name, T1, T2, T3, T4, T5) \

DECLARE_AGGREGATED_TRANSITION3(Name##Name__TR5, T1, T2, T3) \

DECLARE_AGGREGATED_TRANSITION3(Name, Name##Name__TR5, T4, T5)

#define DECLARE_AGGREGATED_TRANSITION6(Name, T1, T2, T3, T4, T5, T6) \

DECLARE_AGGREGATED_TRANSITION4(Name##Name__TR6, T1, T2, T3, T4) \

DECLARE_AGGREGATED_TRANSITION3(Name, Name##Name__TR6, T5, T6)

#define DECLARE_AGGREGATED_TRANSITION7(Name, T1, T2, T3, T4, T5, T6, T7) \

DECLARE_AGGREGATED_TRANSITION4(Name##Name__TR7, T1, T2, T3, T4) \

DECLARE_AGGREGATED_TRANSITION4(Name, Name##Name__TR7, T5, T6, T7)

#define DECLARE_SERIALIZABLE_STATE(Name, Policy, State) \

typedef MeshMachine::TSerializableStateFork<Policy, State> Name;

#define DECLARE_SERIALIZABLE_STATE_WITH_ERRORTAG(Name, Policy, ErrorTagPolicy, State) \

typedef MeshMachine::TSerializableStateFork<Policy, State> Name;

#define DECLARE_SERIALIZABLE_TRANSITION(Name, Policy, StateTransition) \

typedef MeshMachine::TSerializableTransition<Policy, StateTransition> Name;

namespace MeshMachine

{

//In an (unusual) case where an MState needs to raise

//raise an error, it can produce KErrorTag as its

//transition tag. The way the actual error code

//is conveyed is undefined at this level. It is suggested

//to use the context for that. It is herby enforced to

//use a naming convention for states that can raise

//an error 'E' suffix (e.g.: AwaitSomethingE).

const TInt KNoTag                       = NetStateMachine::KExecuteAlways - 3;

const TInt KErrorTag                    = NetStateMachine::KExecuteAlways - 4;

const TInt KCancelTag                   = NetStateMachine::KExecuteAlways - 5;

const TInt KActiveTag                   = NetStateMachine::KExecuteAlways - 6;

class AMMNodeBase;

typedef MeshMachine::TNodeContext<AMMNodeBase> TContext;

//-=========================================================

//

//Default cancel handling for states

//

//-=========================================================

template <class TCONTEXT>

class TState : public NetStateMachine::AContext<TCONTEXT>,

               public NetStateMachine::MState

    {

public:

	NETSM_TPL_DECLARE_CTR(TState, NetStateMachine::MState, TCONTEXT)

	typedef TCONTEXT TContext;

    TState(TCONTEXT& aContext) :

        NetStateMachine::AContext<TCONTEXT>(aContext)

        {

        }

	virtual void Cancel()

        {

        if (this->iContext.iNodeActivity)

        	{

        	this->iContext.iNodeActivity->SetError(KErrCancel);

        	}

        }

    };

//-=========================================================

//

// Default error handling State Transition

//

//-=========================================================

template <class TCONTEXT>

class TStateTransition : public NetStateMachine::AContext<TCONTEXT>,

                         public NetStateMachine::MStateTransition

    {

public:

	NETSM_TPL_DECLARE_CTR(TStateTransition, NetStateMachine::MStateTransition, TCONTEXT)

	typedef TCONTEXT TContext;

    TStateTransition(TCONTEXT& aContext) :

        NetStateMachine::AContext<TCONTEXT>(aContext)

        {

        }

	virtual void Error( TInt aError )

	    {

        NetStateMachine::AContext<TCONTEXT>::iContext.iReturn = aError;

        if(NetStateMachine::AContext<TCONTEXT>::iContext.iNodeActivity != NULL)

        	{

        	NetStateMachine::AContext<TCONTEXT>::iContext.iNodeActivity->SetError(aError);

	        NetStateMachine::AContext<TCONTEXT>::iContext.iNodeActivity->SetIdle(); //By default, set activity to idle

        	}

        }

    };

//-=========================================================

//

//Default state fork

//

//-=========================================================

template <class TCONTEXT>

class TStateFork : public NetStateMachine::AContext<TCONTEXT>,

                   public NetStateMachine::MStateFork

    {

public:

    NETSM_TPL_DECLARE_CTR(TStateFork, NetStateMachine::MStateTransition, TCONTEXT)

	typedef TCONTEXT TContext;

    TStateFork(TCONTEXT& aContext) :

        NetStateMachine::AContext<TCONTEXT>(aContext)

        {

        }

	virtual TInt TransitionTag()

    	{

    	return KNoTag | NetStateMachine::EForward;

    	}

    };

//-=========================================================

//

//Serializable states & transitions

//

//-=========================================================

template <TInt ERRORTAG>

class TStateErrorTransitionTag

	{

public:

	static TInt ErrorTag(const TNodeContextBase& /*aContext*/) { return ERRORTAG; };

	};

template <class TPOLICY, typename TSTATEFORK, class TERRORTAGPOLICY = TStateErrorTransitionTag<KErrorTag> >

class TSerializableStateFork : public TSTATEFORK

    {

public:

	typedef typename TSTATEFORK::TContext TContext;

	NETSM_TPL_DECLARE_CTR(TSerializableStateFork, NetStateMachine::MStateFork, TContext)

    TSerializableStateFork(TContext& aContext)

    :	TSTATEFORK(aContext)

		{

		}

	virtual TInt TransitionTag()

    	{

    	if (TPOLICY::IsBlocked(TSTATEFORK::iContext))

    		{

    		return (AActivitySemaphore::ParkState(TSTATEFORK::iContext)==KErrNone)?

    			NetStateMachine::EIgnore : TERRORTAGPOLICY::ErrorTag(TSTATEFORK::iContext);

    		}

    	else

    		{

		   	MeshMachine::AActivitySemaphore* as = static_cast<MeshMachine::AActivitySemaphore*>(TSTATEFORK::iContext.iNodeActivity->FetchExtInterface(MeshMachine::AActivitySemaphore::KInterfaceId));

			__ASSERT_DEBUG(as, User::Panic(KSpecAssert_ElemMeshMachStaH, 1)); //State/transition mismatched with the activity object (activity doesn't support serialisation - wrong derivation?)

			// Log whether the state unparked

			if(as->IsWaiting())

				{

				AActivitySemaphore::UnparkState(TSTATEFORK::iContext);

				}

    		return TSTATEFORK::TransitionTag();

    		}

    	}

    };

template <class TPOLICY, typename TSTATETRANSITION>

class TSerializableTransition : public TSTATETRANSITION

    {

public:

	typedef typename TSTATETRANSITION::TContext TContext;

	NETSM_TPL_DECLARE_CTR(TSerializableTransition, NetStateMachine::MStateTransition, TContext)

    TSerializableTransition(TContext& aContext)

    :	TSTATETRANSITION(aContext)

		{

		}

    virtual void DoL()

    	{

   		//If this assertion fires, the serilisable transition has been

   		//wrongly positioned in the first triple of its activity.

   		__ASSERT_DEBUG(TSTATETRANSITION::iContext.iNodeActivity, User::Panic(KSpecAssert_ElemMeshMachStaH, 2));

    	if (TPOLICY::IsBlocked(TSTATETRANSITION::iContext))

    		{

    		AActivitySemaphore::ParkTransitionL(TSTATETRANSITION::iContext);

    		}

    	else

    		{

#ifdef SYMBIAN_TRACE_ENABLE

			// Log whether the transition unparked

		   	MeshMachine::AActivitySemaphore* as = static_cast<MeshMachine::AActivitySemaphore*>(TSTATETRANSITION::iContext.iNodeActivity->FetchExtInterface(MeshMachine::AActivitySemaphore::KInterfaceId));

			__ASSERT_DEBUG(as, User::Panic(KSpecAssert_ElemMeshMachStaH, 3)); //State/transition mismatched with the activity object (activity doesn't support serialisation - wrong derivation?)

			if(as->IsWaiting())

				{

				MESH_LOG_CONTEXT_EXT(KMeshMachineSubTag, TSTATETRANSITION::iContext, _L8("TSerializableTransition::DoL unparked"));

				}

#endif

    		TSTATETRANSITION::DoL();

    		}

    	}

    };

//-=========================================================

//

//Aggregated transitions

//

//-=========================================================

template <class T1, class T2, class TCONTEXT>

class TAggregatedTransition : public TStateTransition<TCONTEXT>

    {

public:

	NETSM_TPL_DECLARE_CTR(TAggregatedTransition, NetStateMachine::MStateTransition, TCONTEXT)

    TAggregatedTransition(TCONTEXT& aContext)

    :	TStateTransition<TCONTEXT>(aContext)

        {

        }

	virtual void DoL()

    	{

    	T1 t1(NetStateMachine::AContext<TCONTEXT>::iContext);

    	T2 t2(NetStateMachine::AContext<TCONTEXT>::iContext);

    	t1.DoL();

    	t2.DoL();

    	}

	virtual void Error(TInt aError)

    	{

    	T1 t1(NetStateMachine::AContext<TCONTEXT>::iContext);

    	T2 t2(NetStateMachine::AContext<TCONTEXT>::iContext);

    	t1.Error(aError);

    	t2.Error(aError);

    	}

    };

//-=========================================================

//

//Commonly used states

//

//-=========================================================

template<typename TMESSAGE>

class TAwaitingMessageState : public MeshMachine::TState<MeshMachine::TContext>

	{

public:

	NETSM_TPL_DECLARE_CTR(TAwaitingMessageState, NetStateMachine::MState, MeshMachine::TContext)

	explicit TAwaitingMessageState(MeshMachine::TContext& aContext) :

		MeshMachine::TState<MeshMachine::TContext>(aContext) {}

	virtual TBool Accept()

		{

#ifdef __GCCXML__

		return EFalse;

#else

		Messages::TNodeSignal& msg = this->iContext.iMessage; //Arm compiler is getting confused otherwise

		return msg.IsMessage<TMESSAGE>();

#endif

		}

	};

template<typename TMESSAGE1, class TMESSAGE2>

class TAwaiting2MessagesState : public MeshMachine::TState<TContext>

	{

public:

	NETSM_TPL_DECLARE_CTR(TAwaiting2MessagesState, NetStateMachine::MState, TContext)

	explicit TAwaiting2MessagesState(TContext& aContext) :

		MeshMachine::TState<TContext>(aContext) {}

	virtual TBool Accept()

			{

#ifdef __GCCXML__

			return EFalse;

#else

			Messages::TNodeSignal& msg = this->iContext.iMessage; //Arm compiler is getting confused otherwise

			return msg.IsMessage<TMESSAGE1>()

				|| msg.IsMessage<TMESSAGE2>();

#endif

			}

	};

template<typename TMESSAGE, TUint32 FlagsToSet = 0, TUint32 FlagsToClear = 0>

class TAwaitingPeerMessage : public MeshMachine::TState<TContext>

    {

public:

	NETSM_TPL_DECLARE_CTR(TAwaitingPeerMessage, NetStateMachine::MState, TContext)

    TAwaitingPeerMessage(TContext& aContext) :

        MeshMachine::TState<TContext>(aContext)

        {

        }

	virtual TBool Accept()

    	{

#ifndef __GCCXML__

		Messages::TNodeSignal& msg = this->iContext.iMessage; //Arm compiler is getting confused otherwise

		if (msg.IsMessage<TMESSAGE>())

			{

			__ASSERT_DEBUG(this->iContext.iPeer, User::Panic(KSpecAssert_ElemMeshMachStaH, 4));

			this->iContext.iPeer->ClearFlags(FlagsToClear);

			this->iContext.iPeer->SetFlags(FlagsToSet);

			return ETrue;

			}

#endif

		return EFalse;

    	}

    };

class AAcceptErrorState

    {

protected:

	IMPORT_C static TBool Accept(MeshMachine::TNodeContextBase& aContext, TBool aSuperAccept);

	};

template<class TSTATE>

class TAcceptErrorState  : public TSTATE, public AAcceptErrorState

    {

public:

	typedef typename TSTATE::TContext TContext;

	NETSM_TPL_DECLARE_CTR(TAcceptErrorState, NetStateMachine::MState, TContext)

    explicit TAcceptErrorState(TContext& aContext)

    :	TSTATE(aContext)

        {

        }

	virtual TBool Accept()

    	{

    	return AAcceptErrorState::Accept(this->iContext, TSTATE::Accept());

    	}

 	virtual void Cancel()

        {

        if(this->iContext.iNodeActivity != NULL)

        	{

        	this->iContext.iNodeActivity->SetError(KErrCancel);

        	}

        TSTATE::Cancel();

        }

    };

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingNull, TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingNull )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingAny, TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingAny )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingClientLeavingRequest, TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingClientLeavingRequest )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingLeaveComplete, TState<TContext>, NetStateMachine::MState, TContext )

    IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingLeaveComplete )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingDestroy, TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingDestroy )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingCancel, TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingCancel )

EXPORT_DECLARE_SMELEMENT_HEADER( TAwaitingErrorRecoveryResponseOrError, TState<TContext>, NetStateMachine::MState, TContext )

	IMPORT_C virtual TBool Accept();

DECLARE_SMELEMENT_FOOTER( TAwaitingErrorRecoveryResponseOrError )

//-=========================================================

//

//Commonly used state forks

//

//-=========================================================

template<TInt TAG>

class TTag : public MeshMachine::TStateFork<TContext>

    {

public:

	NETSM_TPL_DECLARE_CTR(TTag, NetStateMachine::MStateFork, TContext)

    TTag(TContext& aContext)

    :	MeshMachine::TStateFork<TContext>(aContext)

        {

        }

	virtual TInt TransitionTag()

    	{

    	return TAG;

    	}

    };

template<TInt ACTIVITYSIG>

class TActiveOrNoTag  : public MeshMachine::TStateFork<TContext>

    {

public:

	NETSM_TPL_DECLARE_CTR(TActiveOrNoTag, NetStateMachine::MStateFork, TContext)

    explicit TActiveOrNoTag(TContext& aContext)

    :	MeshMachine::TStateFork<TContext>(aContext)

        {

        }

 	virtual TInt TransitionTag()

     	{

		return (this->iContext.iNode.CountActivities(ACTIVITYSIG))?

			MeshMachine::KActiveTag : MeshMachine::KNoTag;

     	}

     };

class AErrorTagOr

    {

protected:

	IMPORT_C static TInt TransitionTag(MeshMachine::TNodeContextBase& aContext);

	};

template<class TFORK>

class TErrorTagOr  : public TFORK, public AErrorTagOr

    {

public:

	typedef typename TFORK::TContext TContext;

	NETSM_TPL_DECLARE_CTR(TErrorTagOr, NetStateMachine::MStateFork, TContext)

     explicit TErrorTagOr(TContext& aContext)

     :	TFORK(aContext)

        {

        }

 	virtual TInt TransitionTag()

     	{

     	TUint tag = AErrorTagOr::TransitionTag(this->iContext);

     	return (tag!=0)? tag : TFORK::TransitionTag();