ActiveState.h

Go to the documentation of this file.

#ifndef ACTIVESTATE_H_
#define ACTIVESTATE_H_

#include "State.h"
#include "SttclThread.h"
#include "SttclMutex.h"
#include "SttclSemaphore.h"
#include "SttclTime.h"

namespace sttcl
{

template
< class StateImpl
, class StateMachineImpl
, class IState
, class StateThreadType
, class TimeDurationType
, class EndDoActionSemaphoreType
, class ActiveStateMutexType
>
class ActiveState;

namespace internal
{
struct ThreadFunctionHelper
{
        template
        < class StateImpl
        , class StateMachineImpl
        , class IState
        , class StateThreadType
        , class TimeDurationType
        , class EndDoActionSemaphoreType
        , class ActiveStateMutexType
        >
    static void* stateThreadMethod(void* args)
    {
        ActiveState<StateImpl
                   ,StateMachineImpl
                   ,IState
                   ,StateThreadType
                   ,EndDoActionSemaphoreType
                   ,TimeDurationType
                   ,ActiveStateMutexType
                   >* pThis =
                        reinterpret_cast<ActiveState<StateImpl
                                                    ,StateMachineImpl
                                                    ,IState
                                                    ,StateThreadType
                                                    ,EndDoActionSemaphoreType
                                                    ,TimeDurationType
                                                    ,ActiveStateMutexType
                                                    >*>(args);
        pThis->runDoAction(pThis->currentContext);
        return 0;
    }
};
}

template
< class StateImpl
, class StateMachineImpl
, class IState
, class StateThreadType = sttcl::internal::SttclThread<STTCL_DEFAULT_THREADIMPL>
, class TimeDurationType = TimeDuration<STTCL_DEFAULT_TIMEDURATIONIMPL>
, class EndDoActionSemaphoreType = internal::SttclSemaphore<STTCL_DEFAULT_SEMAPHOREIMPL>
, class ActiveStateMutexType = internal::SttclMutex<STTCL_DEFAULT_MUTEXIMPL,TimeDurationType>
>
class ActiveState
: public sttcl::StateBase<StateMachineImpl,IState>
{
        friend class sttcl::internal::ThreadFunctionHelper;
public:
    typedef StateMachineImpl Context;

    typedef StateImpl Implementation;

    typedef StateBase<StateMachineImpl,IState> StateBaseType;

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

    typedef StateThreadType StateThreadImpl;

    typedef EndDoActionSemaphoreType EndDoActionSemaphoreImpl;

    typedef TimeDurationType TimeDurationImpl;

    typedef ActiveStateMutexType ActiveStateMutexImpl;

    inline const TimeDurationImpl& getDoFrequency() const
        {
        return doFrequency;
        }

    inline void setDoFrequency(const TimeDurationImpl& newValue)
        {
        doFrequency = newValue;
        }

    bool endDoActionRequestedImpl()
    {
                bool result = endDoActionSemaphore.try_wait(doFrequency);
                return result;
    }

    inline void entryImpl(Context* context)
    {
    }

    inline void exitImpl(Context* context)
    {

    }


    inline void exitingDoActionImpl()
    {
    }

    inline void joinDoActionThreadImpl()
    {
        if(!StateThreadType::isSelf(stateThread))
        {
                stateThread.join();
        }
    }

    inline void unblockDoActionImpl()
    {
    }

    inline void endDoImpl(Context* context)
    {
                endDoActionSemaphore.post();
        if(!StateThreadType::isSelf(stateThread))
        {
                if(isDoActionRunning())
                {
                        static_cast<StateImpl*>(this)->unblockDoActionImpl();
                }
                        static_cast<Implementation*>(this)->joinDoActionThreadImpl();
                        currentContext = 0;
        }
    }

    inline const StateThreadType& getStateThread() const
    {
        return stateThread;
    }

    inline void startDoImpl(Context* context)
    {
//        if(doAction)
//        {
                        currentContext = context;
                stateThread.run(this);
//        }
    }

    inline bool isDoActionRunning() const
    {
        sttcl::internal::AutoLocker<ActiveStateMutexType> lock(activeStateMutex);
                return doActionRunning;
    }

    void finalizeSubStateMachinesImpl(bool recursive)
    {
    }

    void initSubStateMachinesImpl(bool recursive)
    {
    }

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

protected:
    ActiveState(StateDoAction argDoAction, bool argRunDoActionOnce = false , TimeDurationType argDoFrequency = TimeDurationType::Zero)
    : doAction(argDoAction)
    , doFrequency(argDoFrequency)
    , currentContext(0)
    , stateThread(&sttcl::internal::ThreadFunctionHelper::stateThreadMethod
                                        < StateImpl
                                        , StateMachineImpl
                                        , IState
                                        , StateThreadType
                                        , EndDoActionSemaphoreType
                                        , TimeDurationType
                                        , ActiveStateMutexType>)
    , endDoActionSemaphore(0)
    , doActionRunning(false)
    , runDoActionOnce(argRunDoActionOnce)
    {
    }

    virtual ~ActiveState()
    {
        if(isDoActionRunning())
        {
                endDo(currentContext);
        }
    }

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

    bool endDoActionRequested()
    {
        return static_cast<Implementation*>(this)->endDoActionRequestedImpl();
    }

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

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

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

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

    void setDoActionRunning(bool value)
    {
        sttcl::internal::AutoLocker<ActiveStateMutexType> lock(activeStateMutex);
                doActionRunning = value;
    }

    void runDoAction(Context* context)
    {
        bool initialCall = true;
        setDoActionRunning(true);
        bool directTransitionTriggered = false;
        do
        {
                // Run the do action
                if(doAction)
                {
                                (static_cast<Implementation*>(this)->*doAction)(context,initialCall);
                                if(initialCall)
                                {
                                        initialCall = false;
                                }
                }

            // 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);
                                directTransitionTriggered = true;
                        }
                }
        } while(!endDoActionRequested() && !runDoActionOnce && !directTransitionTriggered);
        static_cast<Implementation*>(this)->exitingDoActionImpl();
        setDoActionRunning(false);
    }

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

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

    StateDoAction doAction;
    TimeDurationType doFrequency;
    Context* currentContext;
    StateThreadType stateThread;
    EndDoActionSemaphoreType endDoActionSemaphore;
    mutable ActiveStateMutexType activeStateMutex;
        bool doActionRunning;
        bool runDoActionOnce;
};

}

#endif /* ACTIVESTATE_H_ */