ConcurrentCompositeState.h

Go to the documentation of this file.

#ifndef CONCURRENTCOMPOSITESTATE_H_
#define CONCURRENTCOMPOSITESTATE_H_

#include "CompositeState.h"
#include "Region.h"

namespace sttcl
{
namespace internal
{

template
< class CompositeStateImpl
, class IInnerState
, class EventArgs
>
class RegionContainer
{
public:
        typedef RegionBase<CompositeStateImpl,IInnerState,EventArgs> RegionBaseType;

        virtual ~RegionContainer() {}

    virtual void regionCompleted(RegionBaseType* region) = 0;
};


template
< class CompositeStateImpl
, class StateMachineImpl
, class IInnerState
, unsigned int NumOfRegions
, class EventArgs
, class StateBaseImpl
>
class ConcurrentCompositeStateWithEventArgs
: public StateBaseImpl
{
public:
//    void changeStateImpl(StateMachineImpl* context,StateBaseImpl* newState)
//    {
//      StateBaseImpl::changeState(context,newState);
//    }

protected:

        typedef RegionBase<CompositeStateImpl,IInnerState,EventArgs> RegionBaseType;
        typedef RegionBaseType* RegionsArray[NumOfRegions];

        typedef StateMachineImpl Context;

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

        typedef typename EventArgsSelectorType::RefCountPtr RefCountPtr;

        typedef typename StateMachineImpl::StateInterface OuterEventHandler;

        typedef typename EventArgsSelectorType::InnerEventHandler InnerEventHandler;

        ConcurrentCompositeStateWithEventArgs(const RegionsArray& argRegions)
        : regions(argRegions)
        {
        }

        void broadcastEvent(Context* context,InnerEventHandler eventHandler,RefCountPtr eventArgs)
        {
                bool allRegionsFinalized = true;
                for(unsigned int i = 0; i < NumOfRegions; ++i)
                {
                        if(!regions[i]->isRegionFinalized())
                        {
                                allRegionsFinalized = false;
                                regions[i]->handleBroadcastedEvent(static_cast<CompositeStateImpl*>(this),eventHandler,eventArgs);
                        }
                        else
                        {
                                if(regions[i]->isRegionThreadRunning())
                                {
                                        regions[i]->endDoRegion(static_cast<CompositeStateImpl*>(this));
                                        regions[i]->joinRegionThread();
                                }
                        }
                }
                if(allRegionsFinalized)
                {
                        context->subStateMachineCompleted(this);
                }
        }

        const RegionsArray& regions;

};

template
< class CompositeStateImpl
, class StateMachineImpl
, class IInnerState
, unsigned int NumOfRegions
, class StateBaseImpl
>
class ConcurrentCompositeStateWithoutEventArgs
: public StateBaseImpl
{
public:
//    void changeStateImpl(StateMachineImpl* context,StateBaseImpl* newState)
//    {
//      StateBaseImpl::changeState(context,newState);
//    }
protected:

        typedef RegionBase<CompositeStateImpl,IInnerState,void> RegionBaseType;

        typedef RegionBaseType* RegionsArray[NumOfRegions];

        typedef StateMachineImpl Context;

        typedef sttcl::internal::EventArgsInterfaceSelector<CompositeStateImpl,IInnerState,void> EventArgsSelectorType;

        typedef typename EventArgsSelectorType::RefCountPtr RefCountPtr;

        typedef typename StateMachineImpl::StateInterface OuterEventHandler;

        typedef typename EventArgsSelectorType::InnerEventHandler InnerEventHandler;

        ConcurrentCompositeStateWithoutEventArgs(const RegionsArray& argRegions)
        : regions(argRegions)
        {
        }

        void broadcastEvent(Context* context,InnerEventHandler eventHandler)
        {
                bool allRegionsFinalized = true;
                for(unsigned int i = 0; i < NumOfRegions; ++i)
                {
                        if(!regions[i]->isRegionFinalized())
                        {
                                allRegionsFinalized = false;
                                regions[i]->handleBroadcastedEvent(static_cast<CompositeStateImpl*>(this),eventHandler);
                        }
                        else
                        {
                                if(regions[i]->isRegionThreadRunning())
                                {
                                        regions[i]->endDoRegion(static_cast<CompositeStateImpl*>(this));
                                        regions[i]->joinRegionThread();
                                }
                        }
                }
                if(allRegionsFinalized)
                {
                        context->subStateMachineCompleted(this);
                }
        }

        const RegionsArray& regions;
};

template
< class CompositeStateImpl
, class StateMachineImpl
, class IInnerState
, unsigned int NumOfRegions
, class EventArgs
, class StateBaseImpl
>
struct ConcurrentCompositeBaseImplementationSelector
{
        typedef ConcurrentCompositeStateWithEventArgs<CompositeStateImpl,StateMachineImpl,IInnerState,NumOfRegions,EventArgs,StateBaseImpl> RESULT_TYPE;

};

template
< class CompositeStateImpl
, class StateMachineImpl
, class IInnerState
, unsigned int NumOfRegions
, class StateBaseImpl
>
struct ConcurrentCompositeBaseImplementationSelector<CompositeStateImpl,StateMachineImpl,IInnerState,NumOfRegions,void,StateBaseImpl>
{
        typedef ConcurrentCompositeStateWithoutEventArgs<CompositeStateImpl,StateMachineImpl,IInnerState,NumOfRegions,StateBaseImpl> RESULT_TYPE;

};

template
< class CompositeStateImpl
, class StateMachineImpl
, class IInnerState
, unsigned int NumOfRegions
, class EventArgs
, class StateBaseImpl
>
class ConcurrentCompositeStateBase
: public ConcurrentCompositeBaseImplementationSelector
          < CompositeStateImpl
          , StateMachineImpl
          , IInnerState
          , NumOfRegions
          , EventArgs
          , StateBaseImpl
          >::RESULT_TYPE
, public RegionContainer<CompositeStateImpl,IInnerState,EventArgs>
{
public:
        typedef ConcurrentCompositeBaseImplementationSelector
                          < CompositeStateImpl
                          , StateMachineImpl
                          , IInnerState
                          , NumOfRegions
                          , EventArgs
                          , StateBaseImpl
                          > BaseClassSelectorType;

        typedef typename BaseClassSelectorType::RESULT_TYPE BaseClassType;

    typedef StateBaseImpl StateImplementationBase;
        typedef typename StateMachineImpl::StateInterface StateInterface;
        typedef typename StateMachineImpl::StateBaseClass StateBaseClass;
        typedef typename BaseClassType::RegionBaseType RegionBaseType;
        typedef typename BaseClassType::RegionsArray RegionsArray;
        typedef StateMachineImpl Context;

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

        typedef typename EventArgsSelectorType::RefCountPtr RefCountPtr;

        typedef typename StateMachineImpl::StateInterface OuterEventHandler;

        typedef typename EventArgsSelectorType::InnerEventHandler InnerEventHandler;

    ConcurrentCompositeStateBase(Context* argContextStateMachine, const RegionsArray& argRegions)
        : BaseClassType(argRegions)
        , contextStateMachine_(argContextStateMachine)
        {
        }

        virtual ~ConcurrentCompositeStateBase()
        {
        }

    inline void entryImpl(Context* context)
    {
        StateImplementationBase::entryImpl(context);
                for(unsigned int i = 0; i < NumOfRegions; ++i)
                {
                        if(BaseClassType::regions[i]->isRegionInitialized())
                        {
                                BaseClassType::regions[i]->enterRegion(static_cast<CompositeStateImpl*>(this));
                        }
                }
    }

    inline void exitImpl(Context* context)
    {
                for(unsigned int i = 0; i < NumOfRegions; ++i)
                {
                        if(BaseClassType::regions[i]->isRegionInitialized())
                        {
                                BaseClassType::regions[i]->exitRegion(static_cast<CompositeStateImpl*>(this));
                        }
                }
        StateImplementationBase::exitImpl(context);
    }

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

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

    bool initializeImpl(bool recursive)
    {
        bool result = true;
                for(unsigned int i = 0; i < NumOfRegions; ++i)
                {
                        if(!BaseClassType::regions[i]->initializeRegion(recursive))
                        {
                                result = false;
                        }
                }
        return result;
    }

    void finalize(bool finalizeSubStateMachines = true)
    {
        finalizeImpl(finalizeSubStateMachines);
    }

    void finalizeImpl(bool recursive)
    {
                for(unsigned int i = 0; i < NumOfRegions; ++i)
                {
                        if(!BaseClassType::regions[i]->isRegionFinalized())
                        {
                                BaseClassType::regions[i]->finalizeRegion(recursive);
                        }
                }
    }

    void startDoImpl(Context* context)
    {
                for(unsigned int i = 0; i < NumOfRegions; ++i)
                {
                        BaseClassType::regions[i]->startDoRegion(static_cast<CompositeStateImpl*>(this));
                }
    }

    void endDoImpl(Context* context)
    {
                for(unsigned int i = 0; i < NumOfRegions; ++i)
                {
                        if(BaseClassType::regions[i]->isRegionThreadRunning())
                        {
                                BaseClassType::regions[i]->endDoRegion(static_cast<CompositeStateImpl*>(this));
                        }
                }
    }

    void regionCompletedImpl(RegionBaseType* region)
    {
        bool allRegionsCompleted = true;
                for(unsigned int i = 0; i < NumOfRegions; ++i)
                {
                        if(!BaseClassType::regions[i]->isRegionFinalized())
                        {
                                allRegionsCompleted = false;
                        }
                }
                if(allRegionsCompleted)
                {
                        context()->subStateMachineCompleted(this);
                }
    }

    Context* context() const { return contextStateMachine_; }

private:
    virtual void regionCompleted(RegionBaseType* region)
    {
        static_cast<CompositeStateImpl*>(this)->regionCompletedImpl(region);
    }

    Context* contextStateMachine_;
};

}

template
< class CompositeStateImpl
, class StateMachineImpl
, class IInnerState
, unsigned int NumOfRegions = 1
, class EventArgs = void
, class StateBaseImpl = State<CompositeStateImpl,StateMachineImpl,typename StateMachineImpl::StateInterface>
>
class ConcurrentCompositeState
: public sttcl::internal::ConcurrentCompositeStateBase
                  < CompositeStateImpl
                  , StateMachineImpl
                  , IInnerState
                  , NumOfRegions
                  , EventArgs
                  , StateBaseImpl
                  >
{
public:
        typedef sttcl::internal::ConcurrentCompositeStateBase
                          < CompositeStateImpl
                          , StateMachineImpl
                          , IInnerState
                          , NumOfRegions
                          , EventArgs
                          , StateBaseImpl
                          > ConcurrenCompositeStateBaseType;

        typedef StateMachineImpl StateMachineClass;

        typedef typename ConcurrenCompositeStateBaseType::RegionBaseType RegionsBaseType;

        typedef typename ConcurrenCompositeStateBaseType::RegionsArray RegionsArray;

        typedef IInnerState InnerStateInterface;

        typedef typename StateMachineImpl::StateInterface OuterStateInterface;
        ConcurrentCompositeState(StateMachineImpl* context, const RegionsArray& argRegions)
        : ConcurrenCompositeStateBaseType(context,argRegions)
        {
        }

        virtual ~ConcurrentCompositeState()
        {
        }

    void changeState(StateMachineImpl* context,sttcl::StateBase<StateMachineImpl,OuterStateInterface>* newState)
    {
        static_cast<CompositeStateImpl*>(this)->changeStateImpl(context,newState);
    }

};
}

#endif /* CONCURRENTCOMPOSITESTATE_H_ */