TimeSeriesPlatformLibrary: Added temporal support options to DataPublisher interfaces.

J. Ritchie Carroll committed 7 years ago

Commit 5c5b4061 parent 04505f228 files · +603 −300Browse files

Showing the changes to Source/Libraries/TimeSeriesPlatformLibrary/Common (5 of 28 files). Show all

Unified · Split

5 files

Source/Libraries/TimeSeriesPlatformLibrary/Common/CommonTypes.cpp +12 −8
Source/Libraries/TimeSeriesPlatformLibrary/Common/CommonTypes.h +21 −9
Source/Libraries/TimeSeriesPlatformLibrary/Common/Convert.cpp +49 −17
Source/Libraries/TimeSeriesPlatformLibrary/Common/Convert.h +12 −8
Source/Libraries/TimeSeriesPlatformLibrary/Common/Nullable.h +1 −1

Source/Libraries/TimeSeriesPlatformLibrary/Common/CommonTypes.cpp+12−8

 const decimal_t Decimal::DotNetMinValue = decimal_t("-79228162514264337593543950335");
+const datetime_t DateTime::MaxValue(max_date_time);
+const datetime_t DateTime::MinValue(min_date_time);
 const string Empty::String {};
-const DateTime Empty::DateTime {};
+const datetime_t Empty::DateTime {};
 const Guid Empty::Guid = NilGuidGen();
     return value;
 }
-DateTime GSF::DateAdd(const DateTime& value, int32_t addValue, TimeInterval interval)
+datetime_t GSF::DateAdd(const datetime_t& value, int32_t addValue, TimeInterval interval)
 {
     switch (interval)
     {
     }
 }
-int32_t GSF::DateDiff(const DateTime& startTime, const DateTime& endTime, TimeInterval interval)
+int32_t GSF::DateDiff(const datetime_t& startTime, const datetime_t& endTime, TimeInterval interval)
 {
     if (interval < TimeInterval::Hour)
     {
     }
 }
-int32_t GSF::DatePart(const DateTime& value, TimeInterval interval)
+int32_t GSF::DatePart(const datetime_t& value, TimeInterval interval)
 {
     static float64_t tickInterval = pow(10.0, time_duration::num_fractional_digits());
     }
 }
-DateTime GSF::Now()
+datetime_t GSF::Now()
 {
-    return DateTime { microsec_clock::local_time() };
+    return datetime_t { microsec_clock::local_time() };
 }
-DateTime GSF::UtcNow()
+datetime_t GSF::UtcNow()
 {
-    return DateTime { microsec_clock::universal_time() };
+    return datetime_t { microsec_clock::universal_time() };
 }

Source/Libraries/TimeSeriesPlatformLibrary/Common/CommonTypes.h+21−9

     typedef double_t float64_t;
     typedef boost::multiprecision::cpp_dec_float_100 decimal_t;
+    // DateTime type
+    typedef boost::posix_time::ptime datetime_t;
     struct Int8
     {
         static const int8_t MaxValue = static_cast<int8_t>(127);
         static const decimal_t DotNetMinValue;
     };
+    struct DateTime
+    {
+        static const datetime_t MaxValue;
+        static const datetime_t MinValue;
+    };
     struct Ticks
     {
+        static const int64_t MaxValue = 3155378975999999999L;       // 12/31/1999 11:59:59.999
+        static const int64_t MinValue = 0L;                         // 01/01/0001 00:00:00.000
+        static const int64_t UnixBaseOffset = 621355968000000000L;  // 01/01/1970 00:00:00.000
+        static const int64_t PTimeBaseOffset = 441481536000000000L; // 01/01/1400 00:00:00.000
         static const int64_t PerSecond = 10000000L;
         static const int64_t PerMillisecond = Ticks::PerSecond / 1000;
         static const int64_t PerMicrosecond = Ticks::PerSecond / 1000000;
         static const int64_t PerMinute = 60L * Ticks::PerSecond;
         static const int64_t PerHour = 60L * Ticks::PerMinute;
         static const int64_t PerDay = 24L * Ticks::PerHour;
-        static const int64_t UnixBaseOffset = 621355968000000000L;  // 01/01/1970 00:00:00
-        static const int64_t PtimeBaseOffset = 441481536000000000L; // 01/01/1400 00:00:00
     };
     template<class T>
     typedef boost::any Object;
     typedef boost::uuids::uuid Guid;
-    typedef boost::posix_time::ptime DateTime;
     typedef boost::posix_time::time_duration TimeSpan;
     typedef boost::system::error_code ErrorCode;
     typedef boost::system::system_error SystemError;
     struct Empty
     {
         static const std::string String;
-        static const GSF::DateTime DateTime;
+        static const GSF::datetime_t DateTime;
         static const GSF::Guid Guid;
         static const GSF::Object Object;
         static const GSF::IPAddress IPAddress;
         Millisecond
     };
-    DateTime DateAdd(const DateTime& value, int32_t addValue, TimeInterval interval);
+    datetime_t DateAdd(const datetime_t& value, int32_t addValue, TimeInterval interval);
-    int32_t DateDiff(const DateTime& startTime, const DateTime& endTime, TimeInterval interval);
+    int32_t DateDiff(const datetime_t& startTime, const datetime_t& endTime, TimeInterval interval);
-    int32_t DatePart(const DateTime& value, TimeInterval interval);
+    int32_t DatePart(const datetime_t& value, TimeInterval interval);
-    DateTime Now();
+    datetime_t Now();
-    DateTime UtcNow();
+    datetime_t UtcNow();
 }
 // Setup standard hash code for Guid

Source/Libraries/TimeSeriesPlatformLibrary/Common/Convert.cpp+49−17

 using namespace boost::gregorian;
 using namespace GSF;
-const DateTime DateTimeEpoch(date(1400, 1, 1), time_duration(0, 0, 0));
+const datetime_t DateTimeEpoch(date(1400, 1, 1), time_duration(0, 0, 0));
 const auto DateTimeTicksPerSecond = time_duration::ticks_per_second();
 string PreparseTimestamp(const string& timestamp, time_duration& utcOffset)
     milliseconds = static_cast<uint16_t>(ticks / 10000 % 1000);
 }
-DateTime GSF::FromUnixTime(time_t unixSOC, uint16_t milliseconds)
+datetime_t GSF::FromUnixTime(time_t unixSOC, uint16_t milliseconds)
 {
     return from_time_t(unixSOC) + boost::posix_time::milliseconds(milliseconds);
 }
-DateTime GSF::FromTicks(const int64_t ticks)
+datetime_t GSF::FromTicks(const int64_t ticks)
 {
     static float64_t tickInterval = float64_t(Ticks::PerSecond);
-    const DateTime time = from_time_t((ticks - Ticks::UnixBaseOffset) / Ticks::PerSecond);
+    const datetime_t time = from_time_t((ticks - Ticks::UnixBaseOffset) / Ticks::PerSecond);
     const int64_t pticks = int64_t(ticks % Ticks::PerSecond / tickInterval * DateTimeTicksPerSecond);
     return time + time_duration(0, 0, 0, pticks % DateTimeTicksPerSecond);
 }
-int64_t GSF::ToTicks(const DateTime& time)
+int64_t GSF::ToTicks(const datetime_t& time)
 {
     static float64_t tickInterval = pow(10.0, time_duration::num_fractional_digits());
     const time_duration offset = time - DateTimeEpoch;
-    return Ticks::PtimeBaseOffset + offset.total_seconds() * Ticks::PerSecond +
+    return Ticks::PTimeBaseOffset + offset.total_seconds() * Ticks::PerSecond +
         int64_t(offset.fractional_seconds() / tickInterval * Ticks::PerSecond);
 }
     return strftime(ptr, maxsize, formatStream.str().data(), &timeinfo);
 }
-DateTime GSF::LocalFromUtc(const DateTime& timestamp)
+datetime_t GSF::LocalFromUtc(const datetime_t& timestamp)
 {
-    return boost::date_time::c_local_adjustor<DateTime>::utc_to_local(timestamp);
+    return boost::date_time::c_local_adjustor<datetime_t>::utc_to_local(timestamp);
 }
 std::string GSF::ToString(const Guid& value)
     return boost::uuids::to_string(value);
 }
-std::string GSF::ToString(const DateTime& value, const char* format)
+std::string GSF::ToString(const datetime_t& value, const char* format)
 {
     stringstream stream;
     time_facet* facet = new time_facet(format);
     return false;
 }
-bool GSF::TryParseDouble(const string& value, float64_t& result)
+bool GSF::TryParseInt32(const std::string& value, int32_t& result, const int32_t defaultValue)
+{
+    try
+    {
+        result = stoi(value);
+        return true;
+    }
+    catch (...)
+    {
+        result = defaultValue;
+        return false;
+    }
+}
+bool GSF::TryParseInt64(const std::string& value, int64_t& result, const int64_t defaultValue)
+{
+    try
+    {
+        result = stoll(value);
+        return true;
+    }
+    catch (...)
+    {
+        result = defaultValue;
+        return false;
+    }
+}
+bool GSF::TryParseDouble(const string& value, float64_t& result, const float64_t defaultValue)
 {
     try
     {
     }
     catch (...)
     {
+        result = defaultValue;
         return false;
     }
 }
     return data;
 }
-// Parse a timestamp string, e.g.: 2018-03-14T19:23:11.665-04:00
+// Attempt to parse a timestamp string, e.g.: 2018-03-14T19:23:11.665-04:00
-bool GSF::TryParseTimestamp(const char* time, DateTime& timestamp, bool parseAsUTC)
+bool GSF::TryParseTimestamp(const char* time, datetime_t& timestamp, const datetime_t& defaultValue, bool parseAsUTC)
 {
     static const locale formats[] = {
         locale(locale::classic(), new time_input_facet("%Y-%m-%d %H:%M:%S%F")),
     static const int32_t formatsCount = sizeof(formats) / sizeof(formats[0]);
+    time_duration utcOffset{};
+    const string cleanTimestamp = PreparseTimestamp(time, utcOffset);
     for (int32_t i = 0; i < formatsCount; i++)
     {
-        time_duration utcOffset{};
+        istringstream stream(cleanTimestamp);
-        istringstream stream(PreparseTimestamp(time, utcOffset));
         stream.imbue(formats[i]);
         stream >> timestamp;
         }
     }
+    timestamp = defaultValue;
     return false;
 }
-DateTime GSF::ParseTimestamp(const char* time, bool parseAsUTC)
+datetime_t GSF::ParseTimestamp(const char* time, bool parseAsUTC)
 {
-    DateTime timestamp;
+    datetime_t timestamp;
-    if (TryParseTimestamp(time, timestamp, parseAsUTC))
+    if (TryParseTimestamp(time, timestamp, DateTime::MinValue, parseAsUTC))
         return timestamp;
     throw runtime_error("Failed to parse timestamp \"" + string(time) + "\"");

Source/Libraries/TimeSeriesPlatformLibrary/Common/Convert.h+12−8

     void ToUnixTime(int64_t ticks, time_t& unixSOC, uint16_t& milliseconds);
     // Convert Unix second of century and milliseconds to DateTime
-    DateTime FromUnixTime(time_t unixSOC, uint16_t milliseconds);
+    datetime_t FromUnixTime(time_t unixSOC, uint16_t milliseconds);
     // Converts a timestamp, in Ticks, to DateTime
-    DateTime FromTicks(int64_t ticks);
+    datetime_t FromTicks(int64_t ticks);
     // Converts a DateTime to Ticks
-    int64_t ToTicks(const DateTime& time);
+    int64_t ToTicks(const datetime_t& time);
     // Thin wrapper around strftime to provide formats for milliseconds (%f) and full-resolution ticks (%t)
     uint32_t TicksToString(char* ptr, uint32_t maxsize, std::string format, int64_t ticks);
-    DateTime LocalFromUtc(const DateTime& timestamp);
+    datetime_t LocalFromUtc(const datetime_t& timestamp);
     // Converts an object to a string
     template<class T>
     std::string ToString(const Guid& value);
-    std::string ToString(const DateTime& value, const char* format = "%Y-%m-%d %H:%M:%S%F");
+    std::string ToString(const datetime_t& value, const char* format = "%Y-%m-%d %H:%M:%S%F");
     std::string ToString(const TimeSpan& value);
     bool ParseBoolean(const std::string& value);
-    bool TryParseDouble(const std::string& value, float64_t& result);
+    bool TryParseInt32(const std::string& value, int32_t& result, int32_t defaultValue = 0);
+    bool TryParseInt64(const std::string& value, int64_t& result, int64_t defaultValue = 0L);
+    bool TryParseDouble(const std::string& value, float64_t& result, float64_t defaultValue = 0.0);
     // Encodes a character value into an escaped RegEx value
     std::string RegExEncode(char value);
     const char* Coalesce(const char* data, const char* nonEmptyValue);
     // Attempts to parse an time string in several common formats
-    bool TryParseTimestamp(const char* time, DateTime& timestamp, bool parseAsUTC = true);
+    bool TryParseTimestamp(const char* time, datetime_t& timestamp, const datetime_t& defaultValue = DateTime::MinValue, bool parseAsUTC = true);
     // Converts a string to a date-time that may be in several common formats
-    DateTime ParseTimestamp(const char* time, bool parseAsUTC = true);
+    datetime_t ParseTimestamp(const char* time, bool parseAsUTC = true);
     // Parses a string of key/value pairs into a case-insensitive string dictionary
     StringMap<std::string> ParseKeyValuePairs(const std::string& value, char parameterDelimiter = ';', char keyValueDelimiter = '=', char startValueDelimiter = '{', char endValueDelimiter = '}');

Source/Libraries/TimeSeriesPlatformLibrary/Common/Nullable.h+1−1

@@ -324,7 +324,7 @@ namespace GSF · 323 unmodified lines
324	return {};	324	return {};
325	}	325	}
326		326
327	inline std::string ToString(const Nullable<DateTime>& value, const char* fmt = "%Y-%m-%d %H:%M:%S%F")	327	inline std::string ToString(const Nullable<datetime_t>& value, const char* fmt = "%Y-%m-%d %H:%M:%S%F")
328	{	328	{
329	if (value.HasValue())	329	if (value.HasValue())
330	return ToString(value.GetValueOrDefault(), fmt);	330	return ToString(value.GetValueOrDefault(), fmt);

TimeSeriesPlatformLibrary: Added temporal support options to DataPublisher interfaces.

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code