Added functions to convert between time_point and secNsec

include/ignition/math/Helpers.hh

@@ -23,6 +23,8 @@
 #include <limits>
 #include <string>
 #include <iostream>
+#include <sstream>
+#include <iomanip>
 #include <vector>
 #include <tuple>
 #include <utility>
@@ -727,6 +729,43 @@ namespace ignition
  }
  }
 
+ /// \brief Convert a std::chrono::steady_clock::time_point to a seconds and
+ /// nanoseconds pair.
+ /// \param[in] _time The time point to convert.
+ /// \return A pair where the first element is the number of seconds and
+ /// the second is the number of nanoseconds.
+ inline std::pair<int64_t, int64_t> timePointToSecNsec(
+ const std::chrono::system_clock::time_point &_time)
+ {
+ auto now_ns = std::chrono::duration_cast<std::chrono::nanoseconds>(
+ _time.time_since_epoch());
+ auto now_s = std::chrono::duration_cast<std::chrono::seconds>(
+ _time.time_since_epoch());
+ int64_t seconds = std::chrono::duration_cast<std::chrono::seconds>(
+ _time.time_since_epoch()).count();
+ int64_t nanoseconds = std::chrono::duration_cast
+ <std::chrono::nanoseconds>(now_ns - now_s).count();
+ return {seconds, nanoseconds};
+ }
+
+ /// \brief Convert to a seconds and nanoseconds to
+ /// std::chrono::steady_clock::time_point.
+ /// \param[in] _sec The seconds to convert.
+ /// \param[in] _nanosec The nanoseconds to convert.
+ /// \return A std::chrono::system_clock::time_poin based on the number of
+ /// seconds and
+ /// the number of nanoseconds.
+ inline std::chrono::system_clock::time_point secNsecToTimePoint(
+ const uint64_t &_sec, const uint64_t &_nanosec)
+ {
+ auto duration = std::chrono::seconds(_sec) + std::chrono::nanoseconds(
+ _nanosec);
+ std::chrono::system_clock::time_point result =
+ std::chrono::system_clock::from_time_t(0);
+ result = result + duration;
+ return result;
+ }
+
  /// \brief Convert a std::chrono::steady_clock::duration to a seconds and
  /// nanoseconds pair.
  /// \param[in] _dur The duration to convert.
@@ -740,6 +779,51 @@ namespace ignition
  return {s.count(), ns.count()};
  }
 
+ // TODO(anyone): Replace this with std::chrono::days.
+ /// This will exist in C++-20
+ typedef std::chrono::duration<uint64_t, std::ratio<86400>> days;
+
+ /// \brief break down durations
+ /// \param[in] d Duration to breaw down
+ /// \return A tuple based on the durations specified
+ template<class...Durations, class DurationIn>
+ std::tuple<Durations...> break_down_durations(DurationIn d) {
+ std::tuple<Durations...> retval;
+ using discard = int[];
+ (void)discard{0, (void((
+ (std::get<Durations>(retval) =
+ std::chrono::duration_cast<Durations>(d)),
+ (d -= std::chrono::duration_cast<DurationIn>(
+ std::get<Durations>(retval))))), 0)...};
+ return retval;
+ }
+
+ /// \brief Convert a std::chrono::steady_clock::duration to a string
+ /// \param[in] _point The std::chrono::system_clock::time_point to convert.
+ /// \return A string formatted with the time_point
+ inline std::string timePointToString(
+ const std::chrono::system_clock::time_point &_point)
+ {
+ auto duration = _point - std::chrono::system_clock::from_time_t(0);
+ auto clean_duration = break_down_durations<days,
+ std::chrono::hours,
+ std::chrono::minutes,
+ std::chrono::seconds,
+ std::chrono::milliseconds>(
+ duration);
+ std::ostringstream output_string;
+ output_string << std::get<0>(clean_duration).count() << " "
+ << std::setw(2) << std::setfill('0')
+ << std::get<1>(clean_duration).count() << ":"
+ << std::setw(2) << std::setfill('0')
+ << std::get<2>(clean_duration).count() << ":"
+ << std::setw(2) << std::setfill('0')
+ << std::setprecision(3)
+ << std::get<3>(clean_duration).count() +
+ std::get<4>(clean_duration).count()/1000.0;
+ return output_string.str();
+ }
+
  // Degrade precision on Windows, which cannot handle 'long double'
  // values properly. See the implementation of Unpair.
  // 32 bit ARM processors also define 'long double' to be the same

src/Helpers_TEST.cc

@@ -518,6 +518,51 @@ TEST(HelpersTest, Pair)
  }
 }
 
+/////////////////////////////////////////////////
+TEST(HelpersTest, timePointToSecNsec)
+{
+ std::pair<int64_t, int64_t> parts = math::timePointToSecNsec(
+ std::chrono::system_clock::from_time_t(0));
+ EXPECT_EQ(parts.first, 0);
+ EXPECT_EQ(parts.second, 0);
+
+ // Jan 2 01:00:00 1970
+ std::tm timeinfo = std::tm();
+ timeinfo.tm_sec = 0;
+ timeinfo.tm_min = 0;
+ timeinfo.tm_hour = 1;
+ timeinfo.tm_mon = 0;
+ timeinfo.tm_year = 70;
+ timeinfo.tm_mday = 2;
+ std::time_t tt = std::mktime(&timeinfo);
+
+ parts = math::timePointToSecNsec(
+ std::chrono::system_clock::from_time_t(tt));
+
+ EXPECT_EQ(parts.first, 24*60*60);
+ EXPECT_EQ(parts.second, 0);
+}
+
+/////////////////////////////////////////////////
+TEST(HelpersTest, secNsecToTimePoint)
+{
+ std::chrono::system_clock::time_point s = math::secNsecToTimePoint(0, 0);
+ EXPECT_EQ(s, std::chrono::system_clock::from_time_t(0));
+
+ // Jan 2 01:00:00 1970
+ std::tm timeinfo = std::tm();
+ timeinfo.tm_sec = 0;
+ timeinfo.tm_min = 0;
+ timeinfo.tm_hour = 1;
+ timeinfo.tm_mon = 0;
+ timeinfo.tm_year = 70;
+ timeinfo.tm_mday = 2;
+ std::time_t tt = std::mktime(&timeinfo);
+
+ s = math::secNsecToTimePoint(24*60*60, 0);
+ EXPECT_EQ(s, std::chrono::system_clock::from_time_t(tt));
+}
+
 /////////////////////////////////////////////////
 TEST(HelpersTest, durationToSecNsec)
 {