StateMachine.h

Go to the documentation of this file.

#ifndef STATEMACHINE_H_
#define STATEMACHINE_H_

#include "SttclConfig.h"

#include "State.h"
#include <cassert>
#if defined(STTCL_DEBUG)
#include <iostream>
//#if defined(STTCL_HAVE_RTTI)
#include <typeinfo>
//#endif
#endif


namespace sttcl
{

template<class StateMachineImpl, class IState>
class StateMachine
{
    struct StateMachineFlags
    {
        unsigned char initialized:1;
        unsigned char initializing:1;
        unsigned char finalized:1;
        unsigned char finalizing:1;

        inline StateMachineFlags()
        : initialized(false)
        , initializing(false)
        , finalized(false)
        , finalizing(false)
        {
        }
    };

public:
    typedef StateMachineImpl Context;
    typedef IState StateInterface;
    typedef StateBase<StateMachineImpl,IState> StateBaseClass;

    friend class StateBase<StateMachineImpl,IState>;

    ~StateMachine()
    {
        if(isInitialized())
        {
                finalize();
        }
    }

    bool initialize(bool force = false)
    {
        bool result = static_cast<Context*>(this)->initializeImpl(force);
        return result;
    }

    void finalize(bool finalizeSubStateMachines = true)
    {
        if(!isFinalizing())
        {
                        flags.finalizing = true;
                        static_cast<Context*>(this)->finalizeImpl(finalizeSubStateMachines);
                        flags.finalizing = false;
        }
    }

    inline bool isReady() const
    {
        return static_cast<const Context*>(this)->isReadyImpl();
    }

    bool isInitialized() const
    {
        return flags.initialized;
    }

    bool isInitalizing() const
    {
        return flags.initializing;
    }

    bool isFinalized() const
    {
        return flags.finalized;
    }

    bool isFinalizing() const
    {
        return flags.finalizing;
    }

    inline StateBaseClass* getState() const
    {
        return state;
    }

    inline bool initializeImpl(bool force)
    {
        if(force || (!isInitialized() && !isInitalizing()))
        {
            flags.initializing = true;
            if(force)
            {
                StateBaseClass* currentState = getState();
                if(currentState)
                {
                        currentState->finalizeSubStateMachines(true);
                }
                if(!isFinalized())
                {
                        finalize(true);
                }
            }

            StateBaseClass* initialState = getInitialState();
            if(initialState)
            {
                                changeState(initialState);
            }
                StateBaseClass* currentState = getState();
                if(currentState)
                {
                        currentState->initSubStateMachines(force);
                }
            flags.initializing = false;
            flags.finalized = false;
            flags.initialized = true;
        }
        return isReady();
    }

    inline void finalizeImpl(bool finalizeSubStateMachines)
    {
        if(!isFinalized() && state)
        {
            if(finalizeSubStateMachines)
            {
                state->finalizeSubStateMachines(true);
            }
            exitCurrentState();
        }
        setState(0);
        flags.finalized = true;
        flags.initialized = false;
    }

    inline void subStateMachineCompleted(StateBaseClass* state)
    {
        static_cast<StateMachineImpl*>(this)->subStateMachineCompletedImpl(state);
    }

    inline void subStateMachineCompletedImpl(StateBaseClass* state)
    {
    }

protected:
    StateMachine()
    : state(0)
    , flags()
    {
    }

    void changeState(typename StateMachine<StateMachineImpl,IState>::StateBaseClass* newState);

    inline void setState(StateBaseClass* newState)
    {
        state = newState;
    }

    StateBaseClass* getInitialState() const
    {
        StateBaseClass* result = static_cast<const Context*>(this)->getInitialStateImpl();
#if defined(STTCL_DEBUG) // && defined(STTCL_HAVE_RTTI)
        if(!result)
        {
                std::cout << "WARNING: " << typeid(static_cast<const Context*>(this)).name() << ".getInitialStateImpl() returned NULL" << std::endl;
        }
#endif
        return result;
    }

    // Default implementations
    //---------------------------------------------------------------------------------------

    inline StateBaseClass* getInitialStateImpl() const
    {
        return 0;
    }

    inline bool isReadyImpl() const
    {
        return flags.initialized && !isFinalized();
    }


    void exitCurrentState();
    void enterNewState();

private:
    StateBaseClass* state;
    StateMachineFlags flags;

};

template<class StateMachineImpl, class IState>
void StateMachine<StateMachineImpl,IState>::changeState(typename StateMachine<StateMachineImpl,IState>::StateBaseClass* newState)
{
    if(isInitalizing() || !isFinalized())
    {
        if(newState)
                {
                        if(newState != state)
                        {
                                exitCurrentState();
                                setState(newState);
                                enterNewState();
                        }
                }
                else // equivalent to finalize
                {
                        finalize();
                }
    }
}

template<class StateMachineImpl, class IState>
void StateMachine<StateMachineImpl,IState>::exitCurrentState()
{
    if(state)
    {
        state->endDo(static_cast<StateMachine<StateMachineImpl,IState>::Context*>(this));
        state->exit(static_cast<StateMachine<StateMachineImpl,IState>::Context*>(this));
    }
}

template<class StateMachineImpl, class IState>
void StateMachine<StateMachineImpl,IState>::enterNewState()
{
    state->entry(static_cast<StateMachine<StateMachineImpl,IState>::Context*>(this));
    state->startDo(static_cast<StateMachine<StateMachineImpl,IState>::Context*>(this));
}

}

#endif /* STATEMACHINE_H_ */