ExecutionContextBase.h

Go to the documentation of this file.

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

#include <coil/Factory.h>

#include <rtm/idl/RTCSkel.h>
#include <rtm/idl/OpenRTMSkel.h>
#include <rtm/Factory.h>
#include <rtm/ExecutionContextProfile.h>
#include <rtm/ExecutionContextWorker.h>

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

#define DEFAULT_EXECUTION_RATE 1000

namespace coil
{
  class Properties;
}

namespace RTC
{
  class ExecutionContextBase
  {
  public:
    ExecutionContextBase(const char* name);

    virtual ~ExecutionContextBase(void);

    virtual void init(coil::Properties& props);

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

    //============================================================
    // implementation functions for EC's CORBA operation
    //============================================================
    CORBA::Boolean isRunning();

    RTC::ReturnCode_t start(void);

    virtual RTC::ReturnCode_t stop(void);

    double getRate(void) const;
    coil::TimeValue getPeriod(void) const;
 
    RTC::ReturnCode_t setRate(double rate);

    RTC::ReturnCode_t addComponent(RTC::LightweightRTObject_ptr comp);

    RTC::ReturnCode_t removeComponent(RTC::LightweightRTObject_ptr comp);

    RTC::ReturnCode_t activateComponent(RTC::LightweightRTObject_ptr comp);

    RTC::ReturnCode_t deactivateComponent(RTC::LightweightRTObject_ptr comp);

    RTC::ReturnCode_t resetComponent(RTC::LightweightRTObject_ptr comp);

    RTC::LifeCycleState getComponentState(RTC::LightweightRTObject_ptr comp);
    const char* getStateString(RTC::LifeCycleState state);
    
    RTC::ExecutionKind getKind(void) const;

    RTC::ExecutionContextProfile* getProfile(void);

    //============================================================
    // Delegated functions to ExecutionContextProfile
    //============================================================
    void setObjRef(RTC::ExecutionContextService_ptr ec_ptr);

    RTC::ExecutionContextService_ptr getObjRef(void) const;

    const char* getKindString(RTC::ExecutionKind kind) const;

    RTC::ReturnCode_t setKind(RTC::ExecutionKind kind);

    RTC::ReturnCode_t setOwner(RTC::LightweightRTObject_ptr comp);

    const RTC::RTObject_ptr getOwner() const;

    const RTC::RTCList& getComponentList() const;

    void setProperties(coil::Properties& props);

    const coil::Properties getProperties() const;

    const RTC::ExecutionContextProfile& getProfile(void) const;
    // end of delegated functions to ExecutionContextProfile
    //============================================================

    //============================================================
    // Delegated functions to ExecutionContextWorker
    //============================================================
    bool isAllCurrentState(RTC::LifeCycleState state)
    {
      return m_worker.isAllCurrentState(state);
    };
    bool isAllNextState(RTC::LifeCycleState state)
    {
      return m_worker.isAllNextState(state);
    };
    bool isOneOfCurrentState(RTC::LifeCycleState state)
    {
      return m_worker.isOneOfCurrentState(state);
    };
    bool isOneOfNextState(RTC::LifeCycleState state)
    {
      return m_worker.isOneOfNextState(state);
    };
    
    void invokeWorker()       { m_worker.invokeWorker(); }
    void invokeWorkerPreDo()  { m_worker.invokeWorkerPreDo(); }
    void invokeWorkerDo()     { m_worker.invokeWorkerDo(); }
    void invokeWorkerPostDo() { m_worker.invokeWorkerPostDo(); }


  protected:
    // template virtual functions related to start/stop
    virtual bool onIsRunning(bool running) { return running; }
    virtual RTC::ReturnCode_t onStarting() { return RTC::RTC_OK; }
    virtual RTC::ReturnCode_t onStarted() { return RTC::RTC_OK; }
    virtual RTC::ReturnCode_t onStopping() { return RTC::RTC_OK; }
    virtual RTC::ReturnCode_t onStopped() { return RTC::RTC_OK; }

    // template virtual functions getting/setting execution rate
    virtual double onGetRate(double rate) const { return rate; }
    virtual double onSettingRate(double rate) { return rate; }
    virtual RTC::ReturnCode_t onSetRate(double rate) { return RTC::RTC_OK; }

    // template virtual functions adding/removing component
    virtual RTC::ReturnCode_t
    onAddingComponent(RTC::LightweightRTObject_ptr rtobj)
    {
      return RTC::RTC_OK;
    }
    virtual RTC::ReturnCode_t
    onAddedComponent(RTC::LightweightRTObject_ptr rtobj)
    {
      return RTC::RTC_OK;
    }
    virtual RTC::ReturnCode_t
    onRemovingComponent(RTC::LightweightRTObject_ptr rtobj)
    {
      return RTC::RTC_OK;
    }
    virtual RTC::ReturnCode_t
    onRemovedComponent(RTC::LightweightRTObject_ptr rtobj)
    {
      return RTC::RTC_OK;
    }

    // template virtual functions related to activation/deactivation/reset
    virtual RTC::ReturnCode_t
    onActivating(RTC::LightweightRTObject_ptr comp)
    {
      return RTC::RTC_OK;
    }
    virtual RTC::ReturnCode_t
    onWaitingActivated(RTC_impl::RTObjectStateMachine* comp, long int count)
    {
      return RTC::RTC_OK;
    }
    virtual RTC::ReturnCode_t
    onActivated(RTC_impl::RTObjectStateMachine* comp,
                                     long int count)
    {
      return RTC::RTC_OK;
    }
    virtual RTC::ReturnCode_t
    onDeactivating(RTC::LightweightRTObject_ptr comp)
    {
      return RTC::RTC_OK;
    }
    virtual RTC::ReturnCode_t
    onWaitingDeactivated(RTC_impl::RTObjectStateMachine* comp, long int count)
    {
      return RTC::RTC_OK;
    }
    virtual RTC::ReturnCode_t
    onDeactivated(RTC_impl::RTObjectStateMachine* comp, long int count)
    {
      return RTC::RTC_OK;
    }
    virtual RTC::ReturnCode_t onResetting(RTC::LightweightRTObject_ptr comp)
    {
      return RTC::RTC_OK;
    }
    virtual RTC::ReturnCode_t
    onWaitingReset(RTC_impl::RTObjectStateMachine* comp, long int count)
    {
      return RTC::RTC_OK;
    }
    virtual RTC::ReturnCode_t
    onReset(RTC_impl::RTObjectStateMachine* comp, long int count)
    {
      return RTC::RTC_OK;
    }

    virtual RTC::LifeCycleState
    onGetComponentState(RTC::LifeCycleState state)
    {
      return state;
    }
    virtual RTC::ExecutionKind
    onGetKind(RTC::ExecutionKind kind) const
    {
      return kind;
    }
    virtual RTC::ExecutionContextProfile*
    onGetProfile(RTC::ExecutionContextProfile*& profile)
    {
      return profile;
    }

  private:
    bool setExecutionRate(coil::Properties& props);
    bool setTransitionMode(coil::Properties& props,
                           const char* key, bool& flag);
    bool setTimeout(coil::Properties& props, const char* key,
                    coil::TimeValue& timevalue);

    RTC::ReturnCode_t waitForActivated(RTC_impl::RTObjectStateMachine* rtobj);
    RTC::ReturnCode_t waitForDeactivated(RTC_impl::RTObjectStateMachine* rtobj);
    RTC::ReturnCode_t waitForReset(RTC_impl::RTObjectStateMachine* rtobj);
    
  protected:
    mutable RTC::Logger rtclog;

    RTC_impl::ExecutionContextWorker m_worker;
    RTC_impl::ExecutionContextProfile m_profile;

    coil::TimeValue m_activationTimeout;
    coil::TimeValue m_deactivationTimeout;
    coil::TimeValue m_resetTimeout;

    bool m_syncActivation;
    bool m_syncDeactivation;
    bool m_syncReset;
  };  // class ExecutionContextBase

  typedef coil::GlobalFactory<ExecutionContextBase> ExecutionContextFactory;

#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
  EXTERN template class DLL_PLUGIN coil::GlobalFactory<ExecutionContextBase>;
#endif
};  // namespace RTC

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

#ifdef __GNUC__
extern template class coil::Singleton<coil::GlobalFactory<RTC::ExecutionContextBase> >;
#endif

#endif // RTC_EXECUTIONCONTEXTBASE_H