Timer.h

Go to the documentation of this file.

 
#include <boost/date_time.hpp>
#include "RobotRaconteur/DataTypes.h"
 
#ifndef ROBOTRACONTEUR_EMSCRIPTEN
#include <boost/asio/deadline_timer.hpp>
#endif
 
#include <boost/system/error_code.hpp>
 
#pragma once
 
namespace RobotRaconteur
{
 
struct ROBOTRACONTEUR_CORE_API TimerEvent
{
    bool stopped;
    boost::posix_time::ptime last_expected;
    boost::posix_time::ptime last_real;
    boost::posix_time::ptime current_expected;
    boost::posix_time::ptime current_real;
 
    TimerEvent();
};
 
class ROBOTRACONTEUR_CORE_API Timer : private boost::noncopyable
{
  public:
    virtual void Start() = 0;
 
    virtual void Stop() = 0;
 
    virtual void TryStop() = 0;
 
    virtual boost::posix_time::time_duration GetPeriod() = 0;
 
    virtual void SetPeriod(const boost::posix_time::time_duration& period) = 0;
 
    virtual bool IsRunning() = 0;
 
    virtual void Clear() = 0;
 
    virtual ~Timer() {}
};
 
class ROBOTRACONTEUR_CORE_API RobotRaconteurNode;
 
class ROBOTRACONTEUR_CORE_API Rate : private boost::noncopyable
{
 
  public:
    virtual void Sleep() = 0;
 
    virtual ~Rate(){};
};
 
class ROBOTRACONTEUR_CORE_API WallRate : public Rate
{
  protected:
    RR_WEAK_PTR<RobotRaconteurNode> node;
    boost::posix_time::time_duration period;
    boost::posix_time::ptime start_time;
    boost::posix_time::ptime last_time;
 
#if !defined(ROBOTRACONTEUR_EMSCRIPTEN) && !defined(ROBOTRACONTEUR_WINDOWS)
    boost::asio::deadline_timer timer;
#endif
 
#ifdef ROBOTRACONTEUR_WINDOWS
    boost::shared_ptr<void> timer_handle;
#endif
#ifdef ROBOTRACONTEUR_LINUX
    timespec ts;
#endif
 
  public:
    WallRate(double frequency, const RR_SHARED_PTR<RobotRaconteurNode>& node = RR_SHARED_PTR<RobotRaconteurNode>());
 
    RR_OVIRTUAL void Sleep() RR_OVERRIDE;
 
    RR_OVIRTUAL ~WallRate() RR_OVERRIDE {}
};
 
class ROBOTRACONTEUR_CORE_API WallTimer : public Timer, public RR_ENABLE_SHARED_FROM_THIS<WallTimer>
{
  protected:
    boost::posix_time::time_duration period;
    boost::posix_time::ptime start_time;
    boost::posix_time::ptime actual_last_time;
    boost::posix_time::ptime last_time;
    bool oneshot;
 
    bool running;
    boost::mutex running_lock;
 
    boost::function<void(const TimerEvent&)> handler;
 
#ifndef ROBOTRACONTEUR_EMSCRIPTEN
    RR_SHARED_PTR<boost::asio::deadline_timer> timer;
#else
    boost::initialized<long> em_timer;
    static std::map<void*, RR_SHARED_PTR<WallTimer> > em_timers;
#endif
 
    RR_WEAK_PTR<RobotRaconteurNode> node;
 
#ifndef ROBOTRACONTEUR_EMSCRIPTEN
    void timer_handler(const boost::system::error_code& ec);
#else
    friend void timer_handler(void* userData);
    void timer_handler1();
    static void node_shutdown(RobotRaconteurNode* node);
#endif
 
  public:
    WallTimer(const boost::posix_time::time_duration& period, boost::function<void(const TimerEvent&)> handler,
              bool oneshot, const RR_SHARED_PTR<RobotRaconteurNode>& node = RR_SHARED_PTR<RobotRaconteurNode>());
 
    RR_OVIRTUAL void Start() RR_OVERRIDE;
 
    RR_OVIRTUAL void Stop() RR_OVERRIDE;
 
    RR_OVIRTUAL void TryStop() RR_OVERRIDE;
 
    RR_OVIRTUAL boost::posix_time::time_duration GetPeriod() RR_OVERRIDE;
 
    RR_OVIRTUAL void SetPeriod(const boost::posix_time::time_duration& period) RR_OVERRIDE;
 
    RR_OVIRTUAL bool IsRunning() RR_OVERRIDE;
 
    RR_OVIRTUAL void Clear() RR_OVERRIDE;
 
    RR_OVIRTUAL ~WallTimer() RR_OVERRIDE {}
};
 
#ifndef ROBOTRACONTEUR_NO_CXX11_TEMPLATE_ALIASES
using TimerPtr = RR_SHARED_PTR<Timer>;
using RatePtr = RR_SHARED_PTR<Rate>;
#endif
 
void HighResolutionSleep(const boost::posix_time::time_duration& duration);
 
} // namespace RobotRaconteur