Region.h

Go to the documentation of this file.

#ifndef REGION_H_
#define REGION_H_

#include "CompositeState.h"
#include "ActiveState.h"
#include "RefCountPtr.h"
#include "SttclMutex.h"
#include "SttclSemaphore.h"
#include "EventQueue.h"

namespace sttcl
{

template
< class RegionContainerImpl
, class IInnerState
, class EventArgs = void
>
class RegionBase;

namespace internal
{
template
< class RegionContainerImpl
, class IInnerState
, class EventArgsType
>
struct EventArgsInterfaceSelector
{
        typedef sttcl::RefCountPtr<EventArgsType> RefCountPtr;

    typedef void (IInnerState::*InnerEventHandler)(RegionContainerImpl*,RegionBase<RegionContainerImpl,IInnerState,EventArgsType>*,RefCountPtr);
};

template
< class RegionContainerImpl
, class IInnerState
>
struct EventArgsInterfaceSelector<RegionContainerImpl,IInnerState,void>
{
        typedef sttcl::RefCountPtr<void> RefCountPtr;

    typedef void (IInnerState::*InnerEventHandler)(RegionContainerImpl*,RegionBase<RegionContainerImpl,IInnerState,void>*);
};

template
< class RegionContainerImpl
, class IInnerState
, class EventArgs
> class IRegionEventDispatchWithArgs
{
public:
        typedef EventArgsInterfaceSelector<RegionContainerImpl,IInnerState,EventArgs> EventArgsSelectorType;

        typedef typename EventArgsSelectorType::RefCountPtr RefCountPtr;

        typedef typename EventArgsSelectorType::InnerEventHandler InnerEventHandler;

        virtual void handleBroadcastedEvent(RegionContainerImpl* context,InnerEventHandler eventHandler, RefCountPtr eventArgs) = 0;

        virtual ~IRegionEventDispatchWithArgs() {}
};

template
< class RegionContainerImpl
, class IInnerState
, class EventArgs
> class IRegionEventDispatchWithoutArgs
{
public:
        typedef EventArgsInterfaceSelector<RegionContainerImpl,IInnerState,void> EventArgsSelectorType;

        typedef typename EventArgsSelectorType::RefCountPtr RefCountPtr;

        typedef typename EventArgsSelectorType::InnerEventHandler InnerEventHandler;

        virtual void handleBroadcastedEvent(RegionContainerImpl* context,InnerEventHandler eventHandler) = 0;

        virtual ~IRegionEventDispatchWithoutArgs() {}
};

template
< class RegionContainerImpl
, class IInnerState
, class EventArgs
>
struct RegionEventDispatchInterfaceSelector
{
        typedef IRegionEventDispatchWithArgs<RegionContainerImpl,IInnerState,EventArgs> RESULT_TYPE;

};

template
< class RegionContainerImpl
, class IInnerState
>
struct RegionEventDispatchInterfaceSelector<RegionContainerImpl,IInnerState,void>
{
        typedef IRegionEventDispatchWithoutArgs<RegionContainerImpl,IInnerState,void> RESULT_TYPE;

};

template
< class RegionContainerImpl
, class IInnerState
, class EventArgs
>
struct DispatchedEvent;

template
< class RegionContainerImpl
, class IInnerState
, class EventArgs
>
class RegionContainer;

}

template
< class RegionContainerImpl
, class IInnerState
, class EventArgs //= void
>
class RegionBase
: public sttcl::internal::RegionEventDispatchInterfaceSelector<RegionContainerImpl,IInnerState,EventArgs>::RESULT_TYPE
{
public:

        typedef typename sttcl::internal::RegionEventDispatchInterfaceSelector<RegionContainerImpl,IInnerState,EventArgs>::RESULT_TYPE RegionEventDispatchInterface;

        typedef typename RegionEventDispatchInterface::RefCountPtr RefCountPtr;

    typedef typename RegionEventDispatchInterface::InnerEventHandler InnerEventHandler;

        RegionBase(RegionContainerImpl* argRegionContainer)
    : regionContainer(argRegionContainer)
        {
        }

        virtual ~RegionBase()
        {
        }

        virtual void enterRegion(RegionContainerImpl* context) = 0;
        virtual void exitRegion(RegionContainerImpl* context) = 0;
        virtual void finalizeRegion(bool recursive) = 0;
        virtual bool initializeRegion(bool recursive) = 0;
        virtual void startDoRegion(RegionContainerImpl* context) = 0;
        virtual void endDoRegion(RegionContainerImpl* context) = 0;
        virtual bool isRegionInitialized() = 0;
        virtual bool isRegionFinalized() = 0;
        virtual bool isRegionThreadRunning() const = 0;
        virtual void joinRegionThread() = 0;

        template<class RegionImpl>
        RegionImpl* getRegionContext()
        {
                return static_cast<RegionImpl*>(this);
        }

        virtual void internalInitialize(bool recursive) = 0;

        virtual void internalFinalize(bool recursive) = 0;

        virtual void queueDispatchedEvent(const sttcl::internal::DispatchedEvent<RegionContainerImpl,IInnerState,EventArgs>& dispatchedEvent) = 0;

protected:
        RegionContainerImpl* regionContainer;
};

namespace internal
{

template
< class RegionContainerImpl
, class IInnerState
, class EventArgs
>
struct DispatchedEvent
{
    typedef RegionBase<RegionContainerImpl,IInnerState,EventArgs> RegionBaseClass;


        typedef EventArgsInterfaceSelector<RegionContainerImpl,IInnerState,EventArgs> EventArgsSelectorType;

        typedef typename EventArgsSelectorType::RefCountPtr RefCountPtr;

        typedef typename EventArgsSelectorType::InnerEventHandler InnerEventHandler;

    typedef void (RegionBaseClass::*InternalEventHandler)(bool);

    RegionContainerImpl* context;
    IInnerState* state;
        InnerEventHandler handler;
        mutable RefCountPtr eventArgs;
        InternalEventHandler internalHandler;
        bool recursiveInternalEvent;

        DispatchedEvent(RegionContainerImpl* argContext, IInnerState* argState, InnerEventHandler argHandler, RefCountPtr argEventArgs)
        : context(argContext)
        , state(argState)
        , handler(argHandler)
        , eventArgs(argEventArgs)
        , internalHandler(0)
        , recursiveInternalEvent(false)
        {
        }

        DispatchedEvent(InternalEventHandler argInternalHandler, bool argRecursiveInternalEvent)
        : context(0)
        , state(0)
        , handler(0)
        , eventArgs()
        , internalHandler(argInternalHandler)
        , recursiveInternalEvent(argRecursiveInternalEvent)
        {
        }

        DispatchedEvent(const DispatchedEvent& rhs)
        : context(rhs.context)
        , state(rhs.state)
        , handler(rhs.handler)
        , eventArgs(rhs.eventArgs)
        , internalHandler(rhs.internalHandler)
        , recursiveInternalEvent(rhs.recursiveInternalEvent)
        {
        }

        DispatchedEvent& operator=(const DispatchedEvent& rhs)
        {
                context = rhs.context;
                state = rhs.state;
                handler = rhs.handler;
                eventArgs = rhs.eventArgs;
                internalHandler = rhs.internalHandler;
                recursiveInternalEvent = rhs.recursiveInternalEvent;
                return *this;
        }

private:
        DispatchedEvent(); // Forbidden
};

template
< class RegionImpl
, class RegionContainerImpl
, class IInnerState
, class EventArgs
>
class RegionBaseImplWithEventArgs
: public RegionBase<RegionContainerImpl,IInnerState,EventArgs>
{
public:
    typedef RegionImpl Implementation;

    typedef RegionBase<RegionContainerImpl,IInnerState,EventArgs> RegionBaseClass;

    typedef typename RegionBaseClass::RefCountPtr RefCountPtr;

    typedef typename RegionBaseClass::InnerEventHandler InnerEventHandler;

    RegionBaseImplWithEventArgs(RegionContainerImpl* argRegionContainer)
    : RegionBaseClass(argRegionContainer)
    {}

    virtual ~RegionBaseImplWithEventArgs() {}

    virtual void handleBroadcastedEvent(RegionContainerImpl* context,InnerEventHandler eventHandler, RefCountPtr eventArgs)
        {
                (static_cast<Implementation*>(this)->*eventHandler)(context,this,eventArgs);
        }

        void dispatchEvent(RegionContainerImpl* context,IInnerState* state, InnerEventHandler eventHandler, RefCountPtr eventArgs)
        {
                if(state)
                {
                        this->queueDispatchedEvent(sttcl::internal::DispatchedEvent<RegionContainerImpl,IInnerState,EventArgs>(context,state,eventHandler,eventArgs));
                }
        }

protected:
        void callDispatchedEventHandler(RegionContainerImpl* context,IInnerState* state,InnerEventHandler eventHandler,RefCountPtr eventArgs)
        {
                (state->*eventHandler)(context,this,eventArgs);
        }

};

template
< class RegionImpl
, class RegionContainerImpl
, class IInnerState
, class EventArgs
>
class RegionBaseImplWithoutEventArgs
: public RegionBase<RegionContainerImpl,IInnerState,EventArgs>
{
public:
    typedef RegionImpl Implementation;

    typedef RegionBase<RegionContainerImpl,IInnerState,EventArgs> RegionBaseClass;

//    typedef typename RegionBaseClass::RegionContainerClass RegionContainerClass;

    typedef typename RegionBaseClass::RefCountPtr RefCountPtr;

    typedef typename RegionBaseClass::InnerEventHandler InnerEventHandler;

    RegionBaseImplWithoutEventArgs(RegionContainerImpl* argRegionContainer)
    : RegionBaseClass(argRegionContainer)
    {}

    virtual ~RegionBaseImplWithoutEventArgs() {}

    virtual void handleBroadcastedEvent(RegionContainerImpl* context,InnerEventHandler eventHandler)
        {
                (static_cast<Implementation*>(this)->*eventHandler)(context,this);
        }

        void dispatchEvent(RegionContainerImpl* context,IInnerState* state, InnerEventHandler eventHandler)
        {
                if(state)
                {
                        RegionContainerImpl* regionContainerContext = static_cast<RegionContainerImpl*>(context);
                        queueDispatchedEvent(sttcl::internal::DispatchedEvent<RegionContainerImpl,IInnerState,void>(regionContainerContext,state,eventHandler,RefCountPtr()));
                }
        }

protected:
        void callDispatchedEventHandler(RegionContainerImpl* context,IInnerState* state,InnerEventHandler eventHandler,RefCountPtr eventArgs)
        {
                (state->*eventHandler)(context,this);
        }
};

template
< class RegionImpl
, class RegionContainerImpl
, class IInnerState
, class EventArgs
>
struct RegionBaseImplementationSelector
{
        typedef RegionBaseImplWithEventArgs<RegionImpl,RegionContainerImpl,IInnerState,EventArgs> RESULT_TYPE;

};

template
< class RegionImpl
, class RegionContainerImpl
, class IInnerState
>
struct RegionBaseImplementationSelector<RegionImpl,RegionContainerImpl,IInnerState,void>
{
        typedef RegionBaseImplWithoutEventArgs<RegionImpl,RegionContainerImpl,IInnerState,void> RESULT_TYPE;

};
}

template
< class RegionImpl
, class RegionContainerImpl
, class IInnerState
, class EventArgs = void
, CompositeStateHistoryType::Values HistoryType = CompositeStateHistoryType::None
, class StateThreadType = sttcl::internal::SttclThread<>
, class TimeDurationType = TimeDuration<STTCL_DEFAULT_TIMEDURATIONIMPL>
, class SemaphoreType = sttcl::internal::SttclSemaphore<STTCL_DEFAULT_SEMAPHOREIMPL,TimeDurationType>
, class MutexType = sttcl::internal::SttclMutex<STTCL_DEFAULT_MUTEXIMPL,TimeDurationType>
, class EventQueueType = sttcl::EventQueue<sttcl::internal::DispatchedEvent<RegionContainerImpl,IInnerState,EventArgs>,TimeDurationType,SemaphoreType,MutexType>
>
class Region
: public CompositeState
        < Region<RegionImpl,RegionContainerImpl,IInnerState,EventArgs,HistoryType,StateThreadType,TimeDurationType,SemaphoreType,MutexType,EventQueueType>
        , RegionContainerImpl
        , IInnerState
        , HistoryType
        , ActiveState
          < Region<RegionImpl,RegionContainerImpl,IInnerState,EventArgs,HistoryType,StateThreadType,TimeDurationType,SemaphoreType,MutexType,EventQueueType>
          , RegionContainerImpl
          , IInnerState
          , StateThreadType
          , TimeDurationType
          , SemaphoreType
          , MutexType
          >
        , StateMachine<RegionImpl, IInnerState>
        >
, public internal::RegionBaseImplementationSelector
        < RegionImpl
        , RegionContainerImpl
        , IInnerState
        , EventArgs
        >::RESULT_TYPE
{
public:
        friend class RegionBase<RegionContainerImpl,IInnerState,EventArgs>;

    typedef RegionImpl Implementation;

    typedef RegionContainerImpl Context;

    typedef Region
                        < RegionImpl
                        , RegionContainerImpl
                        , IInnerState
                        , EventArgs
                        , HistoryType
                        , StateThreadType
                , TimeDurationType
                , SemaphoreType
                , MutexType
                , EventQueueType
                > SelfClassType;
    typedef ActiveState
                  < SelfClassType
                  , RegionContainerImpl
                  , IInnerState
                  , StateThreadType
                  , TimeDurationType
                  , SemaphoreType
                  , MutexType
                  > ActiveStateImpl;

    typedef CompositeState
                < SelfClassType
                , RegionContainerImpl
                , IInnerState
                , HistoryType
                , ActiveStateImpl
                , StateMachine<RegionImpl, IInnerState>
                > CompositeStateBase;

    typedef typename internal::RegionBaseImplementationSelector<RegionImpl,RegionContainerImpl,IInnerState,EventArgs>::RESULT_TYPE SelectedRegionBase;

    typedef typename SelectedRegionBase::RegionBaseClass RegionBaseClass;

    typedef sttcl::internal::EventArgsInterfaceSelector<RegionContainerImpl,IInnerState,EventArgs> EventArgsSelectorType;

        typedef typename EventArgsSelectorType::RefCountPtr RefCountPtr;

        typedef typename EventArgsSelectorType::InnerEventHandler InnerEventHandler;

    typedef void (RegionBaseClass::*InternalEventHandler)(bool);

    typedef typename CompositeStateBase::StateImplementationBase StateImplementationBase;

    typedef typename CompositeStateBase::StateMachineImplementationBase RegionStateMachine;

    typedef typename CompositeStateBase::StateDoAction StateDoAction;

        typedef typename CompositeStateBase::CompositeStateHistoryBaseClass CompositeStateHistoryBaseClass;

        //typedef StateBase<RegionImpl,InnerEventHandler> InnerStateClass;
        typedef typename CompositeStateBase::InnerStateClass InnerStateClass;

        typedef typename CompositeStateBase::OuterStateInterface OuterStateInterface;

        typedef typename CompositeStateBase::StateInterface StateInterface;

        typedef StateBase<RegionImpl,IInnerState> RegionStateBase;

        typedef RegionStateBase StateBaseClass;

    typedef typename StateImplementationBase::StateThreadImpl RegionThreadImpl;

        Region(RegionContainerImpl* argRegionContainer, TimeDurationType argDoActionFrequency = TimeDurationType::Zero)
        : CompositeStateBase(&SelfClassType::regionDoAction)
        , SelectedRegionBase(argRegionContainer)
        , eventDispatchQueue()
        , checkEventFrequency(argDoActionFrequency)
        {
        }

        virtual ~Region()
        {
        }

        void dispatchInternalEvent(InternalEventHandler internalEventHandler, bool recursive)
        {
                eventDispatchQueue.push_back(sttcl::internal::DispatchedEvent<RegionContainerImpl,IInnerState,EventArgs>(internalEventHandler,recursive));
        }

    void changeStateImpl(RegionContainerImpl* context,IInnerState* newState)
    {
    }

        void changeState(RegionStateBase* newState)
        {
                RegionStateMachine::changeState(newState);
        }

        void startingRegionThread()
        {

        }

        void endingRegionThread()
        {

        }

    void entryImpl(Context* context)
    {
        CompositeStateBase::entryImpl(context);
    }

    void exitImpl(Context* context)
    {
        CompositeStateBase::exitImpl(context);
    }

    bool initializeImpl(bool force)
    {
        if(!RegionThreadImpl::isSelf(static_cast<StateImplementationBase*>(this)->getStateThread()))
        {
                        // dispatch initialization to region thread
                dispatchInternalEvent(&RegionBaseClass::internalInitialize,force);
        }
        else
        {
                internalInitialize(force);
        }
        return true;
    }

    inline void finalizeImpl(bool finalizeSubStateMachines)
    {
        if(!RegionThreadImpl::isSelf(static_cast<StateImplementationBase*>(this)->getStateThread()))
        {
                        // dispatch finalization to region thread
                        dispatchInternalEvent(&RegionBaseClass::internalFinalize,finalizeSubStateMachines);
        }
        else
        {
                internalFinalize(finalizeSubStateMachines);
        }
    }

    bool endDoActionRequestedImpl()
    {
        return //static_cast<RegionContainerImplementationBase*>(this)->isFinalized() ||
                   static_cast<StateImplementationBase*>(this)->endDoActionRequestedImpl();
    }

    void exitingDoActionImpl()
    {
                static_cast<RegionImpl*>(this)->endingRegionThread();
    }

    void joinDoActionThreadImpl()
    {
                static_cast<StateImplementationBase*>(this)->joinDoActionThreadImpl();
    }

    void unblockDoActionImpl()
    {
                static_cast<StateImplementationBase*>(this)->unblockDoActionImpl();
                unblockEventsAvailable();
    }

    void endDoImpl(RegionContainerImpl* context)
    {
           if(!RegionThreadImpl::isSelf(static_cast<StateImplementationBase*>(this)->getStateThread()))
           {
                   static_cast<StateImplementationBase*>(this)->endDoImpl(context);
           }
    }

private:
        virtual void queueDispatchedEvent(const sttcl::internal::DispatchedEvent<RegionContainerImpl,IInnerState,EventArgs>& dispatchedEvent)
        {
                eventDispatchQueue.push_back(dispatchedEvent);
        }

        virtual void enterRegion(RegionContainerImpl* context)
        {
                static_cast<StateBase<RegionContainerImpl,IInnerState>*>(this)->entry(context);
        }

        virtual void exitRegion(RegionContainerImpl* context)
        {
                static_cast<StateBase<RegionContainerImpl,IInnerState>*>(this)->exit(context);
        }

        virtual void startDoRegion(RegionContainerImpl* context)
        {
                static_cast<RegionImpl*>(this)->startingRegionThread();
                static_cast<StateBase<RegionContainerImpl,IInnerState>*>(this)->startDo(context);
        }

        virtual void endDoRegion(RegionContainerImpl* context)
        {
                static_cast<StateBase<RegionContainerImpl,IInnerState>*>(this)->endDo(context);
        }

        virtual void finalizeRegion(bool recursive)
        {
                static_cast<RegionImpl*>(this)->finalize(recursive);
        }

        virtual bool initializeRegion(bool recursive)
        {
                static_cast<RegionImpl*>(this)->initialize(recursive);
                return static_cast<RegionImpl*>(this)->isReady();
        }

        virtual bool isRegionInitialized()
        {
                return static_cast<RegionImpl*>(this)->isInitialized();
        }

        virtual bool isRegionFinalized()
        {
                return static_cast<RegionImpl*>(this)->isFinalized();
        }

        virtual bool isRegionThreadRunning() const
        {
                return static_cast<const RegionImpl*>(this)->isDoActionRunning();
        }

        virtual void joinRegionThread()
        {
                static_cast<RegionImpl*>(this)->joinDoActionThreadImpl();
        }

        virtual void internalInitialize(bool recursive)
        {
        static_cast<RegionStateMachine*>(this)->initializeImpl(recursive);
        }

        virtual void internalFinalize(bool recursive)
        {
        static_cast<RegionStateMachine*>(this)->finalizeImpl(recursive);
        typedef sttcl::internal::RegionContainer<RegionContainerImpl,IInnerState,EventArgs> IRegionContainer;
        IRegionContainer* iregionContainer = static_cast<IRegionContainer*>(RegionBaseClass::regionContainer);
        iregionContainer->regionCompleted(static_cast<RegionBase<RegionContainerImpl,IInnerState,EventArgs>*>(this));
        }

        void unblockEventsAvailable()
        {
                eventDispatchQueue.unblock();
        }

        bool checkEventsAvailable()
        {
                return eventDispatchQueue.waitForEvents(checkEventFrequency);
        }

        void regionDoAction(typename ActiveStateImpl::Context* context, bool firstCall)
        {
                if(checkEventsAvailable())
                {
                        while(!eventDispatchQueue.empty())
                        {
                                sttcl::internal::DispatchedEvent<RegionContainerImpl,IInnerState,EventArgs> dispatchedEvent = eventDispatchQueue.front();
                                eventDispatchQueue.pop_front();
                                if(dispatchedEvent.internalHandler)
                                {
                                        (this->*dispatchedEvent.internalHandler)(dispatchedEvent.recursiveInternalEvent);
                                }
                                else
                                {
                                        this->callDispatchedEventHandler(dispatchedEvent.context,dispatchedEvent.state,dispatchedEvent.handler,dispatchedEvent.eventArgs);
                                }
                        }
                }
        }

        EventQueueType eventDispatchQueue;
        TimeDurationType checkEventFrequency;
};

}

#endif /* REGION_H_ */