sigrid/gsf · Ink

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);

Source/Libraries/TimeSeriesPlatformLibrary/Data/DataRow.cpp+7−7

Source/Libraries/TimeSeriesPlatformLibrary/Data/DataRow.h+4−4

@@ -87,10 +87,10 @@ namespace Data · 86 unmodified lines
87	void SetBooleanValue(int32_t columnIndex, const GSF::Nullable<bool>& value);	87	void SetBooleanValue(int32_t columnIndex, const GSF::Nullable<bool>& value);
88	void SetBooleanValue(const std::string& columnName, const GSF::Nullable<bool>& value);	88	void SetBooleanValue(const std::string& columnName, const GSF::Nullable<bool>& value);
89		89
90	GSF::Nullable<GSF::DateTime> ValueAsDateTime(int32_t columnIndex);	90	GSF::Nullable<GSF::datetime_t> ValueAsDateTime(int32_t columnIndex);
91	GSF::Nullable<GSF::DateTime> ValueAsDateTime(const std::string& columnName);	91	GSF::Nullable<GSF::datetime_t> ValueAsDateTime(const std::string& columnName);
92	void SetDateTimeValue(int32_t columnIndex, const GSF::Nullable<GSF::DateTime>& value);	92	void SetDateTimeValue(int32_t columnIndex, const GSF::Nullable<GSF::datetime_t>& value);
93	void SetDateTimeValue(const std::string& columnName, const GSF::Nullable<GSF::DateTime>& value);	93	void SetDateTimeValue(const std::string& columnName, const GSF::Nullable<GSF::datetime_t>& value);
94		94
95	GSF::Nullable<GSF::float32_t> ValueAsSingle(int32_t columnIndex);	95	GSF::Nullable<GSF::float32_t> ValueAsSingle(int32_t columnIndex);
96	GSF::Nullable<GSF::float32_t> ValueAsSingle(const std::string& columnName);	96	GSF::Nullable<GSF::float32_t> ValueAsSingle(const std::string& columnName);

Source/Libraries/TimeSeriesPlatformLibrary/FilterExpressions/ExpressionTree.cpp+9−9

@@ -387,24 +387,24 @@ Nullable<Guid> ValueExpression::ValueAsNullableGuid() const · 386 unmodified lines
387	return Cast<Guid>(Value);	387	return Cast<Guid>(Value);
388	}	388	}
389		389
390	DateTime ValueExpression::ValueAsDateTime() const	390	datetime_t ValueExpression::ValueAsDateTime() const
391	{	391	{
392	ValidateValueType(ExpressionValueType::DateTime);	392	ValidateValueType(ExpressionValueType::DateTime);
393		393
394	if (ValueIsNullable)	394	if (ValueIsNullable)
395	return Cast<Nullable<DateTime>>(Value).GetValueOrDefault();	395	return Cast<Nullable<datetime_t>>(Value).GetValueOrDefault();
396		396
397	return Cast<DateTime>(Value);	397	return Cast<datetime_t>(Value);
398	}	398	}
399		399
400	Nullable<DateTime> ValueExpression::ValueAsNullableDateTime() const	400	Nullable<datetime_t> ValueExpression::ValueAsNullableDateTime() const
401	{	401	{
402	ValidateValueType(ExpressionValueType::DateTime);	402	ValidateValueType(ExpressionValueType::DateTime);
403		403
404	if (ValueIsNullable)	404	if (ValueIsNullable)
405	return Cast<Nullable<DateTime>>(Value);	405	return Cast<Nullable<datetime_t>>(Value);
406		406
407	return Cast<DateTime>(Value);	407	return Cast<datetime_t>(Value);
408	}	408	}
409		409
410	UnaryExpression::UnaryExpression(const ExpressionUnaryType unaryType, ExpressionPtr value) :	410	UnaryExpression::UnaryExpression(const ExpressionUnaryType unaryType, ExpressionPtr value) :
@@ -1626,7 +1626,7 @@ ValueExpressionPtr ExpressionTree::IsDate(const ValueExpressionPtr& testValue) c · 1215 unmodified lines
1626	if (testValue->ValueType == ExpressionValueType::DateTime)	1626	if (testValue->ValueType == ExpressionValueType::DateTime)
1627	return ExpressionTree::True;	1627	return ExpressionTree::True;
1628		1628
1629	DateTime timestamp;	1629	datetime_t timestamp;
1630		1630
1631	if (testValue->ValueType == ExpressionValueType::String && TryParseTimestamp(testValue->ValueAsString().c_str(), timestamp))	1631	if (testValue->ValueType == ExpressionValueType::String && TryParseTimestamp(testValue->ValueAsString().c_str(), timestamp))
1632	return ExpressionTree::True;	1632	return ExpressionTree::True;
@@ -3119,7 +3119,7 @@ ValueExpressionPtr ExpressionTree::Convert(const ValueExpressionPtr& sourceValue · 1486 unmodified lines
3119	}	3119	}
3120	case ExpressionValueType::DateTime:	3120	case ExpressionValueType::DateTime:
3121	{	3121	{
3122	const DateTime result = sourceValue->ValueAsDateTime();	3122	const datetime_t result = sourceValue->ValueAsDateTime();
3123	const time_t value = to_time_t(result);	3123	const time_t value = to_time_t(result);
3124		3124
3125	switch (targetValueType)	3125	switch (targetValueType)
@@ -3236,7 +3236,7 @@ ValueExpressionPtr ExpressionTree::NullValue(const ExpressionValueType targetVal · 110 unmodified lines
3236	case ExpressionValueType::Guid:	3236	case ExpressionValueType::Guid:
3237	return NewSharedPtr<ValueExpression>(ExpressionValueType::Guid, Nullable<Guid>(nullptr), true);	3237	return NewSharedPtr<ValueExpression>(ExpressionValueType::Guid, Nullable<Guid>(nullptr), true);
3238	case ExpressionValueType::DateTime:	3238	case ExpressionValueType::DateTime:
3239	return NewSharedPtr<ValueExpression>(ExpressionValueType::DateTime, Nullable<DateTime>(nullptr), true);	3239	return NewSharedPtr<ValueExpression>(ExpressionValueType::DateTime, Nullable<datetime_t>(nullptr), true);
3240	default:	3240	default:
3241	return NewSharedPtr<ValueExpression>(ExpressionValueType::Undefined, nullptr);	3241	return NewSharedPtr<ValueExpression>(ExpressionValueType::Undefined, nullptr);
3242	}	3242	}

Source/Libraries/TimeSeriesPlatformLibrary/FilterExpressions/ExpressionTree.h+2−2

@@ -127,8 +127,8 @@ namespace FilterExpressions · 126 unmodified lines
127	GSF::Guid ValueAsGuid() const;	127	GSF::Guid ValueAsGuid() const;
128	Nullable<GSF::Guid> ValueAsNullableGuid() const;	128	Nullable<GSF::Guid> ValueAsNullableGuid() const;
129		129
130	GSF::DateTime ValueAsDateTime() const;	130	GSF::datetime_t ValueAsDateTime() const;
131	Nullable<GSF::DateTime> ValueAsNullableDateTime() const;	131	Nullable<GSF::datetime_t> ValueAsNullableDateTime() const;
132	};	132	};
133		133
134	typedef GSF::SharedPtr<ValueExpression> ValueExpressionPtr;	134	typedef GSF::SharedPtr<ValueExpression> ValueExpressionPtr;

Source/Libraries/TimeSeriesPlatformLibrary/FilterExpressions/FilterExpressionParser.cpp+1−1

@@ -59,7 +59,7 @@ static GSF::Guid ParseGuidLiteral(string guidLiteral) · 58 unmodified lines
59	return ParseGuid(guidLiteral.c_str());	59	return ParseGuid(guidLiteral.c_str());
60	}	60	}
61		61
62	static DateTime ParseDateTimeLiteral(string time)	62	static datetime_t ParseDateTimeLiteral(string time)
63	{	63	{
64	// Remove any surrounding '#' symbols from date/time, ANTLR grammar already	64	// Remove any surrounding '#' symbols from date/time, ANTLR grammar already
65	// ensures date/time starting with '#' symbol will also end with one	65	// ensures date/time starting with '#' symbol will also end with one

Source/Libraries/TimeSeriesPlatformLibrary/Samples/AdvancedPublish.cpp+35−11

 using namespace GSF::FilterExpressions;
 DataPublisherPtr Publisher;
-TimerPtr PublishTimer;
+TimerPtr PublishTimer, CompletionTimer;
 vector<DeviceMetadataPtr> DevicesToPublish;
 vector<MeasurementMetadataPtr> MeasurementsToPublish;
 vector<PhasorMetadataPtr> PhasorsToPublish;
 bool RunPublisher(uint16_t port);
-void DisplayClientConnected(DataPublisher* source, const Guid& subscriberID, const string& connectionID);
+void DisplayClientConnected(DataPublisher* source, const SubscriberConnectionPtr& connection);
-void DisplayClientDisconnected(DataPublisher* source, const Guid& subscriberID, const string& connectionID);
+void DisplayClientDisconnected(DataPublisher* source, const SubscriberConnectionPtr& connection);
 void DisplayStatusMessage(DataPublisher* source, const string& message);
 void DisplayErrorMessage(DataPublisher* source, const string& message);
+void HandleTemporalSubscriptionRequested(DataPublisher* source, const SubscriberConnectionPtr& connection);
+void HandleTemporalProcessingIntervalChangeRequested(DataPublisher* source, const SubscriberConnectionPtr& connection);
 void LoadMetadataToPublish(vector<DeviceMetadataPtr>& deviceMetadata, vector<MeasurementMetadataPtr>& measurementMetadata, vector<PhasorMetadataPtr>& phasorMetadata)
 {
     DeviceMetadataPtr device1Metadata = NewSharedPtr<DeviceMetadata>();
-    const DateTime timestamp = UtcNow();
+    const datetime_t timestamp = UtcNow();
     // Add a device
     device1Metadata->Name = "Test PMU";
         Publisher->RegisterClientDisconnectedCallback(&DisplayClientDisconnected);
         Publisher->RegisterStatusMessageCallback(&DisplayStatusMessage);
         Publisher->RegisterErrorMessageCallback(&DisplayErrorMessage);
+        Publisher->RegisterTemporalSubscriptionRequestedCallback(&HandleTemporalSubscriptionRequested);
+        Publisher->RegisterTemporalProcessingIntervalChangeRequestedCallback(&HandleTemporalProcessingIntervalChangeRequested);
+        // Enable temporal subscription support
+        Publisher->SetSupportsTemporalSubscriptions(true);
         // Load metadata to be used for publication
         LoadMetadataToPublish(DevicesToPublish, MeasurementsToPublish, PhasorsToPublish);
     return running;
 }
-void DisplayClientConnected(DataPublisher* source, const Guid& subscriberID, const string& connectionID)
+void DisplayClientConnected(DataPublisher* source, const SubscriberConnectionPtr& connection)
 {
     cout << ">> New Client Connected:" << endl;
-    cout << "   Subscriber ID: " << ToString(subscriberID) << endl;
+    cout << "   Subscriber ID: " << ToString(connection->GetSubscriberID()) << endl;
-    cout << "   Connection ID: " << connectionID << endl << endl;
+    cout << "   Connection ID: " << ToString(connection->GetConnectionID()) << endl << endl;
 }
-void DisplayClientDisconnected(DataPublisher* source, const Guid& subscriberID, const string& connectionID)
+void DisplayClientDisconnected(DataPublisher* source, const SubscriberConnectionPtr& connection)
 {
     cout << ">> Client Disconnected:" << endl;
-    cout << "   Subscriber ID: " << ToString(subscriberID) << endl;
+    cout << "   Subscriber ID: " << ToString(connection->GetSubscriberID()) << endl;
-    cout << "   Connection ID: " << connectionID << endl << endl;
+    cout << "   Connection ID: " << ToString(connection->GetConnectionID()) << endl << endl;
 }
 // Callback which is called to display status messages from the subscriber.
 void DisplayErrorMessage(DataPublisher* source, const string& message)
 {
     cerr << message << endl << endl;
 }
+void HandleTemporalSubscriptionRequested(DataPublisher* source, const SubscriberConnectionPtr& connection)
+{
+    cout << "Client \"" << connection->GetConnectionID() << "\" with subscriber ID " << ToString(connection->GetSubscriberID()) << " has requested a temporal subscription starting at " << ToString(connection->GetStartTimeConstraint()) << endl << endl;
+    CompletionTimer = NewSharedPtr<Timer>(1000, [connection](Timer*, void*)
+    {
+        connection->CompleteTemporalSubscription();
+    });
+    CompletionTimer->Start();
+}
+void HandleTemporalProcessingIntervalChangeRequested(DataPublisher* source, const SubscriberConnectionPtr& connection)
+{
+    cout << "Client \"" << connection->GetConnectionID() << "\" with subscriber ID " << ToString(connection->GetSubscriberID()) << " has requested to change its temporal processing interval to " << ToString(connection->GetProcessingInterval()) << "ms" << endl << endl;
+}

Source/Libraries/TimeSeriesPlatformLibrary/Samples/FilterExpressionTests.cpp+9−9

Source/Libraries/TimeSeriesPlatformLibrary/Samples/SimplePublish.cpp+9−9

Source/Libraries/TimeSeriesPlatformLibrary/Samples/SubscriberHandler.cpp+1−1

@@ -104,7 +104,7 @@ void SubscriberHandler::DataStartTime(time_t unixSOC, uint16_t milliseconds) · 103 unmodified lines
104	// TODO: This reports timestamp, time_t format, of very first received measurement (if useful)	104	// TODO: This reports timestamp, time_t format, of very first received measurement (if useful)
105	}	105	}
106		106
107	void SubscriberHandler::DataStartTime(DateTime startTime)	107	void SubscriberHandler::DataStartTime(datetime_t startTime)
108	{	108	{
109	// TODO: This reports timestamp, ptime format, of very first received measurement (if useful)	109	// TODO: This reports timestamp, ptime format, of very first received measurement (if useful)
110	}	110	}

Source/Libraries/TimeSeriesPlatformLibrary/Samples/SubscriberHandler.h+1−1

@@ -41,7 +41,7 @@ protected: · 40 unmodified lines
41	void StatusMessage(const std::string& message) override;	41	void StatusMessage(const std::string& message) override;
42	void ErrorMessage(const std::string& message) override;	42	void ErrorMessage(const std::string& message) override;
43	void DataStartTime(time_t unixSOC, uint16_t milliseconds) override;	43	void DataStartTime(time_t unixSOC, uint16_t milliseconds) override;
44	void DataStartTime(GSF::DateTime startTime) override;	44	void DataStartTime(GSF::datetime_t startTime) override;
45	void ReceivedMetadata(const std::vector<uint8_t>& payload) override;	45	void ReceivedMetadata(const std::vector<uint8_t>& payload) override;
46	void ReceivedNewMeasurements(const std::vector<GSF::TimeSeries::MeasurementPtr>& measurements) override;	46	void ReceivedNewMeasurements(const std::vector<GSF::TimeSeries::MeasurementPtr>& measurements) override;
47	void ParsedMetadata() override;	47	void ParsedMetadata() override;

Source/Libraries/TimeSeriesPlatformLibrary/Transport/DataPublisher.cpp+94−34

@@ -36,24 +36,13 @@ using namespace GSF::FilterExpressions; · 35 unmodified lines
36	using namespace GSF::TimeSeries;	36	using namespace GSF::TimeSeries;
37	using namespace GSF::TimeSeries::Transport;	37	using namespace GSF::TimeSeries::Transport;
38		38
39	struct SubscriberConnectionInfo
40	{
41	const GSF::Guid SubscriberID;
42	const string ConnectionID;
43
44	SubscriberConnectionInfo(const GSF::Guid& subscriberID, string connectionID) :
45	SubscriberID(subscriberID),
46	ConnectionID(std::move(connectionID))
47	{
48	}
49	};
50
51	DataPublisher::DataPublisher(const TcpEndPoint& endpoint) :	39	DataPublisher::DataPublisher(const TcpEndPoint& endpoint) :
52	m_nodeID(NewGuid()),	40	m_nodeID(NewGuid()),
53	m_securityMode(SecurityMode::None),	41	m_securityMode(SecurityMode::None),
54	m_allowMetadataRefresh(true),	42	m_allowMetadataRefresh(true),
55	m_allowNaNValueFilter(true),	43	m_allowNaNValueFilter(true),
56	m_forceNaNValueFilter(false),	44	m_forceNaNValueFilter(false),
		45	m_supportsTemporalSubscriptions(false),
57	m_cipherKeyRotationPeriod(60000),	46	m_cipherKeyRotationPeriod(60000),
58	m_userData(nullptr),	47	m_userData(nullptr),
59	m_disposing(false),	48	m_disposing(false),
@@ -116,19 +105,21 @@ void DataPublisher::AcceptConnection(const SubscriberConnectionPtr& connection, · 56 unmodified lines
116	m_subscriberConnectionsLock.unlock();	105	m_subscriberConnectionsLock.unlock();
117		106
118	connection->Start();	107	connection->Start();
119	DispatchClientConnected(connection->GetSubscriberID(), connection->GetConnectionID());	108	DispatchClientConnected(connection);
120	}	109	}
121		110
122	StartAccept();	111	StartAccept();
123	}	112	}
124		113
		114	void DataPublisher::ConnectionTerminated(const SubscriberConnectionPtr& connection)
		115	{
		116	DispatchClientDisconnected(connection);
		117	}
		118
125	void DataPublisher::RemoveConnection(const SubscriberConnectionPtr& connection)	119	void DataPublisher::RemoveConnection(const SubscriberConnectionPtr& connection)
126	{	120	{
127	m_subscriberConnectionsLock.lock();	121	m_subscriberConnectionsLock.lock();
128		122	m_subscriberConnections.erase(connection);
129	if (m_subscriberConnections.erase(connection))
130	DispatchClientDisconnected(connection->GetSubscriberID(), connection->GetConnectionID());
131
132	m_subscriberConnectionsLock.unlock();	123	m_subscriberConnectionsLock.unlock();
133	}	124	}
134		125
@@ -169,16 +160,28 @@ void DataPublisher::DispatchErrorMessage(const string& message) · 34 unmodified lines
169	Dispatch(&ErrorMessageDispatcher, reinterpret_cast<const uint8_t*>(message.c_str()), 0, messageSize);	160	Dispatch(&ErrorMessageDispatcher, reinterpret_cast<const uint8_t*>(message.c_str()), 0, messageSize);
170	}	161	}
171		162
172	void DataPublisher::DispatchClientConnected(const GSF::Guid& subscriberID, const string& connectionID)	163	void DataPublisher::DispatchClientConnected(const SubscriberConnectionPtr& connection)
		164	{
		165	SubscriberConnection* connectionReference = &*connection;
		166	Dispatch(&ClientConnectedDispatcher, reinterpret_cast<uint8_t>(&connectionReference), 0, sizeof(SubscriberConnection*));
		167	}
		168
		169	void DataPublisher::DispatchClientDisconnected(const SubscriberConnectionPtr& connection)
		170	{
		171	SubscriberConnection* connectionReference = &*connection;
		172	Dispatch(&ClientDisconnectedDispatcher, reinterpret_cast<uint8_t>(&connectionReference), 0, sizeof(SubscriberConnection*));
		173	}
		174
		175	void DataPublisher::DispatchTemporalSubscriptionRequested(const SubscriberConnectionPtr& connection)
173	{	176	{
174	SubscriberConnectionInfo* data = new SubscriberConnectionInfo(subscriberID, connectionID);	177	SubscriberConnection* connectionReference = &*connection;
175	Dispatch(&ClientConnectedDispatcher, reinterpret_cast<uint8_t>(&data), 0, sizeof(SubscriberConnectionInfo*));	178	Dispatch(&TemporalSubscriptionRequestedDispatcher, reinterpret_cast<uint8_t>(&connectionReference), 0, sizeof(SubscriberConnection*));
176	}	179	}
177		180
178	void DataPublisher::DispatchClientDisconnected(const GSF::Guid& subscriberID, const std::string& connectionID)	181	void DataPublisher::DispatchTemporalProcessingIntervalChangeRequested(const SubscriberConnectionPtr& connection)
179	{	182	{
180	SubscriberConnectionInfo* data = new SubscriberConnectionInfo(subscriberID, connectionID);	183	SubscriberConnection* connectionReference = &*connection;
181	Dispatch(&ClientDisconnectedDispatcher, reinterpret_cast<uint8_t>(&data), 0, sizeof(SubscriberConnectionInfo*));	184	Dispatch(&TemporalProcessingIntervalChangeRequestedDispatcher, reinterpret_cast<uint8_t>(&connectionReference), 0, sizeof(SubscriberConnection*));
182	}	185	}
183		186
184	// Dispatcher function for status messages. Decodes the message and provides it to the user via the status message callback.	187	// Dispatcher function for status messages. Decodes the message and provides it to the user via the status message callback.
@@ -207,32 +210,56 @@ void DataPublisher::ErrorMessageDispatcher(DataPublisher* source, const vector<u · 22 unmodified lines
207		210
208	void DataPublisher::ClientConnectedDispatcher(DataPublisher* source, const vector<uint8_t>& buffer)	211	void DataPublisher::ClientConnectedDispatcher(DataPublisher* source, const vector<uint8_t>& buffer)
209	{	212	{
210	SubscriberConnectionInfo* data = reinterpret_cast<SubscriberConnectionInfo>(const_cast<uint8_t>(&buffer[0]));	213	SubscriberConnection* connection = reinterpret_cast<SubscriberConnection>(const_cast<uint8_t>(&buffer[0]));
211		214
212	if (source != nullptr)	215	if (source != nullptr)
213	{	216	{
214	const SubscriberConnectionCallback clientConnectedCallback = source->m_clientConnectedCallback;	217	const SubscriberConnectionCallback clientConnectedCallback = source->m_clientConnectedCallback;
215		218
216	if (clientConnectedCallback != nullptr)	219	if (clientConnectedCallback != nullptr)
217	clientConnectedCallback(source, data->SubscriberID, data->ConnectionID);	220	clientConnectedCallback(source, connection->GetReference());
218	}	221	}
219
220	delete data;
221	}	222	}
222		223
223	void DataPublisher::ClientDisconnectedDispatcher(DataPublisher* source, const std::vector<uint8_t>& buffer)	224	void DataPublisher::ClientDisconnectedDispatcher(DataPublisher* source, const std::vector<uint8_t>& buffer)
224	{	225	{
225	SubscriberConnectionInfo* data = reinterpret_cast<SubscriberConnectionInfo>(const_cast<uint8_t>(&buffer[0]));	226	SubscriberConnection* connection = reinterpret_cast<SubscriberConnection>(const_cast<uint8_t>(&buffer[0]));
226		227
227	if (source != nullptr)	228	if (source != nullptr)
228	{	229	{
229	const SubscriberConnectionCallback clientDisconnectedCallback = source->m_clientDisconnectedCallback;	230	const SubscriberConnectionCallback clientDisconnectedCallback = source->m_clientDisconnectedCallback;
230		231
231	if (clientDisconnectedCallback != nullptr)	232	if (clientDisconnectedCallback != nullptr)
232	clientDisconnectedCallback(source, data->SubscriberID, data->ConnectionID);	233	clientDisconnectedCallback(source, connection->GetReference());
		234
		235	source->RemoveConnection(connection->GetReference());
		236	}
		237	}
		238
		239	void DataPublisher::TemporalSubscriptionRequestedDispatcher(DataPublisher* source, const std::vector<uint8_t>& buffer)
		240	{
		241	SubscriberConnection* connection = reinterpret_cast<SubscriberConnection>(const_cast<uint8_t>(&buffer[0]));
		242
		243	if (source != nullptr)
		244	{
		245	const SubscriberConnectionCallback temporalSubscriptionRequestedCallback = source->m_temporalSubscriptionRequestedCallback;
		246
		247	if (temporalSubscriptionRequestedCallback != nullptr)
		248	temporalSubscriptionRequestedCallback(source, connection->GetReference());
233	}	249	}
		250	}
		251
		252	void DataPublisher::TemporalProcessingIntervalChangeRequestedDispatcher(DataPublisher* source, const std::vector<uint8_t>& buffer)
		253	{
		254	SubscriberConnection* connection = reinterpret_cast<SubscriberConnection>(const_cast<uint8_t>(&buffer[0]));
		255
		256	if (source != nullptr)
		257	{
		258	const SubscriberConnectionCallback temporalProcessingIntervalChangeRequestedCallback = source->m_temporalProcessingIntervalChangeRequestedCallback;
234		259
235	delete data;	260	if (temporalProcessingIntervalChangeRequestedCallback != nullptr)
		261	temporalProcessingIntervalChangeRequestedCallback(source, connection->GetReference());
		262	}
236	}	263	}
237		264
238	int32_t DataPublisher::GetColumnIndex(const GSF::Data::DataTablePtr& table, const std::string& columnName)	265	int32_t DataPublisher::GetColumnIndex(const GSF::Data::DataTablePtr& table, const std::string& columnName)
@@ -683,14 +710,27 @@ vector<MeasurementMetadataPtr> DataPublisher::FilterMetadata(const string& filte · 444 unmodified lines
683		710
684	void DataPublisher::PublishMeasurements(const vector<Measurement>& measurements)	711	void DataPublisher::PublishMeasurements(const vector<Measurement>& measurements)
685	{	712	{
686	for (const auto& connection : m_subscriberConnections)	713	vector<MeasurementPtr> measurementPtrs;
687	connection->PublishMeasurements(measurements);	714
		715	measurementPtrs.reserve(measurements.size());
		716
		717	for (const auto& measurement : measurements)
		718	measurementPtrs.push_back(ToPtr(measurement));
		719
		720	PublishMeasurements(measurementPtrs);
688	}	721	}
689		722
690	void DataPublisher::PublishMeasurements(const vector<MeasurementPtr>& measurements)	723	void DataPublisher::PublishMeasurements(const vector<MeasurementPtr>& measurements)
691	{	724	{
		725	m_subscriberConnectionsLock.lock();
		726
692	for (const auto& connection : m_subscriberConnections)	727	for (const auto& connection : m_subscriberConnections)
693	connection->PublishMeasurements(measurements);	728	{
		729	if (connection->GetIsSubscribed() && !connection->GetIsTemporalSubscription())
		730	connection->PublishMeasurements(measurements);
		731	}
		732
		733	m_subscriberConnectionsLock.unlock();
694	}	734	}
695		735
696	const GSF::Guid& DataPublisher::GetNodeID() const	736	const GSF::Guid& DataPublisher::GetNodeID() const
@@ -743,6 +783,16 @@ void DataPublisher::SetNaNValueFilterForced(bool forced) · 46 unmodified lines
743	m_forceNaNValueFilter = forced;	783	m_forceNaNValueFilter = forced;
744	}	784	}
745		785
		786	bool DataPublisher::GetSupportsTemporalSubscriptions() const
		787	{
		788	return m_supportsTemporalSubscriptions;
		789	}
		790
		791	void DataPublisher::SetSupportsTemporalSubscriptions(bool value)
		792	{
		793	m_supportsTemporalSubscriptions = value;
		794	}
		795
746	uint32_t DataPublisher::GetCipherKeyRotationPeriod() const	796	uint32_t DataPublisher::GetCipherKeyRotationPeriod() const
747	{	797	{
748	return m_cipherKeyRotationPeriod;	798	return m_cipherKeyRotationPeriod;
@@ -823,4 +873,14 @@ void DataPublisher::RegisterClientConnectedCallback(const SubscriberConnectionCa · 74 unmodified lines
823	void DataPublisher::RegisterClientDisconnectedCallback(const SubscriberConnectionCallback& clientDisconnectedCallback)	873	void DataPublisher::RegisterClientDisconnectedCallback(const SubscriberConnectionCallback& clientDisconnectedCallback)
824	{	874	{
825	m_clientDisconnectedCallback = clientDisconnectedCallback;	875	m_clientDisconnectedCallback = clientDisconnectedCallback;
826	}	876	}
		877
		878	void DataPublisher::RegisterTemporalSubscriptionRequestedCallback(const SubscriberConnectionCallback& temporalSubscriptionRequestedCallback)
		879	{
		880	m_temporalSubscriptionRequestedCallback = temporalSubscriptionRequestedCallback;
		881	}
		882
		883	void DataPublisher::RegisterTemporalProcessingIntervalChangeRequestedCallback(const SubscriberConnectionCallback& temporalProcessingIntervalChangeRequestedCallback)
		884	{
		885	m_temporalProcessingIntervalChangeRequestedCallback = temporalProcessingIntervalChangeRequestedCallback;
		886	}

Source/Libraries/TimeSeriesPlatformLibrary/Transport/DataPublisher.h+34−13

@@ -44,12 +44,13 @@ namespace Transport · 43 unmodified lines
44	{	44	{
45	class DataPublisher : public EnableSharedThisPtr<DataPublisher> // NOLINT	45	class DataPublisher : public EnableSharedThisPtr<DataPublisher> // NOLINT
46	{	46	{
47	private:	47	public:
48	// Function pointer types	48	// Function pointer types
49	typedef std::function<void(DataPublisher*, const std::vector<uint8_t>&)> DispatcherFunction;	49	typedef std::function<void(DataPublisher*, const std::vector<uint8_t>&)> DispatcherFunction;
50	typedef std::function<void(DataPublisher*, const std::string&)> MessageCallback;	50	typedef std::function<void(DataPublisher*, const std::string&)> MessageCallback;
51	typedef std::function<void(DataPublisher*, const GSF::Guid&, const std::string&)> SubscriberConnectionCallback;	51	typedef std::function<void(DataPublisher*, const SubscriberConnectionPtr&)> SubscriberConnectionCallback;
52		52
		53	private:
53	// Structure used to dispatch	54	// Structure used to dispatch
54	// callbacks on the callback thread.	55	// callbacks on the callback thread.
55	struct CallbackDispatcher	56	struct CallbackDispatcher
@@ -70,6 +71,7 @@ namespace Transport · 14 unmodified lines
70	bool m_allowMetadataRefresh;	71	bool m_allowMetadataRefresh;
71	bool m_allowNaNValueFilter;	72	bool m_allowNaNValueFilter;
72	bool m_forceNaNValueFilter;	73	bool m_forceNaNValueFilter;
		74	bool m_supportsTemporalSubscriptions;
73	uint32_t m_cipherKeyRotationPeriod;	75	uint32_t m_cipherKeyRotationPeriod;
74	void* m_userData;	76	void* m_userData;
75	bool m_disposing;	77	bool m_disposing;
@@ -93,6 +95,7 @@ namespace Transport · 17 unmodified lines
93	// Command channel handlers	95	// Command channel handlers
94	void StartAccept();	96	void StartAccept();
95	void AcceptConnection(const SubscriberConnectionPtr& connection, const ErrorCode& error);	97	void AcceptConnection(const SubscriberConnectionPtr& connection, const ErrorCode& error);
		98	void ConnectionTerminated(const SubscriberConnectionPtr& connection);
96	void RemoveConnection(const SubscriberConnectionPtr& connection);	99	void RemoveConnection(const SubscriberConnectionPtr& connection);
97		100
98	// Callbacks	101	// Callbacks
@@ -100,19 +103,25 @@ namespace Transport · 1 unmodified line
100	MessageCallback m_errorMessageCallback;	103	MessageCallback m_errorMessageCallback;
101	SubscriberConnectionCallback m_clientConnectedCallback;	104	SubscriberConnectionCallback m_clientConnectedCallback;
102	SubscriberConnectionCallback m_clientDisconnectedCallback;	105	SubscriberConnectionCallback m_clientDisconnectedCallback;
		106	SubscriberConnectionCallback m_temporalSubscriptionRequestedCallback;
		107	SubscriberConnectionCallback m_temporalProcessingIntervalChangeRequestedCallback;
103		108
104	// Dispatchers	109	// Dispatchers
105	void Dispatch(const DispatcherFunction& function);	110	void Dispatch(const DispatcherFunction& function);
106	void Dispatch(const DispatcherFunction& function, const uint8_t* data, uint32_t offset, uint32_t length);	111	void Dispatch(const DispatcherFunction& function, const uint8_t* data, uint32_t offset, uint32_t length);
107	void DispatchStatusMessage(const std::string& message);	112	void DispatchStatusMessage(const std::string& message);
108	void DispatchErrorMessage(const std::string& message);	113	void DispatchErrorMessage(const std::string& message);
109	void DispatchClientConnected(const GSF::Guid& subscriberID, const std::string& connectionID);	114	void DispatchClientConnected(const SubscriberConnectionPtr& connection);
110	void DispatchClientDisconnected(const GSF::Guid& subscriberID, const std::string& connectionID);	115	void DispatchClientDisconnected(const SubscriberConnectionPtr& connection);
		116	void DispatchTemporalSubscriptionRequested(const SubscriberConnectionPtr& connection);
		117	void DispatchTemporalProcessingIntervalChangeRequested(const SubscriberConnectionPtr& connection);
111		118
112	static void StatusMessageDispatcher(DataPublisher* source, const std::vector<uint8_t>& buffer);	119	static void StatusMessageDispatcher(DataPublisher* source, const std::vector<uint8_t>& buffer);
113	static void ErrorMessageDispatcher(DataPublisher* source, const std::vector<uint8_t>& buffer);	120	static void ErrorMessageDispatcher(DataPublisher* source, const std::vector<uint8_t>& buffer);
114	static void ClientConnectedDispatcher(DataPublisher* source, const std::vector<uint8_t>& buffer);	121	static void ClientConnectedDispatcher(DataPublisher* source, const std::vector<uint8_t>& buffer);
115	static void ClientDisconnectedDispatcher(DataPublisher* source, const std::vector<uint8_t>& buffer);	122	static void ClientDisconnectedDispatcher(DataPublisher* source, const std::vector<uint8_t>& buffer);
		123	static void TemporalSubscriptionRequestedDispatcher(DataPublisher* source, const std::vector<uint8_t>& buffer);
		124	static void TemporalProcessingIntervalChangeRequestedDispatcher(DataPublisher* source, const std::vector<uint8_t>& buffer);
116	static int32_t GetColumnIndex(const GSF::Data::DataTablePtr& table, const std::string& columnName);	125	static int32_t GetColumnIndex(const GSF::Data::DataTablePtr& table, const std::string& columnName);
117	public:	126	public:
118	// Creates a new instance of the data publisher.	127	// Creates a new instance of the data publisher.
@@ -123,14 +132,22 @@ namespace Transport · 4 unmodified lines
123	// tied up by the publisher.	132	// tied up by the publisher.
124	~DataPublisher();	133	~DataPublisher();
125		134
126	// Define metadata from existing metadata tables	135	// Defines metadata from existing metadata records
127	void DefineMetadata(const std::vector<DeviceMetadataPtr>& deviceMetadata, const std::vector<MeasurementMetadataPtr>& measurementMetadata, const std::vector<PhasorMetadataPtr>& phasorMetadata, int32_t versionNumber = 0);	136	void DefineMetadata(const std::vector<DeviceMetadataPtr>& deviceMetadata, const std::vector<MeasurementMetadataPtr>& measurementMetadata, const std::vector<PhasorMetadataPtr>& phasorMetadata, int32_t versionNumber = 0);
128		137
129	// Define metadata from an existing dataset	138	// Defines metadata from an existing dataset
130	void DefineMetadata(const GSF::Data::DataSetPtr& metadata);	139	void DefineMetadata(const GSF::Data::DataSetPtr& metadata);
131		140
		141	// Gets primary metadata. This dataset contains all the normalized metadata tables that define
		142	// the available detail about the data points that can be subscribed to by clients.
132	const GSF::Data::DataSetPtr& GetMetadata() const;	143	const GSF::Data::DataSetPtr& GetMetadata() const;
		144
		145	// Gets filtering metadata. This dataset, derived from primary metadata, contains a flattened
		146	// table used to subscribe to a filtered set of points with an expression, e.g.:
		147	// FILTER ActiveMeasurements WHERE SignalType LIKE '%PHA'
133	const GSF::Data::DataSetPtr& GetFilteringMetadata() const;	148	const GSF::Data::DataSetPtr& GetFilteringMetadata() const;
		149
		150	// Filters primary MeasurementDetail metadata returning values as measurement metadata records
134	std::vector<MeasurementMetadataPtr> FilterMetadata(const std::string& filterExpression) const;	151	std::vector<MeasurementMetadataPtr> FilterMetadata(const std::string& filterExpression) const;
135		152
136	void PublishMeasurements(const std::vector<Measurement>& measurements);	153	void PublishMeasurements(const std::vector<Measurement>& measurements);
@@ -154,6 +171,9 @@ namespace Transport · 17 unmodified lines
154	bool IsNaNValueFilterForced() const;	171	bool IsNaNValueFilterForced() const;
155	void SetNaNValueFilterForced(bool forced);	172	void SetNaNValueFilterForced(bool forced);
156		173
		174	bool GetSupportsTemporalSubscriptions() const;
		175	void SetSupportsTemporalSubscriptions(bool value);
		176
157	uint32_t GetCipherKeyRotationPeriod() const;	177	uint32_t GetCipherKeyRotationPeriod() const;
158	void SetCipherKeyRotationPeriod(uint32_t period);	178	void SetCipherKeyRotationPeriod(uint32_t period);
159		179
@@ -169,17 +189,18 @@ namespace Transport · 9 unmodified lines
169	// Callback registration	189	// Callback registration
170	//	190	//
171	// Callback functions are defined with the following signatures:	191	// Callback functions are defined with the following signatures:
172	// void ProcessStatusMessage(DataPublisher*, const string& message)	192	// void ProcessStatusMessage(DataPublisher* source, const string& message)
173	// void ProcessErrorMessage(DataPublisher*, const string& message)	193	// void ProcessErrorMessage(DataPublisher* source, const string& message)
174	// void ProcessClientConnected(DataPublisher*, const GSF::Guid& subscriberID, const string& connectionID);	194	// void ProcessClientConnected(DataPublisher* source, const SubscriberConnectionPtr& connection);
175	// void ProcessClientDisconnected(DataPublisher*, const GSF::Guid& subscriberID, const string& connectionID);	195	// void ProcessClientDisconnected(DataPublisher* source, const SubscriberConnectionPtr& connection);
		196	// void ProcessTemporalSubscriptionRequested(DataPublisher* source, const SubscriberConnectionPtr& connection);
		197	// void ProcessTemporalProcessingIntervalChangeRequested(DataPublisher* source, const SubscriberConnectionPtr& connection);
176	void RegisterStatusMessageCallback(const MessageCallback& statusMessageCallback);	198	void RegisterStatusMessageCallback(const MessageCallback& statusMessageCallback);
177	void RegisterErrorMessageCallback(const MessageCallback& errorMessageCallback);	199	void RegisterErrorMessageCallback(const MessageCallback& errorMessageCallback);
178	void RegisterClientConnectedCallback(const SubscriberConnectionCallback& clientConnectedCallback);	200	void RegisterClientConnectedCallback(const SubscriberConnectionCallback& clientConnectedCallback);
179	void RegisterClientDisconnectedCallback(const SubscriberConnectionCallback& clientDisconnectedCallback);	201	void RegisterClientDisconnectedCallback(const SubscriberConnectionCallback& clientDisconnectedCallback);
180		202	void RegisterTemporalSubscriptionRequestedCallback(const SubscriberConnectionCallback& temporalSubscriptionRequestedCallback);
181	//static std::string DecodeClientString(const SubscriberConnectionPtr& connection, const uint8_t* data, uint32_t offset, uint32_t length);	203	void RegisterTemporalProcessingIntervalChangeRequestedCallback(const SubscriberConnectionCallback& temporalProcessingIntervalChangeRequestedCallback);
182	//static std::vector<uint8_t> EncodeClientString(const SubscriberConnectionPtr& connection, const std::string& value);
183		204
184	friend class SubscriberConnection;	205	friend class SubscriberConnection;
185	};	206	};

Source/Libraries/TimeSeriesPlatformLibrary/Transport/DataSubscriber.h+10−9

     class DataSubscriber // NOLINT
     {
-    private:
+    public:
         // Function pointer types
         typedef std::function<void(DataSubscriber*, const std::vector<uint8_t>&)> DispatcherFunction;
         typedef std::function<void(DataSubscriber*, const std::string&)> MessageCallback;
         typedef std::function<void(DataSubscriber*)> ConfigurationChangedCallback;
         typedef std::function<void(DataSubscriber*)> ConnectionTerminatedCallback;
+    private:
         // Structure used to dispatch
         // callbacks on the callback thread.
         struct CallbackDispatcher
         // Callback registration
         //
         // Callback functions are defined with the following signatures:
-        //   void ProcessStatusMessage(DataSubscriber*, const string& message)
+        //   void ProcessStatusMessage(DataSubscriber* source, const string& message)
-        //   void ProcessErrorMessage(DataSubscriber*, const string& message)
+        //   void ProcessErrorMessage(DataSubscriber* source, const string& message)
-        //   void ProcessDataStartTime(DataSubscriber*, int64_t startTime)
+        //   void ProcessDataStartTime(DataSubscriber* source, int64_t startTime)
-        //   void ProcessMetadata(DataSubscriber*, const vector<uint8_t>& metadata)
+        //   void ProcessMetadata(DataSubscriber* source, const vector<uint8_t>& metadata)
-        //   void ProcessNewMeasurements(DataSubscriber*, const vector<MeasurementPtr>& newMeasurements)
+        //   void ProcessNewMeasurements(DataSubscriber* source, const vector<MeasurementPtr>& newMeasurements)
-        //   void ProcessProcessingComplete(DataSubscriber*, const string& message)
+        //   void ProcessProcessingComplete(DataSubscriber* source, const string& message)
-        //   void ProcessConfigurationChanged(DataSubscriber*)
+        //   void ProcessConfigurationChanged(DataSubscriber* source)
-        //   void ProcessConnectionTerminated(DataSubscriber*)
+        //   void ProcessConnectionTerminated(DataSubscriber* source)
         //
         // Metadata is provided to the user as zlib-compressed XML,
         // and must be decompressed and interpreted before it can be used.

Source/Libraries/TimeSeriesPlatformLibrary/Transport/PublisherInstance.cpp+32−8

     instance->ErrorMessage(message);
 }
-void PublisherInstance::HandleClientConnected(DataPublisher* source, const GSF::Guid& subscriberID, const std::string& connectionID)
+void PublisherInstance::HandleClientConnected(DataPublisher* source, const SubscriberConnectionPtr& connection)
 {
     PublisherInstance* instance = static_cast<PublisherInstance*>(source->GetUserData());
-    instance->ClientConnected(subscriberID, connectionID);
+    instance->ClientConnected(connection);
 }
-void PublisherInstance::HandleClientDisconnected(DataPublisher* source, const GSF::Guid& subscriberID, const std::string& connectionID)
+void PublisherInstance::HandleClientDisconnected(DataPublisher* source, const SubscriberConnectionPtr& connection)
 {
     PublisherInstance* instance = static_cast<PublisherInstance*>(source->GetUserData());
-    instance->ClientDisconnected(subscriberID, connectionID);
+    instance->ClientDisconnected(connection);
+}
+void PublisherInstance::HandleTemporalSubscriptionRequested(DataPublisher* source, const SubscriberConnectionPtr& connection)
+{
+    PublisherInstance* instance = static_cast<PublisherInstance*>(source->GetUserData());
+    instance->TemporalSubscriptionRequested(connection);
+}
+void PublisherInstance::HandleTemporalProcessingIntervalChangeRequested(DataPublisher* source, const SubscriberConnectionPtr& connection)
+{
+    PublisherInstance* instance = static_cast<PublisherInstance*>(source->GetUserData());
+    instance->TemporalProcessingIntervalChangeRequested(connection);
 }
 void PublisherInstance::StatusMessage(const string& message)
     cerr << message << endl << endl;
 }
-void PublisherInstance::ClientConnected(const GSF::Guid& subscriberID, const string& connectionID)
+void PublisherInstance::ClientConnected(const SubscriberConnectionPtr& connection)
+{
+    cout << "Client \"" << connection->GetConnectionID() << "\" with subscriber ID " << ToString(connection->GetSubscriberID()) << " connected..." << endl << endl;
+}
+void PublisherInstance::ClientDisconnected(const SubscriberConnectionPtr& connection)
+{
+    cout << "Client \"" << connection->GetConnectionID() << "\" with subscriber ID " << ToString(connection->GetSubscriberID()) << " disconnected..." << endl << endl;
+}
+void PublisherInstance::TemporalSubscriptionRequested(const SubscriberConnectionPtr& connection)
 {
-    cout << "Client \"" << connectionID << "\" with subscriber ID " << ToString(subscriberID) << " connected..." << endl << endl;
+    cout << "Client \"" << connection->GetConnectionID() << "\" with subscriber ID " << ToString(connection->GetSubscriberID()) << " has requested a temporal subscription starting at " << ToString(connection->GetStartTimeConstraint()) << endl << endl;
 }
-void PublisherInstance::ClientDisconnected(const GSF::Guid& subscriberID, const std::string& connectionID)
+void PublisherInstance::TemporalProcessingIntervalChangeRequested(const SubscriberConnectionPtr& connection)
 {
-    cout << "Client \"" << connectionID << "\" with subscriber ID " << ToString(subscriberID) << " disconnected..." << endl << endl;
+    cout << "Client \"" << connection->GetConnectionID() << "\" with subscriber ID " << ToString(connection->GetSubscriberID()) << " has requested to change its temporal processing interval to " << ToString(connection->GetProcessingInterval()) << "ms" << endl << endl;
 }
 void PublisherInstance::Initialize()
     m_publisher.RegisterErrorMessageCallback(&HandleErrorMessage);
     m_publisher.RegisterClientConnectedCallback(&HandleClientConnected);
     m_publisher.RegisterClientDisconnectedCallback(&HandleClientDisconnected);
+    m_publisher.RegisterTemporalSubscriptionRequestedCallback(&HandleTemporalSubscriptionRequested);
+    m_publisher.RegisterTemporalProcessingIntervalChangeRequestedCallback(&HandleTemporalProcessingIntervalChangeRequested);
     m_initialized = true;
 }

Source/Libraries/TimeSeriesPlatformLibrary/Transport/PublisherInstance.h+8−4

         // Internal subscription event handlers
         static void HandleStatusMessage(DataPublisher* source, const std::string& message);
         static void HandleErrorMessage(DataPublisher* source, const std::string& message);
-        static void HandleClientConnected(DataPublisher* source, const Guid& subscriberID, const std::string& connectionID);
+        static void HandleClientConnected(DataPublisher* source, const SubscriberConnectionPtr& connection);
-        static void HandleClientDisconnected(DataPublisher* source, const Guid& subscriberID, const std::string& connectionID);
+        static void HandleClientDisconnected(DataPublisher* source, const SubscriberConnectionPtr& connection);
+        static void HandleTemporalSubscriptionRequested(DataPublisher* source, const SubscriberConnectionPtr& connection);
+        static void HandleTemporalProcessingIntervalChangeRequested(DataPublisher* source, const SubscriberConnectionPtr& connection);
     protected:
         virtual void StatusMessage(const std::string& message);	// Defaults output to cout
         virtual void ErrorMessage(const std::string& message);	// Defaults output to cerr
-        virtual void ClientConnected(const Guid& subscriberID, const std::string& connectionID);
+        virtual void ClientConnected(const SubscriberConnectionPtr& connection);
-        virtual void ClientDisconnected(const Guid& subscriberID, const std::string& connectionID);
+        virtual void ClientDisconnected(const SubscriberConnectionPtr& connection);
+        virtual void TemporalSubscriptionRequested(const SubscriberConnectionPtr& connection);
+        virtual void TemporalProcessingIntervalChangeRequested(const SubscriberConnectionPtr& connection);
     public:
         PublisherInstance(uint16_t port, bool ipV6);

Source/Libraries/TimeSeriesPlatformLibrary/Transport/SubscriberConnection.cpp+114−58

     m_subscriberID(NewGuid()),
     m_operationalModes(OperationalModes::NoFlags),
     m_encoding(OperationalEncoding::UTF8),
+    m_startTimeConstraint(DateTime::MaxValue),
+    m_stopTimeConstraint(DateTime::MaxValue),
+    m_processingInterval(-1),
     m_usePayloadCompression(false),
     m_useCompactMeasurementFormat(true),
     m_includeTime(true),
     return m_parent;
 }
+SubscriberConnectionPtr SubscriberConnection::GetReference()
+{
+    return shared_from_this();
+}
 TcpSocket& SubscriberConnection::CommandChannelSocket()
 {
     return m_commandChannelSocket;
     return m_encoding;
 }
+bool SubscriberConnection::GetIsTemporalSubscription() const
+{
+    return m_startTimeConstraint < DateTime::MaxValue;
+}
+const GSF::datetime_t& SubscriberConnection::GetStartTimeConstraint() const
+{
+    return m_startTimeConstraint;
+}
+void SubscriberConnection::SetStartTimeConstraint(const GSF::datetime_t& value)
+{
+    m_startTimeConstraint = value;
+}
+const GSF::datetime_t& SubscriberConnection::GetStopTimeConstraint() const
+{
+    return m_stopTimeConstraint;
+}
+void SubscriberConnection::SetStopTimeConstraint(const GSF::datetime_t& value)
+{
+    m_stopTimeConstraint = value;
+}
+int32_t SubscriberConnection::GetProcessingInterval() const
+{
+    return m_processingInterval;
+}
+void SubscriberConnection::SetProcessingInterval(int32_t value)
+{
+    m_processingInterval = value;
+    m_parent->DispatchTemporalProcessingIntervalChangeRequested(shared_from_this());
+    m_parent->DispatchStatusMessage(m_connectionID + " was assigned a new processing interval of " + ToString(value) + ".");
+}
 bool SubscriberConnection::GetUsePayloadCompression() const
 {
     return m_usePayloadCompression;
     m_pingTimer.Stop();
     m_commandChannelSocket.shutdown(socket_base::shutdown_both);
     m_commandChannelSocket.cancel();
-    m_parent->RemoveConnection(shared_from_this());
+    m_parent->ConnectionTerminated(shared_from_this());
-}
-void SubscriberConnection::PublishMeasurements(const vector<Measurement>& measurements)
-{
-    if (measurements.empty() || !m_isSubscribed)
-        return;
-    if (!m_startTimeSent)
-        m_startTimeSent = SendDataStartTime(measurements[0].Timestamp);
-    // TODO: Consider queuing measurements for processing
-    CompactMeasurement serializer(m_signalIndexCache, m_baseTimeOffsets, m_includeTime, m_useCompactMeasurementFormat);
-    vector<uint8_t> packet, buffer;
-    int32_t count = 0;
-    packet.reserve(MaxPacketSize);
-    buffer.reserve(16);
-    for (size_t i = 0; i < measurements.size(); i++)
-    {
-        const Measurement& measurement = measurements[i];
-        const uint16_t runtimeID = m_signalIndexCache->GetSignalIndex(measurement.SignalID);
-        if (runtimeID == UInt16::MaxValue)
-            continue;
-        const uint32_t length = serializer.SerializeMeasurement(measurement, buffer, runtimeID);
-        if (packet.size() + length > MaxPacketSize)
-        {
-            PublishDataPacket(packet, count);
-            packet.clear();
-            count = 0;
-        }
-        WriteBytes(packet, buffer);
-        buffer.clear();
-        count++;
-    }
-    if (count > 0)
-        PublishDataPacket(packet, count);
 }
 void SubscriberConnection::PublishMeasurements(const vector<MeasurementPtr>& measurements)
         PublishDataPacket(packet, count);
 }
+void SubscriberConnection::CompleteTemporalSubscription()
+{
+    SendResponse(ServerResponse::ProcessingComplete, ServerCommand::Subscribe, ToString(m_parent->GetNodeID()));
+}
 void SubscriberConnection::HandleSubscribe(uint8_t* data, uint32_t length)
 {
     try
                     if (TryGetValue(settings, "requestNaNValueFilter", setting))
                         SetIsNaNFiltered(ParseBoolean(setting));
+                    if (TryGetValue(settings, "startTimeConstraint", setting))
+                        TryParseTimestamp(setting.c_str(), m_startTimeConstraint, DateTime::MaxValue);
+                    if (TryGetValue(settings, "startTimeConstraint", setting))
+                        TryParseTimestamp(setting.c_str(), m_startTimeConstraint, DateTime::MaxValue);
+                    if (TryGetValue(settings, "processingInterval", setting) && !setting.empty())
+                        TryParseInt32(setting, m_processingInterval, -1);
+                    if (GetIsTemporalSubscription())
+                    {
+                        if (!m_parent->GetSupportsTemporalSubscriptions())
+                            throw PublisherException("Publisher does not temporal subscriptions");
+                        if (m_startTimeConstraint > m_stopTimeConstraint)
+                            throw PublisherException("Specified stop time of requested temporal subscription precedes start time");
+                    }
                     SetUsePayloadCompression(usePayloadCompression);
                     SetUseCompactMeasurementFormat(useCompactMeasurementFormat);
                     SetIsSubscribed(true);
                     SendResponse(ServerResponse::Succeeded, ServerCommand::Subscribe, message);
                     m_parent->DispatchStatusMessage(message);
+                    if (GetIsTemporalSubscription())
+                        m_parent->DispatchTemporalSubscriptionRequested(shared_from_this());
                 }
                 else
                 {
-                    const string message = byteLength > 0 ?
+                    HandleSubscribeFailure(byteLength > 0 ?
                         "Not enough buffer was provided to parse client data subscription." :
-                        "Cannot initialize client data subscription without a connection string.";
+                        "Cannot initialize client data subscription without a connection string.");
-                    SendResponse(ServerResponse::Failed, ServerCommand::Subscribe, message);
-                    m_parent->DispatchErrorMessage(message);
                 }
             }
         }
         else
         {
-            const string message = "Not enough buffer was provided to parse client data subscription.";
+            HandleSubscribeFailure("Not enough buffer was provided to parse client data subscription.");
-            SendResponse(ServerResponse::Failed, ServerCommand::Subscribe, message);
-            m_parent->DispatchErrorMessage(message);
         }
     }
-    catch (const std::exception& ex)
+    catch (const PublisherException& ex)
     {
-        const string message = "Failed to process client data subscription due to exception: " + string(ex.what());
+        HandleSubscribeFailure("Failed to process client data subscription due to exception: " + string(ex.what()));
-        SendResponse(ServerResponse::Failed, ServerCommand::Subscribe, message);
+    }
-        m_parent->DispatchErrorMessage(message);
+    catch (...)
+    {
+        HandleSubscribeFailure("Failed to process client data subscription due to exception: " + boost::current_exception_diagnostic_information(true));
     }
 }
+void SubscriberConnection::HandleSubscribeFailure(const std::string& message)
+{
+    SendResponse(ServerResponse::Failed, ServerCommand::Subscribe, message);
+    m_parent->DispatchErrorMessage(message);
+    if (GetIsTemporalSubscription())
+        CompleteTemporalSubscription();
+}
 void SubscriberConnection::HandleUnsubscribe()
 {
     SetIsSubscribed(false);
+    if (GetIsTemporalSubscription())
+        CompleteTemporalSubscription();
 }
 void SubscriberConnection::HandleMetadataRefresh(uint8_t* data, uint32_t length)
     m_parent->DispatchStatusMessage("Received meta-data refresh request from " + GetConnectionID() + ", preparing response...");
     StringMap<ExpressionTreePtr> filterExpressions;
-    const DateTime startTime = UtcNow(); //-V821
+    const datetime_t startTime = UtcNow(); //-V821
     try
     {
 {
 }
-void SubscriberConnection::HandleUpdateProcessingInterval(uint8_t* data, uint32_t length)
+void SubscriberConnection::HandleUpdateProcessingInterval(const uint8_t* data, uint32_t length)
 {
+    // Make sure there is enough buffer for new processing interval value
+    if (length >= 4)
+    {
+        // Next 4 bytes are an integer representing the new processing interval
+        const int32_t processingInterval = EndianConverter::Default.ConvertBigEndian(*reinterpret_cast<const int32_t*>(data));
+        SetProcessingInterval(processingInterval);
+        SendResponse(ServerResponse::Succeeded, ServerCommand::UpdateProcessingInterval, "New processing interval of " + ToString(processingInterval) + " assigned.");
+    }
+    else
+    {
+        const string message = "Not enough buffer was provided to update client processing interval.";
+        SendResponse(ServerResponse::Failed, ServerCommand::UpdateProcessingInterval, message);
+        m_parent->DispatchErrorMessage(message);
+    }
 }
 void SubscriberConnection::HandleDefineOperationalModes(uint8_t* data, uint32_t length)
     }
 }
+bool SubscriberConnection::SendResponse(uint8_t responseCode, uint8_t commandCode)
+{
+    return SendResponse(responseCode, commandCode, vector<uint8_t>(0));
+}
 bool SubscriberConnection::SendResponse(uint8_t responseCode, uint8_t commandCode, const string& message)
 {
     return SendResponse(responseCode, commandCode, EncodeString(message));

Source/Libraries/TimeSeriesPlatformLibrary/Transport/SubscriberConnection.h+48−5

     class DataPublisher;
     typedef GSF::SharedPtr<DataPublisher> DataPublisherPtr;
+    class SubscriberConnection;
+    typedef GSF::SharedPtr<SubscriberConnection> SubscriberConnectionPtr;
     // Represents a subscriber connection to a data publisher
     class SubscriberConnection : public GSF::EnableSharedThisPtr<SubscriberConnection> // NOLINT
     {
         std::string m_subscriptionInfo;
         uint32_t m_operationalModes;
         uint32_t m_encoding;
+        GSF::datetime_t m_startTimeConstraint;
+        GSF::datetime_t m_stopTimeConstraint;
+        int32_t m_processingInterval;
         bool m_usePayloadCompression;
         bool m_useCompactMeasurementFormat;
         bool m_includeTime;
         SignalIndexCachePtr m_signalIndexCache;
         int32_t m_timeIndex;
         int64_t m_baseTimeOffsets[2];
-        DateTime m_lastPublishTime;
+        datetime_t m_lastPublishTime;
         //TSSCMeasurementParser m_tsscMeasurementParser;
         //bool m_tsscResetRequested;
         //uint16_t m_tsscSequenceNumber;
         // Server request handlers
         void HandleSubscribe(uint8_t* data, uint32_t length);
+        void HandleSubscribeFailure(const std::string& message);
         void HandleUnsubscribe();
         void HandleMetadataRefresh(uint8_t* data, uint32_t length);
         void HandleRotateCipherKeys();
-        void HandleUpdateProcessingInterval(uint8_t* data, uint32_t length);
+        void HandleUpdateProcessingInterval(const uint8_t* data, uint32_t length);
         void HandleDefineOperationalModes(uint8_t* data, uint32_t length);
         void HandleConfirmNotification(uint8_t* data, uint32_t length);
         void HandleConfirmBufferBlock(uint8_t* data, uint32_t length);
         ~SubscriberConnection();
         const DataPublisherPtr& GetParent() const;
+        SubscriberConnectionPtr GetReference();
         GSF::TcpSocket& CommandChannelSocket();
-        // Gets or sets subscriber identification used when subscriber is known and pre-established
+        // Gets or sets subscriber UUID used when subscriber is known and pre-established
         const GSF::Guid& GetSubscriberID() const;
         void SetSubscriberID(const GSF::Guid& id);
+        // Gets subscriber connection identification, e.g., remote IP/port, for display and logging references
         const std::string& GetConnectionID() const;
+        // Gets subscriber remote IP address
         const GSF::IPAddress& GetIPAddress() const;
+        // Gets subscriber communications port
         const std::string& GetHostName() const;
+        // Gets or sets established subscriber operational modes
         uint32_t GetOperationalModes() const;
         void SetOperationalModes(uint32_t value);
+        // Gets established subscriber string encoding
         uint32_t GetEncoding() const;
+        // Gets flags that determines if this subscription is temporal based
+        bool GetIsTemporalSubscription() const;
+        // Gets or sets the start time temporal processing constraint
+        const GSF::datetime_t& GetStartTimeConstraint() const;
+        void SetStartTimeConstraint(const GSF::datetime_t& value);
+        // Gets or sets the stop time temporal processing constraint
+        const GSF::datetime_t& GetStopTimeConstraint() const;
+        void SetStopTimeConstraint(const GSF::datetime_t& value);
+        // Gets or sets the desired temporal processing interval, in milliseconds
+        // With the exception of the values of -1 and 0, this value specifies the desired processing interval for data, i.e.,
+        // basically a delay, or timer interval, over which to process data. A value of -1 means to use the default processing
+        // interval while a value of 0 means to process data as fast as possible.
+        int32_t GetProcessingInterval() const;
+        void SetProcessingInterval(int32_t value);
+        // Gets or sets flag that determines if payload compression should be enabled in data packets
         bool GetUsePayloadCompression() const;
         void SetUsePayloadCompression(bool value);
+        // Gets or sets flag that determines if the compact measurement format should be used in data packets
         bool GetUseCompactMeasurementFormat() const;
         void SetUseCompactMeasurementFormat(bool value);
+        // Gets or sets flag that determines if time should be included in data packets when the compact measurement format used
         bool GetIncludeTime() const;
         void SetIncludeTime(bool value);
+        // Gets or sets flag that determines if time should be restricted to millisecond resolution in data packets when the
+        // compact measurement format used; otherwise, full resolution time will be used
         bool GetUseMillisecondResolution() const;
         void SetUseMillisecondResolution(bool value);
+        // Gets or sets flag that determines if NaN values should be excluded from data packets
         bool GetIsNaNFiltered() const;
         void SetIsNaNFiltered(bool value);
+        // Gets or sets flag that determines if subscriber connection is currently subscribed
         bool GetIsSubscribed() const;
         void SetIsSubscribed(bool value);
+        // Gets or sets subscription details about subscriber
         const std::string& GetSubscriptionInfo() const;
         void SetSubscriptionInfo(const std::string& value);
+        // Gets or sets signal index cache for subscriber representing run-time mappings for subscribed points
         const SignalIndexCachePtr& GetSignalIndexCache() const;
         void SetSignalIndexCache(SignalIndexCachePtr signalIndexCache);
         void Start();
         void Stop();
-        void PublishMeasurements(const std::vector<Measurement>& measurements);
         void PublishMeasurements(const std::vector<MeasurementPtr>& measurements);
+        void CompleteTemporalSubscription();
         void CommandChannelSendAsync(uint8_t* data, uint32_t offset, uint32_t length);
         void DataChannelSendAsync(uint8_t* data, uint32_t offset, uint32_t length);
         void WriteHandler(const ErrorCode& error, uint32_t bytesTransferred);
+        bool SendResponse(uint8_t responseCode, uint8_t commandCode);
         bool SendResponse(uint8_t responseCode, uint8_t commandCode, const std::string& message);
-        bool SendResponse(uint8_t responseCode, uint8_t commandCode, const std::vector<uint8_t>& data = {});
+        bool SendResponse(uint8_t responseCode, uint8_t commandCode, const std::vector<uint8_t>& data);
         std::string DecodeString(const uint8_t* data, uint32_t offset, uint32_t length) const;
         std::vector<uint8_t> EncodeString(const std::string& value) const;

Source/Libraries/TimeSeriesPlatformLibrary/Transport/SubscriberInstance.cpp+4−4

Source/Libraries/TimeSeriesPlatformLibrary/Transport/SubscriberInstance.h+1−1

@@ -79,7 +79,7 @@ namespace Transport · 78 unmodified lines
79	virtual void StatusMessage(const std::string& message); // Defaults output to cout	79	virtual void StatusMessage(const std::string& message); // Defaults output to cout
80	virtual void ErrorMessage(const std::string& message); // Defaults output to cerr	80	virtual void ErrorMessage(const std::string& message); // Defaults output to cerr
81	virtual void DataStartTime(time_t unixSOC, uint16_t milliseconds);	81	virtual void DataStartTime(time_t unixSOC, uint16_t milliseconds);
82	virtual void DataStartTime(DateTime startTime);	82	virtual void DataStartTime(datetime_t startTime);
83	virtual void ReceivedMetadata(const std::vector<uint8_t>& payload);	83	virtual void ReceivedMetadata(const std::vector<uint8_t>& payload);
84	virtual void ParsedMetadata();	84	virtual void ParsedMetadata();
85	virtual void ReceivedNewMeasurements(const std::vector<MeasurementPtr>& measurements);	85	virtual void ReceivedNewMeasurements(const std::vector<MeasurementPtr>& measurements);

Source/Libraries/TimeSeriesPlatformLibrary/Transport/TransportTypes.cpp+18−1

@@ -64,7 +64,7 @@ float64_t Measurement::AdjustedValue() const · 63 unmodified lines
64	return Value * Multiplier + Adder;	64	return Value * Multiplier + Adder;
65	}	65	}
66		66
67	DateTime Measurement::GetDateTime() const	67	datetime_t Measurement::GetDateTime() const
68	{	68	{
69	return FromTicks(Timestamp);	69	return FromTicks(Timestamp);
70	}	70	}
@@ -74,6 +74,23 @@ void Measurement::GetUnixTime(time_t& unixSOC, uint16_t& milliseconds) const · 3 unmodified lines
74	ToUnixTime(Timestamp, unixSOC, milliseconds);	74	ToUnixTime(Timestamp, unixSOC, milliseconds);
75	}	75	}
76		76
		77	MeasurementPtr TimeSeries::ToPtr(const Measurement& source)
		78	{
		79	MeasurementPtr destination = NewSharedPtr<Measurement>();
		80
		81	destination->ID = source.ID;
		82	destination->Source = source.Source;
		83	destination->SignalID = source.SignalID;
		84	destination->Tag = source.Tag;
		85	destination->Value = source.Value;
		86	destination->Adder = source.Adder;
		87	destination->Multiplier = source.Multiplier;
		88	destination->Timestamp = source.Timestamp;
		89	destination->Flags = source.Flags;
		90
		91	return destination;
		92	}
		93
77	SignalReference::SignalReference() :	94	SignalReference::SignalReference() :
78	SignalID(Empty::Guid),	95	SignalID(Empty::Guid),
79	Index(0),	96	Index(0),

Source/Libraries/TimeSeriesPlatformLibrary/Transport/TransportTypes.h+5−4

         float64_t AdjustedValue() const;
         // Gets Timestamp as DateTime
-        DateTime GetDateTime() const;
+        datetime_t GetDateTime() const;
         // Gets Timestamp in Unix second of century and milliseconds
         void GetUnixTime(time_t& unixSOC, uint16_t& milliseconds) const;
     };
     typedef SharedPtr<Measurement> MeasurementPtr;
+    MeasurementPtr ToPtr(const Measurement& source);
     enum SignalKind : int16_t
     {
         SignalReference Reference;	// Parsed signal reference structure
         uint16_t PhasorSourceIndex; // Measurement phasor index, if measurement represents a "Phasor"
         std::string Description;    // Detailed measurement description (free-form)
-        DateTime UpdatedOn;			// Time of last meta-data update
+        datetime_t UpdatedOn;			// Time of last meta-data update
     };
     typedef SharedPtr<MeasurementMetadata> MeasurementMetadataPtr;
         std::string Type;			// Phasor type, i.e., "V" for voltage or "I" for current
         std::string Phase;			// Phasor phase, one of, "+", "-", "0", "A", "B" or "C"
         uint16_t SourceIndex;	    // Phasor ordered index, uses 1-based indexing (key to MeasurementMetadata.PhasorSourceIndex)
-        DateTime UpdatedOn;		    // Time of last meta-data update
+        datetime_t UpdatedOn;		    // Time of last meta-data update
     };
     typedef SharedPtr<PhasorMetadata> PhasorMetadataPtr;
         std::string VendorDeviceName;   // Original vendor device name, e.g., PMU brand (if useful / provided)
         float64_t Longitude;	        // Device longitude (if reported)
         float64_t Latitude;		        // Device latitude (if reported)
-        DateTime UpdatedOn;			    // Time of last meta-data update
+        datetime_t UpdatedOn;			    // Time of last meta-data update
         // Associated measurement and phasor meta-data
         std::vector<MeasurementMetadataPtr> Measurements;   // DataPublisher does not need to assign

TimeSeriesPlatformLibrary: Added temporal support options to DataPublisher interfaces.

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code

@@ -394,7 +394,7 @@ Object DataRow::GetComputedValue(const DataColumnPtr& column, DataType targetTyp · 393 unmodified lines
394	}	394	}
395	case ExpressionValueType::DateTime:	395	case ExpressionValueType::DateTime:
396	{	396	{
397	const DateTime result = sourceValue->ValueAsDateTime();	397	const datetime_t result = sourceValue->ValueAsDateTime();
398	const time_t value = to_time_t(result);	398	const time_t value = to_time_t(result);
399		399
400	switch (targetType)	400	switch (targetType)
@@ -690,22 +690,22 @@ void DataRow::SetBooleanValue(const string& columnName, const Nullable<bool>& va · 289 unmodified lines
690	SetBooleanValue(GetColumnIndex(columnName), value);	690	SetBooleanValue(GetColumnIndex(columnName), value);
691	}	691	}
692		692
693	Nullable<DateTime> DataRow::ValueAsDateTime(const int32_t columnIndex)	693	Nullable<datetime_t> DataRow::ValueAsDateTime(const int32_t columnIndex)
694	{	694	{
695	return GetValue<DateTime>(columnIndex, DataType::DateTime);	695	return GetValue<datetime_t>(columnIndex, DataType::DateTime);
696	}	696	}
697		697
698	Nullable<DateTime> DataRow::ValueAsDateTime(const string& columnName)	698	Nullable<datetime_t> DataRow::ValueAsDateTime(const string& columnName)
699	{	699	{
700	return ValueAsDateTime(GetColumnIndex(columnName));	700	return ValueAsDateTime(GetColumnIndex(columnName));
701	}	701	}
702		702
703	void DataRow::SetDateTimeValue(const int32_t columnIndex, const Nullable<DateTime>& value)	703	void DataRow::SetDateTimeValue(const int32_t columnIndex, const Nullable<datetime_t>& value)
704	{	704	{
705	SetValue<DateTime>(columnIndex, value, DataType::DateTime);	705	SetValue<datetime_t>(columnIndex, value, DataType::DateTime);
706	}	706	}
707		707
708	void DataRow::SetDateTimeValue(const string& columnName, const Nullable<DateTime>& value)	708	void DataRow::SetDateTimeValue(const string& columnName, const Nullable<datetime_t>& value)
709	{	709	{
710	SetDateTimeValue(GetColumnIndex(columnName), value);	710	SetDateTimeValue(GetColumnIndex(columnName), value);
711	}	711	}

@@ -1177,42 +1177,42 @@ int main(int argc, char* argv[]) · 1176 unmodified lines
1177	valueExpression = FilterExpressionParser::Evaluate(dataRow, "DateAdd('2019-02-04', 2, 'Month')");	1177	valueExpression = FilterExpressionParser::Evaluate(dataRow, "DateAdd('2019-02-04', 2, 'Month')");
1178		1178
1179	assert(valueExpression->ValueType == ExpressionValueType::DateTime);	1179	assert(valueExpression->ValueType == ExpressionValueType::DateTime);
1180	assert(valueExpression->ValueAsDateTime() == DateTime(date(2019, 4, 4)));	1180	assert(valueExpression->ValueAsDateTime() == datetime_t(date(2019, 4, 4)));
1181	cout << "Test " << ++test << " succeeded..." << endl;	1181	cout << "Test " << ++test << " succeeded..." << endl;
1182		1182
1183	// Test 119	1183	// Test 119
1184	valueExpression = FilterExpressionParser::Evaluate(dataRow, "DateAdd(#1/31/2019#, 1, 'Day')");	1184	valueExpression = FilterExpressionParser::Evaluate(dataRow, "DateAdd(#1/31/2019#, 1, 'Day')");
1185		1185
1186	assert(valueExpression->ValueType == ExpressionValueType::DateTime);	1186	assert(valueExpression->ValueType == ExpressionValueType::DateTime);
1187	assert(valueExpression->ValueAsDateTime() == DateTime(date(2019, 2, 1)));	1187	assert(valueExpression->ValueAsDateTime() == datetime_t(date(2019, 2, 1)));
1188	cout << "Test " << ++test << " succeeded..." << endl;	1188	cout << "Test " << ++test << " succeeded..." << endl;
1189		1189
1190	// Test 120	1190	// Test 120
1191	valueExpression = FilterExpressionParser::Evaluate(dataRow, "DateAdd(#2019-01-31#, 2, 'Week')");	1191	valueExpression = FilterExpressionParser::Evaluate(dataRow, "DateAdd(#2019-01-31#, 2, 'Week')");
1192		1192
1193	assert(valueExpression->ValueType == ExpressionValueType::DateTime);	1193	assert(valueExpression->ValueType == ExpressionValueType::DateTime);
1194	assert(valueExpression->ValueAsDateTime() == DateTime(date(2019, 2, 14)));	1194	assert(valueExpression->ValueAsDateTime() == datetime_t(date(2019, 2, 14)));
1195	cout << "Test " << ++test << " succeeded..." << endl;	1195	cout << "Test " << ++test << " succeeded..." << endl;
1196		1196
1197	// Test 121	1197	// Test 121
1198	valueExpression = FilterExpressionParser::Evaluate(dataRow, "DateAdd(#2019-01-31#, 25, 'Hour')");	1198	valueExpression = FilterExpressionParser::Evaluate(dataRow, "DateAdd(#2019-01-31#, 25, 'Hour')");
1199		1199
1200	assert(valueExpression->ValueType == ExpressionValueType::DateTime);	1200	assert(valueExpression->ValueType == ExpressionValueType::DateTime);
1201	assert(valueExpression->ValueAsDateTime() == DateTime(date(2019, 2, 1), time_duration(1, 0, 0)));	1201	assert(valueExpression->ValueAsDateTime() == datetime_t(date(2019, 2, 1), time_duration(1, 0, 0)));
1202	cout << "Test " << ++test << " succeeded..." << endl;	1202	cout << "Test " << ++test << " succeeded..." << endl;
1203		1203
1204	// Test 122	1204	// Test 122
1205	valueExpression = FilterExpressionParser::Evaluate(dataRow, "DateAdd(#2018-12-31 23:58#, 3, 'Minute')");	1205	valueExpression = FilterExpressionParser::Evaluate(dataRow, "DateAdd(#2018-12-31 23:58#, 3, 'Minute')");
1206		1206
1207	assert(valueExpression->ValueType == ExpressionValueType::DateTime);	1207	assert(valueExpression->ValueType == ExpressionValueType::DateTime);
1208	assert(valueExpression->ValueAsDateTime() == DateTime(date(2019, 1, 1), time_duration(0, 1, 0)));	1208	assert(valueExpression->ValueAsDateTime() == datetime_t(date(2019, 1, 1), time_duration(0, 1, 0)));
1209	cout << "Test " << ++test << " succeeded..." << endl;	1209	cout << "Test " << ++test << " succeeded..." << endl;
1210		1210
1211	// Test 123	1211	// Test 123
1212	valueExpression = FilterExpressionParser::Evaluate(dataRow, "DateAdd('2019-01-1 00:59', 61, 'Second')");	1212	valueExpression = FilterExpressionParser::Evaluate(dataRow, "DateAdd('2019-01-1 00:59', 61, 'Second')");
1213		1213
1214	assert(valueExpression->ValueType == ExpressionValueType::DateTime);	1214	assert(valueExpression->ValueType == ExpressionValueType::DateTime);
1215	assert(valueExpression->ValueAsDateTime() == DateTime(date(2019, 1, 1), time_duration(1, 0, 1)));	1215	assert(valueExpression->ValueAsDateTime() == datetime_t(date(2019, 1, 1), time_duration(1, 0, 1)));
1216	cout << "Test " << ++test << " succeeded..." << endl;	1216	cout << "Test " << ++test << " succeeded..." << endl;
1217		1217
1218	const float64_t baseFraction = pow(10.0, time_duration::num_fractional_digits());	1218	const float64_t baseFraction = pow(10.0, time_duration::num_fractional_digits());
@@ -1222,14 +1222,14 @@ int main(int argc, char* argv[]) · 3 unmodified lines
1222	valueExpression = FilterExpressionParser::Evaluate(dataRow, "DateAdd('2019-01-1 00:00:59.999', 2, 'Millisecond')");	1222	valueExpression = FilterExpressionParser::Evaluate(dataRow, "DateAdd('2019-01-1 00:00:59.999', 2, 'Millisecond')");
1223		1223
1224	assert(valueExpression->ValueType == ExpressionValueType::DateTime);	1224	assert(valueExpression->ValueType == ExpressionValueType::DateTime);
1225	assert(valueExpression->ValueAsDateTime() == DateTime(date(2019, 1, 1), time_duration(0, 1, 0, fracSecond(1))));	1225	assert(valueExpression->ValueAsDateTime() == datetime_t(date(2019, 1, 1), time_duration(0, 1, 0, fracSecond(1))));
1226	cout << "Test " << ++test << " succeeded..." << endl;	1226	cout << "Test " << ++test << " succeeded..." << endl;
1227		1227
1228	// Test 125	1228	// Test 125
1229	valueExpression = FilterExpressionParser::Evaluate(dataRow, "DateAdd(#1/1/2019 0:0:1.029#, -FramesPerSecond, 'Millisecond')");	1229	valueExpression = FilterExpressionParser::Evaluate(dataRow, "DateAdd(#1/1/2019 0:0:1.029#, -FramesPerSecond, 'Millisecond')");
1230		1230
1231	assert(valueExpression->ValueType == ExpressionValueType::DateTime);	1231	assert(valueExpression->ValueType == ExpressionValueType::DateTime);
1232	assert(valueExpression->ValueAsDateTime() == DateTime(date(2019, 1, 1), time_duration(0, 0, 0, fracSecond(999))));	1232	assert(valueExpression->ValueAsDateTime() == datetime_t(date(2019, 1, 1), time_duration(0, 0, 0, fracSecond(999))));
1233	cout << "Test " << ++test << " succeeded..." << endl;	1233	cout << "Test " << ++test << " succeeded..." << endl;
1234		1234
1235	// Test 126	1235	// Test 126
@@ -1429,7 +1429,7 @@ int main(int argc, char* argv[]) · 193 unmodified lines
1429	cout << "Test " << ++test << " succeeded..." << endl;	1429	cout << "Test " << ++test << " succeeded..." << endl;
1430		1430
1431	// Test 150	1431	// Test 150
1432	const DateTime time = ParseTimestamp("2019-02-10T15:55:25.090477Z");	1432	const datetime_t time = ParseTimestamp("2019-02-10T15:55:25.090477Z");
1433	const int64_t ticks = ToTicks(time);	1433	const int64_t ticks = ToTicks(time);
1434		1434
1435	assert(ticks == 636854109250904770L);	1435	assert(ticks == 636854109250904770L);

@@ -36,8 +36,8 @@ TimerPtr PublishTimer; · 35 unmodified lines
36	vector<MeasurementMetadataPtr> MeasurementsToPublish;	36	vector<MeasurementMetadataPtr> MeasurementsToPublish;
37		37
38	bool RunPublisher(uint16_t port);	38	bool RunPublisher(uint16_t port);
39	void DisplayClientConnected(DataPublisher* source, const Guid& subscriberID, const string& connectionID);	39	void DisplayClientConnected(DataPublisher* source, const SubscriberConnectionPtr& connection);
40	void DisplayClientDisconnected(DataPublisher* source, const Guid& subscriberID, const string& connectionID);	40	void DisplayClientDisconnected(DataPublisher* source, const SubscriberConnectionPtr& connection);
41	void DisplayStatusMessage(DataPublisher* source, const string& message);	41	void DisplayStatusMessage(DataPublisher* source, const string& message);
42	void DisplayErrorMessage(DataPublisher* source, const string& message);	42	void DisplayErrorMessage(DataPublisher* source, const string& message);
43		43
@@ -168,18 +168,18 @@ bool RunPublisher(uint16_t port) · 124 unmodified lines
168	return running;	168	return running;
169	}	169	}
170		170
171	void DisplayClientConnected(DataPublisher* source, const Guid& subscriberID, const string& connectionID)	171	void DisplayClientConnected(DataPublisher* source, const SubscriberConnectionPtr& connection)
172	{	172	{
173	cout << ">> New Client Connected:" << endl;	173	cout << ">> New Client Connected:" << endl;
174	cout << " Subscriber ID: " << ToString(subscriberID) << endl;	174	cout << " Subscriber ID: " << ToString(connection->GetSubscriberID()) << endl;
175	cout << " Connection ID: " << connectionID << endl << endl;	175	cout << " Connection ID: " << ToString(connection->GetConnectionID()) << endl << endl;
176	}	176	}
177		177
178	void DisplayClientDisconnected(DataPublisher* source, const Guid& subscriberID, const string& connectionID)	178	void DisplayClientDisconnected(DataPublisher* source, const SubscriberConnectionPtr& connection)
179	{	179	{
180	cout << ">> Client Disconnected:" << endl;	180	cout << ">> Client Disconnected:" << endl;
181	cout << " Subscriber ID: " << ToString(subscriberID) << endl;	181	cout << " Subscriber ID: " << ToString(connection->GetSubscriberID()) << endl;
182	cout << " Connection ID: " << connectionID << endl << endl;	182	cout << " Connection ID: " << ToString(connection->GetConnectionID()) << endl << endl;
183	}	183	}
184		184
185	// Callback which is called to display status messages from the subscriber.	185	// Callback which is called to display status messages from the subscriber.
@@ -192,4 +192,4 @@ void DisplayStatusMessage(DataPublisher* source, const string& message) · 6 unmodified lines
192	void DisplayErrorMessage(DataPublisher* source, const string& message)	192	void DisplayErrorMessage(DataPublisher* source, const string& message)
193	{	193	{
194	cerr << message << endl << endl;	194	cerr << message << endl << endl;
195	}	195	}

@@ -562,7 +562,7 @@ void SubscriberInstance::DataStartTime(time_t unixSOC, uint16_t milliseconds) · 561 unmodified lines
562	{	562	{
563	}	563	}
564		564
565	void SubscriberInstance::DataStartTime(DateTime startTime)	565	void SubscriberInstance::DataStartTime(datetime_t startTime)
566	{	566	{
567	}	567	}
568		568
@@ -876,7 +876,7 @@ void SubscriberInstance::ConstructConfigurationFrames(const StringMap<DeviceMeta · 307 unmodified lines
876	phasorReference->Phasor->Type = "?";	876	phasorReference->Phasor->Type = "?";
877	phasorReference->Phasor->Phase = "+";	877	phasorReference->Phasor->Phase = "+";
878	phasorReference->Phasor->SourceIndex = i;	878	phasorReference->Phasor->SourceIndex = i;
879	phasorReference->Phasor->UpdatedOn = DateTime();	879	phasorReference->Phasor->UpdatedOn = datetime_t();
880		880
881	phasorReference->Angle = nullptr;	881	phasorReference->Angle = nullptr;
882	phasorReference->Magnitude = nullptr;	882	phasorReference->Magnitude = nullptr;
@@ -912,7 +912,7 @@ void SubscriberInstance::ConstructConfigurationFrames(const StringMap<DeviceMeta · 29 unmodified lines
912	measurement->Reference.Kind = SignalKind::Analog;	912	measurement->Reference.Kind = SignalKind::Analog;
913	measurement->PhasorSourceIndex = 0U;	913	measurement->PhasorSourceIndex = 0U;
914	measurement->Description = "";	914	measurement->Description = "";
915	measurement->UpdatedOn = DateTime();	915	measurement->UpdatedOn = datetime_t();
916		916
917	configurationFrame->Analogs.push_back(measurement);	917	configurationFrame->Analogs.push_back(measurement);
918	}	918	}
@@ -946,7 +946,7 @@ void SubscriberInstance::ConstructConfigurationFrames(const StringMap<DeviceMeta · 27 unmodified lines
946	measurement->Reference.Kind = SignalKind::Digital;	946	measurement->Reference.Kind = SignalKind::Digital;
947	measurement->PhasorSourceIndex = 0U;	947	measurement->PhasorSourceIndex = 0U;
948	measurement->Description = "";	948	measurement->Description = "";
949	measurement->UpdatedOn = DateTime();	949	measurement->UpdatedOn = datetime_t();
950		950
951	configurationFrame->Digitals.push_back(measurement);	951	configurationFrame->Digitals.push_back(measurement);
952	}	952	}