Timer.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2006-2021 Istituto Italiano di Tecnologia (IIT)
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef YARP_OS_TIMER_H
#define YARP_OS_TIMER_H
 
#include <yarp/os/api.h>
 
#ifndef YARP_NO_DEPRECATED // since YARP 3.3
#define YARP_INCLUDING_DEPRECATED_HEADER_ON_PURPOSE
#include <yarp/os/Mutex.h>
#undef YARP_INCLUDING_DEPRECATED_HEADER_ON_PURPOSE
#endif
 
#include <functional>
#include <mutex>
 
namespace yarp {
namespace os {
 
struct YARP_os_API YarpTimerEvent
{
    double lastExpected;
 
    double lastReal;
 
    double currentExpected;
 
    double currentReal;
 
    double lastDuration;
 
    unsigned int runCount;
};
 
struct YARP_os_API TimerSettings
{
    TimerSettings(double inPeriod) :
            period(inPeriod),
            totalTime(0.0),
            totalRunCount(0),
            tolerance(0.001)
    {
    }
    TimerSettings(double inPeriod, size_t count, double seconds) :
            period(inPeriod),
            totalTime(seconds),
            totalRunCount(count),
            tolerance(0.001)
    {
    }
    TimerSettings(double inPeriod, size_t count, double seconds, double inTollerance) :
            period(inPeriod),
            totalTime(seconds),
            totalRunCount(count),
            tolerance(inTollerance)
    {
    }
 
    bool operator==(const TimerSettings& rhs) const
    {
        return period == rhs.period && totalTime == rhs.totalTime && totalRunCount == rhs.totalRunCount && tolerance == rhs.tolerance;
    }
 
 
    double period;
    double totalTime;
    size_t totalRunCount;
    double tolerance;
};
 
class YARP_os_API Timer
{
public:
    typedef std::function<bool(const yarp::os::YarpTimerEvent&)> TimerCallback;
    Timer(const Timer&) = delete;
    Timer operator=(const Timer&) = delete;
 
#ifndef YARP_NO_DEPRECATED // Since YARP 3.3
YARP_WARNING_PUSH
YARP_DISABLE_DEPRECATED_WARNING
    Timer(const yarp::os::TimerSettings& settings,
          const TimerCallback& callback,
          bool newThread,
          yarp::os::Mutex* mutex);
 
    template <class T>
    Timer(const yarp::os::TimerSettings& settings,
          bool (T::*callback)(const yarp::os::YarpTimerEvent&),
          T* object,
          bool newThread,
          yarp::os::Mutex* mutex) :
 
            Timer(settings, std::bind(callback, object, std::placeholders::_1), newThread, mutex)
    {
    }
 
    template <class T>
    Timer(const yarp::os::TimerSettings& settings,
          bool (T::*callback)(const yarp::os::YarpTimerEvent&) const,
          const T* object,
          bool newThread,
          yarp::os::Mutex* mutex) :
 
            Timer(settings, std::bind(callback, object, std::placeholders::_1), newThread, mutex)
    {
    }
YARP_WARNING_POP
#endif
 
    Timer(const yarp::os::TimerSettings& settings,
          const TimerCallback& callback,
          bool newThread,
          std::mutex* mutex = nullptr);
 
    template <class T>
    Timer(const yarp::os::TimerSettings& settings,
          bool (T::*callback)(const yarp::os::YarpTimerEvent&),
          T* object,
          bool newThread,
          std::mutex* mutex = nullptr) :
 
            Timer(settings, std::bind(callback, object, std::placeholders::_1), newThread, mutex)
    {
    }
 
    template <class T>
    Timer(const yarp::os::TimerSettings& settings,
          bool (T::*callback)(const yarp::os::YarpTimerEvent&) const,
          const T* object,
          bool newThread,
          std::mutex* mutex = nullptr) :
 
            Timer(settings, std::bind(callback, object, std::placeholders::_1), newThread, mutex)
    {
    }
 
    virtual ~Timer();
 
    void setSettings(const yarp::os::TimerSettings& settings);
 
    const yarp::os::TimerSettings getSettings();
 
    virtual bool start();
 
    virtual bool step();
 
    virtual void stop();
 
    virtual bool isRunning();
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    class PrivateImpl;
 
private:
    PrivateImpl* impl;
#endif // DOXYGEN_SHOULD_SKIP_THIS
};
 
} // namespace os
} // namespace yarp
 
#endif // YARP_OS_TIMER_H