// StateHandler
// Holds pointers to an object's methods and provides a bottleneck for 
//  calling them.
template< typename THost >
class StateHandler
{
private:
	typedef void(THost::*Callback)();
	Callback mEnter;
	Callback mUpdate;
	Callback mExit;

public:
	void Set( Callback enter, Callback update, Callback exit )
	{
		assert( enter && update && exit );
		mEnter = enter;
		mUpdate = update;
		mExit = exit;
	}
	void Enter( THost* host )	{ assert( host ); (host->*mEnter)(); }
	void Update( THost* host )	{ assert( host ); (host->*mUpdate)(); }
	void Exit( THost* host )	{ assert( host ); (host->*mExit)(); }
};


// StateMachine
// Maintains a pointer an instance of THost, and a pointer to a StateHandler 
//  instance that is used to call methods on the host.
// It is invalid for the StateHandler object to contain a NULL pointer,
//  and must be initialized with a StateHandler that calls empty functions if
//  that behavior is desired.  This is to avoid all the bugs and branching
//  that comes with NULL pointers.
template< typename THost >
class StateMachine
{
private:
	StateHandler< THost >*	mStateHandler;
	THost*			mHost;

public:
	StateMachine( StateHandler< THost >& initState ) 
	: mHost( 0 ),
	  mStateHandler( &initState )
	{}

	void SetHost( THost* host )
	{
		assert( host );
		mHost = host;
	}

	// Calls the Update method for the StateHandler.
	void Update()
	{
		assert( mHost );
		assert( mStateHandler );
		mStateHandler->Update( mHost );
	}
	
	// Changes states, calling Exit on the current state before changing and 
	// calling Enter on the new state after changing.
	void Goto( StateHandler< THost >& s )
	{
		assert( mHost );
		assert( mStateHandler );
		assert( &s );
		mStateHandler->Exit( mHost );
		mStateHandler = &s;
		mStateHandler->Enter( mHost );
	}
};

// These macros are used to easily and cleanly set up a host class
// to use a state machine.
#define STUB_STATE_HANDLER_FUNCS( STATENAME )	(backslash)
	void enter ## STATENAME (){}		(backslash)
	void update ## STATENAME (){}		(backslash)
	void exit ## STATENAME (){}

#define DECLARE_STATE_HANDLER_FUNCS( STATENAME )(backslash)
	void enter ## STATENAME ();		(backslash)
	void update ## STATENAME ();		(backslash)
	void exit ## STATENAME ();

#define SET_STATE_HANDLER( CLASS, STATENAME )	(backslash)
	mState ## STATENAME.Set(		(backslash)
	& CLASS ::enter ## STATENAME,	(backslash)
	& CLASS ::update ## STATENAME,	(backslash)
	& CLASS ::exit ## STATENAME );

class TestScreen : public AbstractScreen
{
	StateMachine< TestScreen > mStateMachine;
	StateHandler< TestScreen > 
		mStateNothing, 
		mStateStart, 
		mStateIdle, 
		mStateStop;
	
	STUB_STATE_HANDLER_FUNCS( Nothing );
	STUB_STATE_HANDLER_FUNCS( Start );
	STUB_STATE_HANDLER_FUNCS( Idle );
	STUB_STATE_HANDLER_FUNCS( Stop );

public:

	TestScreen();
	virtual ~TestScreen()	{}
	virtual void Start()	{ mStateMachine.Goto( mStateStart ); }
	virtual void Stop()	{ mStateMachine.Goto( mStateStop ); }
	virtual void Suspend()	{}
	virtual void Resume()	{}
	virtual void Update()	{ mStateMachine.Update(); }
};

...

TestScreen::TestScreen()
: mStateMachine( mStateNothing )
{
	mStateMachine.SetHost( this );
	SET_STATE_HANDLER( TestScreen, Nothing );
	SET_STATE_HANDLER( TestScreen, Start );
	SET_STATE_HANDLER( TestScreen, Idle );
	SET_STATE_HANDLER( TestScreen, Stop );
}