State.h

Go to the documentation of this file.

#ifndef STATE_H_
#define STATE_H_

namespace sttcl
{

template<class StateMachineImpl, class IState>
class StateMachine;

template<class StateMachineImpl,class IState>
class StateBase
: public IState
{
    friend class StateMachine<StateMachineImpl,IState>;

public:
    typedef StateMachineImpl Context;

    typedef IState StateInterface;

    virtual void finalizeSubStateMachines(bool recursive) = 0;

    virtual void initSubStateMachines(bool recursive) = 0;

    virtual void entry(Context* context) = 0;
    virtual void exit(Context* context) = 0;
    virtual void startDo(Context* context) = 0;
    virtual void endDo(Context* context) = 0;

    void changeStateImpl(Context* context,StateBase<StateMachineImpl,IState>* newState)
    {
        context->changeState(newState);
    }

    template<class StateMachineContext>
    void changeStateImpl(StateMachineContext* context,StateBase<StateMachineImpl,IState>* newState)
    {
        context->changeState(newState);
    }
protected:

    StateBase() {}
    virtual ~StateBase() {}

};

template<class StateImpl,class StateMachineImpl,class IState>
class State
: public StateBase<StateMachineImpl,IState>
{
public:
    typedef StateMachineImpl Context;

    typedef StateImpl Implementation;

    typedef StateBase<StateMachineImpl,IState> StateBaseType;

    typedef void (Implementation::*StateDoAction)(Context*,bool);

    inline void entryImpl(Context* context)
    {
    }

    inline void exitImpl(Context* context)
    {
    }

    inline void startDoImpl(Context* context)
    {
        if(doAction)
        {
            (static_cast<Implementation*>(this)->*doAction)(context,true);
        }
    }

    inline void endDoImpl(Context* context)
    {
    }

    void finalizeSubStateMachinesImpl(bool recursive)
    {
    }

    void initSubStateMachinesImpl(bool recursive)
    {
    }

    bool checkDirectTransitionImpl(Context* context, bool& finalize, StateBaseType*& nextState)
    {
        nextState = 0;
        finalize = false;
        return false;
    }

protected:
    State(StateDoAction argDoAction = 0)
    : doAction(argDoAction)
    {
    }

    virtual ~State()
    {
    }

    void changeState(Context* context,StateBaseType* newState)
    {
        static_cast<Implementation*>(this)->changeStateImpl(context,newState);
    }

    template<class StateMachineContext>
    void changeState(StateMachineContext* context,StateBaseType* newState)
    {
        static_cast<Implementation*>(this)->changeStateImpl(context,newState);
    }

    StateDoAction doAction;

private:
    virtual void entry(Context* context)
    {
        static_cast<Implementation*>(this)->entryImpl(context);
    }

    virtual void exit(Context* context)
    {
        static_cast<Implementation*>(this)->exitImpl(context);
    }

//    template<class StateMachineContext>
//    virtual void entry(StateMachineContext* context)
//    {
//        static_cast<Implementation*>(this)->entryImpl(context);
//    }
//
//    template<class StateMachineContext>
//    virtual void exit(StateMachineContext* context)
//    {
//        static_cast<Implementation*>(this)->exitImpl(context);
//    }

    virtual void startDo(Context* context)
    {
        // Run the do action
        static_cast<Implementation*>(this)->startDoImpl(context);

        // Handle direct transitions
        StateBaseType* nextState = 0;
        bool finalize = false;
        if(static_cast<Implementation*>(this)->checkDirectTransitionImpl(context,finalize,nextState))
                {
                        if(finalize)
                        {
                                context->finalize();
                        }
                        else if(nextState)
                        {
                                changeState(context,nextState);
                        }
                }
    }

    virtual void endDo(Context* context)
    {
        static_cast<Implementation*>(this)->endDoImpl(context);
    }

    virtual void finalizeSubStateMachines(bool recursive)
    {
        static_cast<Implementation*>(this)->finalizeSubStateMachinesImpl(recursive);
    }

    virtual void initSubStateMachines(bool recursive)
    {
        static_cast<Implementation*>(this)->initSubStateMachinesImpl(recursive);
    }

};
}

#endif /* STATE_H_ */