time_utils.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <ctime>
#include <string>
 
#include <cras_cpp_common/expected.hpp>
#include <ros/duration.h>
#include <ros/rate.h>
#include <ros/time.h>
 
namespace cras
{
 
template<typename T, typename ::std::enable_if_t<
    ::std::is_same<T, ::ros::Time>::value ||
    ::std::is_same<T, ::ros::WallTime>::value ||
    ::std::is_same<T, ::ros::SteadyTime>::value
  >* = nullptr>
struct DurationType
{
};
 
template<> struct DurationType<ros::Time>
{
  typedef ::ros::Duration value;
};
 
template<> struct DurationType<ros::WallTime>
{
  typedef ::ros::WallDuration value;
};
 
template<> struct DurationType<ros::SteadyTime>
{
  typedef ::ros::WallDuration value;
};
 
template<
  typename T1,
  typename T2,
  typename ::std::enable_if_t<
    ::std::is_same<T1, ::ros::Time>::value ||
    ::std::is_same<T1, ::ros::WallTime>::value ||
    ::std::is_same<T1, ::ros::SteadyTime>::value>* = nullptr,
  typename ::std::enable_if_t<
    ::std::is_same<T2, ::ros::Time>::value ||
    ::std::is_same<T2, ::ros::WallTime>::value ||
    ::std::is_same<T2, ::ros::SteadyTime>::value>* = nullptr
>
inline T1 convertTime(const T2& time)
{
  return T1{time.sec, time.nsec};
}
 
template<
  typename D1,
  typename D2,
  typename ::std::enable_if_t<
    ::std::is_same<D1, ::ros::Duration>::value ||
    ::std::is_same<D1, ::ros::WallDuration>::value>* = nullptr,
  typename ::std::enable_if_t<
    ::std::is_same<D2, ::ros::Duration>::value ||
    ::std::is_same<D2, ::ros::WallDuration>::value>* = nullptr
>
inline D1 convertDuration(const D2& duration)
{
  return D1{duration.sec, duration.nsec};
}
 
::ros::Duration remainingTime(const ::ros::Time& query, double timeout);
 
::ros::Duration remainingTime(const ::ros::Time& query, const ::ros::Duration& timeout);
 
double frequency(const ::ros::Rate& rate, bool maxCycleTimeMeansZero = false);
 
double frequency(const ::ros::WallRate& rate, bool maxCycleTimeMeansZero = false);
 
::ros::Rate safeRate(double frequency);
 
::ros::WallRate safeWallRate(double frequency);
 
::ros::Time nowFallbackToWall();
 
::ros::Time saturateAdd(const ::ros::Time& time, const ::ros::Duration& duration);
 
::ros::WallTime saturateAdd(const ::ros::WallTime& time, const ::ros::WallDuration& duration);
 
::ros::SteadyTime saturateAdd(const ::ros::SteadyTime& time, const ::ros::WallDuration& duration);
 
::tm toStructTm(const ::ros::Time& time);
 
inline ::tm toStructTm(const ::ros::WallTime& time)
{
  return ::cras::toStructTm(::cras::convertTime<::ros::Time>(time));
}
 
inline ::tm toStructTm(const ::ros::SteadyTime& time)
{
  return ::cras::toStructTm(::cras::convertTime<::ros::Time>(time));
}
 
::cras::expected<::ros::Time, ::std::string> fromStructTm(const ::tm& time);
 
int getYear(const ::ros::Time& time);
 
inline int getYear(const ::ros::WallTime& time)
{
  return ::cras::getYear(::cras::convertTime<::ros::Time>(time));
}
 
inline int getYear(const ::ros::SteadyTime& time)
{
  return ::cras::getYear(::cras::convertTime<::ros::Time>(time));
}
 
}
 
namespace ros
{
 
bool operator==(const ::ros::Rate& r1, const ::ros::Rate& r2);
 
bool operator==(const ::ros::WallRate& r1, const ::ros::WallRate& r2);
 
::ros::Duration operator*(const ::ros::Duration& val1, const ::ros::Duration& val2);
 
::ros::Duration operator/(const ::ros::Duration& numerator, const ::ros::Duration& denominator);
 
::ros::WallDuration operator*(const ::ros::WallDuration& val1, const ::ros::WallDuration& val2);
 
::ros::WallDuration operator/(const ::ros::WallDuration& numerator, const ::ros::WallDuration& denominator);
 
}