// 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 "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:

// Structures to create a const static (build time) map of states

// THIS API IS INTERNAL TO NETWORKING AND IS SUBJECT TO CHANGE AND NOT FOR EXTERNAL USE

// 

//

/**

 @file 

 @internalTechnology

*/

#include <e32base.h>

// Enable logging for debug builds or builds with the comms flogger enabled - must be defined before including e32utrace.h

#if (defined(_DEBUG) || defined(__FLOG_ACTIVE)) && !defined(SYMBIAN_TRACE_ENABLE)

#define SYMBIAN_TRACE_ENABLE

#endif

#ifndef _SM_StateTriple_H_

#define _SM_StateTriple_H_

#define DEFINE_TRIPLES_TABLE( name ) \

	const NetStateMachine::TStateTriple name[] = { \

		{ \

		(NetStateMachine::TStateTransitionCtor)NULL, \

		(NetStateMachine::TStateCtor)NULL, \

		(NetStateMachine::TStateForkCtor)NULL, \

		NetStateMachine::KTableBoundaryTag_Internal, \

		NULL \

		},

#define TRIPLES_TABLE_END() \

		{ \

		(NetStateMachine::TStateTransitionCtor)NULL, \

		(NetStateMachine::TStateCtor)NULL, \

		(NetStateMachine::TStateForkCtor)NULL, \

		NetStateMachine::KTableBoundaryTag_Internal, \

		NULL \

		} \

	};

#ifdef SYMBIAN_TRACE_ENABLE

#define FIRST_TRIPLE( firstState, firstStateFork ) \

		{ \

		(NetStateMachine::TStateTransitionCtor)NULL, \

		NetStateMachine::TStateSizeChecker<firstState>::GetVTablePtr, \

		NetStateMachine::TStateForkSizeChecker<firstStateFork>::GetVTablePtr, \

		NetStateMachine::KFirstTripleTag_Internal, \

		_S8("NULL->"#firstState) \

		}

//STATE_TRIPLE can also be used instead of FIRST_TRIPLE to specify a "starting" transition.

//Starting transition is a transition that is executed in case the statemachine is already running

//and an event that would normally cause the statemachine to start occurs.

#define STATE_TRIPLE( transitionTag, stateTransition, state, stateFork ) \

		{ \

		NetStateMachine::TStateTransitionSizeChecker<stateTransition>::GetVTablePtr, \

		NetStateMachine::TStateSizeChecker<state>::GetVTablePtr, \

		NetStateMachine::TStateForkSizeChecker<stateFork>::GetVTablePtr, \

		transitionTag, \

		_S8(#stateTransition "->" #state) \

		}

#define THROUGH_TRIPLE( transitionTag, stateTransition, stateFork ) \

		{ \

		NetStateMachine::TStateTransitionSizeChecker<stateTransition>::GetVTablePtr, \

		(NetStateMachine::TStateCtor)NULL, \

		NetStateMachine::TStateForkSizeChecker<stateFork>::GetVTablePtr, \

		transitionTag, \

		_S8(#stateTransition "->" #stateFork) \

		}

#define LAST_TRIPLE( transitionTag, lastTransition ) \

		{ \

		NetStateMachine::TStateTransitionSizeChecker<lastTransition>::GetVTablePtr, \

		(NetStateMachine::TStateCtor)NULL, \

		(NetStateMachine::TStateForkCtor)NULL, \

		transitionTag, \

		_S8(#lastTransition "->NULL") \

		}

#else

#define FIRST_TRIPLE( firstState, firstStateFork ) \

		{ \

		(NetStateMachine::TStateTransitionCtor)NULL, \

		NetStateMachine::TStateSizeChecker<firstState>::GetVTablePtr, \

		NetStateMachine::TStateForkSizeChecker<firstStateFork>::GetVTablePtr, \

		NetStateMachine::KFirstTripleTag_Internal, \

		NULL \

		}

//STATE_TRIPLE can also be used instead of FIRST_TRIPLE to specify a "starting" transition.

//Starting transition is a transition that is executed in case the statemachine is already running

//and an event that would normally cause the statemachine to start occurs.

#define STATE_TRIPLE( transitionTag, stateTransition, state, stateFork ) \

		{ \

		NetStateMachine::TStateTransitionSizeChecker<stateTransition>::GetVTablePtr, \

		NetStateMachine::TStateSizeChecker<state>::GetVTablePtr, \

		NetStateMachine::TStateForkSizeChecker<stateFork>::GetVTablePtr, \

		transitionTag, \

		NULL \

		}

#define THROUGH_TRIPLE( transitionTag, stateTransition, stateFork ) \

		{ \

		NetStateMachine::TStateTransitionSizeChecker<stateTransition>::GetVTablePtr, \

		(NetStateMachine::TStateCtor)NULL, \

		NetStateMachine::TStateForkSizeChecker<stateFork>::GetVTablePtr, \

		transitionTag, \

		NULL \

		}

#define LAST_TRIPLE( transitionTag, lastTransition ) \

		{ \

		NetStateMachine::TStateTransitionSizeChecker<lastTransition>::GetVTablePtr, \

		(NetStateMachine::TStateCtor)NULL, \

		(NetStateMachine::TStateForkCtor)NULL, \

		transitionTag, \

		NULL \

		}

#endif

#define FIRST_TRIPLE_ENTRY( firstState, firstStateFork ) \

	FIRST_TRIPLE( firstState, firstStateFork ),

#define STATE_TRIPLE_ENTRY( transitionTag, stateTransition, state, stateFork ) \

	STATE_TRIPLE( transitionTag, stateTransition, state, stateFork ),

#define THROUGH_TRIPLE_ENTRY( transitionTag, stateTransition, stateFork ) \

	THROUGH_TRIPLE( transitionTag, stateTransition, stateFork ),

#define LAST_TRIPLE_ENTRY( transitionTag, lastTransition ) \

	LAST_TRIPLE( transitionTag, lastTransition ),

namespace NetStateMachine

{

const TInt KExecuteAlways               = 0x0FFFFFFF;

const TInt KTableBoundaryTag_Internal   = KExecuteAlways - 1; //Should never be used except for the MM itself

const TInt KFirstTripleTag_Internal     = KExecuteAlways - 2; //Should never be used except for the MM itself

//Used as a flag to determine which direction to move 

//in the array of triples for the next transition => the actual transition tag

//is only 31bits

enum KDirection

	{

	EIgnore   = 0x40000000, //do nothing, go nowhere, return (bin 0100...)

	EForward  = 0x00000000,

	EBackward = 0x80000000  //(bin 1000...)

	};

const TInt KMaxStateClassByteSize = 16;

//!!Memory given to MState/MStateTransition derived classes is stack allocated.

//The memory therefore is valid only between the constructor and one and 

//only one subsequent call. No class variables can therefore preserve

//the object state for possible cancel or error call. All such variables

//are to be accessed via the given aContext pointer

//The destructor of the state must not cancel the operation

//There is no guarantie that the destructor of state or transition will be

//called at all

class MStateTransition

	{

	friend class ACore;

protected:

	explicit MStateTransition() 

		{

		};

	virtual ~MStateTransition()

		{

		};

protected:

	virtual void DoL() = 0;

	virtual void Error( TInt aError ) = 0;

	};

class MState

	{

	friend class ACore;

protected:

	explicit MState() 

		{

		};

	virtual ~MState()

		{

		};

protected:

	virtual TBool Accept() = 0;

	virtual void Cancel() = 0;

	};

class MStateFork

	{

	friend class ACore;

protected:

	explicit MStateFork() 

		{

		};

	virtual ~MStateFork()

		{

		};

protected:

	virtual TInt TransitionTag() = 0; //returns a transition tag + direction see KDirection enum

	};

typedef MStateTransition* (*TStateTransitionCtor)(TDesC8& aMem, TAny* aContext);

typedef MState* (*TStateCtor)(TDesC8& aMem, TAny* aContext);

typedef MStateFork* (*TStateForkCtor)(TDesC8& aMem, TAny* aContext);

struct TStateTriple

	{

	TStateTransitionCtor iTCtor;

	TStateCtor iSCtor;

	TStateForkCtor iFCtor;

	TInt iTransitionTag : 30;

	const TText8* iName; //For logging purposes only but present in all configurations to preserve BC. Static const (ROM), 4B.

	};

template <class TSTATETRANSITION>

struct TStateTransitionSizeChecker

    {

    inline static MStateTransition* GetVTablePtr(TDesC8& aMem, TAny* aContext)

    	{

    	__ASSERT_COMPILE(sizeof(TSTATETRANSITION) < KMaxStateClassByteSize); //size of the class is greater than KMaxStateClassByteSize

    	return TSTATETRANSITION::GetVTablePtr(aMem,aContext);

    	}

    };

template <class TSTATE>

struct TStateSizeChecker

    {

    inline static MState* GetVTablePtr(TDesC8& aMem, TAny* aContext)

    	{

    	__ASSERT_COMPILE(sizeof(TSTATE) < KMaxStateClassByteSize); //size of the class is greater than KMaxStateClassByteSize

    	return TSTATE::GetVTablePtr(aMem,aContext);

    	}

    };

template <class TSTATEFORK>

struct TStateForkSizeChecker

    {

    inline static MStateFork* GetVTablePtr(TDesC8& aMem, TAny* aContext)

    	{

    	__ASSERT_COMPILE(sizeof(TSTATEFORK) < KMaxStateClassByteSize); //size of the class is greater than KMaxStateClassByteSize

    	return TSTATEFORK::GetVTablePtr(aMem,aContext);

    	}

    };

} //namespace NetStateMachine

#endif //_SM_StateTriple_H_