Add string to Timestamp converter (#61)

Signed-off-by: Juan López Fernández <juanlopez@eprosima.com>

Author: juanlofer-eprosima

cpp_utils/include/cpp_utils/time/time_utils.hpp

@@ -47,6 +47,7 @@ CPP_UTILS_DllAPI Timestamp the_end_of_time() noexcept;
 //! Returns the minimum time available for \c Timestamp
 CPP_UTILS_DllAPI Timestamp the_beginning_of_time() noexcept;
 
+//! Construct a \c Timestamp given a date and time.
 CPP_UTILS_DllAPI Timestamp date_to_timestamp(
         unsigned int year,
         unsigned int month,
@@ -55,6 +56,12 @@ CPP_UTILS_DllAPI Timestamp date_to_timestamp(
         unsigned int minute = 0,
         unsigned int second = 0);
 
+//! Construct a \c Timestamp given a time (uses current date).
+CPP_UTILS_DllAPI Timestamp time_to_timestamp(
+        unsigned int hour = 0,
+        unsigned int minute = 0,
+        unsigned int second = 0);
+
 /**
  * @brief Convert a \c Timestamp to a string following a specific format.
  *
@@ -71,6 +78,20 @@ CPP_UTILS_DllAPI std::string timestamp_to_string(
         const std::string& format = "%Y-%m-%d_%H-%M-%S",
         bool local_time = false);
 
+/**
+ * @brief Convert to \c Timestamp a string following a specific format.
+ *
+ * @param timestamp string to parse.
+ * @param format string formatting the date.
+ * @param local_time whether to use the local time zone or UTC.
+ *
+ * @return timestamp from the string in the format given
+ */
+CPP_UTILS_DllAPI Timestamp string_to_timestamp(
+        const std::string& timestamp,
+        const std::string& format = "%Y-%m-%d_%H-%M-%S",
+        bool local_time = false);
+
 CPP_UTILS_DllAPI std::chrono::milliseconds duration_to_ms(
         const Duration_ms& duration) noexcept;
 

cpp_utils/src/cpp/time/time_utils.cpp

@@ -24,6 +24,7 @@
 #include <cpp_utils/macros/macros.hpp>
 #include <cpp_utils/time/time_utils.hpp>
 #include <cpp_utils/exception/PreconditionNotMet.hpp>
+#include <cpp_utils/Log.hpp>
 
 // These functions has different names in windows
 #if _EPROSIMA_WINDOWS_PLATFORM
@@ -68,6 +69,26 @@ Timestamp date_to_timestamp(
     return std::chrono::system_clock::from_time_t(timegm(&tm));
 }
 
+Timestamp time_to_timestamp(
+        unsigned int hour /* = 0 */,
+        unsigned int minute /* = 0 */,
+        unsigned int second /* = 0 */)
+{
+    std::tm tm;
+
+    // Initialise with current timestamp to set date
+    auto current_ts = now();
+    std::chrono::high_resolution_clock::time_point::duration duration = current_ts.time_since_epoch();
+    time_t duration_seconds = std::chrono::duration_cast<std::chrono::seconds>(duration).count();
+    tm = *std::gmtime(&duration_seconds);
+
+    tm.tm_sec = static_cast<int>(second);
+    tm.tm_min = static_cast<int>(minute);
+    tm.tm_hour = static_cast<int>(hour);
+
+    return std::chrono::system_clock::from_time_t(timegm(&tm));
+}
+
 std::string timestamp_to_string(
         const Timestamp& timestamp,
         const std::string& format /* = "%Z_%Y-%m-%d_%H-%M-%S" */,
@@ -99,6 +120,42 @@ std::string timestamp_to_string(
     return ss.str();
 }
 
+Timestamp string_to_timestamp(
+        const std::string& timestamp,
+        const std::string& format /* = "%Z_%Y-%m-%d_%H-%M-%S" */,
+        bool local_time /* = false */)
+{
+    std::istringstream ss(timestamp);
+    std::tm tm{};
+    ss >> std::get_time(&tm, format.c_str());
+    if (ss.fail())
+    {
+        throw PreconditionNotMet(
+                  STR_ENTRY << "Format <" << format << "> to convert string to Timestamp is not valid for timestamp " << timestamp <<
+                      ".");
+    }
+
+    std::time_t utc_time;
+    if (local_time)
+    {
+        // Attempt to automatically determine if DST in effect
+        tm.tm_isdst = -1;
+        // WARNING: might not be available in all systems, mktime sets this value to 0/1 if succesfully found this info
+        utc_time = std::mktime(&tm);
+        if (tm.tm_isdst < 0)
+        {
+            logWarning(
+                UTILS_TIME,
+                "DST information could not be found in the system, converted timestamp might be an hour off.");
+        }
+    }
+    else
+    {
+        utc_time = timegm(&tm);
+    }
+    return std::chrono::system_clock::from_time_t(utc_time);
+}
+
 std::chrono::milliseconds duration_to_ms(
         const Duration_ms& duration) noexcept
 {

cpp_utils/test/unittest/time/CMakeLists.txt

@@ -29,8 +29,8 @@ set(TEST_SOURCES
     )
 
 set(TEST_LIST
-        timestamp_to_string
-        timestamp_to_string_local
+        timestamp_to_string_to_timestamp
+        timestamp_to_string_to_timestamp_local
         timestamp_to_string_format
     )
 

cpp_utils/test/unittest/time/time_utils_test.cpp

@@ -25,14 +25,16 @@
 using namespace eprosima::utils;
 
 /**
- * Test function timestamp_to_string with a time stamp.
+ * Test function timestamp_to_string with a time stamp, as well the inverse conversion string_to_timestamp.
  *
  * CASES:
  * - now
+ * - now with alternative format
  * - old time
  * - future time
+ * - some time today
  */
-TEST(time_utils_test, timestamp_to_string)
+TEST(time_utils_test, timestamp_to_string_to_timestamp)
 {
     // now
     {
@@ -51,7 +53,40 @@ TEST(time_utils_test, timestamp_to_string)
             << "-" << number_trailing_zeros_format(local_tm.tm_min, 2)
             << "-" << number_trailing_zeros_format(local_tm.tm_sec, 2);
 
+        // Test timestamp_to_string
         ASSERT_EQ(now_time_str, expected_string_os.str());
+
+        // Test string_to_timestamp
+        Timestamp now_time_from_str = string_to_timestamp(now_time_str);
+        // NOTE: cannot directly compare timestamps because some precision is lost during ts->str conversion
+        ASSERT_EQ(timestamp_to_string(now_time_from_str), expected_string_os.str());
+    }
+
+    // now with alternative format
+    {
+        Timestamp now_time = now();
+        std::string format = "%S-%M-%H___%d-%m-%Y";
+        std::string now_time_str = timestamp_to_string(now_time, format);
+
+        time_t time = std::chrono::system_clock::to_time_t(now_time);
+        std::tm local_tm = *gmtime(&time);
+
+        std::ostringstream expected_string_os;
+        expected_string_os
+            << number_trailing_zeros_format(local_tm.tm_sec, 2)
+            << "-" << number_trailing_zeros_format(local_tm.tm_min, 2)
+            << "-" << number_trailing_zeros_format(local_tm.tm_hour, 2)
+            << "___" << number_trailing_zeros_format(local_tm.tm_mday, 2)
+            << "-" << number_trailing_zeros_format(local_tm.tm_mon + 1, 2)
+            << "-" << number_trailing_zeros_format(local_tm.tm_year + 1900, 4);
+
+        // Test timestamp_to_string
+        ASSERT_EQ(now_time_str, expected_string_os.str());
+
+        // Test string_to_timestamp
+        Timestamp now_time_from_str = string_to_timestamp(now_time_str, format);
+        // NOTE: cannot directly compare timestamps because some precision is lost during ts->str conversion
+        ASSERT_EQ(timestamp_to_string(now_time_from_str, format), expected_string_os.str());
     }
 
     // old time
@@ -68,7 +103,13 @@ TEST(time_utils_test, timestamp_to_string)
             << "-" << 39
             << "-" << 42;
 
+        // Test timestamp_to_string
         ASSERT_EQ(old_time_str, expected_string_os.str());
+
+        // Test string_to_timestamp
+        Timestamp old_time_from_str = string_to_timestamp(old_time_str);
+        // NOTE: cannot directly compare timestamps because some precision is lost during ts->str conversion
+        ASSERT_EQ(timestamp_to_string(old_time_from_str), expected_string_os.str());
     }
 
     // future time
@@ -85,19 +126,55 @@ TEST(time_utils_test, timestamp_to_string)
             << "-" << "00"
             << "-" << "00";
 
+        // Test timestamp_to_string
         ASSERT_EQ(future_time_str, expected_string_os.str());
+
+        // Test string_to_timestamp
+        Timestamp future_time_from_str = string_to_timestamp(future_time_str);
+        // NOTE: cannot directly compare timestamps because some precision is lost during ts->str conversion
+        ASSERT_EQ(timestamp_to_string(future_time_from_str), expected_string_os.str());
+    }
+
+    // some time today
+    {
+        Timestamp some_time_today = time_to_timestamp(13u, 13u, 13u);
+        std::string some_time_today_str = timestamp_to_string(some_time_today);
+
+        // Get current timestamp and use its date to construct expected string
+        Timestamp now_ts = now();
+        std::string now_time_str = timestamp_to_string(now_ts);
+        time_t now_time = std::chrono::system_clock::to_time_t(now_ts);
+        std::tm now_tm = *gmtime(&now_time);
+
+        std::ostringstream expected_string_os;
+        expected_string_os
+            << number_trailing_zeros_format(now_tm.tm_year + 1900, 4)
+            << "-" << number_trailing_zeros_format(now_tm.tm_mon + 1, 2)
+            << "-" << number_trailing_zeros_format(now_tm.tm_mday, 2)
+            << "_" << "13"
+            << "-" << "13"
+            << "-" << "13";
+
+        // Test timestamp_to_string
+        ASSERT_EQ(some_time_today_str, expected_string_os.str());
+
+        // Test string_to_timestamp
+        Timestamp some_time_today_from_str = string_to_timestamp(some_time_today_str);
+        // NOTE: cannot directly compare timestamps because some precision is lost during ts->str conversion
+        ASSERT_EQ(timestamp_to_string(some_time_today_from_str), expected_string_os.str());
     }
 }
 
 /**
- * Test function timestamp_to_string with a time stamp with local time.
+ * Test function timestamp_to_string with a time stamp with local time, as well the inverse conversion string_to_timestamp.
  *
  * NOTE: only case is now because the local time zone depends on the part of the year and the test becomes a mess.
  */
-TEST(time_utils_test, timestamp_to_string_local)
+TEST(time_utils_test, timestamp_to_string_to_timestamp_local)
 {
     Timestamp now_time = now();
-    std::string now_time_str = timestamp_to_string(now_time, "%Y-%m-%d_%H-%M-%S", true);
+    std::string format = "%Y-%m-%d_%H-%M-%S";
+    std::string now_time_str = timestamp_to_string(now_time, format, true);
 
     time_t time = std::chrono::system_clock::to_time_t(now_time);
     std::tm local_tm = *localtime(&time);
@@ -112,7 +189,13 @@ TEST(time_utils_test, timestamp_to_string_local)
         << "-" << number_trailing_zeros_format(local_tm.tm_min, 2)
         << "-" << number_trailing_zeros_format(local_tm.tm_sec, 2);
 
+    // Test timestamp_to_string
     ASSERT_EQ(now_time_str, expected_string_os.str());
+
+    // Test string_to_timestamp
+    Timestamp now_time_from_str = string_to_timestamp(now_time_str, format, true);
+    // NOTE: cannot directly compare timestamps because some precision is lost during ts->str conversion
+    ASSERT_EQ(timestamp_to_string(now_time_from_str, format, true), expected_string_os.str());
 }
 
 /**