Add fractional seconds support for Linux

Author: arturl

Release/src/utilities/asyncrt_utils.cpp

@@ -33,6 +33,8 @@ using namespace Windows::Storage::Streams;
 #if !defined(_MS_WINDOWS)
 #include <boost/date_time/posix_time/posix_time.hpp>
 #include <boost/date_time/posix_time/posix_time_io.hpp>
+// GCC 4.8 does not support regex, use boost. TODO: switch to std::regex in GCC 4.9
+#include <boost/regex.hpp>
 using namespace boost::locale::conv;
 #endif
 
@@ -472,8 +474,8 @@ datetime datetime::timeval_to_datetime(struct timeval time)
 {
     const uint64_t epoch_offset = 11644473600LL; // diff between windows and unix epochs (seconds)
     uint64_t result = epoch_offset + time.tv_sec;
-    result *= 10000000LL; // convert to 10e-7
-    result += time.tv_usec*10; //add microseconds (in 10e-7)
+    result *= _secondTicks; // convert to 10e-7
+    result += time.tv_usec; //add microseconds (in 10e-7)
     return datetime(result);
 }
 #endif
@@ -594,17 +596,36 @@ utility::string_t datetime::to_string(date_format format) const
     return outStream.str();
 #else //LINUX
     uint64_t input = m_interval; 
-    input /= 10000000LL; // convert to seconds
+    uint64_t frac_sec = input % _secondTicks;
+    input /= _secondTicks; // convert to seconds
     time_t time = (time_t)input - (time_t)11644473600LL;// diff between windows and unix epochs (seconds)
 
     struct tm datetime;
     gmtime_r(&time, &datetime);
 
-    const int max_dt_length = 29;
-    char output[max_dt_length+1]; output[max_dt_length] = '\0';
-    strftime(output, max_dt_length+1, 
-        format == RFC_1123 ? "%a, %d %b %Y %H:%M:%S GMT" : "%Y-%m-%dT%H:%M:%SZ",
-        &datetime);
+    const int max_dt_length = 64;
+    char output[max_dt_length+1] = {0};
+    
+    if (format != RFC_1123 && frac_sec > 0)
+    {
+        // Append fractional second, which is a 7-digit value with no trailing zeros
+        // This way, '1200' becomes '00012'
+        char buf[9] = { 0 };
+        snprintf(buf, sizeof(buf), ".%07ld", (long int)frac_sec);
+        // trim trailing zeros
+        for (int i = 7; buf[i] == '0'; i--) buf[i] = '\0';
+        // format the datetime into a separate buffer
+        char datetime_str[max_dt_length+1] = {0};
+        strftime(datetime_str, sizeof(datetime_str), "%Y-%m-%dT%H:%M:%S", &datetime);
+        // now print this buffer into the output buffer
+        snprintf(output, sizeof(output), "%s%sZ", datetime_str, buf);
+    }
+    else
+    {
+        strftime(output, sizeof(output), 
+            format == RFC_1123 ? "%a, %d %b %Y %H:%M:%S GMT" : "%Y-%m-%dT%H:%M:%SZ",
+            &datetime);
+    }
 
     return std::string(output);
 #endif
@@ -633,6 +654,23 @@ bool __cdecl datetime::system_type_to_datetime(void* pvsysTime, double seconds,
 }
 #endif
 
+// Take a string that represents a fractional second and return the number of ticks
+// This is equivalent to doing atof on the string and multiplying by 10000000,
+// but does not lose precision
+uint64_t timeticks_from_second(const utility::string_t& str)
+{
+    _ASSERTE(str.size()>1);
+    _ASSERTE(str[0]==U('.'));
+    uint64_t ufrac_second = 0;
+    for(int i=1; i<=7; ++i)
+    {
+        ufrac_second *= 10;
+        auto add = i < (int)str.size() ? str[i] - U('0') : 0;
+        ufrac_second += add;
+    }
+    return ufrac_second;
+}
+
 /// <summary>
 /// Returns a string representation of the datetime. The string is formatted based on RFC 1123 or ISO 8601
 /// </summary>
@@ -753,12 +791,26 @@ datetime __cdecl datetime::from_string(const utility::string_t& dateString, date
 
     struct tm output = tm();
 
+    // avoid floating point math to preserve precision
+    uint64_t ufrac_second = 0;
+
     if ( format == RFC_1123 )
     {
         strptime(input.data(), "%a, %d %b %Y %H:%M:%S GMT", &output);
     } 
     else
     {
+        // Try to extract the fractional second from the timestamp
+        boost::regex r_frac_second("(.+)(\\.\\d+)(Z$)");
+        boost::smatch m;
+
+        if(boost::regex_search(input,m,r_frac_second))
+        {
+            auto frac = m[2].str(); // this is the fractional second
+            ufrac_second = timeticks_from_second(frac);
+            input = m[1].str() + m[3].str();
+        }
+        
         auto result = strptime(input.data(), "%Y-%m-%dT%H:%M:%SZ", &output);
 
         if ( result == nullptr )
@@ -767,6 +819,12 @@ datetime __cdecl datetime::from_string(const utility::string_t& dateString, date
         }
         if ( result == nullptr )
         {
+            // Fill the date portion with the epoch,
+            // strptime will do the rest
+            memset(&output, 0, sizeof(struct tm));
+            output.tm_year = 70;
+            output.tm_mon = 1;
+            output.tm_mday = 1;
             result = strptime(input.data(), "%H:%M:%SZ", &output);
         }
         if ( result == nullptr )
@@ -787,6 +845,7 @@ datetime __cdecl datetime::from_string(const utility::string_t& dateString, date
 
     struct timeval tv = timeval();
     tv.tv_sec = time;
+    tv.tv_usec = (__suseconds_t)ufrac_second;
     return timeval_to_datetime(tv);
 #endif
 }

Release/tests/Functional/utils/datetime.cpp

@@ -93,55 +93,60 @@ TEST(parsing_time_extended)
     }
 }
 
-TEST(parsing_time_roundtrip_datetime)
+TEST(parsing_time_roundtrip_datetime01)
 {
     // Preserve all 7 digits after the comma:
-    {
-        utility::string_t str = _XPLATSTR("2013-11-19T14:30:59.1234567Z");
-        auto dt = utility::datetime::from_string(str, utility::datetime::ISO_8601);
-        utility::string_t str2 = dt.to_string(utility::datetime::ISO_8601);
-        VERIFY_ARE_EQUAL(str2, str);
-    }
+    utility::string_t str = _XPLATSTR("2013-11-19T14:30:59.1234567Z");
+    auto dt = utility::datetime::from_string(str, utility::datetime::ISO_8601);
+    utility::string_t str2 = dt.to_string(utility::datetime::ISO_8601);
+    VERIFY_ARE_EQUAL(str2, str);
+}
+
+TEST(parsing_time_roundtrip_datetime02)
+{
     // lose the last '999' without rounding up
-    {
     utility::string_t str = _XPLATSTR("2013-11-19T14:30:59.1234567999Z");
     auto dt = utility::datetime::from_string(str, utility::datetime::ISO_8601);
     utility::string_t str2 = dt.to_string(utility::datetime::ISO_8601);
     VERIFY_ARE_EQUAL(str2, _XPLATSTR("2013-11-19T14:30:59.1234567Z"));
-    }
+}
+
+TEST(parsing_time_roundtrip_datetime03)
+{
     // leading 0-s after the comma, tricky to parse correctly
-    {
-        utility::string_t str = _XPLATSTR("2013-11-19T14:30:59.00123Z");
-        auto dt = utility::datetime::from_string(str, utility::datetime::ISO_8601);
-        utility::string_t str2 = dt.to_string(utility::datetime::ISO_8601);
-        VERIFY_ARE_EQUAL(str2, str);
-    }
+    utility::string_t str = _XPLATSTR("2013-11-19T14:30:59.00123Z");
+    auto dt = utility::datetime::from_string(str, utility::datetime::ISO_8601);
+    utility::string_t str2 = dt.to_string(utility::datetime::ISO_8601);
+    VERIFY_ARE_EQUAL(str2, str);
+}
+
+TEST(parsing_time_roundtrip_datetime4)
+{
     // another leading 0 test
-    {
-        utility::string_t str = _XPLATSTR("2013-11-19T14:30:59.0000001Z");
-        auto dt = utility::datetime::from_string(str, utility::datetime::ISO_8601);
-        utility::string_t str2 = dt.to_string(utility::datetime::ISO_8601);
-        VERIFY_ARE_EQUAL(str2, str);
-    }
+    utility::string_t str = _XPLATSTR("2013-11-19T14:30:59.0000001Z");
+    auto dt = utility::datetime::from_string(str, utility::datetime::ISO_8601);
+    utility::string_t str2 = dt.to_string(utility::datetime::ISO_8601);
+    VERIFY_ARE_EQUAL(str2, str);
+}
+
+TEST(parsing_time_roundtrip_datetime05)
+{
     // this is going to be truncated
-    {
-        utility::string_t str = _XPLATSTR("2013-11-19T14:30:59.00000001Z");
-        auto dt = utility::datetime::from_string(str, utility::datetime::ISO_8601);
-        utility::string_t str2 = dt.to_string(utility::datetime::ISO_8601);
-        VERIFY_ARE_EQUAL(str2, _XPLATSTR("2013-11-19T14:30:59Z"));
-    }
+    utility::string_t str = _XPLATSTR("2013-11-19T14:30:59.00000001Z");
+    auto dt = utility::datetime::from_string(str, utility::datetime::ISO_8601);
+    utility::string_t str2 = dt.to_string(utility::datetime::ISO_8601);
+    VERIFY_ARE_EQUAL(str2, _XPLATSTR("2013-11-19T14:30:59Z"));
 }
 
 TEST(parsing_time_roundtrip_time)
 {
     // time only without date
-    {
-        utility::string_t str = _XPLATSTR("14:30:59.1234567Z");
-        auto dt = utility::datetime::from_string(str, utility::datetime::ISO_8601);
-        utility::string_t str2 = dt.to_string(utility::datetime::ISO_8601);
-        // Must look for a substring now, since the date part is filled with today's date
-        VERIFY_IS_TRUE(str2.find(str) != std::string::npos);
-    }
+    utility::string_t str = _XPLATSTR("14:30:59.1234567Z");
+    //utility::string_t str = _XPLATSTR("14:30:01Z");
+    auto dt = utility::datetime::from_string(str, utility::datetime::ISO_8601);
+    utility::string_t str2 = dt.to_string(utility::datetime::ISO_8601);
+    // Must look for a substring now, since the date part is filled with today's date
+    VERIFY_IS_TRUE(str2.find(str) != std::string::npos);
 }
 
 } // SUITE(datetime)