clock.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2013 Aldebaran Robotics. All rights reserved.
 * Use of this source code is governed by a BSD-style license that can be
 * found in the COPYING file.
 */

#pragma once
#ifndef _QI_CLOCK_HPP_
# define _QI_CLOCK_HPP_

# include <qi/api.hpp>
# include <qi/types.hpp>
# include <boost/chrono/chrono.hpp>

namespace qi
{
  typedef boost::chrono::duration<int64_t, boost::nano>         Duration;
  typedef boost::chrono::duration<int64_t, boost::nano>         NanoSeconds;
  typedef boost::chrono::duration<int64_t, boost::micro>        MicroSeconds;
  typedef boost::chrono::duration<int64_t, boost::milli>        MilliSeconds;
  typedef boost::chrono::duration<int64_t>                      Seconds;
  typedef boost::chrono::duration<int64_t, boost::ratio<60> >   Minutes;
  typedef boost::chrono::duration<int64_t, boost::ratio<3600> > Hours;

  class QI_API SteadyClock
  {
  public:
    typedef int64_t rep; 
    typedef boost::nano period; 
    typedef boost::chrono::duration<rep, period> duration; 

    typedef boost::chrono::time_point<SteadyClock> time_point;

    BOOST_STATIC_CONSTEXPR bool is_steady = boost::chrono::steady_clock::is_steady;

  public:
    QI_API_DEPRECATED
    typedef time_point SteadyClockTimePoint;

    enum Expect {
      Expect_SoonerOrLater, 
      Expect_Later,         
      Expect_Sooner         
    };

    static time_point now();
  };


  class QI_API Clock
  {
  public:
    typedef int64_t rep; 
    typedef boost::nano period; 
    typedef boost::chrono::duration<rep, period> duration; 

    typedef boost::chrono::time_point<Clock> time_point;

    BOOST_STATIC_CONSTEXPR bool is_steady = boost::chrono::steady_clock::is_steady;

  public:
    enum Expect {
      Expect_SoonerOrLater, 
      Expect_Later,         
      Expect_Sooner         
    };

    static time_point now();

    static uint32_t toUint32ms(const time_point &t) throw();
    static int32_t toInt32ms(const time_point &t) throw();

    static time_point fromUint32ms(uint32_t t_ms, time_point guess,
                                   Expect expect=Expect_SoonerOrLater) throw();
    static time_point fromInt32ms(int32_t t_ms, time_point guess,
                                  Expect expect=Expect_SoonerOrLater) throw();
  };

  class QI_API SystemClock
  {
  public:
    typedef int64_t rep; 
    typedef boost::nano period; 
    typedef boost::chrono::duration<rep, period> duration; 

    typedef boost::chrono::time_point<SystemClock> time_point;

    BOOST_STATIC_CONSTEXPR bool is_steady = false;

  public:

    QI_API_DEPRECATED
    typedef time_point WallClockTimePoint;

    static time_point now();

    static std::time_t to_time_t(const time_point& t) throw();

    // Converts std::time_t to a system clock time point
    static time_point from_time_t(const std::time_t &t) throw();
  };

  QI_API_DEPRECATED
  typedef SystemClock WallClock;


  typedef SteadyClock::time_point SteadyClockTimePoint; 
  typedef Clock::time_point ClockTimePoint; 
  typedef SystemClock::time_point SystemClockTimePoint; 
  QI_API_DEPRECATED
  typedef SystemClockTimePoint WallClockTimePoint; 

  QI_API_DEPRECATED
  inline QI_API SteadyClockTimePoint steadyClockNow() {
    return SteadyClock::now();
  }

  QI_API_DEPRECATED
  inline QI_API SystemClockTimePoint wallClockNow() {
    return SystemClock::now();
  }

  QI_API void sleepFor(const qi::Duration& d);
  template <class Rep, class Period>
  inline void sleepFor(const boost::chrono::duration<Rep, Period>& d);

  QI_API void sleepUntil(const SteadyClockTimePoint &t);
  template <class Duration>
  inline void sleepUntil(const boost::chrono::time_point<SteadyClock, Duration>& t);

  QI_API void sleepUntil(const ClockTimePoint &t);
  template <class Duration>
  inline void sleepUntil(const boost::chrono::time_point<Clock, Duration>& t);

  QI_API void sleepUntil(const SystemClockTimePoint& t);
  template <class Duration>
  inline void sleepUntil(const boost::chrono::time_point<SystemClock, Duration>& t);

  QI_API std::string toISO8601String(const SystemClockTimePoint &t);

  template <class DurationTo, class TimePointFrom>
  inline DurationTo durationSince(const TimePointFrom& t);
}

# ifdef __APPLE__
  // export template instanciation for RTTI issues across libraries. (mostly for OSX)
  template class QI_API boost::chrono::duration<int64_t, boost::nano>;
  template class QI_API boost::chrono::duration<int64_t, boost::micro>;
  template class QI_API boost::chrono::duration<int64_t, boost::milli>;
  template class QI_API boost::chrono::duration<int64_t>;
  template class QI_API boost::chrono::duration<int64_t, boost::ratio<60> >;
  template class QI_API boost::chrono::duration<int64_t, boost::ratio<3600> >;
  template class QI_API boost::chrono::time_point<qi::SteadyClock>;
  template class QI_API boost::chrono::time_point<qi::SystemClock>;
# endif

# include <qi/detail/clock.hxx>

#endif  // _QI_OS_HPP_