CompositeState.h

Go to the documentation of this file.

#ifndef COMPOSITESTATE_H_
#define COMPOSITESTATE_H_

#include "State.h"

namespace sttcl
{

struct CompositeStateHistoryType
{
        enum Values
        {
                None ,
                Deep ,
                Shallow ,
        };
};

namespace internal
{
template<class InnerStateType>
class CompositeStateBase
{
protected:
        CompositeStateBase()
        {
        }
        ~CompositeStateBase()
        {
        }

        void saveCurrentState(InnerStateType* currentState)
        {
        }

        InnerStateType* getStateHistory()
        {
                return 0;
        }

        template<class CompositeStateImpl>
        InnerStateType* resumeStateHistory(CompositeStateImpl* compositeState)
        {
                if(!compositeState->isReady())
                {
                        compositeState->initialize();
                }
                InnerStateType* currentState = compositeState->getState();
                return currentState;
        }

        template<class CompositeStateImpl>
        InnerStateType* finalizeStateHistory(CompositeStateImpl* compositeState)
        {
                InnerStateType* currentState = compositeState->getState();
                return currentState;
        }

};

template<class InnerStateType>
class CompositeStateBaseWithDeepHistory
{
protected:
        CompositeStateBaseWithDeepHistory()
        : lastState(0)
        {
        }
        ~CompositeStateBaseWithDeepHistory()
        {
        }

        void saveCurrentState(InnerStateType* currentState)
        {
                lastState = currentState;
        }

        InnerStateType* getStateHistory()
        {
                return lastState;
        }

        template<class CompositeStateImpl>
        InnerStateType* resumeStateHistory(CompositeStateImpl* compositeState)
        {
                if(lastState != 0)
                {
                        compositeState->changeState(lastState);

                }
                else
                {
                        compositeState->initialize();
                }
                InnerStateType* currentState = compositeState->getState();
                if(currentState)
                {
                        currentState->initSubStateMachines(true);
                }
                return currentState;
        }

        template<class CompositeStateImpl>
        InnerStateType* finalizeStateHistory(CompositeStateImpl* compositeState)
        {
                InnerStateType* currentState = compositeState->getState();
                if(currentState)
                {
                        currentState->finalizeSubStateMachines(true);
                }
                saveCurrentState(currentState);
                return 0;
        }

        InnerStateType* lastState;
};

template<class InnerStateType>
class CompositeStateBaseWithShallowHistory
{
protected:
        CompositeStateBaseWithShallowHistory()
        : lastState(0)
        {
        }
        ~CompositeStateBaseWithShallowHistory()
        {
        }

        void saveCurrentState(InnerStateType* currentState)
        {
                lastState = currentState;
        }

        InnerStateType* getStateHistory()
        {
                return lastState;
        }

        template<class CompositeStateImpl>
        InnerStateType* resumeStateHistory(CompositeStateImpl* compositeState)
        {
                if(lastState != 0)
                {
                        compositeState->changeState(lastState);
                }
                else
                {
                        compositeState->initialize();
                }
                InnerStateType* currentState = compositeState->getState();
                if(currentState)
                {
                        currentState->initSubStateMachines(false);
                }
                return currentState;
        }

        template<class CompositeStateImpl>
        InnerStateType* finalizeStateHistory(CompositeStateImpl* compositeState)
        {
                InnerStateType* currentState = compositeState->getState();
                if(currentState)
                {
                        currentState->finalizeSubStateMachines(false);
                }
                saveCurrentState(currentState);
                return 0;
        }

        InnerStateType* lastState;
};

template<CompositeStateHistoryType::Values HistoryType, class InnerStateType>
struct CompositeStateBaseSelector
{
        typedef sttcl::internal::CompositeStateBase<InnerStateType> RESULT_TYPE;
};

template<class InnerStateType>
struct CompositeStateBaseSelector<CompositeStateHistoryType::Deep,InnerStateType>
{
        typedef sttcl::internal::CompositeStateBaseWithDeepHistory<InnerStateType> RESULT_TYPE;
};

template<class InnerStateType>
struct CompositeStateBaseSelector<CompositeStateHistoryType::Shallow,InnerStateType>
{
        typedef sttcl::internal::CompositeStateBaseWithShallowHistory<InnerStateType> RESULT_TYPE;
};
}

template
< class CompositeStateImpl
, class StateMachineImpl
, class IInnerState
, CompositeStateHistoryType::Values HistoryType = CompositeStateHistoryType::None
, class StateBaseImpl = State<CompositeStateImpl,StateMachineImpl,typename StateMachineImpl::StateInterface>
, class StateMachineBaseImpl = StateMachine<CompositeStateImpl, IInnerState>
>
class CompositeState
: public StateBaseImpl
, public StateMachineBaseImpl
, public internal::CompositeStateBaseSelector<HistoryType,typename StateMachineBaseImpl::StateBaseClass>::RESULT_TYPE
{
public:
    typedef CompositeStateImpl Implementation;

    typedef StateMachineImpl Context;

    typedef StateBaseImpl StateImplementationBase;

    typedef StateMachineBaseImpl StateMachineImplementationBase;

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

        typedef typename internal::CompositeStateBaseSelector<HistoryType,typename StateMachineBaseImpl::StateBaseClass>::RESULT_TYPE CompositeStateHistoryBaseClass;

        typedef typename StateMachineBaseImpl::StateBaseClass InnerStateClass;

        typedef typename StateMachineImpl::StateInterface OuterStateInterface;

        typedef typename StateMachineBaseImpl::StateInterface StateInterface;

        CompositeState(StateDoAction argDoAction = 0)
        : StateBaseImpl(argDoAction)
        {
        }

        virtual ~CompositeState()
        {
        }

    void changeState(InnerStateClass* newState)
    {
        StateMachineBaseImpl::changeState(newState);
    }

    bool initializeImpl(bool force)
    {
        return static_cast<StateMachineBaseImpl*>(this)->initializeImpl(force);
    }

    inline void finalizeImpl(bool finalizeSubStateMachines)
    {
        static_cast<StateMachineBaseImpl*>(this)->finalizeImpl(finalizeSubStateMachines);
        subStateMachineCompleted();
    }

    inline void subStateMachineCompletedImpl()
    {
        // TODO: Propagate completion events asynchronously (e.g. for Region and ConcurrentCompositeState)
    }

    inline void subStateMachineCompleted()
    {
        static_cast<CompositeStateImpl*>(this)->subStateMachineCompletedImpl();
    }

    void entryImpl(Context* context)
    {
        StateBaseImpl::entryImpl(context);
        StateMachineBaseImpl::setState(this->resumeStateHistory(static_cast<CompositeStateImpl*>(this)));
    }

    void exitImpl(Context* context)
    {
                StateMachineBaseImpl::exitCurrentState();
        StateMachineBaseImpl::setState(this->finalizeStateHistory(static_cast<CompositeStateImpl*>(this)));
        StateBaseImpl::exitImpl(context);
    }

protected:
    void changeState(Context* context,StateBase<StateMachineImpl,OuterStateInterface>* newState)
    {
        StateBaseImpl::changeState(context,newState);
    }

    virtual void finalizeSubStateMachines(bool recursive)
    {
        if(!recursive)
        {
                static_cast<StateMachineBaseImpl*>(this)->finalize(recursive);
        }
    }

    virtual void initSubStateMachines(bool recursive)
    {
                InnerStateClass* currentState = StateMachineBaseImpl::getState();
        if(!recursive)
        {
                if(currentState != static_cast<CompositeStateImpl*>(this)->getInitialState())
                {
                        StateMachineBaseImpl::initialize(true);
                }
        }
        else if(StateMachineBaseImpl::isReady())
        {
                if(currentState)
                {
                        currentState->initSubStateMachines(recursive);
                }
        }
        else
        {
                        StateMachineBaseImpl::initialize(true);
        }
    }
};

}

#endif /* COMPOSITESTATE_H_ */