ExecutionContextWorker.h

Go to the documentation of this file.

// -*- C++ -*-
#ifndef RTC_EXECUTIONCONTEXTWORKER_H
#define RTC_EXECUTIONCONTEXTWORKER_H

#include <coil/Mutex.h>
#include <coil/Condition.h>
#include <vector>

#include <rtm/idl/RTCSkel.h>
#include <rtm/SystemLogger.h>
//#include <rtm/StateMachine.h>
//#include <rtm/RTObjectStateMachine.h>

#define NUM_OF_LIFECYCLESTATE 4

#ifdef WIN32
#pragma warning( disable : 4290 )
#endif

namespace RTC
{
  class RTObject_impl;
};
namespace RTC_impl
{
  class RTObjectStateMachine;
  typedef RTC::LightweightRTObject_ptr LightweightRTObject_ptr;
  typedef RTC::LightweightRTObject_var LightweightRTObject_var;
  class ExecutionContextWorker
  {
    typedef coil::Guard<coil::Mutex> Guard;

  public:
    ExecutionContextWorker();


    virtual ~ExecutionContextWorker(void);

    //============================================================
    // Object reference to EC
    //============================================================
    void setECRef(RTC::ExecutionContextService_ptr ref);
    RTC::ExecutionContextService_ptr getECRef();

    //============================================================
    // ExecutionContext
    //============================================================
    CORBA::Boolean isRunning(void);

    RTC::ReturnCode_t start(void);

    RTC::ReturnCode_t stop(void);

    RTC::ReturnCode_t startThread(void);

    RTC::ReturnCode_t stopThread(void);

    
    RTC::ReturnCode_t rateChanged();

    RTC::ReturnCode_t activateComponent(RTC::LightweightRTObject_ptr comp,
                                        RTObjectStateMachine*& rtobj);
    RTC::ReturnCode_t waitActivateComplete(RTObjectStateMachine*& rtobj,
                                           coil::TimeValue timeout = 1.0,
                                           long int cycle = 1000);
    RTC::ReturnCode_t deactivateComponent(RTC::LightweightRTObject_ptr comp,
                                          RTObjectStateMachine*& rtobj);
    RTC::ReturnCode_t waitDeactivateComplete(RTObjectStateMachine*& rtobj,
                                             coil::TimeValue timeout = 1.0,
                                             long int cycle = 1000);

    RTC::ReturnCode_t resetComponent(RTC::LightweightRTObject_ptr com,
                                     RTObjectStateMachine*& rtobj);
    RTC::ReturnCode_t waitResetComplete(RTObjectStateMachine*& rtobj,
                                        coil::TimeValue timeout = 1.0,
                                        long int cycle = 1000);

    RTC::LifeCycleState getComponentState(RTC::LightweightRTObject_ptr comp);
    const char* getStateString(RTC::LifeCycleState state)
    {
      const char* st[] = {
        "CREATED_STATE",
        "INACTIVE_STATE",
        "ACTIVE_STATE",
        "ERROR_STATE"
      };
      return state >= RTC::CREATED_STATE && state <= RTC::ERROR_STATE ?
        st[state] : "";
    }
    RTC::ReturnCode_t addComponent(RTC::LightweightRTObject_ptr comp);

    RTC::ReturnCode_t bindComponent(RTC::RTObject_impl* rtc);

    RTC::ReturnCode_t removeComponent(RTC::LightweightRTObject_ptr comp);
    RTObjectStateMachine* findComponent(RTC::LightweightRTObject_ptr comp);

    bool isAllCurrentState(RTC::LifeCycleState state);
    bool isAllNextState(RTC::LifeCycleState state);
    bool isOneOfCurrentState(RTC::LifeCycleState state);
    bool isOneOfNextState(RTC::LifeCycleState state);

    void invokeWorker();
    void invokeWorkerPreDo();
    void invokeWorkerDo();
    void invokeWorkerPostDo();

    void updateComponentList();

    //------------------------------------------------------------
    // member variables
  protected:
    RTC::Logger rtclog;

    RTC::ExecutionContextService_var m_ref;

    bool m_running;

    std::vector<RTC_impl::RTObjectStateMachine*> m_comps;
    mutable coil::Mutex m_mutex;
    std::vector<RTC_impl::RTObjectStateMachine*> m_addedComps;
    mutable coil::Mutex m_addedMutex;
    std::vector<RTC_impl::RTObjectStateMachine*> m_removedComps;
    mutable coil::Mutex m_removedMutex;
    typedef std::vector<RTC_impl::RTObjectStateMachine*>::iterator CompItr;

  }; // class PeriodicExecutionContext
}; // namespace RTC

#ifdef WIN32
#pragma warning( default : 4290 )
#endif

#endif // RTC_PERIODICEXECUTIONCONTEXT_H