open_source / mqtt-cpp

Browse Code »

Commit 51becbde163409f1aa31c0102ca3da081e7eeb6f

Authored by Peter M. Groen 2022-01-24 01:15:46 +0100

0 parents

Committed the entire project

Inline Side-by-side

Showing 74 changed files with 17345 additions and 0 deletions

CMakeLists.txt 0 → 100644

View file @51becbd

		1	+++ a/CMakeLists.txt
		1	+cmake_minimum_required(VERSION 3.0)
		2	+LIST(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
		3	+
		4	+# Check to see if there is versioning information available
		5	+if(IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/osdev_versioning/cmake)
		6	+ LIST(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/osdev_versioning/cmake)
		7	+ include(osdevversion)
		8	+endif()
		9	+
		10	+include(projectheader)
		11	+project_header(osdev_mqtt)
		12	+
		13	+add_subdirectory(src)
		14	+add_subdirectory(tests/pub)
		15	+add_subdirectory(tests/sub)
		16	+
		17	+
		18	+# include(packaging)
		19	+# package_component()

src/CMakeLists.txt 0 → 100644

View file @51becbd

		1	+++ a/src/CMakeLists.txt
		1	+cmake_minimum_required(VERSION 3.12)
		2	+LIST(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../cmake)
		3	+include(projectheader)
		4	+project_header(mqtt)
		5	+
		6	+find_package( Boost REQUIRED COMPONENTS regex )
		7	+
		8	+include(compiler)
		9	+
		10	+include_directories(
		11	+ ${CMAKE_CURRENT_SOURCE_DIR}/../logutils
		12	+)
		13	+
		14	+set(SRC_LIST
		15	+ ${CMAKE_CURRENT_SOURCE_DIR}/clientpaho.cpp
		16	+ ${CMAKE_CURRENT_SOURCE_DIR}/commondefs.cpp
		17	+ ${CMAKE_CURRENT_SOURCE_DIR}/connectionstatus.cpp
		18	+ ${CMAKE_CURRENT_SOURCE_DIR}/compiletimedigits.h
		19	+ ${CMAKE_CURRENT_SOURCE_DIR}/compiletimestring.h
		20	+ ${CMAKE_CURRENT_SOURCE_DIR}/credentials.cpp
		21	+ ${CMAKE_CURRENT_SOURCE_DIR}/errorcode.cpp
		22	+ ${CMAKE_CURRENT_SOURCE_DIR}/token.cpp
		23	+ ${CMAKE_CURRENT_SOURCE_DIR}/ihistogram.cpp
		24	+ ${CMAKE_CURRENT_SOURCE_DIR}/timemeasurement.cpp
		25	+ ${CMAKE_CURRENT_SOURCE_DIR}/mqttidgenerator.cpp
		26	+ ${CMAKE_CURRENT_SOURCE_DIR}/mqtttypeconverter.cpp
		27	+ ${CMAKE_CURRENT_SOURCE_DIR}/mqttutil.cpp
		28	+ ${CMAKE_CURRENT_SOURCE_DIR}/mqttmessage.cpp
		29	+ ${CMAKE_CURRENT_SOURCE_DIR}/mqttclient.cpp
		30	+ ${CMAKE_CURRENT_SOURCE_DIR}/mqttfailure.cpp
		31	+ ${CMAKE_CURRENT_SOURCE_DIR}/mqttsuccess.cpp
		32	+ ${CMAKE_CURRENT_SOURCE_DIR}/utils.cpp
		33	+ ${CMAKE_CURRENT_SOURCE_DIR}/imqttclientimpl.cpp
		34	+ ${CMAKE_CURRENT_SOURCE_DIR}/istatecallback.cpp
		35	+ ${CMAKE_CURRENT_SOURCE_DIR}/scopeguard.cpp
		36	+ ${CMAKE_CURRENT_SOURCE_DIR}/serverstate.cpp
		37	+ ${CMAKE_CURRENT_SOURCE_DIR}/sharedreaderlock.cpp
		38	+ ${CMAKE_CURRENT_SOURCE_DIR}/stringutils.cpp
		39	+ ${CMAKE_CURRENT_SOURCE_DIR}/uriparser.cpp
		40	+ # Helper files ( Utillities )
		41	+ ${CMAKE_CURRENT_SOURCE_DIR}/bimap.h
		42	+ ${CMAKE_CURRENT_SOURCE_DIR}/compat-c++14.h
		43	+ ${CMAKE_CURRENT_SOURCE_DIR}/compat-chrono.h
		44	+ ${CMAKE_CURRENT_SOURCE_DIR}/histogram.h
		45	+ ${CMAKE_CURRENT_SOURCE_DIR}/histogramprovider.h
		46	+ ${CMAKE_CURRENT_SOURCE_DIR}/imqttclient.h
		47	+ ${CMAKE_CURRENT_SOURCE_DIR}/imqttclientimpl.h
		48	+ ${CMAKE_CURRENT_SOURCE_DIR}/lockguard.h
		49	+ ${CMAKE_CURRENT_SOURCE_DIR}/macrodefs.h
		50	+ ${CMAKE_CURRENT_SOURCE_DIR}/measure.h
		51	+ ${CMAKE_CURRENT_SOURCE_DIR}/metaprogrammingdefs.h
		52	+ ${CMAKE_CURRENT_SOURCE_DIR}/mqttstream.h
		53	+ ${CMAKE_CURRENT_SOURCE_DIR}/stringify.h
		54	+ ${CMAKE_CURRENT_SOURCE_DIR}/stringutils.h
		55	+ ${CMAKE_CURRENT_SOURCE_DIR}/synchronizedqueue.h
		56	+ ${CMAKE_CURRENT_SOURCE_DIR}/utils.h
		57	+ ${CMAKE_CURRENT_SOURCE_DIR}/uriutils.h
		58	+)
		59	+
		60	+include(library)
		61	+add_libraries(
		62	+ PUBLIC
		63	+ Boost::boost
		64	+ Boost::regex
		65	+ paho-mqtt3a
		66	+)
		67	+
		68	+include(installation)
		69	+install_component()

src/bimap.h 0 → 100644

View file @51becbd

		1	+++ a/src/bimap.h
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+
		20	+#ifndef OSDEV_COMPONENTS_MQTT_BIMAP_H
		21	+#define OSDEV_COMPONENTS_MQTT_BIMAP_H
		22	+
		23	+// boost
		24	+#include <boost/bimap.hpp>
		25	+
		26	+namespace osdev {
		27	+namespace components {
		28	+namespace mqtt {
		29	+
		30	+/**
		31	+ * @brief Factory function to create boost::bimap from an initializer list
		32	+ *
		33	+ * Usage:
		34	+ * @code
		35	+ * auto myBimap = makeBimap<int, int>( { { 1, 2 }, { 2, 3 } } );
		36	+ * @endcode
		37	+ */
		38	+template <typename L, typename R>
		39	+boost::bimap<L, R> makeBimap(std::initializer_list<typename boost::bimap<L, R>::value_type> list)
		40	+{
		41	+ return boost::bimap<L, R>(list.begin(), list.end());
		42	+}
		43	+
		44	+} // End namespace mqtt
		45	+} // End namespace components
		46	+} // End namespace osdev
		47	+
		48	+#endif // OSDEV_COMPONENTS_MQTT_BIMAP_H

src/clientpaho.cpp 0 → 100644

View file @51becbd

		1	+++ a/src/clientpaho.cpp
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#include "clientpaho.h"
		20	+
		21	+#include "errorcode.h"
		22	+#include "mqttutil.h"
		23	+#include "lockguard.h"
		24	+#include "metaprogrammingdefs.h"
		25	+#include "mqttstream.h"
		26	+#include "scopeguard.h"
		27	+#include "uriparser.h"
		28	+
		29	+// std::chrono
		30	+#include "compat-chrono.h"
		31	+
		32	+// std
		33	+#include <algorithm>
		34	+#include <iterator>
		35	+
		36	+using namespace osdev::components::mqtt;
		37	+
		38	+namespace {
		39	+
		40	+#if defined(__clang__)
		41	+#pragma GCC diagnostic push
		42	+#pragma GCC diagnostic ignored "-Wunused-template"
		43	+#endif
		44	+
		45	+OSDEV_COMPONENTS_HASMEMBER_TRAIT(onSuccess5)
		46	+
		47	+template <typename TRet>
		48	+inline typename std::enable_if<!has_onSuccess5<TRet>::value, TRet>::type initializeMqttStruct(TRet*)
		49	+{
		50	+ return MQTTAsync_disconnectOptions_initializer;
		51	+}
		52	+
		53	+template <typename TRet>
		54	+inline typename std::enable_if<has_onSuccess5<TRet>::value, TRet>::type initializeMqttStruct(TRet*)
		55	+{
		56	+// For some reason g++ on centos7 evaluates the function body even when it is discarded by SFINAE.
		57	+// This leads to a compile error on an undefined symbol. We will use the old initializer macro, but this
		58	+// method should not be chosen when the struct does not contain member onSuccess5!
		59	+// On yocto warrior mqtt-paho-c 1.3.0 the macro MQTTAsync_disconnectOptions_initializer5 is not defined.
		60	+// while the struct does have an onSuccess5 member. In that case we do need correct initializer code.
		61	+// We fall back to the MQTTAsync_disconnectOptions_initializer macro and initialize
		62	+// additional fields ourself (which unfortunately results in a pesky compiler warning about missing field initializers).
		63	+#ifndef MQTTAsync_disconnectOptions_initializer5
		64	+#pragma GCC diagnostic push
		65	+#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
		66	+ TRet ret = MQTTAsync_disconnectOptions_initializer;
		67	+ ret.struct_version = 1;
		68	+ ret.onSuccess5 = nullptr;
		69	+ ret.onFailure5 = nullptr;
		70	+ return ret;
		71	+#pragma GCC diagnostic pop
		72	+#else
		73	+ return MQTTAsync_disconnectOptions_initializer5;
		74	+#endif
		75	+}
		76	+
		77	+template <typename TRet>
		78	+struct Init
		79	+{
		80	+ static TRet initialize()
		81	+ {
		82	+ return initializeMqttStruct<TRet>(static_cast<TRet*>(nullptr));
		83	+ }
		84	+};
		85	+#if defined(__clang__)
		86	+#pragma GCC diagnostic pop
		87	+#endif
		88	+
		89	+} // namespace
		90	+
		91	+std::atomic_int ClientPaho::s_numberOfInstances(0);
		92	+
		93	+ClientPaho::ClientPaho(const std::string& _endpoint,
		94	+ const std::string& _id,
		95	+ const std::function<void(const std::string&, ConnectionStatus)>& connectionStatusCallback,
		96	+ const std::function<void(const std::string& clientId, std::int32_t pubMsgToken)>& deliveryCompleteCallback)
		97	+ : m_mutex()
		98	+ , m_endpoint()
		99	+ , m_username()
		100	+ , m_password()
		101	+ , m_clientId(_id)
		102	+ , m_pendingOperations()
		103	+ , m_operationResult()
		104	+ , m_operationsCompleteCV()
		105	+ , m_subscriptions()
		106	+ , m_pendingSubscriptions()
		107	+ , m_subscribeTokenToTopic()
		108	+ , m_unsubscribeTokenToTopic()
		109	+ , m_pendingPublishes()
		110	+ , m_processPendingPublishes(false)
		111	+ , m_pendingPublishesReadyCV()
		112	+ , m_client()
		113	+ , m_connectionStatus(ConnectionStatus::Disconnected)
		114	+ , m_connectionStatusCallback(connectionStatusCallback)
		115	+ , m_deliveryCompleteCallback(deliveryCompleteCallback)
		116	+ , m_lastUnsubscribe(-1)
		117	+ , m_connectPromise()
		118	+ , m_disconnectPromise()
		119	+ , m_callbackEventQueue(m_clientId)
		120	+ , m_workerThread()
		121	+{
		122	+ if (0 == s_numberOfInstances++) {
		123	+ MQTTAsync_setTraceCallback(&ClientPaho::onLogPaho);
		124	+ }
		125	+ // MLOGIC_COMMON_DEBUG("ClientPaho", "%1 - ctor ClientPaho %2", m_clientId, this);
		126	+ parseEndpoint(_endpoint);
		127	+ auto rc = MQTTAsync_create(&m_client, m_endpoint.c_str(), m_clientId.c_str(), MQTTCLIENT_PERSISTENCE_NONE, nullptr);
		128	+ if (MQTTASYNC_SUCCESS == rc)
		129	+ {
		130	+ MQTTAsync_setCallbacks(m_client, reinterpret_cast<void*>(this), ClientPaho::onConnectionLost, ClientPaho::onMessageArrived, ClientPaho::onDeliveryComplete);
		131	+ m_workerThread = std::thread(&ClientPaho::callbackEventHandler, this);
		132	+ }
		133	+ else
		134	+ {
		135	+ // Do something sensible here.
		136	+ }
		137	+}
		138	+
		139	+ClientPaho::~ClientPaho()
		140	+{
		141	+ if( MQTTAsync_isConnected( m_client ) )
		142	+ {
		143	+ this->unsubscribeAll();
		144	+
		145	+ this->waitForCompletion(std::chrono::milliseconds(2000), std::set<int32_t>{});
		146	+ this->disconnect(true, 5000);
		147	+ }
		148	+ else
		149	+ {
		150	+ // If the status was already disconnected this call does nothing
		151	+ setConnectionStatus(ConnectionStatus::Disconnected);
		152	+ }
		153	+
		154	+ if (0 == --s_numberOfInstances)
		155	+ {
		156	+ // encountered a case where termination of the logging system within paho led to a segfault.
		157	+ // This was a paho thread that was cleaned while at the same time the logging system was terminated.
		158	+ // Removing the trace callback will not solve the underlying problem but hopefully will trigger it less
		159	+ // frequently.
		160	+ MQTTAsync_setTraceCallback(nullptr);
		161	+ }
		162	+
		163	+ MQTTAsync_destroy(&m_client);
		164	+
		165	+ m_callbackEventQueue.stop();
		166	+ if (m_workerThread.joinable())
		167	+ {
		168	+ m_workerThread.join();
		169	+ }
		170	+}
		171	+
		172	+std::string ClientPaho::clientId() const
		173	+{
		174	+ return m_clientId;
		175	+}
		176	+
		177	+ConnectionStatus ClientPaho::connectionStatus() const
		178	+{
		179	+ return m_connectionStatus;
		180	+}
		181	+
		182	+std::int32_t ClientPaho::connect(bool wait)
		183	+{
		184	+ {
		185	+ OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		186	+ if (ConnectionStatus::Disconnected != m_connectionStatus)
		187	+ {
		188	+ return -1;
		189	+ }
		190	+ setConnectionStatus(ConnectionStatus::ConnectInProgress);
		191	+ }
		192	+
		193	+ MQTTAsync_connectOptions conn_opts = MQTTAsync_connectOptions_initializer;
		194	+ conn_opts.keepAliveInterval = 20;
		195	+ conn_opts.cleansession = 1;
		196	+ conn_opts.onSuccess = &ClientPaho::onConnectSuccess;
		197	+ conn_opts.onFailure = &ClientPaho::onConnectFailure;
		198	+ conn_opts.context = this;
		199	+ conn_opts.automaticReconnect = 1;
		200	+ if (!m_username.empty())
		201	+ {
		202	+ conn_opts.username = m_username.c_str();
		203	+ }
		204	+
		205	+ if (!m_password.empty())
		206	+ {
		207	+ conn_opts.password = m_password.c_str();
		208	+ }
		209	+
		210	+ std::promise<void> waitForConnectPromise{};
		211	+ auto waitForConnect = waitForConnectPromise.get_future();
		212	+ m_connectPromise.reset();
		213	+ if (wait)
		214	+ {
		215	+ m_connectPromise = std::make_unique<std::promise<void>>(std::move(waitForConnectPromise));
		216	+ }
		217	+
		218	+ {
		219	+ OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		220	+ if (!m_pendingOperations.insert(-100).second)
		221	+ {
		222	+ // Write something
		223	+ }
		224	+ m_operationResult.erase(-100);
		225	+ }
		226	+
		227	+ int rc = MQTTAsync_connect(m_client, &conn_opts);
		228	+ if (MQTTASYNC_SUCCESS != rc)
		229	+ {
		230	+ setConnectionStatus(ConnectionStatus::Disconnected);
		231	+ OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		232	+ m_operationResult[-100] = false;
		233	+ m_pendingOperations.erase(-100);
		234	+ }
		235	+
		236	+ if (wait)
		237	+ {
		238	+ waitForConnect.get();
		239	+ m_connectPromise.reset();
		240	+ }
		241	+ return -100;
		242	+}
		243	+
		244	+std::int32_t ClientPaho::disconnect(bool wait, int timeoutMs)
		245	+{
		246	+ ConnectionStatus currentStatus = m_connectionStatus;
		247	+
		248	+ {
		249	+ OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		250	+ if (ConnectionStatus::Disconnected == m_connectionStatus \|\| ConnectionStatus::DisconnectInProgress == m_connectionStatus) {
		251	+ return -1;
		252	+ }
		253	+
		254	+ currentStatus = m_connectionStatus;
		255	+ setConnectionStatus(ConnectionStatus::DisconnectInProgress);
		256	+ }
		257	+
		258	+ MQTTAsync_disconnectOptions disconn_opts = Init<MQTTAsync_disconnectOptions>::initialize();
		259	+ disconn_opts.timeout = timeoutMs;
		260	+ disconn_opts.onSuccess = &ClientPaho::onDisconnectSuccess;
		261	+ disconn_opts.onFailure = &ClientPaho::onDisconnectFailure;
		262	+ disconn_opts.context = this;
		263	+
		264	+ std::promise<void> waitForDisconnectPromise{};
		265	+ auto waitForDisconnect = waitForDisconnectPromise.get_future();
		266	+ m_disconnectPromise.reset();
		267	+ if (wait) {
		268	+ m_disconnectPromise = std::make_unique<std::promise<void>>(std::move(waitForDisconnectPromise));
		269	+ }
		270	+
		271	+ {
		272	+ OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		273	+ if (!m_pendingOperations.insert(-200).second)
		274	+ {
		275	+ // "ClientPaho", "%1 disconnect - token %2 already in use", m_clientId, -200)
		276	+ }
		277	+ m_operationResult.erase(-200);
		278	+ }
		279	+
		280	+ int rc = MQTTAsync_disconnect(m_client, &disconn_opts);
		281	+ if (MQTTASYNC_SUCCESS != rc) {
		282	+ if (MQTTASYNC_DISCONNECTED == rc) {
		283	+ currentStatus = ConnectionStatus::Disconnected;
		284	+ }
		285	+
		286	+ setConnectionStatus(currentStatus);
		287	+ OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		288	+ m_operationResult[-200] = false;
		289	+ m_pendingOperations.erase(-200);
		290	+
		291	+ if (MQTTASYNC_DISCONNECTED == rc) {
		292	+ return -1;
		293	+ }
		294	+ // ("ClientPaho", "%1 - failed to disconnect, return code %2", m_clientId, pahoAsyncErrorCodeToString(rc));
		295	+ }
		296	+
		297	+ if (wait) {
		298	+ if (std::future_status::timeout == waitForDisconnect.wait_for(std::chrono::milliseconds(timeoutMs + 100)))
		299	+ {
		300	+ // ("ClientPaho", "%1 - timeout occurred on disconnect", m_clientId);
		301	+
		302	+ }
		303	+ waitForDisconnect.get();
		304	+ m_disconnectPromise.reset();
		305	+ }
		306	+ return -200;
		307	+}
		308	+
		309	+std::int32_t ClientPaho::publish(const MqttMessage& message, int qos)
		310	+{
		311	+ if (ConnectionStatus::DisconnectInProgress == m_connectionStatus)
		312	+ {
		313	+ // ("ClientPaho", "%1 - disconnect in progress, ignoring publish with qos %2 on topic %3", m_clientId, qos, message.topic());
		314	+ return -1;
		315	+ }
		316	+ else if (ConnectionStatus::Disconnected == m_connectionStatus)
		317	+ {
		318	+ // ("ClientPaho", "%1 - unable to publish, not connected", m_clientId);
		319	+ }
		320	+
		321	+ if (!isValidTopic(message.topic()))
		322	+ {
		323	+ // ("ClientPaho", "%1 - topic %2 is invalid", m_clientId, message.topic());
		324	+ }
		325	+
		326	+ if (qos > 2)
		327	+ {
		328	+ qos = 2;
		329	+ }
		330	+ else if (qos < 0)
		331	+ {
		332	+ qos = 0;
		333	+ }
		334	+
		335	+
		336	+ std::unique_lock<std::mutex> lck(m_mutex);
		337	+ if (ConnectionStatus::ReconnectInProgress == m_connectionStatus \|\| m_processPendingPublishes) {
		338	+ m_pendingPublishesReadyCV.wait(lck, [this]() { return !m_processPendingPublishes; });
		339	+ if (ConnectionStatus::ReconnectInProgress == m_connectionStatus) {
		340	+ // ("ClientPaho", "Adding publish to pending queue.");
		341	+ m_pendingPublishes.push_front(Publish{ qos, message });
		342	+ return -1;
		343	+ }
		344	+ }
		345	+
		346	+ return publishInternal(message, qos);
		347	+}
		348	+
		349	+void ClientPaho::publishPending()
		350	+{
		351	+ {
		352	+ OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		353	+ if (!m_processPendingPublishes) {
		354	+ return;
		355	+ }
		356	+ }
		357	+
		358	+ if (ConnectionStatus::Connected != m_connectionStatus)
		359	+ {
		360	+ // MqttException, "Not connected");
		361	+ }
		362	+
		363	+ while (!m_pendingPublishes.empty())
		364	+ {
		365	+ const auto& pub = m_pendingPublishes.back();
		366	+ publishInternal(pub.data, pub.qos);
		367	+ // else ("ClientPaho", "%1 - pending publish on topic %2 failed : %3", m_clientId, pub.data.topic(), e.what());
		368	+
		369	+ m_pendingPublishes.pop_back();
		370	+ }
		371	+
		372	+ {
		373	+ OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		374	+ m_processPendingPublishes = false;
		375	+ }
		376	+ m_pendingPublishesReadyCV.notify_all();
		377	+}
		378	+
		379	+std::int32_t ClientPaho::subscribe(const std::string& topic, int qos, const std::function<void(MqttMessage msg)>& cb)
		380	+{
		381	+ if (ConnectionStatus::Connected != m_connectionStatus)
		382	+ {
		383	+ // MqttException, "Not connected"
		384	+ }
		385	+
		386	+ if (!isValidTopic(topic))
		387	+ {
		388	+ // ("ClientPaho", "%1 - topic %2 is invalid", m_clientId, topic);
		389	+ }
		390	+
		391	+ if (qos > 2)
		392	+ {
		393	+ qos = 2;
		394	+ }
		395	+ else if (qos < 0)
		396	+ {
		397	+ qos = 0;
		398	+ }
		399	+
		400	+ {
		401	+ OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		402	+
		403	+ auto itExisting = m_subscriptions.find(topic);
		404	+ if (m_subscriptions.end() != itExisting) {
		405	+ if (itExisting->second.qos == qos) {
		406	+ return -1;
		407	+ }
		408	+ // (OverlappingTopicException, "existing subscription with same topic, but different qos", topic);
		409	+ }
		410	+
		411	+ auto itPending = m_pendingSubscriptions.find(topic);
		412	+ if (m_pendingSubscriptions.end() != itPending) {
		413	+ if (itPending->second.qos == qos) {
		414	+ auto itToken = std::find_if(m_subscribeTokenToTopic.begin(), m_subscribeTokenToTopic.end(), [&topic](const std::pair<MQTTAsync_token, std::string>& item) { return topic == item.second; });
		415	+ if (m_subscribeTokenToTopic.end() != itToken) {
		416	+ return itToken->first;
		417	+ }
		418	+ else {
		419	+ return -1;
		420	+ }
		421	+ }
		422	+ // (OverlappingTopicException, "pending subscription with same topic, but different qos", topic);
		423	+ }
		424	+
		425	+ std::string existingTopic{};
		426	+ if (isOverlappingInternal(topic, existingTopic))
		427	+ {
		428	+ // (OverlappingTopicException, "overlapping topic", existingTopic, topic);
		429	+ }
		430	+
		431	+ // ("ClientPaho", "%1 - adding subscription on topic %2 to the pending subscriptions", m_clientId, topic);
		432	+ m_pendingSubscriptions.emplace(std::make_pair(topic, Subscription{ qos, boost::regex(convertTopicToRegex(topic)), cb }));
		433	+ }
		434	+ return subscribeInternal(topic, qos);
		435	+}
		436	+
		437	+void ClientPaho::resubscribe()
		438	+{
		439	+ decltype(m_pendingSubscriptions) pendingSubscriptions{};
		440	+ {
		441	+ OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		442	+ std::copy(m_pendingSubscriptions.begin(), m_pendingSubscriptions.end(), std::inserter(pendingSubscriptions, pendingSubscriptions.end()));
		443	+ }
		444	+
		445	+ for (const auto& s : pendingSubscriptions)
		446	+ {
		447	+ subscribeInternal(s.first, s.second.qos);
		448	+ }
		449	+}
		450	+
		451	+std::int32_t ClientPaho::unsubscribe(const std::string& topic, int qos)
		452	+{
		453	+ {
		454	+ OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		455	+ bool found = false;
		456	+ for (const auto& s : m_subscriptions)
		457	+ {
		458	+ if (topic == s.first && qos == s.second.qos)
		459	+ {
		460	+ found = true;
		461	+ break;
		462	+ }
		463	+ }
		464	+ if (!found)
		465	+ {
		466	+ return -1;
		467	+ }
		468	+ }
		469	+
		470	+ MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer;
		471	+ opts.onSuccess = &ClientPaho::onUnsubscribeSuccess;
		472	+ opts.onFailure = &ClientPaho::onUnsubscribeFailure;
		473	+ opts.context = this;
		474	+
		475	+ {
		476	+ // Need to lock the mutex because it is possible that the callback is faster than
		477	+ // the insertion of the token into the pending operations.
		478	+ OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		479	+ auto rc = MQTTAsync_unsubscribe(m_client, topic.c_str(), &opts);
		480	+ if (MQTTASYNC_SUCCESS != rc)
		481	+ {
		482	+ // ("ClientPaho", "%1 - unsubscribe on topic %2 failed with code %3", m_clientId, topic, pahoAsyncErrorCodeToString(rc));
		483	+ }
		484	+
		485	+ if (!m_pendingOperations.insert(opts.token).second)
		486	+ {
		487	+ // ("ClientPaho", "%1 unsubscribe - token %2 already in use", m_clientId, opts.token);
		488	+ }
		489	+
		490	+ m_operationResult.erase(opts.token);
		491	+ if (m_unsubscribeTokenToTopic.count(opts.token) > 0)
		492	+ {
		493	+ // ("ClientPaho", "%1 - token already in use, replacing unsubscribe from topic %2 with topic %3", m_clientId, m_unsubscribeTokenToTopic[opts.token], topic);
		494	+ }
		495	+ m_lastUnsubscribe = opts.token; // centos7 workaround
		496	+ m_unsubscribeTokenToTopic[opts.token] = topic;
		497	+ }
		498	+
		499	+ // Because of a bug in paho-c on centos7 the unsubscribes need to be sequential (best effort).
		500	+ this->waitForCompletion(std::chrono::seconds(1), std::set<int32_t>{ opts.token });
		501	+
		502	+ return opts.token;
		503	+}
		504	+
		505	+void ClientPaho::unsubscribeAll()
		506	+{
		507	+ decltype(m_subscriptions) subscriptions{};
		508	+ {
		509	+ OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		510	+ subscriptions = m_subscriptions;
		511	+ }
		512	+
		513	+ for (const auto& s : subscriptions) {
		514	+ this->unsubscribe(s.first, s.second.qos);
		515	+ }
		516	+}
		517	+
		518	+std::chrono::milliseconds ClientPaho::waitForCompletion(std::chrono::milliseconds waitFor, const std::set<std::int32_t>& tokens) const
		519	+{
		520	+ if (waitFor <= std::chrono::milliseconds(0)) {
		521	+ return std::chrono::milliseconds(0);
		522	+ }
		523	+ std::chrono::milliseconds timeElapsed{};
		524	+ {
		525	+ osdev::components::mqtt::measurement::TimeMeasurement msr("waitForCompletion", [&timeElapsed](const std::string&, std::chrono::steady_clock::time_point, std::chrono::microseconds sinceStart, std::chrono::microseconds)
		526	+ {
		527	+ timeElapsed = std::chrono::ceil<std::chrono::milliseconds>(sinceStart);
		528	+ });
		529	+ std::unique_lock<std::mutex> lck(m_mutex);
		530	+ // ("ClientPaho", "%1 waitForCompletion - pending operations : %2", m_clientId, m_pendingOperations);
		531	+ m_operationsCompleteCV.wait_for(lck, waitFor, [this, &tokens]()
		532	+ {
		533	+ if (tokens.empty())
		534	+ { // wait for all operations to end
		535	+ return m_pendingOperations.empty();
		536	+ }
		537	+ else if (tokens.size() == 1)
		538	+ {
		539	+ return m_pendingOperations.find(*tokens.cbegin()) == m_pendingOperations.end();
		540	+ }
		541	+ std::vector<std::int32_t> intersect{};
		542	+ std::set_intersection(m_pendingOperations.begin(), m_pendingOperations.end(), tokens.begin(), tokens.end(), std::back_inserter(intersect));
		543	+ return intersect.empty();
		544	+ } );
		545	+ }
		546	+ return timeElapsed;
		547	+}
		548	+
		549	+bool ClientPaho::isOverlapping(const std::string& topic) const
		550	+{
		551	+ std::string existingTopic{};
		552	+ return isOverlapping(topic, existingTopic);
		553	+}
		554	+
		555	+bool ClientPaho::isOverlapping(const std::string& topic, std::string& existingTopic) const
		556	+{
		557	+ OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		558	+ return isOverlappingInternal(topic, existingTopic);
		559	+}
		560	+
		561	+std::vector<std::int32_t> ClientPaho::pendingOperations() const
		562	+{
		563	+ OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		564	+ std::vector<std::int32_t> retval{};
		565	+ retval.resize(m_pendingOperations.size());
		566	+ std::copy(m_pendingOperations.begin(), m_pendingOperations.end(), retval.begin());
		567	+ return retval;
		568	+}
		569	+
		570	+bool ClientPaho::hasPendingSubscriptions() const
		571	+{
		572	+ OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		573	+ return !m_pendingSubscriptions.empty();
		574	+}
		575	+
		576	+boost::optional<bool> ClientPaho::operationResult(std::int32_t token) const
		577	+{
		578	+ OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		579	+ boost::optional<bool> ret{};
		580	+ auto cit = m_operationResult.find(token);
		581	+ if (m_operationResult.end() != cit)
		582	+ {
		583	+ ret = cit->second;
		584	+ }
		585	+ return ret;
		586	+}
		587	+
		588	+void ClientPaho::parseEndpoint(const std::string& _endpoint)
		589	+{
		590	+ auto ep = UriParser::parse(_endpoint);
		591	+ if (ep.find("user") != ep.end())
		592	+ {
		593	+ m_username = ep["user"];
		594	+ ep["user"].clear();
		595	+ }
		596	+
		597	+ if (ep.find("password") != ep.end())
		598	+ {
		599	+ m_password = ep["password"];
		600	+ ep["password"].clear();
		601	+ }
		602	+ m_endpoint = UriParser::toString(ep);
		603	+}
		604	+
		605	+std::int32_t ClientPaho::publishInternal(const MqttMessage& message, int qos)
		606	+{
		607	+ MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer;
		608	+ opts.onSuccess = &ClientPaho::onPublishSuccess;
		609	+ opts.onFailure = &ClientPaho::onPublishFailure;
		610	+ opts.context = this;
		611	+ auto msg = message.toAsyncMessage();
		612	+ msg.qos = qos;
		613	+
		614	+ // Need to lock the mutex because it is possible that the callback is faster than
		615	+ // the insertion of the token into the pending operations.
		616	+
		617	+ // OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		618	+ auto rc = MQTTAsync_sendMessage(m_client, message.topic().c_str(), &msg, &opts);
		619	+ if (MQTTASYNC_SUCCESS != rc)
		620	+ {
		621	+ // ("ClientPaho", "%1 - publish on topic %2 failed with code %3", m_clientId, message.topic(), pahoAsyncErrorCodeToString(rc));
		622	+ }
		623	+
		624	+ if (!m_pendingOperations.insert(opts.token).second)
		625	+ {
		626	+ // ("ClientPaho", "%1 publishInternal - token %2 already in use", m_clientId, opts.token);
		627	+ }
		628	+ m_operationResult.erase(opts.token);
		629	+ return opts.token;
		630	+}
		631	+
		632	+std::int32_t ClientPaho::subscribeInternal(const std::string& topic, int qos)
		633	+{
		634	+ MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer;
		635	+ opts.onSuccess = &ClientPaho::onSubscribeSuccess;
		636	+ opts.onFailure = &ClientPaho::onSubscribeFailure;
		637	+ opts.context = this;
		638	+
		639	+ // Need to lock the mutex because it is possible that the callback is faster than
		640	+ // the insertion of the token into the pending operations.
		641	+ OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		642	+ auto rc = MQTTAsync_subscribe(m_client, topic.c_str(), qos, &opts);
		643	+ if (MQTTASYNC_SUCCESS != rc)
		644	+ {
		645	+ m_pendingSubscriptions.erase(topic);
		646	+ // ("ClientPaho", "%1 - subscription on topic %2 failed with code %3", m_clientId, topic, pahoAsyncErrorCodeToString(rc));
		647	+ // (MqttException, "Subscription failed");
		648	+ }
		649	+
		650	+ if (!m_pendingOperations.insert(opts.token).second)
		651	+ {
		652	+ // ("ClientPaho", "%1 subscribe - token %2 already in use", m_clientId, opts.token);
		653	+ }
		654	+ m_operationResult.erase(opts.token);
		655	+ if (m_subscribeTokenToTopic.count(opts.token) > 0)
		656	+ {
		657	+ // ("ClientPaho", "%1 - overwriting pending subscription on topic %2 with topic %3", m_clientId, m_subscribeTokenToTopic[opts.token], topic);
		658	+ }
		659	+ m_subscribeTokenToTopic[opts.token] = topic;
		660	+ return opts.token;
		661	+}
		662	+
		663	+void ClientPaho::setConnectionStatus(ConnectionStatus status)
		664	+{
		665	+ ConnectionStatus curStatus = m_connectionStatus;
		666	+ m_connectionStatus = status;
		667	+ if (status != curStatus && m_connectionStatusCallback)
		668	+ {
		669	+ m_connectionStatusCallback(m_clientId, status);
		670	+ }
		671	+}
		672	+
		673	+bool ClientPaho::isOverlappingInternal(const std::string& topic, std::string& existingTopic) const
		674	+{
		675	+ existingTopic.clear();
		676	+ for (const auto& s : m_pendingSubscriptions)
		677	+ {
		678	+ if (testForOverlap(s.first, topic))
		679	+ {
		680	+ existingTopic = s.first;
		681	+ return true;
		682	+ }
		683	+ }
		684	+
		685	+ for (const auto& s : m_subscriptions)
		686	+ {
		687	+ if (testForOverlap(s.first, topic))
		688	+ {
		689	+ existingTopic = s.first;
		690	+ return true;
		691	+ }
		692	+ }
		693	+ return false;
		694	+}
		695	+
		696	+void ClientPaho::pushIncomingEvent(std::function<void()> ev)
		697	+{
		698	+ m_callbackEventQueue.push(ev);
		699	+}
		700	+
		701	+void ClientPaho::callbackEventHandler()
		702	+{
		703	+ // ("ClientPaho", "%1 - starting callback event handler", m_clientId);
		704	+ for (;;) {
		705	+ std::vector<std::function<void()>> events;
		706	+ if (!m_callbackEventQueue.pop(events))
		707	+ {
		708	+ break;
		709	+ }
		710	+
		711	+ for (const auto& ev : events)
		712	+ {
		713	+ ev();
		714	+ // ("ClientPaho", "%1 - Exception occurred: %2", m_clientId, mlogicException);
		715	+ }
		716	+ }
		717	+ // ("ClientPaho", "%1 - leaving callback event handler", m_clientId);
		718	+}
		719	+
		720	+void ClientPaho::onConnectOnInstance(const std::string& cause)
		721	+{
		722	+ (void)cause;
		723	+ // toLogFile ("ClientPaho", "onConnectOnInstance %1 - reconnected (cause %2)", m_clientId, cause);
		724	+ {
		725	+ OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		726	+ std::copy(m_subscriptions.begin(), m_subscriptions.end(), std::inserter(m_pendingSubscriptions, m_pendingSubscriptions.end()));
		727	+ m_subscriptions.clear();
		728	+ m_processPendingPublishes = true; // all publishes are on hold until publishPending is called.
		729	+ }
		730	+
		731	+ setConnectionStatus(ConnectionStatus::Connected);
		732	+}
		733	+
		734	+void ClientPaho::onConnectSuccessOnInstance(const MqttSuccess& response)
		735	+{
		736	+ auto connectData = response.connectionData();
		737	+ // ("ClientPaho", "onConnectSuccessOnInstance %1 - connected to endpoint %2 (mqtt version %3, session present %4)",
		738	+ // m_clientId, connectData.serverUri(), connectData.mqttVersion(), connectData.sessionPresent());
		739	+ {
		740	+ OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		741	+ // Register the connect callback that is used in reconnect scenarios.
		742	+ auto rc = MQTTAsync_setConnected(m_client, this, &ClientPaho::onConnect);
		743	+ if (MQTTASYNC_SUCCESS != rc)
		744	+ {
		745	+ // ("ClientPaho", "onConnectSuccessOnInstance %1 - registering the connected callback failed with code %2", m_clientId, pahoAsyncErrorCodeToString(rc));
		746	+ }
		747	+ // For MQTTV5
		748	+ //rc = MQTTAsync_setDisconnected(m_client, this, &ClientPaho::onDisconnect);
		749	+ //if (MQTTASYNC_SUCCESS != rc) {
		750	+ // // ("ClientPaho", "onConnectSuccessOnInstance %1 - registering the disconnected callback failed with code %2", m_clientId, pahoAsyncErrorCodeToString(rc));
		751	+ //}
		752	+ // ("ClientPaho", "onConnectSuccessOnInstance %1 - pending operations : %2, removing operation -100", m_clientId, m_pendingOperations);
		753	+ m_operationResult[-100] = true;
		754	+ m_pendingOperations.erase(-100);
		755	+ }
		756	+ setConnectionStatus(ConnectionStatus::Connected);
		757	+ if (m_connectPromise)
		758	+ {
		759	+ m_connectPromise->set_value();
		760	+ }
		761	+ m_operationsCompleteCV.notify_all();
		762	+}
		763	+
		764	+void ClientPaho::onConnectFailureOnInstance(const MqttFailure& response)
		765	+{
		766	+ (void)response;
		767	+ // ("ClientPaho", "onConnectFailureOnInstance %1 - connection failed with code %2 (%3)", m_clientId, response.codeToString(), response.message());
		768	+ {
		769	+ OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		770	+ if (m_connectPromise) {
		771	+ m_connectPromise->set_value();
		772	+ }
		773	+ // ("ClientPaho", "onConnectFailureOnInstance %1 - pending operations : %2, removing operation -100", m_clientId, m_pendingOperations);
		774	+ m_operationResult[-100] = false;
		775	+ m_pendingOperations.erase(-100);
		776	+ }
		777	+ if (ConnectionStatus::ConnectInProgress == m_connectionStatus)
		778	+ {
		779	+ setConnectionStatus(ConnectionStatus::Disconnected);
		780	+ }
		781	+ m_operationsCompleteCV.notify_all();
		782	+}
		783	+
		784	+//void ClientPaho::onDisconnectOnInstance(enum MQTTReasonCodes reasonCode)
		785	+//{
		786	+// MLOGIC_COMMON_INFO("ClientPaho", "onDisconnectOnInstance %1 - disconnect (reason %2)", MQTTReasonCode_toString(reasonCode));
		787	+//}
		788	+
		789	+void ClientPaho::onDisconnectSuccessOnInstance(const MqttSuccess&)
		790	+{
		791	+ // ("ClientPaho", "onDisconnectSuccessOnInstance %1 - disconnected from endpoint %2", m_clientId, m_endpoint);
		792	+ {
		793	+ OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		794	+ m_subscriptions.clear();
		795	+ m_pendingSubscriptions.clear();
		796	+ m_subscribeTokenToTopic.clear();
		797	+ m_unsubscribeTokenToTopic.clear();
		798	+
		799	+ // ("ClientPaho", "onDisconnectSuccessOnInstance %1 - pending operations : %2, removing all operations", m_clientId, m_pendingOperations);
		800	+ m_operationResult[-200] = true;
		801	+ m_pendingOperations.clear();
		802	+ }
		803	+
		804	+ setConnectionStatus(ConnectionStatus::Disconnected);
		805	+
		806	+ if (m_disconnectPromise) {
		807	+ m_disconnectPromise->set_value();
		808	+ }
		809	+ m_operationsCompleteCV.notify_all();
		810	+}
		811	+
		812	+void ClientPaho::onDisconnectFailureOnInstance(const MqttFailure& response)
		813	+{
		814	+ (void)response;
		815	+ // ("ClientPaho", "onDisconnectFailureOnInstance %1 - disconnect failed with code %2 (%3)", m_clientId, response.codeToString(), response.message());
		816	+ {
		817	+ OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		818	+ // ("ClientPaho", "onDisconnectFailureOnInstance %1 - pending operations : %2, removing operation -200", m_clientId, m_pendingOperations);
		819	+ m_operationResult[-200] = false;
		820	+ m_pendingOperations.erase(-200);
		821	+ }
		822	+
		823	+ if (MQTTAsync_isConnected(m_client))
		824	+ {
		825	+ setConnectionStatus(ConnectionStatus::Connected);
		826	+ }
		827	+ else
		828	+ {
		829	+ setConnectionStatus(ConnectionStatus::Disconnected);
		830	+ }
		831	+
		832	+ if (m_disconnectPromise)
		833	+ {
		834	+ m_disconnectPromise->set_value();
		835	+ }
		836	+ m_operationsCompleteCV.notify_all();
		837	+}
		838	+
		839	+void ClientPaho::onPublishSuccessOnInstance(const MqttSuccess& response)
		840	+{
		841	+ auto pd = response.publishData();
		842	+ // ("ClientPaho", "onPublishSuccessOnInstance %1 - publish with token %2 succeeded (message was %3)", m_clientId, response.token(), pd.payload());
		843	+ {
		844	+ OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		845	+ // ("ClientPaho", "onPublishSuccessOnInstance %1 - pending operations : %2, removing operation %3", m_clientId, m_pendingOperations, response.token());
		846	+ m_operationResult[response.token()] = true;
		847	+ m_pendingOperations.erase(response.token());
		848	+ }
		849	+ m_operationsCompleteCV.notify_all();
		850	+}
		851	+
		852	+void ClientPaho::onPublishFailureOnInstance(const MqttFailure& response)
		853	+{
		854	+ // ("ClientPaho", "onPublishFailureOnInstance %1 - publish with token %2 failed with code %3 (%4)", m_clientId, response.token(), response.codeToString(), response.message());
		855	+ {
		856	+ OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		857	+ // ("ClientPaho", "onPublishFailureOnInstance %1 - pending operations : %2, removing operation %3", m_clientId, m_pendingOperations, response.token());
		858	+ m_operationResult[response.token()] = false;
		859	+ m_pendingOperations.erase(response.token());
		860	+ }
		861	+ m_operationsCompleteCV.notify_all();
		862	+}
		863	+
		864	+void ClientPaho::onSubscribeSuccessOnInstance(const MqttSuccess& response)
		865	+{
		866	+ // ("ClientPaho", "onSubscribeSuccessOnInstance %1 - subscribe with token %2 succeeded", m_clientId, response.token());
		867	+ OSDEV_COMPONENTS_SCOPEGUARD(m_operationsCompleteCV, [this]() { m_operationsCompleteCV.notify_all(); });
		868	+ OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		869	+ bool operationOk = false;
		870	+ OSDEV_COMPONENTS_SCOPEGUARD(m_pendingOperations, [this, &response, &operationOk]()
		871	+ {
		872	+ // ("ClientPaho", "onSubscribeSuccessOnInstance %1 - pending operations : %2, removing operation %3", m_clientId, m_pendingOperations, response.token());
		873	+ m_operationResult[response.token()] = operationOk;
		874	+ m_pendingOperations.erase(response.token());
		875	+ });
		876	+ auto it = m_subscribeTokenToTopic.find(response.token());
		877	+ if (m_subscribeTokenToTopic.end() == it) {
		878	+ // ("ClientPaho", "onSubscribeSuccessOnInstance %1 - unknown token %2", m_clientId, response.token());
		879	+ return;
		880	+ }
		881	+ auto topic = it->second;
		882	+ m_subscribeTokenToTopic.erase(it);
		883	+
		884	+ auto pendingIt = m_pendingSubscriptions.find(topic);
		885	+ if (m_pendingSubscriptions.end() == pendingIt)
		886	+ {
		887	+ // ("ClientPaho", "onSubscribeSuccessOnInstance %1 - cannot find pending subscription for token %2", m_clientId, response.token());
		888	+ return;
		889	+ }
		890	+ if (response.qos() != pendingIt->second.qos)
		891	+ {
		892	+ // ("ClientPaho", "onSubscribeSuccessOnInstance %1 - subscription requested qos %2, endpoint assigned qos %3", m_clientId, pendingIt->second.qos, response.qos());
		893	+ }
		894	+ // ("ClientPaho", "onSubscribeSuccessOnInstance %1 - move pending subscription on topic %2 to the registered subscriptions", m_clientId, topic);
		895	+ m_subscriptions.emplace(std::make_pair(pendingIt->first, std::move(pendingIt->second)));
		896	+ m_pendingSubscriptions.erase(pendingIt);
		897	+ operationOk = true;
		898	+}
		899	+
		900	+void ClientPaho::onSubscribeFailureOnInstance(const MqttFailure& response)
		901	+{
		902	+ // ("ClientPaho", "onSubscribeFailureOnInstance %1 - subscription failed with code %2 (%3)", m_clientId, response.codeToString(), response.message());
		903	+ OSDEV_COMPONENTS_SCOPEGUARD(m_operationsCompleteCV, [this]() { m_operationsCompleteCV.notify_all(); });
		904	+ OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		905	+ OSDEV_COMPONENTS_SCOPEGUARD(m_pendingOperations, [this, &response]()
		906	+ {
		907	+ // MLOGIC_COMMON_DEBUG("ClientPaho", "onSubscribeFailureOnInstance %1 - pending operations : %2, removing operation %3", m_clientId, m_pendingOperations, response.token());
		908	+ m_operationResult[response.token()] = false;
		909	+ m_pendingOperations.erase(response.token());
		910	+ });
		911	+
		912	+ auto it = m_subscribeTokenToTopic.find(response.token());
		913	+ if (m_subscribeTokenToTopic.end() == it)
		914	+ {
		915	+ // ("ClientPaho", "onSubscribeFailureOnInstance %1 - unknown token %2", m_clientId, response.token());
		916	+ return;
		917	+ }
		918	+ auto topic = it->second;
		919	+ m_subscribeTokenToTopic.erase(it);
		920	+
		921	+ auto pendingIt = m_pendingSubscriptions.find(topic);
		922	+ if (m_pendingSubscriptions.end() == pendingIt)
		923	+ {
		924	+ // ("ClientPaho", "onSubscribeFailureOnInstance %1 - cannot find pending subscription for token %2", m_clientId, response.token());
		925	+ return;
		926	+ }
		927	+ // ("ClientPaho", "onSubscribeFailureOnInstance %1 - remove pending subscription on topic %2", m_clientId, topic);
		928	+ m_pendingSubscriptions.erase(pendingIt);
		929	+}
		930	+
		931	+void ClientPaho::onUnsubscribeSuccessOnInstance(const MqttSuccess& response)
		932	+{
		933	+ // ("ClientPaho", "onUnsubscribeSuccessOnInstance %1 - unsubscribe with token %2 succeeded", m_clientId, response.token());
		934	+
		935	+ OSDEV_COMPONENTS_SCOPEGUARD(m_operationsCompleteCV, [this]() { m_operationsCompleteCV.notify_all(); });
		936	+ OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		937	+
		938	+ // On centos7 the unsubscribe response is a nullptr, so we do not have a valid token.
		939	+ // As a workaround the last unsubscribe token is stored and is used when no valid token is available.
		940	+ // This is by no means bullet proof because rapid unsubscribes in succession will overwrite this member
		941	+ // before the callback on the earlier unsubscribe has arrived. On centos7 the unsubscribes have to be handled
		942	+ // sequentially (see ClientPaho::unsubscribe)!
		943	+ auto token = response.token();
		944	+ if (-1 == token)
		945	+ {
		946	+ token = m_lastUnsubscribe;
		947	+ m_lastUnsubscribe = -1;
		948	+ }
		949	+
		950	+ bool operationOk = false;
		951	+ OSDEV_COMPONENTS_SCOPEGUARD(m_pendingOperations, [this, token, &operationOk]()
		952	+ {
		953	+ // ("ClientPaho", "onUnsubscribeSuccessOnInstance %1 - pending operations : %2, removing operation %3", m_clientId, m_pendingOperations, token);
		954	+ m_operationResult[token] = operationOk;
		955	+ m_pendingOperations.erase(token);
		956	+ });
		957	+
		958	+ auto it = m_unsubscribeTokenToTopic.find(token);
		959	+ if (m_unsubscribeTokenToTopic.end() == it)
		960	+ {
		961	+ // ("ClientPaho", "onUnsubscribeSuccessOnInstance %1 - unknown token %2", m_clientId, token);
		962	+ return;
		963	+ }
		964	+ auto topic = it->second;
		965	+ m_unsubscribeTokenToTopic.erase(it);
		966	+
		967	+ auto registeredIt = m_subscriptions.find(topic);
		968	+ if (m_subscriptions.end() == registeredIt) {
		969	+ // ("ClientPaho", "onUnsubscribeSuccessOnInstance %1 - cannot find subscription for token %2", m_clientId, response.token());
		970	+ return;
		971	+ }
		972	+ // ("ClientPaho", "onUnsubscribeSuccessOnInstance %1 - remove subscription on topic %2 from the registered subscriptions", m_clientId, topic);
		973	+ m_subscriptions.erase(registeredIt);
		974	+ operationOk = true;
		975	+}
		976	+
		977	+void ClientPaho::onUnsubscribeFailureOnInstance(const MqttFailure& response)
		978	+{
		979	+ // ("ClientPaho", "onUnsubscribeFailureOnInstance %1 - subscription failed with code %2 (%3)", m_clientId, response.codeToString(), response.message());
		980	+ OSDEV_COMPONENTS_SCOPEGUARD(m_operationsCompleteCV, [this]() { m_operationsCompleteCV.notify_all(); });
		981	+ OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		982	+ OSDEV_COMPONENTS_SCOPEGUARD(m_pendingOperations, [this, &response]()
		983	+ {
		984	+ // ("ClientPaho", "onUnsubscribeFailureOnInstance %1 - pending operations : %2, removing operation %3", m_clientId, m_pendingOperations, response.token());
		985	+ m_operationResult[response.token()] = false;
		986	+ m_pendingOperations.erase(response.token());
		987	+ });
		988	+
		989	+ auto it = m_unsubscribeTokenToTopic.find(response.token());
		990	+ if (m_unsubscribeTokenToTopic.end() == it)
		991	+ {
		992	+ // ("ClientPaho", "onUnsubscribeFailureOnInstance %1 - unknown token %2", m_clientId, response.token());
		993	+ return;
		994	+ }
		995	+ auto topic = it->second;
		996	+ m_unsubscribeTokenToTopic.erase(it);
		997	+}
		998	+
		999	+int ClientPaho::onMessageArrivedOnInstance(const MqttMessage& message)
		1000	+{
		1001	+ // ("ClientPaho", "onMessageArrivedOnInstance %1 - received message on topic %2, retained : %3, dup : %4", m_clientId, message.topic(), message.retained(), message.duplicate());
		1002	+
		1003	+ std::function<void(MqttMessage)> cb;
		1004	+
		1005	+ {
		1006	+ OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		1007	+ for (const auto& s : m_subscriptions)
		1008	+ {
		1009	+ if (boost::regex_match(message.topic(), s.second.topicRegex))
		1010	+ {
		1011	+ cb = s.second.callback;
		1012	+ }
		1013	+ }
		1014	+ }
		1015	+
		1016	+ if (cb)
		1017	+ {
		1018	+ cb(message);
		1019	+ }
		1020	+ else
		1021	+ {
		1022	+ // ("ClientPaho", "onMessageArrivedOnInstance %1 - no topic filter found for message received on topic %2", m_clientId, message.topic());
		1023	+ }
		1024	+ return 1;
		1025	+}
		1026	+
		1027	+void ClientPaho::onDeliveryCompleteOnInstance(MQTTAsync_token token)
		1028	+{
		1029	+ // ("ClientPaho", "onDeliveryCompleteOnInstance %1 - message with token %2 is delivered", m_clientId, token);
		1030	+ if (m_deliveryCompleteCallback)
		1031	+ {
		1032	+ m_deliveryCompleteCallback(m_clientId, static_cast<std::int32_t>(token));
		1033	+ }
		1034	+}
		1035	+
		1036	+void ClientPaho::onConnectionLostOnInstance(const std::string& cause)
		1037	+{
		1038	+ (void)cause;
		1039	+ // ("ClientPaho", "onConnectionLostOnInstance %1 - connection lost (%2)", m_clientId, cause);
		1040	+ setConnectionStatus(ConnectionStatus::ReconnectInProgress);
		1041	+
		1042	+ OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		1043	+ // Remove all tokens related to subscriptions from the active operations.
		1044	+ for (const auto& p : m_subscribeTokenToTopic)
		1045	+ {
		1046	+ // ("ClientPaho", "onConnectionLostOnInstance %1 - pending operations : %2, removing operation %3", m_clientId, m_pendingOperations, p.first);
		1047	+ m_pendingOperations.erase(p.first);
		1048	+ }
		1049	+
		1050	+ for (const auto& p : m_unsubscribeTokenToTopic)
		1051	+ {
		1052	+ // ("ClientPaho", "onConnectionLostOnInstance %1 - pending operations : %2, removing operation %3", m_clientId, m_pendingOperations, p.first);
		1053	+ m_pendingOperations.erase(p.first);
		1054	+ }
		1055	+ // Clear the administration used in the subscribe process.
		1056	+ m_subscribeTokenToTopic.clear();
		1057	+ m_unsubscribeTokenToTopic.clear();
		1058	+}
		1059	+
		1060	+// static
		1061	+void ClientPaho::onConnect(void* context, char* cause)
		1062	+{
		1063	+ if (context)
		1064	+ {
		1065	+ auto* cl = reinterpret_cast<ClientPaho*>(context);
		1066	+ std::string reason(nullptr == cause ? "unknown cause" : cause);
		1067	+ cl->pushIncomingEvent([cl, reason]() { cl->onConnectOnInstance(reason); });
		1068	+ }
		1069	+}
		1070	+
		1071	+// static
		1072	+void ClientPaho::onConnectSuccess(void* context, MQTTAsync_successData* response)
		1073	+{
		1074	+ if (context)
		1075	+ {
		1076	+ auto* cl = reinterpret_cast<ClientPaho*>(context);
		1077	+ if (!response) {
		1078	+ // connect should always have a valid response struct.
		1079	+ // ("ClientPaho", "onConnectSuccess - no response data");
		1080	+ }
		1081	+ MqttSuccess resp(response->token, ConnectionData(response->alt.connect.serverURI, response->alt.connect.MQTTVersion, response->alt.connect.sessionPresent));
		1082	+ cl->pushIncomingEvent([cl, resp]() { cl->onConnectSuccessOnInstance(resp); });
		1083	+ }
		1084	+}
		1085	+
		1086	+// static
		1087	+void ClientPaho::onConnectFailure(void* context, MQTTAsync_failureData* response)
		1088	+{
		1089	+ if (context)
		1090	+ {
		1091	+ auto* cl = reinterpret_cast<ClientPaho*>(context);
		1092	+ MqttFailure resp(response);
		1093	+ cl->pushIncomingEvent([cl, resp]() { cl->onConnectFailureOnInstance(resp); });
		1094	+ }
		1095	+}
		1096	+
		1097	+//// static
		1098	+//void ClientPaho::onDisconnect(void* context, MQTTProperties* properties, enum MQTTReasonCodes reasonCode)
		1099	+//{
		1100	+// apply_unused_parameters(properties);
		1101	+// try {
		1102	+// if (context) {
		1103	+// auto* cl = reinterpret_cast<ClientPaho*>(context);
		1104	+// cl->pushIncomingEvent([cl, reasonCode]() { cl->onDisconnectOnInstance(reasonCode); });
		1105	+// }
		1106	+// }
		1107	+// catch (...) {
		1108	+// }
		1109	+// catch (const std::exception& e) {
		1110	+// MLOGIC_COMMON_ERROR("ClientPaho", "onDisconnect - exception : %1", e.what());
		1111	+// }
		1112	+// catch (...) {
		1113	+// MLOGIC_COMMON_ERROR("ClientPaho", "onDisconnect - unknown exception");
		1114	+// }
		1115	+//}
		1116	+
		1117	+// static
		1118	+void ClientPaho::onDisconnectSuccess(void* context, MQTTAsync_successData* response)
		1119	+{
		1120	+ if (context)
		1121	+ {
		1122	+ auto* cl = reinterpret_cast<ClientPaho*>(context);
		1123	+ MqttSuccess resp(response ? response->token : 0);
		1124	+ cl->pushIncomingEvent([cl, resp]() { cl->onDisconnectSuccessOnInstance(resp); });
		1125	+ }
		1126	+}
		1127	+
		1128	+// static
		1129	+void ClientPaho::onDisconnectFailure(void* context, MQTTAsync_failureData* response)
		1130	+{
		1131	+ if (context)
		1132	+ {
		1133	+ auto* cl = reinterpret_cast<ClientPaho*>(context);
		1134	+ MqttFailure resp(response);
		1135	+ cl->pushIncomingEvent([cl, resp]() { cl->onDisconnectFailureOnInstance(resp); });
		1136	+ }
		1137	+}
		1138	+
		1139	+// static
		1140	+void ClientPaho::onPublishSuccess(void* context, MQTTAsync_successData* response)
		1141	+{
		1142	+ if (context)
		1143	+ {
		1144	+ auto* cl = reinterpret_cast<ClientPaho*>(context);
		1145	+ if (!response)
		1146	+ {
		1147	+ // publish should always have a valid response struct.
		1148	+ // toLogFile ("ClientPaho", "onPublishSuccess - no response data");
		1149	+ }
		1150	+ MqttSuccess resp(response->token, MqttMessage(response->alt.pub.destinationName == nullptr ? "null" : response->alt.pub.destinationName, response->alt.pub.message));
		1151	+ cl->pushIncomingEvent([cl, resp]() { cl->onPublishSuccessOnInstance(resp); });
		1152	+ }
		1153	+}
		1154	+
		1155	+// static
		1156	+void ClientPaho::onPublishFailure(void* context, MQTTAsync_failureData* response)
		1157	+{
		1158	+ (void)response;
		1159	+ if (context)
		1160	+ {
		1161	+ auto* cl = reinterpret_cast<ClientPaho*>(context);
		1162	+ MqttFailure resp(response);
		1163	+ cl->pushIncomingEvent([cl, resp]() { cl->onPublishFailureOnInstance(resp); });
		1164	+ }
		1165	+}
		1166	+
		1167	+// static
		1168	+void ClientPaho::onSubscribeSuccess(void* context, MQTTAsync_successData* response)
		1169	+{
		1170	+ if (context)
		1171	+ {
		1172	+ auto* cl = reinterpret_cast<ClientPaho*>(context);
		1173	+ if (!response)
		1174	+ {
		1175	+ // subscribe should always have a valid response struct.
		1176	+ // MLOGIC_COMMON_FATAL("ClientPaho", "onSubscribeSuccess - no response data");
		1177	+ }
		1178	+ MqttSuccess resp(response->token, response->alt.qos);
		1179	+ cl->pushIncomingEvent([cl, resp]() { cl->onSubscribeSuccessOnInstance(resp); });
		1180	+ }
		1181	+}
		1182	+
		1183	+// static
		1184	+void ClientPaho::onSubscribeFailure(void* context, MQTTAsync_failureData* response)
		1185	+{
		1186	+ if (context)
		1187	+ {
		1188	+ auto* cl = reinterpret_cast<ClientPaho*>(context);
		1189	+ MqttFailure resp(response);
		1190	+ cl->pushIncomingEvent([cl, resp]() { cl->onSubscribeFailureOnInstance(resp); });
		1191	+ }
		1192	+}
		1193	+
		1194	+// static
		1195	+void ClientPaho::onUnsubscribeSuccess(void* context, MQTTAsync_successData* response)
		1196	+{
		1197	+ if (context)
		1198	+ {
		1199	+ auto* cl = reinterpret_cast<ClientPaho*>(context);
		1200	+ MqttSuccess resp(response ? response->token : -1);
		1201	+ cl->pushIncomingEvent([cl, resp]() { cl->onUnsubscribeSuccessOnInstance(resp); });
		1202	+ }
		1203	+}
		1204	+
		1205	+// static
		1206	+void ClientPaho::onUnsubscribeFailure(void* context, MQTTAsync_failureData* response)
		1207	+{
		1208	+ if (context)
		1209	+ {
		1210	+ auto* cl = reinterpret_cast<ClientPaho*>(context);
		1211	+ MqttFailure resp(response);
		1212	+ cl->pushIncomingEvent([cl, resp]() { cl->onUnsubscribeFailureOnInstance(resp); });
		1213	+ }
		1214	+}
		1215	+
		1216	+// static
		1217	+int ClientPaho::onMessageArrived(void* context, char* topicName, int, MQTTAsync_message* message)
		1218	+{
		1219	+
		1220	+ OSDEV_COMPONENTS_SCOPEGUARD(freeMessage, [&topicName, &message]()
		1221	+ {
		1222	+ MQTTAsync_freeMessage(&message);
		1223	+ MQTTAsync_free(topicName);
		1224	+ });
		1225	+
		1226	+ if (context)
		1227	+ {
		1228	+ auto* cl = reinterpret_cast<ClientPaho*>(context);
		1229	+ MqttMessage msg(topicName, *message);
		1230	+ cl->pushIncomingEvent([cl, msg]() { cl->onMessageArrivedOnInstance(msg); });
		1231	+ }
		1232	+
		1233	+ return 1; // always return true. Otherwise this callback is triggered again.
		1234	+}
		1235	+
		1236	+// static
		1237	+void ClientPaho::onDeliveryComplete(void* context, MQTTAsync_token token)
		1238	+{
		1239	+ if (context)
		1240	+ {
		1241	+ auto* cl = reinterpret_cast<ClientPaho*>(context);
		1242	+ cl->pushIncomingEvent([cl, token]() { cl->onDeliveryCompleteOnInstance(token); });
		1243	+ }
		1244	+}
		1245	+
		1246	+// static
		1247	+void ClientPaho::onConnectionLost(void* context, char* cause)
		1248	+{
		1249	+ OSDEV_COMPONENTS_SCOPEGUARD(freeCause, [&cause]()
		1250	+ {
		1251	+ if (cause)
		1252	+ {
		1253	+ MQTTAsync_free(cause);
		1254	+ }
		1255	+ });
		1256	+
		1257	+ if (context)
		1258	+ {
		1259	+ auto* cl = reinterpret_cast<ClientPaho*>(context);
		1260	+ std::string msg(nullptr == cause ? "cause unknown" : cause);
		1261	+ cl->pushIncomingEvent([cl, msg]() { cl->onConnectionLostOnInstance(msg); });
		1262	+ }
		1263	+}
		1264	+
		1265	+// static
		1266	+void ClientPaho::onLogPaho(enum MQTTASYNC_TRACE_LEVELS level, char* message)
		1267	+{
		1268	+ (void)message;
		1269	+ switch (level)
		1270	+ {
		1271	+ case MQTTASYNC_TRACE_MAXIMUM:
		1272	+ case MQTTASYNC_TRACE_MEDIUM:
		1273	+ case MQTTASYNC_TRACE_MINIMUM: {
		1274	+ // ("ClientPaho", "paho - %1", message)
		1275	+ break;
		1276	+ }
		1277	+ case MQTTASYNC_TRACE_PROTOCOL: {
		1278	+ // ("ClientPaho", "paho - %1", message)
		1279	+ break;
		1280	+ }
		1281	+ case MQTTASYNC_TRACE_ERROR:
		1282	+ case MQTTASYNC_TRACE_SEVERE:
		1283	+ case MQTTASYNC_TRACE_FATAL: {
		1284	+ // ("ClientPaho", "paho - %1", message)
		1285	+ break;
		1286	+ }
		1287	+ }
		1288	+}

src/clientpaho.h 0 → 100644

View file @51becbd

		1	+++ a/src/clientpaho.h
		1	+#ifndef OSDEV_COMPONENTS_MQTT_CLIENTPAHO_H
		2	+#define OSDEV_COMPONENTS_MQTT_CLIENTPAHO_H
		3	+
		4	+// std
		5	+#include <atomic>
		6	+#include <condition_variable>
		7	+#include <deque>
		8	+#include <functional>
		9	+#include <future>
		10	+#include <map>
		11	+#include <memory>
		12	+#include <mutex>
		13	+#include <string>
		14	+#include <vector>
		15	+
		16	+// boost
		17	+#include <boost/regex.hpp>
		18	+
		19	+// paho
		20	+#include <MQTTAsync.h>
		21	+
		22	+// osdev::components::mqtt
		23	+#include "synchronizedqueue.h"
		24	+#include "imqttclientimpl.h"
		25	+#include "mqttfailure.h"
		26	+#include "mqttsuccess.h"
		27	+
		28	+namespace osdev {
		29	+namespace components {
		30	+namespace mqtt {
		31	+
		32	+/**
		33	+ * @brief Wrapper class for the paho-c library.
		34	+ * This implementation uses the clean session flag and recreates subscriptions on reconnect.
		35	+ *
		36	+ * The implementation allows multiple subscriptions as long as the subscriptions do not have overlap. For mqtt 3 it is not
		37	+ * possible to track down the subscription based on the incoming message meta information. By matching the topic against
		38	+ * the various topic filters a subscription can be identified (but only when there is only one subscription that matches).
		39	+ */
		40	+class ClientPaho : public IMqttClientImpl
		41	+{
		42	+public:
		43	+ /**
		44	+ * @brief Construct a ClientPaho instance.
		45	+ * @param endpoint The endpoint to connect to
		46	+ * @param id The clientId that is used in the connection.
		47	+ * @param connectionStatusCallback The callback on which connection status information is communicated.
		48	+ * @param deliveryCompleteCallback Callback that is called with the publish message tokens for messages that are delivered.
		49	+ * Being delivered has different meanings depending on the quality of service.
		50	+ */
		51	+ ClientPaho(const std::string& endpoint,
		52	+ const std::string& id,
		53	+ const std::function<void(const std::string&, ConnectionStatus)>& connectionStatusCallback,
		54	+ const std::function<void(const std::string&, std::int32_t)>& deliveryCompleteCallback);
		55	+ virtual ~ClientPaho() override;
		56	+
		57	+ // Non copyable, non movable.
		58	+ ClientPaho(const ClientPaho&) = delete;
		59	+ ClientPaho& operator=(const ClientPaho&) = delete;
		60	+ ClientPaho(ClientPaho&&) = delete;
		61	+ ClientPaho& operator=(ClientPaho&&) = delete;
		62	+
		63	+ /**
		64	+ * @see IMqttClientImpl
		65	+ */
		66	+ virtual std::string clientId() const override;
		67	+
		68	+ /**
		69	+ * @see IMqttClientImpl
		70	+ */
		71	+ virtual ConnectionStatus connectionStatus() const override;
		72	+
		73	+ /**
		74	+ * @see IMqttClientImpl
		75	+ */
		76	+ virtual std::int32_t connect(bool wait) override;
		77	+
		78	+ /**
		79	+ * @see IMqttClientImpl
		80	+ */
		81	+ virtual std::int32_t disconnect(bool wait, int timeoutMs) override;
		82	+
		83	+ /**
		84	+ * @see IMqttClientImpl
		85	+ */
		86	+ virtual std::int32_t publish(const MqttMessage& message, int qos) override;
		87	+
		88	+ /**
		89	+ * @see IMqttClientImpl
		90	+ */
		91	+ virtual void publishPending() override;
		92	+
		93	+ /**
		94	+ * @see IMqttClientImpl
		95	+ */
		96	+ virtual std::int32_t subscribe(const std::string& topic, int qos, const std::function<void(MqttMessage msg)>& cb) override;
		97	+
		98	+ /**
		99	+ * @see IMqttClientImpl
		100	+ */
		101	+ virtual void resubscribe() override;
		102	+
		103	+ /**
		104	+ * @see IMqttClientImpl
		105	+ */
		106	+ virtual std::int32_t unsubscribe(const std::string& topic, int qos) override;
		107	+
		108	+ /**
		109	+ * @see IMqttClientImpl
		110	+ */
		111	+ virtual void unsubscribeAll() override;
		112	+
		113	+ /**
		114	+ * @see IMqttClientImpl
		115	+ */
		116	+ virtual std::chrono::milliseconds waitForCompletion(std::chrono::milliseconds waitFor, const std::set<std::int32_t>& tokens) const override;
		117	+
		118	+ /**
		119	+ * @see IMqttClientImpl
		120	+ */
		121	+ virtual bool isOverlapping(const std::string& topic) const override;
		122	+
		123	+ /**
		124	+ * @see IMqttClientImpl
		125	+ */
		126	+ virtual bool isOverlapping(const std::string& topic, std::string& existingTopic) const override;
		127	+
		128	+ /**
		129	+ * @see IMqttClientImpl
		130	+ */
		131	+ virtual std::vector<std::int32_t> pendingOperations() const override;
		132	+
		133	+ /**
		134	+ * @see IMqttClientImpl
		135	+ */
		136	+ virtual bool hasPendingSubscriptions() const override;
		137	+
		138	+ /**
		139	+ * @see IMqttClientImpl
		140	+ */
		141	+ virtual boost::optional<bool> operationResult(std::int32_t token) const override;
		142	+
		143	+private:
		144	+ void parseEndpoint(const std::string& endpoint);
		145	+
		146	+ std::int32_t publishInternal(const MqttMessage& message, int qos);
		147	+ std::int32_t subscribeInternal(const std::string& topic, int qos);
		148	+
		149	+ void setConnectionStatus(ConnectionStatus status);
		150	+ bool isOverlappingInternal(const std::string& topic, std::string& existingTopic) const;
		151	+
		152	+ /**
		153	+ * @brief Internal struct for subscriber information.
		154	+ * Used to store subscriptions.
		155	+ */
		156	+ struct Subscription
		157	+ {
		158	+ int qos;
		159	+ boost::regex topicRegex;
		160	+ std::function<void(MqttMessage)> callback;
		161	+ };
		162	+
		163	+ /**
		164	+ * @brief Internal struct for publisher information.
		165	+ * Used to store pending publishes during reconnection.
		166	+ */
		167	+ struct Publish
		168	+ {
		169	+ int qos;
		170	+ MqttMessage data;
		171	+ };
		172	+
		173	+ /**
		174	+ * @brief Add an incoming callback event to the synchronized queue.
		175	+ * @param ev A function object that calls one of the event handlers on a ClientPaho instance, but other types of actions are also possible.
		176	+ */
		177	+ void pushIncomingEvent(std::function<void()> ev);
		178	+
		179	+ /**
		180	+ * @brief Worker method that executes the events.
		181	+ */
		182	+ void callbackEventHandler();
		183	+
		184	+ /**
		185	+ * @brief Callback method that is called when a reconnect succeeds.
		186	+ * @param cause The cause of the original disconnect.
		187	+ */
		188	+ void onConnectOnInstance(const std::string& cause);
		189	+
		190	+ /**
		191	+ * @brief Callback that is called when a connect call succeeds.
		192	+ * This callback is also called when a reconnect succeeds because the paho library reuses the initial connect command!
		193	+ * The connection status is set to Connected.
		194	+ * @param response A success response with connection data.
		195	+ */
		196	+ void onConnectSuccessOnInstance(const MqttSuccess& response);
		197	+
		198	+ /**
		199	+ * @brief Callback that is called when a connect call fails after being sent to the endpoint.
		200	+ * This callback is also called when a reconnect fails because the paho library reuses the initial connect command!
		201	+ * The connection status is set to Disconnected when the connection state is ConnectInProgress, othwerwise the connection status is left as is.
		202	+ * @param response A failure response.
		203	+ */
		204	+ void onConnectFailureOnInstance(const MqttFailure& response);
		205	+
		206	+ //void onDisconnectOnInstance(enum MQTTReasonCodes reasonCode); for MQTT V5 which is not supported by centos7 paho-c
		207	+
		208	+ /**
		209	+ * @brief Callback that is called when a disconnect call succeeds.
		210	+ * The connection status is set to Disconnected.
		211	+ * @param response A success response with no specific data.
		212	+ */
		213	+ void onDisconnectSuccessOnInstance(const MqttSuccess& response);
		214	+
		215	+ /**
		216	+ * @brief Callback that is called when a disconnect call fails after being sent to the endpoint.
		217	+ * Based on the result returned by the paho library The connection status is set to Disconnected or Connected.
		218	+ * @param response A failure response.
		219	+ */
		220	+ void onDisconnectFailureOnInstance(const MqttFailure& response);
		221	+
		222	+ /**
		223	+ * @brief Callback that is called when a publish call succeeds.
		224	+ * This callback is called before the delivery complete callback.
		225	+ * @param response A success response with the published message.
		226	+ */
		227	+ void onPublishSuccessOnInstance(const MqttSuccess& response);
		228	+
		229	+ /**
		230	+ * @brief Callback that is called when a publish call fails after being sent to the endpoint.
		231	+ * @param response A failure response.
		232	+ */
		233	+ void onPublishFailureOnInstance(const MqttFailure& response);
		234	+
		235	+ /**
		236	+ * @brief Callback that is called when a subscribe call succeeds.
		237	+ * @param response A success response with the subscription information. The actual used qos is conveyed in this response.
		238	+ */
		239	+ void onSubscribeSuccessOnInstance(const MqttSuccess& response);
		240	+
		241	+ /**
		242	+ * @brief Callback that is called when a subscribe call fails after being sent to the endpoint.
		243	+ * @param response A failure response.
		244	+ */
		245	+ void onSubscribeFailureOnInstance(const MqttFailure& response);
		246	+
		247	+ /**
		248	+ * @brief Callback that is called when an unsubscribe call succeeds.
		249	+ * @param response A success response with no specific data.
		250	+ */
		251	+ void onUnsubscribeSuccessOnInstance(const MqttSuccess& response);
		252	+
		253	+ /**
		254	+ * @brief Callback that is called when an unsubscribe call fails after being sent to the endpoint.
		255	+ * @param response A failure response.
		256	+ */
		257	+ void onUnsubscribeFailureOnInstance(const MqttFailure& response);
		258	+
		259	+ /**
		260	+ * @brief Callback that is called when a message is received.
		261	+ * @param message The message payload and meta data.
		262	+ */
		263	+ int onMessageArrivedOnInstance(const MqttMessage& message);
		264	+
		265	+ /**
		266	+ * @brief Callback that is called when the delivery of a publish message is considered complete.
		267	+ * The definition of complete depends on the quality of service used in the publish command.
		268	+ * @param token The token with the publish command is sent.
		269	+ */
		270	+ void onDeliveryCompleteOnInstance(MQTTAsync_token token);
		271	+
		272	+ /**
		273	+ * @brief Callback that is called when the connection is broken.
		274	+ * @param cause The reason string. Always "cause unknown" for mqtt3 endpoints.
		275	+ */
		276	+ void onConnectionLostOnInstance(const std::string& cause);
		277	+
		278	+ // Static callback functions that are registered on the paho library. Functions call their *OnInstance() counterparts.
		279	+ static void onConnect(void* context, char* cause);
		280	+ static void onConnectSuccess(void* context, MQTTAsync_successData* response);
		281	+ static void onConnectFailure(void* context, MQTTAsync_failureData* response);
		282	+ //static void onDisconnect(void* context, MQTTProperties* properties, enum MQTTReasonCodes reasonCode); for MQTT V5 which is not supported by centos7 paho-c
		283	+ static void onDisconnectSuccess(void* context, MQTTAsync_successData* response);
		284	+ static void onDisconnectFailure(void* context, MQTTAsync_failureData* response);
		285	+ static void onPublishSuccess(void* context, MQTTAsync_successData* response);
		286	+ static void onPublishFailure(void* context, MQTTAsync_failureData* response);
		287	+ static void onSubscribeSuccess(void* context, MQTTAsync_successData* response);
		288	+ static void onSubscribeFailure(void* context, MQTTAsync_failureData* response);
		289	+ static void onUnsubscribeSuccess(void* context, MQTTAsync_successData* response);
		290	+ static void onUnsubscribeFailure(void* context, MQTTAsync_failureData* response);
		291	+ static int onMessageArrived(void* context, char* topicName, int topicLen, MQTTAsync_message* message);
		292	+ static void onDeliveryComplete(void* context, MQTTAsync_token token);
		293	+ static void onConnectionLost(void* context, char* cause);
		294	+
		295	+ /**
		296	+ * @brief Connects the paho logging to the mlogic logging system.
		297	+ * This callback is registered the first time a ClientPaho instance is constructed.
		298	+ */
		299	+ static void onLogPaho(enum MQTTASYNC_TRACE_LEVELS level, char* message);
		300	+
		301	+ mutable std::mutex m_mutex;
		302	+ std::string m_endpoint;
		303	+ std::string m_username;
		304	+ std::string m_password;
		305	+ std::string m_clientId;
		306	+ std::set<MQTTAsync_token> m_pendingOperations;
		307	+ std::map<MQTTAsync_token, bool> m_operationResult;
		308	+ mutable std::condition_variable m_operationsCompleteCV;
		309	+ std::map<std::string, Subscription> m_subscriptions;
		310	+ std::map<std::string, Subscription> m_pendingSubscriptions;
		311	+ std::map<MQTTAsync_token, std::string> m_subscribeTokenToTopic;
		312	+ std::map<MQTTAsync_token, std::string> m_unsubscribeTokenToTopic;
		313	+ std::deque<Publish> m_pendingPublishes;
		314	+ bool m_processPendingPublishes;
		315	+ mutable std::condition_variable m_pendingPublishesReadyCV;
		316	+ ::MQTTAsync m_client;
		317	+ std::atomic<ConnectionStatus> m_connectionStatus;
		318	+ std::function<void(const std::string&, ConnectionStatus)> m_connectionStatusCallback;
		319	+ std::function<void(const std::string&, std::int32_t)> m_deliveryCompleteCallback;
		320	+ MQTTAsync_token m_lastUnsubscribe; ///< centos7 workaround
		321	+ std::unique_ptr<std::promise<void>> m_connectPromise;
		322	+ std::unique_ptr<std::promise<void>> m_disconnectPromise;
		323	+
		324	+ SynchronizedQueue<std::function<void()>> m_callbackEventQueue;
		325	+ std::thread m_workerThread;
		326	+
		327	+ static std::atomic_int s_numberOfInstances;
		328	+};
		329	+
		330	+} // End namespace mqtt
		331	+} // End namespace components
		332	+} // End namespace osdev
		333	+
		334	+#endif // OSDEV_COMPONENTS_MQTT_CLIENTPAHO_H

src/commondefs.cpp 0 → 100644

View file @51becbd

		1	+++ a/src/commondefs.cpp
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#include "commondefs.h"
		20	+
		21	+// std
		22	+#include <ctime>
		23	+#include <iomanip>
		24	+
		25	+namespace osdev {
		26	+namespace components {
		27	+namespace mqtt {
		28	+
		29	+std::ostream& operator<<(std::ostream& os, const StdTimeMs& rhs)
		30	+{
		31	+ const std::time_t rhsTimeT = std::chrono::system_clock::to_time_t(rhs);
		32	+ struct tm tms
		33	+ {
		34	+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, nullptr
		35	+ };
		36	+ if (nullptr == gmtime_r(&rhsTimeT, &tms)) {
		37	+ os << "unknown";
		38	+ }
		39	+ else {
		40	+ char str[26] = { 0 };
		41	+ if (std::strftime(str, sizeof(str), "%Y-%m-%d %H:%M:%S.", &tms) > 0) {
		42	+ std::ostringstream oss;
		43	+ oss << str << std::setfill('0') << std::setw(3) << std::chrono::duration_cast<std::chrono::milliseconds>(rhs.timePoint - std::chrono::system_clock::from_time_t(rhsTimeT)).count() << ' ';
		44	+ if (std::strftime(str, sizeof(str), "%z", &tms) == 0) {
		45	+ return os;
		46	+ }
		47	+ oss << str;
		48	+ os << oss.str();
		49	+ }
		50	+ }
		51	+ return os;
		52	+}
		53	+
		54	+} // End namespace mqtt
		55	+} // End namespace components
		56	+} // End namespace osdev
		57	+
		58	+namespace std {
		59	+
		60	+std::ostream& operator<<(std::ostream& os, const osdev::components::mqtt::StdTime& rhs)
		61	+{
		62	+ /// @todo: Use put_time when it's implemented in gcc (5.0)
		63	+ // auto rhsTimeT = std::chrono::system_clock::to_time_t(rhs);
		64	+ // os << std::put_time(std::localtime(&rhsTimeT), "%F %T");
		65	+ const std::time_t rhsTimeT = std::chrono::system_clock::to_time_t(rhs);
		66	+ struct tm tms
		67	+ {
		68	+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, nullptr
		69	+ };
		70	+ if (nullptr == gmtime_r(&rhsTimeT, &tms)) {
		71	+ os << "unknown";
		72	+ }
		73	+ else {
		74	+ char str[26];
		75	+ if (std::strftime(str, sizeof(str), "%Y-%m-%d %H:%M:%S %z", &tms) > 0) {
		76	+ os << str;
		77	+ }
		78	+ }
		79	+ return os;
		80	+}
		81	+
		82	+} // End namespace std

src/commondefs.h 0 → 100644

View file @51becbd

		1	+++ a/src/commondefs.h
		1	+#ifndef OSDEV_COMPONENTS_MQTT_COMMONDEFS_H
		2	+#define OSDEV_COMPONENTS_MQTT_COMMONDEFS_H
		3	+
		4	+// std
		5	+#include <chrono>
		6	+#include <cstdint>
		7	+#include <map>
		8	+#include <ostream>
		9	+#include <set>
		10	+#include <string>
		11	+#include <vector>
		12	+
		13	+// boost
		14	+#include <boost/lexical_cast.hpp>
		15	+#include <boost/optional.hpp>
		16	+#include <boost/uuid/uuid.hpp>
		17	+#include <boost/uuid/uuid_io.hpp>
		18	+
		19	+#include "utils.h"
		20	+
		21	+
		22	+/// @brief Check if an id is valid
		23	+/// @throws InvalidArgumentException if id is invalid
		24	+#define OSDEV_COMPONENTS_CHECKMQTTID(id) \
		25	+ [&] { \
		26	+ if (id.is_nil()) { \
		27	+ } \
		28	+ }()
		29	+
		30	+
		31	+namespace osdev {
		32	+namespace components {
		33	+namespace mqtt {
		34	+
		35	+using MqttId = boost::uuids::uuid;
		36	+using OptionalId = MqttId;
		37	+using MqttIdSet = std::set<MqttId>;
		38	+using MqttIdSetIterator = MqttIdSet::const_iterator;
		39	+using MqttIdSetDelta = std::pair<MqttIdSet, MqttIdSet>;
		40	+using StdTime = std::chrono::system_clock::time_point;
		41	+using OptionalTime = boost::optional<StdTime>;
		42	+using StdTimeVec = std::vector<StdTime>;
		43	+using SequenceNumber = std::uint32_t;
		44	+using OptionalSequenceNumber = boost::optional<SequenceNumber>;
		45	+using CustomField = std::string;
		46	+using CustomFieldCollection = std::vector<CustomField>;
		47	+
		48	+using CountryCodeEnum = std::int32_t;
		49	+
		50	+/**
		51	+ * @brief Defines a parsed uri.
		52	+ */
		53	+using ParsedUri = std::map<std::string, std::string>;
		54	+
		55	+/**
		56	+ * @brief Type for the parsed query part of a uri.
		57	+ */
		58	+using ParsedQuery = std::map<std::string, std::string>;
		59	+
		60	+/**
		61	+ * @brief Type for the parsed path part of a uri.
		62	+ */
		63	+using ParsedPath = std::vector<std::string>;
		64	+
		65	+/**
		66	+ * @brief Defines a duration with the granularity of a day in seconds (24 * 60 * 60 = 86400).
		67	+ * This duration can be used to create a time_point at midnight of a given DateTime amongst others.
		68	+ *
		69	+ * The representation is a signed type so that negative durations are also possible.
		70	+ */
		71	+using days = std::chrono::duration<std::int32_t, std::ratio<86400>>;
		72	+
		73	+/**
		74	+ * @brief Defines a duration with the granularity of a year in seconds. A year is a bit longer than 365 days (365.2425). If a year is
		75	+ * subtracted from a date the time part of the new date will therefore differ from the time part of the subtracted from date.
		76	+ *
		77	+ * The representation is a signed type so that negative durations are also possible.
		78	+ */
		79	+using years = std::chrono::duration<std::int32_t, std::ratio<31556952>>; // excactly 365 days would give 31536000
		80	+
		81	+/**
		82	+ * A timepoint type that is printed with millisecond resolution.
		83	+ */
		84	+struct StdTimeMs
		85	+{
		86	+ StdTimeMs(const StdTime& tp)
		87	+ : timePoint(tp)
		88	+ {
		89	+ }
		90	+
		91	+ operator StdTime() const { return timePoint; }
		92	+
		93	+ StdTime timePoint;
		94	+};
		95	+
		96	+std::ostream& operator<<(std::ostream& os, const StdTimeMs& rhs);
		97	+
		98	+} // End namespace mqtt
		99	+} // End namespace components
		100	+} // End namespace osdev
		101	+
		102	+namespace std {
		103	+
		104	+std::ostream& operator<<(std::ostream& os, const osdev::components::mqtt::StdTime& rhs);
		105	+
		106	+} // End namespace std
		107	+
		108	+#endif // OSDEV_COMPONENTS_MQTT_COMMONDEFS_H

src/compat-c++14.h 0 → 100644

View file @51becbd

		1	+++ a/src/compat-c++14.h
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#ifndef OSDEV_COMPONENTS_COMPATCXX14
		20	+#define OSDEV_COMPONENTS_COMPATCXX14
		21	+
		22	+#include <memory>
		23	+
		24	+// The below code must be skipped if we use a C++14 or newer compiler
		25	+#if __cplusplus == 201103L
		26	+
		27	+namespace std {
		28	+/// Copied from libstdc++ 4.9.2 bits/unique_ptr.h
		29	+
		30	+template <typename _Tp>
		31	+struct _MakeUniq
		32	+{
		33	+ typedef unique_ptr<_Tp> __single_object;
		34	+};
		35	+
		36	+template <typename _Tp>
		37	+struct _MakeUniq<_Tp[]>
		38	+{
		39	+ typedef unique_ptr<_Tp[]> __array;
		40	+};
		41	+
		42	+template <typename _Tp, size_t _Bound>
		43	+struct _MakeUniq<_Tp[_Bound]>
		44	+{
		45	+ struct __invalid_type
		46	+ {
		47	+ };
		48	+};
		49	+
		50	+/// std::make_unique for single objects
		51	+template <typename _Tp, typename... _Args>
		52	+inline typename _MakeUniq<_Tp>::__single_object make_unique(_Args&&... __args)
		53	+{
		54	+ return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...));
		55	+}
		56	+
		57	+/// std::make_unique for arrays of unknown bound
		58	+template <typename _Tp>
		59	+inline typename _MakeUniq<_Tp>::__array make_unique(size_t __num)
		60	+{
		61	+ return unique_ptr<_Tp>(new typename remove_extent<_Tp>::type[__num]());
		62	+}
		63	+
		64	+/// Disable std::make_unique for arrays of known bound
		65	+template <typename _Tp, typename... _Args>
		66	+inline typename _MakeUniq<_Tp>::__invalid_type make_unique(_Args&&...) = delete;
		67	+
		68	+} // End namespace std
		69	+
		70	+#endif // Check for C++14
		71	+
		72	+#endif

src/compat-chrono.h 0 → 100644

View file @51becbd

		1	+++ a/src/compat-chrono.h
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#include <chrono>
		20	+#include <type_traits>
		21	+
		22	+// function std::chrono::ceil is added in the c++17 standard.
		23	+// Added implementation from https://en.cppreference.com/w/cpp/chrono/duration/ceil
		24	+// to this compatibility header. The header only defines this implementation when
		25	+// the c++ compiler is used with an older standard.
		26	+
		27	+#if !defined __cpp_lib_chrono \|\| __cpp_lib_chrono < 201611
		28	+
		29	+namespace std {
		30	+namespace chrono {
		31	+
		32	+template <class T>
		33	+struct is_duration : std::false_type
		34	+{
		35	+};
		36	+template <class Rep, class Period>
		37	+struct is_duration<
		38	+ std::chrono::duration<Rep, Period>> : std::true_type
		39	+{
		40	+};
		41	+
		42	+template <class To, class Rep, class Period,
		43	+ class = typename enable_if<is_duration<To>{}>::type>
		44	+To ceil(const std::chrono::duration<Rep, Period>& d)
		45	+{
		46	+ To t = std::chrono::duration_cast<To>(d);
		47	+ if (t < d)
		48	+ return t + To{ 1 };
		49	+ return t;
		50	+}
		51	+
		52	+} // End namespace chrono
		53	+} // End namespace std
		54	+
		55	+#endif

src/compiletimedigits.h 0 → 100644

View file @51becbd

		1	+++ a/src/compiletimedigits.h
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#ifndef OSDEV_COMPONENTS_MQTT_COMPILETIMEDIGITS_H
		20	+#define OSDEV_COMPONENTS_MQTT_COMPILETIMEDIGITS_H
		21	+
		22	+// std
		23	+#include <string>
		24	+
		25	+#include "compiletimestring.h"
		26	+
		27	+namespace osdev {
		28	+namespace components {
		29	+namespace mqtt {
		30	+
		31	+/**
		32	+ * @brief Calculate the number of digits needed to represent a given value in a given base.
		33	+ * @tparam B The base to use.
		34	+ * @param value The value to represent.
		35	+ * @return The number of digits.
		36	+ */
		37	+template <unsigned B>
		38	+constexpr std::size_t numberOfDigits(unsigned value) noexcept
		39	+{
		40	+ static_assert(B > 0, "base must be larger than zero");
		41	+ return (value / B) == 0 ? 1 : (1 + numberOfDigits<B>(value / B));
		42	+}
		43	+
		44	+/**
		45	+ * @return stringified digit that represents the given single digit value.
		46	+ * @note Values can range from 0 to 37 inclusive which maps on 0-9A-Z.
		47	+ */
		48	+template <unsigned value>
		49	+constexpr char digit() noexcept
		50	+{
		51	+ static_assert(value <= 37, "Value must lie between 0 and 37 both inclusive");
		52	+ return (value < 10 ? '0' + static_cast<char>(value) : 'A' + static_cast<char>(value) - 10);
		53	+}
		54	+
		55	+/**
		56	+ * @brief Recursive template definition that is used to determine the value of a given number N in a given base B.
		57	+ * @tparam N The number to obtain the representation for.
		58	+ * @tparam B The base to use.
		59	+ * @tparam Len The length of the representation including the 0 terminator.
		60	+ * If not provided the length is calculated on first instantiation of this template.
		61	+ * @tparam remains Empty parameter pack on first instantiation. Will be filled further by every following instantiation.
		62	+ */
		63	+template <unsigned N, unsigned B, std::size_t Len = numberOfDigits<B>(N) + 1, unsigned... remains>
		64	+struct Digits
		65	+{
		66	+
		67	+ static constexpr auto create() noexcept -> std::array<char, Len>
		68	+ {
		69	+ static_assert(B > 0, "base must be larger than zero");
		70	+ return Digits<N / B, B, Len, digit<N % B>(), remains...>::create();
		71	+ }
		72	+};
		73	+
		74	+/**
		75	+ * @brief Termination template that will return the actual hex digit array that represents the given value.
		76	+ * @tparam B The base to use.
		77	+ * @tparam Len The length of the hexadecimal representation including 0 terminator.
		78	+ * @tparam remains Parameter pack that contains the hexadecimal character representations.
		79	+ */
		80	+template <unsigned B, std::size_t Len, unsigned... remains>
		81	+struct Digits<0, B, Len, remains...>
		82	+{
		83	+
		84	+ static constexpr auto create() noexcept -> std::array<char, Len>
		85	+ {
		86	+ static_assert(sizeof...(remains) + 1 == Len, "Parameter 'Len' must be equal to the length of the parameter pack 'remains' including the termination zero");
		87	+ return std::array<char, Len>{ { remains..., 0 } };
		88	+ }
		89	+};
		90	+
		91	+/**
		92	+ * @brief Digits builder can be used in combination with the compiletime_string.
		93	+ * @tparam N The number to obtain the compile time string representation for.
		94	+ * @tparam B The base to use (up to 37).
		95	+ * This template struct defines a produce() method and the return type of that method.
		96	+ */
		97	+template <unsigned N, unsigned B>
		98	+struct ProduceDigits
		99	+{
		100	+ /**
		101	+ * @brief Return type definition of the produce method.
		102	+ */
		103	+ using return_t = std::array<char, numberOfDigits<B>(N) + 1>;
		104	+
		105	+ /**
		106	+ * @brief Produce the actual representation.
		107	+ */
		108	+ static constexpr return_t produce() noexcept
		109	+ {
		110	+ return Digits<N, B>::create();
		111	+ }
		112	+};
		113	+
		114	+} // End namespace mqtt
		115	+} // End namespace components
		116	+} // End namespace osdev
		117	+
		118	+#endif // OSDEV_COMPONENTS_MQTT_COMPILETIMEDIGITS_H

src/compiletimestring.h 0 → 100644

View file @51becbd

		1	+++ a/src/compiletimestring.h
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#ifndef OSDEV_COMPONENTS_MQTT_COMPILETIMESTRING_H
		20	+#define OSDEV_COMPONENTS_MQTT_COMPILETIMESTRING_H
		21	+
		22	+/// @file
		23	+///
		24	+/// Support for compiletime string building.
		25	+///
		26	+/// In some cases it is necessary to embed string messages as read only string literals
		27	+/// so that they can be used in low memory conditions for example.
		28	+/// This header defines two macro's that can be used to build managed string literals.
		29	+/// These managed string literals can be concatenated and searched at compiletime.
		30	+/// When the compiler is done with this code only the embedded string literal that are
		31	+/// used by normal expressions remain in the binary.
		32	+/// The implementation is a mix of meta template programming and the use of constexpr
		33	+/// expressions and is based on an idea found on <a href="http://stackoverflow.com/a/15912824">stackoverflow</a>.
		34	+/// This code is meant to handle small strings (up to say 100 characters). Larger strings can trigger the maximum
		35	+/// template recursion depth of the compiler (-ftemplate-depth). This depth is set at 900. So in principle strings
		36	+/// of 900 characters can be handled. However this is very inefficient and will prolong compiletime severly.
		37	+///
		38	+/// Here follows an example of how this code can be used.
		39	+/// @code
		40	+/// auto str1 = OSDEV_COMPONENTS_CSTRING("This is a test");
		41	+/// auto str2 = OSDEV_COMPONENTS_CSTRING(" with concatenation");
		42	+/// auto str3 = str1 + str2;
		43	+/// const char* s = str3.chars;
		44	+/// @endcode
		45	+/// str3.chars contains the compiletime concatenated string.
		46	+///
		47	+/// When examing the binary one will see that it contains the null terminated string literal
		48	+/// @code
		49	+/// This is a test with concatenation^@
		50	+/// @endcode
		51	+/// The str1 and str2 literals are discarded since they are never used in a non compiletime way.
		52	+/// @note This code is not meant to handle string literals with internal \0 characters. Beware!
		53	+
		54	+#include <limits>
		55	+
		56	+#include "metaprogrammingdefs.h"
		57	+
		58	+/// @brief Build a managed substring string literal from a string literal input
		59	+/// The strings are build compile time.
		60	+/// The upper bound is one past the last character that the caller is interested in.
		61	+#define OSDEV_COMPONENTS_CSTRING_BOUNDED(string_literal, lower, upper) \
		62	+ [] { \
		63	+ constexpr std::size_t lb = (lower); \
		64	+ constexpr std::size_t ub = (upper); \
		65	+ static_assert(lb <= ub, "lower bound must be smaller than or equal to upper bound"); \
		66	+ static_assert(ub < sizeof(string_literal), \
		67	+ "upper bound must be smaller than or equal to the length of the string"); \
		68	+ struct constexpr_string_type \
		69	+ { \
		70	+ const char* chars = string_literal; \
		71	+ }; \
		72	+ return typename osdev::components::mqtt::apply_bounded_range<lb, ub, \
		73	+ osdev::components::mqtt::string_builder<constexpr_string_type>::template produce>::result{}; \
		74	+ }()
		75	+
		76	+/// @brief Build a managed string literal from a string literal input
		77	+#define OSDEV_COMPONENTS_CSTRING(string_literal) \
		78	+ OSDEV_COMPONENTS_CSTRING_BOUNDED(string_literal, 0, sizeof(string_literal) - 1)
		79	+
		80	+namespace osdev {
		81	+namespace components {
		82	+namespace mqtt {
		83	+
		84	+/// @brief Managed string literal.
		85	+/// This class is used to hold string literals at compile time.
		86	+template <char... str>
		87	+struct compiletime_string
		88	+{
		89	+ /// @brief Declaration of the string
		90	+ static constexpr const char chars[sizeof...(str) + 1] = { str..., '\0' };
		91	+};
		92	+
		93	+/// @brief Definition of the string
		94	+template <char... str>
		95	+constexpr const char compiletime_string<str...>::chars[sizeof...(str) + 1];
		96	+
		97	+/// @brief Managed string literal builder.
		98	+/// This class is used to build string literals at compile time.
		99	+template <typename lambda_str_type>
		100	+struct string_builder
		101	+{
		102	+ /// @brief maps indices list on the char array
		103	+ template <std::size_t... indices>
		104	+ struct produce
		105	+ {
		106	+ typedef compiletime_string<lambda_str_type{}.chars[indices]...> result;
		107	+ };
		108	+};
		109	+
		110	+/// @brief Adapter for coupling other producers to string_builder.
		111	+/// tparam T The type of producer to adapt.
		112	+/// @note The adapter must define its return type as return_t and provide a static method produce() which produces the result.
		113	+/// The return type must be a kind of array type of chars (char[len], std::array<char,len>, etc).
		114	+template <typename T>
		115	+struct adapt_for_string_builder
		116	+{
		117	+ static constexpr typename T::return_t chars = T::produce();
		118	+};
		119	+
		120	+/// @brief Concatenate two managed string literals
		121	+/// The literals are packed in a variadic template.
		122	+/// These templates are formed by the MLOGIC_COMMON_CSTRING* macro's
		123	+/// The concatenation is done at compiletime.
		124	+template <char... str0, char... str1>
		125	+compiletime_string<str0..., str1...> operator+(compiletime_string<str0...>, compiletime_string<str1...>)
		126	+{
		127	+ return {};
		128	+}
		129	+
		130	+/// @brief Search for a character in a string literal from the right side.
		131	+/// The character index is returned relative to the left side.
		132	+/// If the character is not found a std::size_t(-1) is returned.
		133	+/// The default search starts at the end of the string. The index
		134	+/// can be given to start the search at another point in the string.
		135	+/// The index is given as nr of characters from the right end side of
		136	+/// the string. To proceed with a search see following example.
		137	+/// @code
		138	+/// constexpr const char s[] = "This is a test";
		139	+/// constexpr std::size_t index = osdev_components::mqtt::rfind(s, 'i'); // gives 5
		140	+/// static_assert(index == 5, "");
		141	+/// constexpr std::size_t index2 = osdev::components::mqtt::rfind(s, 'i', sizeof(s) - index); // gives 2
		142	+/// static_assert(index2 == 2, "");
		143	+/// @endcode
		144	+/// This function should only be used at compile time!
		145	+template <std::size_t N>
		146	+constexpr std::size_t rfind(const char (&str)[N], char c, std::size_t index = 0)
		147	+{
		148	+ return index >= N ? std::numeric_limits<std::size_t>::max() : str[N - index - 1] == c ? N - index - 1 : rfind(str, c, index + 1);
		149	+}
		150	+
		151	+} // End namespace mqtt
		152	+} // End namespace components
		153	+} // End namespace osdev
		154	+
		155	+#endif // OSDEV_COMPONENTS_MQTT_COMPILETIMESTRING_H

src/connectionstatus.cpp 0 → 100644

View file @51becbd

		1	+++ a/src/connectionstatus.cpp
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#include "connectionstatus.h"
		20	+
		21	+using namespace osdev::components::mqtt;
		22	+
		23	+std::ostream& operator<<(std::ostream &os, ConnectionStatus rhs)
		24	+{
		25	+ switch( rhs )
		26	+ {
		27	+ case ConnectionStatus::Disconnected:
		28	+ return os << "Disconnected";
		29	+ case ConnectionStatus::DisconnectInProgress:
		30	+ return os << "DisconnectInProgress";
		31	+ case ConnectionStatus::ConnectInProgress:
		32	+ return os << "ConnectInProgress";
		33	+ case ConnectionStatus::ReconnectInProgress:
		34	+ return os << "ReconnectInProgress";
		35	+ case ConnectionStatus::Connected:
		36	+ return os << "Connected";
		37	+ }
		38	+ return os << "Unknown"; // Should never be reached.
		39	+}

src/connectionstatus.h 0 → 100644

View file @51becbd

		1	+++ a/src/connectionstatus.h
		1	+#ifndef OSDEV_COMPONENTS_MQTT_CONNECTIONSTATUS_H
		2	+#define OSDEV_COMPONENTS_MQTT_CONNECTIONSTATUS_H
		3	+
		4	+// std
		5	+#include <ostream>
		6	+
		7	+namespace osdev {
		8	+namespace components {
		9	+namespace mqtt {
		10	+
		11	+/*!
		12	+ * \brief Enumeration for MQTT connection Status
		13	+ */
		14	+enum class ConnectionStatus
		15	+{
		16	+ Disconnected, ///< Client is disconnected.
		17	+ DisconnectInProgress, ///< Client is being disconnected.
		18	+ ConnectInProgress, ///< Client is being connected.
		19	+ ReconnectInProgress, ///< Client tries to reconnect.
		20	+ Connected, ///< Client is connected.
		21	+};
		22	+
		23	+/*!
		24	+ * \brief Stream operator for the connection status
		25	+ */
		26	+std::ostream& operator<<(std::ostream &os, ConnectionStatus rhs);
		27	+
		28	+} // End namespace mqtt
		29	+} // End namespace components
		30	+} // End namespace osdev
		31	+
		32	+#endif // OSDEV_COMPONENTS_MQTT_CONNECTIONSTATUS_H

src/credentials.cpp 0 → 100644

View file @51becbd

		1	+++ a/src/credentials.cpp
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#include "credentials.h"
		20	+
		21	+using namespace osdev::components::mqtt;
		22	+
		23	+Credentials::Credentials()
		24	+ : m_username()
		25	+ , m_password()
		26	+{}
		27	+
		28	+Credentials::Credentials( const std::string &username, const std::string &password )
		29	+ : m_username( username )
		30	+ , m_password( password )
		31	+{}

src/credentials.h 0 → 100644

View file @51becbd

		1	+++ a/src/credentials.h
		1	+#ifndef OSDEV_COMPONENTS_MQTT_CREDENTIALS_H
		2	+#define OSDEV_COMPONENTS_MQTT_CREDENTIALS_H
		3	+
		4	+// std
		5	+#include <string>
		6	+
		7	+namespace osdev {
		8	+namespace components {
		9	+namespace mqtt {
		10	+
		11	+/*!
		12	+ * \brief Class that holds user credentials
		13	+ */
		14	+class Credentials
		15	+{
		16	+public:
		17	+ /*!
		18	+ * \brief Default CTor, empty credentials
		19	+ */
		20	+ Credentials();
		21	+
		22	+ /*!
		23	+ * \brief Constructor for username/password credentials
		24	+ * \param username - The username
		25	+ * \param password - The password
		26	+ */
		27	+ Credentials(const std::string &username, const std::string &password);
		28	+
		29	+ const std::string& username() const { return m_username; }
		30	+ const std::string& password() const { return m_password; }
		31	+private:
		32	+ std::string m_username;
		33	+ std::string m_password;
		34	+};
		35	+
		36	+} // End namespace mqtt
		37	+} // End namespace components
		38	+} // End namespace osdev
		39	+
		40	+#endif // OSDEV_COMPONENTS_MQTT_CREDENTIALS_H

src/date.h 0 → 100644

View file @51becbd

		1	+++ a/src/date.h
		1	+#ifndef DATE_H
		2	+#define DATE_H
		3	+
		4	+// The MIT License (MIT)
		5	+//
		6	+// Copyright (c) 2015, 2016, 2017 Howard Hinnant
		7	+// Copyright (c) 2016 Adrian Colomitchi
		8	+// Copyright (c) 2017 Florian Dang
		9	+// Copyright (c) 2017 Paul Thompson
		10	+// Copyright (c) 2018, 2019 Tomasz Kamiński
		11	+// Copyright (c) 2019 Jiangang Zhuang
		12	+//
		13	+// Permission is hereby granted, free of charge, to any person obtaining a copy
		14	+// of this software and associated documentation files (the "Software"), to deal
		15	+// in the Software without restriction, including without limitation the rights
		16	+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
		17	+// copies of the Software, and to permit persons to whom the Software is
		18	+// furnished to do so, subject to the following conditions:
		19	+//
		20	+// The above copyright notice and this permission notice shall be included in all
		21	+// copies or substantial portions of the Software.
		22	+//
		23	+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
		24	+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		25	+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
		26	+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
		27	+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
		28	+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
		29	+// SOFTWARE.
		30	+//
		31	+// Our apologies. When the previous paragraph was written, lowercase had not yet
		32	+// been invented (that would involve another several millennia of evolution).
		33	+// We did not mean to shout.
		34	+
		35	+#ifndef HAS_STRING_VIEW
		36	+# if __cplusplus >= 201703 \|\| (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
		37	+# define HAS_STRING_VIEW 1
		38	+# else
		39	+# define HAS_STRING_VIEW 0
		40	+# endif
		41	+#endif // HAS_STRING_VIEW
		42	+
		43	+#include <cassert>
		44	+#include <algorithm>
		45	+#include <cctype>
		46	+#include <chrono>
		47	+#include <climits>
		48	+#include <cmath>
		49	+#include <cstddef>
		50	+#include <cstdint>
		51	+#include <cstdlib>
		52	+#include <ctime>
		53	+#include <ios>
		54	+#include <istream>
		55	+#include <iterator>
		56	+#include <limits>
		57	+#include <locale>
		58	+#include <memory>
		59	+#include <ostream>
		60	+#include <ratio>
		61	+#include <sstream>
		62	+#include <stdexcept>
		63	+#include <string>
		64	+#if HAS_STRING_VIEW
		65	+# include <string_view>
		66	+#endif
		67	+#include <utility>
		68	+#include <type_traits>
		69	+
		70	+#ifdef __GNUC__
		71	+# pragma GCC diagnostic push
		72	+# if __GNUC__ > 4 \|\| (__GNUC__ == 4 && __GNUC_MINOR__ > 7)
		73	+# pragma GCC diagnostic ignored "-Wpedantic"
		74	+# endif
		75	+# if __GNUC__ < 5
		76	+ // GCC 4.9 Bug 61489 Wrong warning with -Wmissing-field-initializers
		77	+# pragma GCC diagnostic ignored "-Wmissing-field-initializers"
		78	+# endif
		79	+#endif
		80	+
		81	+#ifdef _MSC_VER
		82	+# pragma warning(push)
		83	+// warning C4127: conditional expression is constant
		84	+# pragma warning(disable : 4127)
		85	+#endif
		86	+
		87	+namespace date
		88	+{
		89	+
		90	+//---------------+
		91	+// Configuration \|
		92	+//---------------+
		93	+
		94	+#ifndef ONLY_C_LOCALE
		95	+# define ONLY_C_LOCALE 0
		96	+#endif
		97	+
		98	+#if defined(_MSC_VER) && (!defined(__clang__) \|\| (_MSC_VER < 1910))
		99	+// MSVC
		100	+# ifndef _SILENCE_CXX17_UNCAUGHT_EXCEPTION_DEPRECATION_WARNING
		101	+# define _SILENCE_CXX17_UNCAUGHT_EXCEPTION_DEPRECATION_WARNING
		102	+# endif
		103	+# if _MSC_VER < 1910
		104	+// before VS2017
		105	+# define CONSTDATA const
		106	+# define CONSTCD11
		107	+# define CONSTCD14
		108	+# define NOEXCEPT _NOEXCEPT
		109	+# else
		110	+// VS2017 and later
		111	+# define CONSTDATA constexpr const
		112	+# define CONSTCD11 constexpr
		113	+# define CONSTCD14 constexpr
		114	+# define NOEXCEPT noexcept
		115	+# endif
		116	+
		117	+#elif defined(__SUNPRO_CC) && __SUNPRO_CC <= 0x5150
		118	+// Oracle Developer Studio 12.6 and earlier
		119	+# define CONSTDATA constexpr const
		120	+# define CONSTCD11 constexpr
		121	+# define CONSTCD14
		122	+# define NOEXCEPT noexcept
		123	+
		124	+#elif __cplusplus >= 201402
		125	+// C++14
		126	+# define CONSTDATA constexpr const
		127	+# define CONSTCD11 constexpr
		128	+# define CONSTCD14 constexpr
		129	+# define NOEXCEPT noexcept
		130	+#else
		131	+// C++11
		132	+# define CONSTDATA constexpr const
		133	+# define CONSTCD11 constexpr
		134	+# define CONSTCD14
		135	+# define NOEXCEPT noexcept
		136	+#endif
		137	+
		138	+#ifndef HAS_UNCAUGHT_EXCEPTIONS
		139	+# if __cplusplus >= 201703 \|\| (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
		140	+# define HAS_UNCAUGHT_EXCEPTIONS 1
		141	+# else
		142	+# define HAS_UNCAUGHT_EXCEPTIONS 0
		143	+# endif
		144	+#endif // HAS_UNCAUGHT_EXCEPTIONS
		145	+
		146	+#ifndef HAS_VOID_T
		147	+# if __cplusplus >= 201703 \|\| (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
		148	+# define HAS_VOID_T 1
		149	+# else
		150	+# define HAS_VOID_T 0
		151	+# endif
		152	+#endif // HAS_VOID_T
		153	+
		154	+// Protect from Oracle sun macro
		155	+#ifdef sun
		156	+# undef sun
		157	+#endif
		158	+
		159	+// Work around for a NVCC compiler bug which causes it to fail
		160	+// to compile std::ratio_{multiply,divide} when used directly
		161	+// in the std::chrono::duration template instantiations below
		162	+namespace detail {
		163	+template <typename R1, typename R2>
		164	+using ratio_multiply = decltype(std::ratio_multiply<R1, R2>{});
		165	+
		166	+template <typename R1, typename R2>
		167	+using ratio_divide = decltype(std::ratio_divide<R1, R2>{});
		168	+} // namespace detail
		169	+
		170	+//-----------+
		171	+// Interface \|
		172	+//-----------+
		173	+
		174	+// durations
		175	+
		176	+using days = std::chrono::duration
		177	+ <int, detail::ratio_multiply<std::ratio<24>, std::chrono::hours::period>>;
		178	+
		179	+using weeks = std::chrono::duration
		180	+ <int, detail::ratio_multiply<std::ratio<7>, days::period>>;
		181	+
		182	+using years = std::chrono::duration
		183	+ <int, detail::ratio_multiply<std::ratio<146097, 400>, days::period>>;
		184	+
		185	+using months = std::chrono::duration
		186	+ <int, detail::ratio_divide<years::period, std::ratio<12>>>;
		187	+
		188	+// time_point
		189	+
		190	+template <class Duration>
		191	+ using sys_time = std::chrono::time_point<std::chrono::system_clock, Duration>;
		192	+
		193	+using sys_days = sys_time<days>;
		194	+using sys_seconds = sys_time<std::chrono::seconds>;
		195	+
		196	+struct local_t {};
		197	+
		198	+template <class Duration>
		199	+ using local_time = std::chrono::time_point<local_t, Duration>;
		200	+
		201	+using local_seconds = local_time<std::chrono::seconds>;
		202	+using local_days = local_time<days>;
		203	+
		204	+// types
		205	+
		206	+struct last_spec
		207	+{
		208	+ explicit last_spec() = default;
		209	+};
		210	+
		211	+class day;
		212	+class month;
		213	+class year;
		214	+
		215	+class weekday;
		216	+class weekday_indexed;
		217	+class weekday_last;
		218	+
		219	+class month_day;
		220	+class month_day_last;
		221	+class month_weekday;
		222	+class month_weekday_last;
		223	+
		224	+class year_month;
		225	+
		226	+class year_month_day;
		227	+class year_month_day_last;
		228	+class year_month_weekday;
		229	+class year_month_weekday_last;
		230	+
		231	+// date composition operators
		232	+
		233	+CONSTCD11 year_month operator/(const year& y, const month& m) NOEXCEPT;
		234	+CONSTCD11 year_month operator/(const year& y, int m) NOEXCEPT;
		235	+
		236	+CONSTCD11 month_day operator/(const day& d, const month& m) NOEXCEPT;
		237	+CONSTCD11 month_day operator/(const day& d, int m) NOEXCEPT;
		238	+CONSTCD11 month_day operator/(const month& m, const day& d) NOEXCEPT;
		239	+CONSTCD11 month_day operator/(const month& m, int d) NOEXCEPT;
		240	+CONSTCD11 month_day operator/(int m, const day& d) NOEXCEPT;
		241	+
		242	+CONSTCD11 month_day_last operator/(const month& m, last_spec) NOEXCEPT;
		243	+CONSTCD11 month_day_last operator/(int m, last_spec) NOEXCEPT;
		244	+CONSTCD11 month_day_last operator/(last_spec, const month& m) NOEXCEPT;
		245	+CONSTCD11 month_day_last operator/(last_spec, int m) NOEXCEPT;
		246	+
		247	+CONSTCD11 month_weekday operator/(const month& m, const weekday_indexed& wdi) NOEXCEPT;
		248	+CONSTCD11 month_weekday operator/(int m, const weekday_indexed& wdi) NOEXCEPT;
		249	+CONSTCD11 month_weekday operator/(const weekday_indexed& wdi, const month& m) NOEXCEPT;
		250	+CONSTCD11 month_weekday operator/(const weekday_indexed& wdi, int m) NOEXCEPT;
		251	+
		252	+CONSTCD11 month_weekday_last operator/(const month& m, const weekday_last& wdl) NOEXCEPT;
		253	+CONSTCD11 month_weekday_last operator/(int m, const weekday_last& wdl) NOEXCEPT;
		254	+CONSTCD11 month_weekday_last operator/(const weekday_last& wdl, const month& m) NOEXCEPT;
		255	+CONSTCD11 month_weekday_last operator/(const weekday_last& wdl, int m) NOEXCEPT;
		256	+
		257	+CONSTCD11 year_month_day operator/(const year_month& ym, const day& d) NOEXCEPT;
		258	+CONSTCD11 year_month_day operator/(const year_month& ym, int d) NOEXCEPT;
		259	+CONSTCD11 year_month_day operator/(const year& y, const month_day& md) NOEXCEPT;
		260	+CONSTCD11 year_month_day operator/(int y, const month_day& md) NOEXCEPT;
		261	+CONSTCD11 year_month_day operator/(const month_day& md, const year& y) NOEXCEPT;
		262	+CONSTCD11 year_month_day operator/(const month_day& md, int y) NOEXCEPT;
		263	+
		264	+CONSTCD11
		265	+ year_month_day_last operator/(const year_month& ym, last_spec) NOEXCEPT;
		266	+CONSTCD11
		267	+ year_month_day_last operator/(const year& y, const month_day_last& mdl) NOEXCEPT;
		268	+CONSTCD11
		269	+ year_month_day_last operator/(int y, const month_day_last& mdl) NOEXCEPT;
		270	+CONSTCD11
		271	+ year_month_day_last operator/(const month_day_last& mdl, const year& y) NOEXCEPT;
		272	+CONSTCD11
		273	+ year_month_day_last operator/(const month_day_last& mdl, int y) NOEXCEPT;
		274	+
		275	+CONSTCD11
		276	+year_month_weekday
		277	+operator/(const year_month& ym, const weekday_indexed& wdi) NOEXCEPT;
		278	+
		279	+CONSTCD11
		280	+year_month_weekday
		281	+operator/(const year& y, const month_weekday& mwd) NOEXCEPT;
		282	+
		283	+CONSTCD11
		284	+year_month_weekday
		285	+operator/(int y, const month_weekday& mwd) NOEXCEPT;
		286	+
		287	+CONSTCD11
		288	+year_month_weekday
		289	+operator/(const month_weekday& mwd, const year& y) NOEXCEPT;
		290	+
		291	+CONSTCD11
		292	+year_month_weekday
		293	+operator/(const month_weekday& mwd, int y) NOEXCEPT;
		294	+
		295	+CONSTCD11
		296	+year_month_weekday_last
		297	+operator/(const year_month& ym, const weekday_last& wdl) NOEXCEPT;
		298	+
		299	+CONSTCD11
		300	+year_month_weekday_last
		301	+operator/(const year& y, const month_weekday_last& mwdl) NOEXCEPT;
		302	+
		303	+CONSTCD11
		304	+year_month_weekday_last
		305	+operator/(int y, const month_weekday_last& mwdl) NOEXCEPT;
		306	+
		307	+CONSTCD11
		308	+year_month_weekday_last
		309	+operator/(const month_weekday_last& mwdl, const year& y) NOEXCEPT;
		310	+
		311	+CONSTCD11
		312	+year_month_weekday_last
		313	+operator/(const month_weekday_last& mwdl, int y) NOEXCEPT;
		314	+
		315	+// Detailed interface
		316	+
		317	+// day
		318	+
		319	+class day
		320	+{
		321	+ unsigned char d_;
		322	+
		323	+public:
		324	+ day() = default;
		325	+ explicit CONSTCD11 day(unsigned d) NOEXCEPT;
		326	+
		327	+ CONSTCD14 day& operator++() NOEXCEPT;
		328	+ CONSTCD14 day operator++(int) NOEXCEPT;
		329	+ CONSTCD14 day& operator--() NOEXCEPT;
		330	+ CONSTCD14 day operator--(int) NOEXCEPT;
		331	+
		332	+ CONSTCD14 day& operator+=(const days& d) NOEXCEPT;
		333	+ CONSTCD14 day& operator-=(const days& d) NOEXCEPT;
		334	+
		335	+ CONSTCD11 explicit operator unsigned() const NOEXCEPT;
		336	+ CONSTCD11 bool ok() const NOEXCEPT;
		337	+};
		338	+
		339	+CONSTCD11 bool operator==(const day& x, const day& y) NOEXCEPT;
		340	+CONSTCD11 bool operator!=(const day& x, const day& y) NOEXCEPT;
		341	+CONSTCD11 bool operator< (const day& x, const day& y) NOEXCEPT;
		342	+CONSTCD11 bool operator> (const day& x, const day& y) NOEXCEPT;
		343	+CONSTCD11 bool operator<=(const day& x, const day& y) NOEXCEPT;
		344	+CONSTCD11 bool operator>=(const day& x, const day& y) NOEXCEPT;
		345	+
		346	+CONSTCD11 day operator+(const day& x, const days& y) NOEXCEPT;
		347	+CONSTCD11 day operator+(const days& x, const day& y) NOEXCEPT;
		348	+CONSTCD11 day operator-(const day& x, const days& y) NOEXCEPT;
		349	+CONSTCD11 days operator-(const day& x, const day& y) NOEXCEPT;
		350	+
		351	+template<class CharT, class Traits>
		352	+std::basic_ostream<CharT, Traits>&
		353	+operator<<(std::basic_ostream<CharT, Traits>& os, const day& d);
		354	+
		355	+// month
		356	+
		357	+class month
		358	+{
		359	+ unsigned char m_;
		360	+
		361	+public:
		362	+ month() = default;
		363	+ explicit CONSTCD11 month(unsigned m) NOEXCEPT;
		364	+
		365	+ CONSTCD14 month& operator++() NOEXCEPT;
		366	+ CONSTCD14 month operator++(int) NOEXCEPT;
		367	+ CONSTCD14 month& operator--() NOEXCEPT;
		368	+ CONSTCD14 month operator--(int) NOEXCEPT;
		369	+
		370	+ CONSTCD14 month& operator+=(const months& m) NOEXCEPT;
		371	+ CONSTCD14 month& operator-=(const months& m) NOEXCEPT;
		372	+
		373	+ CONSTCD11 explicit operator unsigned() const NOEXCEPT;
		374	+ CONSTCD11 bool ok() const NOEXCEPT;
		375	+};
		376	+
		377	+CONSTCD11 bool operator==(const month& x, const month& y) NOEXCEPT;
		378	+CONSTCD11 bool operator!=(const month& x, const month& y) NOEXCEPT;
		379	+CONSTCD11 bool operator< (const month& x, const month& y) NOEXCEPT;
		380	+CONSTCD11 bool operator> (const month& x, const month& y) NOEXCEPT;
		381	+CONSTCD11 bool operator<=(const month& x, const month& y) NOEXCEPT;
		382	+CONSTCD11 bool operator>=(const month& x, const month& y) NOEXCEPT;
		383	+
		384	+CONSTCD14 month operator+(const month& x, const months& y) NOEXCEPT;
		385	+CONSTCD14 month operator+(const months& x, const month& y) NOEXCEPT;
		386	+CONSTCD14 month operator-(const month& x, const months& y) NOEXCEPT;
		387	+CONSTCD14 months operator-(const month& x, const month& y) NOEXCEPT;
		388	+
		389	+template<class CharT, class Traits>
		390	+std::basic_ostream<CharT, Traits>&
		391	+operator<<(std::basic_ostream<CharT, Traits>& os, const month& m);
		392	+
		393	+// year
		394	+
		395	+class year
		396	+{
		397	+ short y_;
		398	+
		399	+public:
		400	+ year() = default;
		401	+ explicit CONSTCD11 year(int y) NOEXCEPT;
		402	+
		403	+ CONSTCD14 year& operator++() NOEXCEPT;
		404	+ CONSTCD14 year operator++(int) NOEXCEPT;
		405	+ CONSTCD14 year& operator--() NOEXCEPT;
		406	+ CONSTCD14 year operator--(int) NOEXCEPT;
		407	+
		408	+ CONSTCD14 year& operator+=(const years& y) NOEXCEPT;
		409	+ CONSTCD14 year& operator-=(const years& y) NOEXCEPT;
		410	+
		411	+ CONSTCD11 year operator-() const NOEXCEPT;
		412	+ CONSTCD11 year operator+() const NOEXCEPT;
		413	+
		414	+ CONSTCD11 bool is_leap() const NOEXCEPT;
		415	+
		416	+ CONSTCD11 explicit operator int() const NOEXCEPT;
		417	+ CONSTCD11 bool ok() const NOEXCEPT;
		418	+
		419	+ static CONSTCD11 year min() NOEXCEPT { return year{-32767}; }
		420	+ static CONSTCD11 year max() NOEXCEPT { return year{32767}; }
		421	+};
		422	+
		423	+CONSTCD11 bool operator==(const year& x, const year& y) NOEXCEPT;
		424	+CONSTCD11 bool operator!=(const year& x, const year& y) NOEXCEPT;
		425	+CONSTCD11 bool operator< (const year& x, const year& y) NOEXCEPT;
		426	+CONSTCD11 bool operator> (const year& x, const year& y) NOEXCEPT;
		427	+CONSTCD11 bool operator<=(const year& x, const year& y) NOEXCEPT;
		428	+CONSTCD11 bool operator>=(const year& x, const year& y) NOEXCEPT;
		429	+
		430	+CONSTCD11 year operator+(const year& x, const years& y) NOEXCEPT;
		431	+CONSTCD11 year operator+(const years& x, const year& y) NOEXCEPT;
		432	+CONSTCD11 year operator-(const year& x, const years& y) NOEXCEPT;
		433	+CONSTCD11 years operator-(const year& x, const year& y) NOEXCEPT;
		434	+
		435	+template<class CharT, class Traits>
		436	+std::basic_ostream<CharT, Traits>&
		437	+operator<<(std::basic_ostream<CharT, Traits>& os, const year& y);
		438	+
		439	+// weekday
		440	+
		441	+class weekday
		442	+{
		443	+ unsigned char wd_;
		444	+public:
		445	+ weekday() = default;
		446	+ explicit CONSTCD11 weekday(unsigned wd) NOEXCEPT;
		447	+ CONSTCD14 weekday(const sys_days& dp) NOEXCEPT;
		448	+ CONSTCD14 explicit weekday(const local_days& dp) NOEXCEPT;
		449	+
		450	+ CONSTCD14 weekday& operator++() NOEXCEPT;
		451	+ CONSTCD14 weekday operator++(int) NOEXCEPT;
		452	+ CONSTCD14 weekday& operator--() NOEXCEPT;
		453	+ CONSTCD14 weekday operator--(int) NOEXCEPT;
		454	+
		455	+ CONSTCD14 weekday& operator+=(const days& d) NOEXCEPT;
		456	+ CONSTCD14 weekday& operator-=(const days& d) NOEXCEPT;
		457	+
		458	+ CONSTCD11 bool ok() const NOEXCEPT;
		459	+
		460	+ CONSTCD11 unsigned c_encoding() const NOEXCEPT;
		461	+ CONSTCD11 unsigned iso_encoding() const NOEXCEPT;
		462	+
		463	+ CONSTCD11 weekday_indexed operator[](unsigned index) const NOEXCEPT;
		464	+ CONSTCD11 weekday_last operator[](last_spec) const NOEXCEPT;
		465	+
		466	+private:
		467	+ static CONSTCD14 unsigned char weekday_from_days(int z) NOEXCEPT;
		468	+
		469	+ friend CONSTCD11 bool operator==(const weekday& x, const weekday& y) NOEXCEPT;
		470	+ friend CONSTCD14 days operator-(const weekday& x, const weekday& y) NOEXCEPT;
		471	+ friend CONSTCD14 weekday operator+(const weekday& x, const days& y) NOEXCEPT;
		472	+ template<class CharT, class Traits>
		473	+ friend std::basic_ostream<CharT, Traits>&
		474	+ operator<<(std::basic_ostream<CharT, Traits>& os, const weekday& wd);
		475	+ friend class weekday_indexed;
		476	+};
		477	+
		478	+CONSTCD11 bool operator==(const weekday& x, const weekday& y) NOEXCEPT;
		479	+CONSTCD11 bool operator!=(const weekday& x, const weekday& y) NOEXCEPT;
		480	+
		481	+CONSTCD14 weekday operator+(const weekday& x, const days& y) NOEXCEPT;
		482	+CONSTCD14 weekday operator+(const days& x, const weekday& y) NOEXCEPT;
		483	+CONSTCD14 weekday operator-(const weekday& x, const days& y) NOEXCEPT;
		484	+CONSTCD14 days operator-(const weekday& x, const weekday& y) NOEXCEPT;
		485	+
		486	+template<class CharT, class Traits>
		487	+std::basic_ostream<CharT, Traits>&
		488	+operator<<(std::basic_ostream<CharT, Traits>& os, const weekday& wd);
		489	+
		490	+// weekday_indexed
		491	+
		492	+class weekday_indexed
		493	+{
		494	+ unsigned char wd_ : 4;
		495	+ unsigned char index_ : 4;
		496	+
		497	+public:
		498	+ weekday_indexed() = default;
		499	+ CONSTCD11 weekday_indexed(const date::weekday& wd, unsigned index) NOEXCEPT;
		500	+
		501	+ CONSTCD11 date::weekday weekday() const NOEXCEPT;
		502	+ CONSTCD11 unsigned index() const NOEXCEPT;
		503	+ CONSTCD11 bool ok() const NOEXCEPT;
		504	+};
		505	+
		506	+CONSTCD11 bool operator==(const weekday_indexed& x, const weekday_indexed& y) NOEXCEPT;
		507	+CONSTCD11 bool operator!=(const weekday_indexed& x, const weekday_indexed& y) NOEXCEPT;
		508	+
		509	+template<class CharT, class Traits>
		510	+std::basic_ostream<CharT, Traits>&
		511	+operator<<(std::basic_ostream<CharT, Traits>& os, const weekday_indexed& wdi);
		512	+
		513	+// weekday_last
		514	+
		515	+class weekday_last
		516	+{
		517	+ date::weekday wd_;
		518	+
		519	+public:
		520	+ explicit CONSTCD11 weekday_last(const date::weekday& wd) NOEXCEPT;
		521	+
		522	+ CONSTCD11 date::weekday weekday() const NOEXCEPT;
		523	+ CONSTCD11 bool ok() const NOEXCEPT;
		524	+};
		525	+
		526	+CONSTCD11 bool operator==(const weekday_last& x, const weekday_last& y) NOEXCEPT;
		527	+CONSTCD11 bool operator!=(const weekday_last& x, const weekday_last& y) NOEXCEPT;
		528	+
		529	+template<class CharT, class Traits>
		530	+std::basic_ostream<CharT, Traits>&
		531	+operator<<(std::basic_ostream<CharT, Traits>& os, const weekday_last& wdl);
		532	+
		533	+namespace detail
		534	+{
		535	+
		536	+struct unspecified_month_disambiguator {};
		537	+
		538	+} // namespace detail
		539	+
		540	+// year_month
		541	+
		542	+class year_month
		543	+{
		544	+ date::year y_;
		545	+ date::month m_;
		546	+
		547	+public:
		548	+ year_month() = default;
		549	+ CONSTCD11 year_month(const date::year& y, const date::month& m) NOEXCEPT;
		550	+
		551	+ CONSTCD11 date::year year() const NOEXCEPT;
		552	+ CONSTCD11 date::month month() const NOEXCEPT;
		553	+
		554	+ template<class = detail::unspecified_month_disambiguator>
		555	+ CONSTCD14 year_month& operator+=(const months& dm) NOEXCEPT;
		556	+ template<class = detail::unspecified_month_disambiguator>
		557	+ CONSTCD14 year_month& operator-=(const months& dm) NOEXCEPT;
		558	+ CONSTCD14 year_month& operator+=(const years& dy) NOEXCEPT;
		559	+ CONSTCD14 year_month& operator-=(const years& dy) NOEXCEPT;
		560	+
		561	+ CONSTCD11 bool ok() const NOEXCEPT;
		562	+};
		563	+
		564	+CONSTCD11 bool operator==(const year_month& x, const year_month& y) NOEXCEPT;
		565	+CONSTCD11 bool operator!=(const year_month& x, const year_month& y) NOEXCEPT;
		566	+CONSTCD11 bool operator< (const year_month& x, const year_month& y) NOEXCEPT;
		567	+CONSTCD11 bool operator> (const year_month& x, const year_month& y) NOEXCEPT;
		568	+CONSTCD11 bool operator<=(const year_month& x, const year_month& y) NOEXCEPT;
		569	+CONSTCD11 bool operator>=(const year_month& x, const year_month& y) NOEXCEPT;
		570	+
		571	+template<class = detail::unspecified_month_disambiguator>
		572	+CONSTCD14 year_month operator+(const year_month& ym, const months& dm) NOEXCEPT;
		573	+template<class = detail::unspecified_month_disambiguator>
		574	+CONSTCD14 year_month operator+(const months& dm, const year_month& ym) NOEXCEPT;
		575	+template<class = detail::unspecified_month_disambiguator>
		576	+CONSTCD14 year_month operator-(const year_month& ym, const months& dm) NOEXCEPT;
		577	+
		578	+CONSTCD11 months operator-(const year_month& x, const year_month& y) NOEXCEPT;
		579	+CONSTCD11 year_month operator+(const year_month& ym, const years& dy) NOEXCEPT;
		580	+CONSTCD11 year_month operator+(const years& dy, const year_month& ym) NOEXCEPT;
		581	+CONSTCD11 year_month operator-(const year_month& ym, const years& dy) NOEXCEPT;
		582	+
		583	+template<class CharT, class Traits>
		584	+std::basic_ostream<CharT, Traits>&
		585	+operator<<(std::basic_ostream<CharT, Traits>& os, const year_month& ym);
		586	+
		587	+// month_day
		588	+
		589	+class month_day
		590	+{
		591	+ date::month m_;
		592	+ date::day d_;
		593	+
		594	+public:
		595	+ month_day() = default;
		596	+ CONSTCD11 month_day(const date::month& m, const date::day& d) NOEXCEPT;
		597	+
		598	+ CONSTCD11 date::month month() const NOEXCEPT;
		599	+ CONSTCD11 date::day day() const NOEXCEPT;
		600	+
		601	+ CONSTCD14 bool ok() const NOEXCEPT;
		602	+};
		603	+
		604	+CONSTCD11 bool operator==(const month_day& x, const month_day& y) NOEXCEPT;
		605	+CONSTCD11 bool operator!=(const month_day& x, const month_day& y) NOEXCEPT;
		606	+CONSTCD11 bool operator< (const month_day& x, const month_day& y) NOEXCEPT;
		607	+CONSTCD11 bool operator> (const month_day& x, const month_day& y) NOEXCEPT;
		608	+CONSTCD11 bool operator<=(const month_day& x, const month_day& y) NOEXCEPT;
		609	+CONSTCD11 bool operator>=(const month_day& x, const month_day& y) NOEXCEPT;
		610	+
		611	+template<class CharT, class Traits>
		612	+std::basic_ostream<CharT, Traits>&
		613	+operator<<(std::basic_ostream<CharT, Traits>& os, const month_day& md);
		614	+
		615	+// month_day_last
		616	+
		617	+class month_day_last
		618	+{
		619	+ date::month m_;
		620	+
		621	+public:
		622	+ CONSTCD11 explicit month_day_last(const date::month& m) NOEXCEPT;
		623	+
		624	+ CONSTCD11 date::month month() const NOEXCEPT;
		625	+ CONSTCD11 bool ok() const NOEXCEPT;
		626	+};
		627	+
		628	+CONSTCD11 bool operator==(const month_day_last& x, const month_day_last& y) NOEXCEPT;
		629	+CONSTCD11 bool operator!=(const month_day_last& x, const month_day_last& y) NOEXCEPT;
		630	+CONSTCD11 bool operator< (const month_day_last& x, const month_day_last& y) NOEXCEPT;
		631	+CONSTCD11 bool operator> (const month_day_last& x, const month_day_last& y) NOEXCEPT;
		632	+CONSTCD11 bool operator<=(const month_day_last& x, const month_day_last& y) NOEXCEPT;
		633	+CONSTCD11 bool operator>=(const month_day_last& x, const month_day_last& y) NOEXCEPT;
		634	+
		635	+template<class CharT, class Traits>
		636	+std::basic_ostream<CharT, Traits>&
		637	+operator<<(std::basic_ostream<CharT, Traits>& os, const month_day_last& mdl);
		638	+
		639	+// month_weekday
		640	+
		641	+class month_weekday
		642	+{
		643	+ date::month m_;
		644	+ date::weekday_indexed wdi_;
		645	+public:
		646	+ CONSTCD11 month_weekday(const date::month& m,
		647	+ const date::weekday_indexed& wdi) NOEXCEPT;
		648	+
		649	+ CONSTCD11 date::month month() const NOEXCEPT;
		650	+ CONSTCD11 date::weekday_indexed weekday_indexed() const NOEXCEPT;
		651	+
		652	+ CONSTCD11 bool ok() const NOEXCEPT;
		653	+};
		654	+
		655	+CONSTCD11 bool operator==(const month_weekday& x, const month_weekday& y) NOEXCEPT;
		656	+CONSTCD11 bool operator!=(const month_weekday& x, const month_weekday& y) NOEXCEPT;
		657	+
		658	+template<class CharT, class Traits>
		659	+std::basic_ostream<CharT, Traits>&
		660	+operator<<(std::basic_ostream<CharT, Traits>& os, const month_weekday& mwd);
		661	+
		662	+// month_weekday_last
		663	+
		664	+class month_weekday_last
		665	+{
		666	+ date::month m_;
		667	+ date::weekday_last wdl_;
		668	+
		669	+public:
		670	+ CONSTCD11 month_weekday_last(const date::month& m,
		671	+ const date::weekday_last& wd) NOEXCEPT;
		672	+
		673	+ CONSTCD11 date::month month() const NOEXCEPT;
		674	+ CONSTCD11 date::weekday_last weekday_last() const NOEXCEPT;
		675	+
		676	+ CONSTCD11 bool ok() const NOEXCEPT;
		677	+};
		678	+
		679	+CONSTCD11
		680	+ bool operator==(const month_weekday_last& x, const month_weekday_last& y) NOEXCEPT;
		681	+CONSTCD11
		682	+ bool operator!=(const month_weekday_last& x, const month_weekday_last& y) NOEXCEPT;
		683	+
		684	+template<class CharT, class Traits>
		685	+std::basic_ostream<CharT, Traits>&
		686	+operator<<(std::basic_ostream<CharT, Traits>& os, const month_weekday_last& mwdl);
		687	+
		688	+// class year_month_day
		689	+
		690	+class year_month_day
		691	+{
		692	+ date::year y_;
		693	+ date::month m_;
		694	+ date::day d_;
		695	+
		696	+public:
		697	+ year_month_day() = default;
		698	+ CONSTCD11 year_month_day(const date::year& y, const date::month& m,
		699	+ const date::day& d) NOEXCEPT;
		700	+ CONSTCD14 year_month_day(const year_month_day_last& ymdl) NOEXCEPT;
		701	+
		702	+ CONSTCD14 year_month_day(sys_days dp) NOEXCEPT;
		703	+ CONSTCD14 explicit year_month_day(local_days dp) NOEXCEPT;
		704	+
		705	+ template<class = detail::unspecified_month_disambiguator>
		706	+ CONSTCD14 year_month_day& operator+=(const months& m) NOEXCEPT;
		707	+ template<class = detail::unspecified_month_disambiguator>
		708	+ CONSTCD14 year_month_day& operator-=(const months& m) NOEXCEPT;
		709	+ CONSTCD14 year_month_day& operator+=(const years& y) NOEXCEPT;
		710	+ CONSTCD14 year_month_day& operator-=(const years& y) NOEXCEPT;
		711	+
		712	+ CONSTCD11 date::year year() const NOEXCEPT;
		713	+ CONSTCD11 date::month month() const NOEXCEPT;
		714	+ CONSTCD11 date::day day() const NOEXCEPT;
		715	+
		716	+ CONSTCD14 operator sys_days() const NOEXCEPT;
		717	+ CONSTCD14 explicit operator local_days() const NOEXCEPT;
		718	+ CONSTCD14 bool ok() const NOEXCEPT;
		719	+
		720	+private:
		721	+ static CONSTCD14 year_month_day from_days(days dp) NOEXCEPT;
		722	+ CONSTCD14 days to_days() const NOEXCEPT;
		723	+};
		724	+
		725	+CONSTCD11 bool operator==(const year_month_day& x, const year_month_day& y) NOEXCEPT;
		726	+CONSTCD11 bool operator!=(const year_month_day& x, const year_month_day& y) NOEXCEPT;
		727	+CONSTCD11 bool operator< (const year_month_day& x, const year_month_day& y) NOEXCEPT;
		728	+CONSTCD11 bool operator> (const year_month_day& x, const year_month_day& y) NOEXCEPT;
		729	+CONSTCD11 bool operator<=(const year_month_day& x, const year_month_day& y) NOEXCEPT;
		730	+CONSTCD11 bool operator>=(const year_month_day& x, const year_month_day& y) NOEXCEPT;
		731	+
		732	+template<class = detail::unspecified_month_disambiguator>
		733	+CONSTCD14 year_month_day operator+(const year_month_day& ymd, const months& dm) NOEXCEPT;
		734	+template<class = detail::unspecified_month_disambiguator>
		735	+CONSTCD14 year_month_day operator+(const months& dm, const year_month_day& ymd) NOEXCEPT;
		736	+template<class = detail::unspecified_month_disambiguator>
		737	+CONSTCD14 year_month_day operator-(const year_month_day& ymd, const months& dm) NOEXCEPT;
		738	+CONSTCD11 year_month_day operator+(const year_month_day& ymd, const years& dy) NOEXCEPT;
		739	+CONSTCD11 year_month_day operator+(const years& dy, const year_month_day& ymd) NOEXCEPT;
		740	+CONSTCD11 year_month_day operator-(const year_month_day& ymd, const years& dy) NOEXCEPT;
		741	+
		742	+template<class CharT, class Traits>
		743	+std::basic_ostream<CharT, Traits>&
		744	+operator<<(std::basic_ostream<CharT, Traits>& os, const year_month_day& ymd);
		745	+
		746	+// year_month_day_last
		747	+
		748	+class year_month_day_last
		749	+{
		750	+ date::year y_;
		751	+ date::month_day_last mdl_;
		752	+
		753	+public:
		754	+ CONSTCD11 year_month_day_last(const date::year& y,
		755	+ const date::month_day_last& mdl) NOEXCEPT;
		756	+
		757	+ template<class = detail::unspecified_month_disambiguator>
		758	+ CONSTCD14 year_month_day_last& operator+=(const months& m) NOEXCEPT;
		759	+ template<class = detail::unspecified_month_disambiguator>
		760	+ CONSTCD14 year_month_day_last& operator-=(const months& m) NOEXCEPT;
		761	+ CONSTCD14 year_month_day_last& operator+=(const years& y) NOEXCEPT;
		762	+ CONSTCD14 year_month_day_last& operator-=(const years& y) NOEXCEPT;
		763	+
		764	+ CONSTCD11 date::year year() const NOEXCEPT;
		765	+ CONSTCD11 date::month month() const NOEXCEPT;
		766	+ CONSTCD11 date::month_day_last month_day_last() const NOEXCEPT;
		767	+ CONSTCD14 date::day day() const NOEXCEPT;
		768	+
		769	+ CONSTCD14 operator sys_days() const NOEXCEPT;
		770	+ CONSTCD14 explicit operator local_days() const NOEXCEPT;
		771	+ CONSTCD11 bool ok() const NOEXCEPT;
		772	+};
		773	+
		774	+CONSTCD11
		775	+ bool operator==(const year_month_day_last& x, const year_month_day_last& y) NOEXCEPT;
		776	+CONSTCD11
		777	+ bool operator!=(const year_month_day_last& x, const year_month_day_last& y) NOEXCEPT;
		778	+CONSTCD11
		779	+ bool operator< (const year_month_day_last& x, const year_month_day_last& y) NOEXCEPT;
		780	+CONSTCD11
		781	+ bool operator> (const year_month_day_last& x, const year_month_day_last& y) NOEXCEPT;
		782	+CONSTCD11
		783	+ bool operator<=(const year_month_day_last& x, const year_month_day_last& y) NOEXCEPT;
		784	+CONSTCD11
		785	+ bool operator>=(const year_month_day_last& x, const year_month_day_last& y) NOEXCEPT;
		786	+
		787	+template<class = detail::unspecified_month_disambiguator>
		788	+CONSTCD14
		789	+year_month_day_last
		790	+operator+(const year_month_day_last& ymdl, const months& dm) NOEXCEPT;
		791	+
		792	+template<class = detail::unspecified_month_disambiguator>
		793	+CONSTCD14
		794	+year_month_day_last
		795	+operator+(const months& dm, const year_month_day_last& ymdl) NOEXCEPT;
		796	+
		797	+CONSTCD11
		798	+year_month_day_last
		799	+operator+(const year_month_day_last& ymdl, const years& dy) NOEXCEPT;
		800	+
		801	+CONSTCD11
		802	+year_month_day_last
		803	+operator+(const years& dy, const year_month_day_last& ymdl) NOEXCEPT;
		804	+
		805	+template<class = detail::unspecified_month_disambiguator>
		806	+CONSTCD14
		807	+year_month_day_last
		808	+operator-(const year_month_day_last& ymdl, const months& dm) NOEXCEPT;
		809	+
		810	+CONSTCD11
		811	+year_month_day_last
		812	+operator-(const year_month_day_last& ymdl, const years& dy) NOEXCEPT;
		813	+
		814	+template<class CharT, class Traits>
		815	+std::basic_ostream<CharT, Traits>&
		816	+operator<<(std::basic_ostream<CharT, Traits>& os, const year_month_day_last& ymdl);
		817	+
		818	+// year_month_weekday
		819	+
		820	+class year_month_weekday
		821	+{
		822	+ date::year y_;
		823	+ date::month m_;
		824	+ date::weekday_indexed wdi_;
		825	+
		826	+public:
		827	+ year_month_weekday() = default;
		828	+ CONSTCD11 year_month_weekday(const date::year& y, const date::month& m,
		829	+ const date::weekday_indexed& wdi) NOEXCEPT;
		830	+ CONSTCD14 year_month_weekday(const sys_days& dp) NOEXCEPT;
		831	+ CONSTCD14 explicit year_month_weekday(const local_days& dp) NOEXCEPT;
		832	+
		833	+ template<class = detail::unspecified_month_disambiguator>
		834	+ CONSTCD14 year_month_weekday& operator+=(const months& m) NOEXCEPT;
		835	+ template<class = detail::unspecified_month_disambiguator>
		836	+ CONSTCD14 year_month_weekday& operator-=(const months& m) NOEXCEPT;
		837	+ CONSTCD14 year_month_weekday& operator+=(const years& y) NOEXCEPT;
		838	+ CONSTCD14 year_month_weekday& operator-=(const years& y) NOEXCEPT;
		839	+
		840	+ CONSTCD11 date::year year() const NOEXCEPT;
		841	+ CONSTCD11 date::month month() const NOEXCEPT;
		842	+ CONSTCD11 date::weekday weekday() const NOEXCEPT;
		843	+ CONSTCD11 unsigned index() const NOEXCEPT;
		844	+ CONSTCD11 date::weekday_indexed weekday_indexed() const NOEXCEPT;
		845	+
		846	+ CONSTCD14 operator sys_days() const NOEXCEPT;
		847	+ CONSTCD14 explicit operator local_days() const NOEXCEPT;
		848	+ CONSTCD14 bool ok() const NOEXCEPT;
		849	+
		850	+private:
		851	+ static CONSTCD14 year_month_weekday from_days(days dp) NOEXCEPT;
		852	+ CONSTCD14 days to_days() const NOEXCEPT;
		853	+};
		854	+
		855	+CONSTCD11
		856	+ bool operator==(const year_month_weekday& x, const year_month_weekday& y) NOEXCEPT;
		857	+CONSTCD11
		858	+ bool operator!=(const year_month_weekday& x, const year_month_weekday& y) NOEXCEPT;
		859	+
		860	+template<class = detail::unspecified_month_disambiguator>
		861	+CONSTCD14
		862	+year_month_weekday
		863	+operator+(const year_month_weekday& ymwd, const months& dm) NOEXCEPT;
		864	+
		865	+template<class = detail::unspecified_month_disambiguator>
		866	+CONSTCD14
		867	+year_month_weekday
		868	+operator+(const months& dm, const year_month_weekday& ymwd) NOEXCEPT;
		869	+
		870	+CONSTCD11
		871	+year_month_weekday
		872	+operator+(const year_month_weekday& ymwd, const years& dy) NOEXCEPT;
		873	+
		874	+CONSTCD11
		875	+year_month_weekday
		876	+operator+(const years& dy, const year_month_weekday& ymwd) NOEXCEPT;
		877	+
		878	+template<class = detail::unspecified_month_disambiguator>
		879	+CONSTCD14
		880	+year_month_weekday
		881	+operator-(const year_month_weekday& ymwd, const months& dm) NOEXCEPT;
		882	+
		883	+CONSTCD11
		884	+year_month_weekday
		885	+operator-(const year_month_weekday& ymwd, const years& dy) NOEXCEPT;
		886	+
		887	+template<class CharT, class Traits>
		888	+std::basic_ostream<CharT, Traits>&
		889	+operator<<(std::basic_ostream<CharT, Traits>& os, const year_month_weekday& ymwdi);
		890	+
		891	+// year_month_weekday_last
		892	+
		893	+class year_month_weekday_last
		894	+{
		895	+ date::year y_;
		896	+ date::month m_;
		897	+ date::weekday_last wdl_;
		898	+
		899	+public:
		900	+ CONSTCD11 year_month_weekday_last(const date::year& y, const date::month& m,
		901	+ const date::weekday_last& wdl) NOEXCEPT;
		902	+
		903	+ template<class = detail::unspecified_month_disambiguator>
		904	+ CONSTCD14 year_month_weekday_last& operator+=(const months& m) NOEXCEPT;
		905	+ template<class = detail::unspecified_month_disambiguator>
		906	+ CONSTCD14 year_month_weekday_last& operator-=(const months& m) NOEXCEPT;
		907	+ CONSTCD14 year_month_weekday_last& operator+=(const years& y) NOEXCEPT;
		908	+ CONSTCD14 year_month_weekday_last& operator-=(const years& y) NOEXCEPT;
		909	+
		910	+ CONSTCD11 date::year year() const NOEXCEPT;
		911	+ CONSTCD11 date::month month() const NOEXCEPT;
		912	+ CONSTCD11 date::weekday weekday() const NOEXCEPT;
		913	+ CONSTCD11 date::weekday_last weekday_last() const NOEXCEPT;
		914	+
		915	+ CONSTCD14 operator sys_days() const NOEXCEPT;
		916	+ CONSTCD14 explicit operator local_days() const NOEXCEPT;
		917	+ CONSTCD11 bool ok() const NOEXCEPT;
		918	+
		919	+private:
		920	+ CONSTCD14 days to_days() const NOEXCEPT;
		921	+};
		922	+
		923	+CONSTCD11
		924	+bool
		925	+operator==(const year_month_weekday_last& x, const year_month_weekday_last& y) NOEXCEPT;
		926	+
		927	+CONSTCD11
		928	+bool
		929	+operator!=(const year_month_weekday_last& x, const year_month_weekday_last& y) NOEXCEPT;
		930	+
		931	+template<class = detail::unspecified_month_disambiguator>
		932	+CONSTCD14
		933	+year_month_weekday_last
		934	+operator+(const year_month_weekday_last& ymwdl, const months& dm) NOEXCEPT;
		935	+
		936	+template<class = detail::unspecified_month_disambiguator>
		937	+CONSTCD14
		938	+year_month_weekday_last
		939	+operator+(const months& dm, const year_month_weekday_last& ymwdl) NOEXCEPT;
		940	+
		941	+CONSTCD11
		942	+year_month_weekday_last
		943	+operator+(const year_month_weekday_last& ymwdl, const years& dy) NOEXCEPT;
		944	+
		945	+CONSTCD11
		946	+year_month_weekday_last
		947	+operator+(const years& dy, const year_month_weekday_last& ymwdl) NOEXCEPT;
		948	+
		949	+template<class = detail::unspecified_month_disambiguator>
		950	+CONSTCD14
		951	+year_month_weekday_last
		952	+operator-(const year_month_weekday_last& ymwdl, const months& dm) NOEXCEPT;
		953	+
		954	+CONSTCD11
		955	+year_month_weekday_last
		956	+operator-(const year_month_weekday_last& ymwdl, const years& dy) NOEXCEPT;
		957	+
		958	+template<class CharT, class Traits>
		959	+std::basic_ostream<CharT, Traits>&
		960	+operator<<(std::basic_ostream<CharT, Traits>& os, const year_month_weekday_last& ymwdl);
		961	+
		962	+#if !defined(_MSC_VER) \|\| (_MSC_VER >= 1900)
		963	+inline namespace literals
		964	+{
		965	+
		966	+CONSTCD11 date::day operator "" _d(unsigned long long d) NOEXCEPT;
		967	+CONSTCD11 date::year operator "" _y(unsigned long long y) NOEXCEPT;
		968	+
		969	+} // inline namespace literals
		970	+#endif // !defined(_MSC_VER) \|\| (_MSC_VER >= 1900)
		971	+
		972	+// CONSTDATA date::month January{1};
		973	+// CONSTDATA date::month February{2};
		974	+// CONSTDATA date::month March{3};
		975	+// CONSTDATA date::month April{4};
		976	+// CONSTDATA date::month May{5};
		977	+// CONSTDATA date::month June{6};
		978	+// CONSTDATA date::month July{7};
		979	+// CONSTDATA date::month August{8};
		980	+// CONSTDATA date::month September{9};
		981	+// CONSTDATA date::month October{10};
		982	+// CONSTDATA date::month November{11};
		983	+// CONSTDATA date::month December{12};
		984	+//
		985	+// CONSTDATA date::weekday Sunday{0u};
		986	+// CONSTDATA date::weekday Monday{1u};
		987	+// CONSTDATA date::weekday Tuesday{2u};
		988	+// CONSTDATA date::weekday Wednesday{3u};
		989	+// CONSTDATA date::weekday Thursday{4u};
		990	+// CONSTDATA date::weekday Friday{5u};
		991	+// CONSTDATA date::weekday Saturday{6u};
		992	+
		993	+#if HAS_VOID_T
		994	+
		995	+template <class T, class = std::void_t<>>
		996	+struct is_clock
		997	+ : std::false_type
		998	+{};
		999	+
		1000	+template <class T>
		1001	+struct is_clock<T, std::void_t<decltype(T::now()), typename T::rep, typename T::period,
		1002	+ typename T::duration, typename T::time_point,
		1003	+ decltype(T::is_steady)>>
		1004	+ : std::true_type
		1005	+{};
		1006	+
		1007	+template<class T> inline constexpr bool is_clock_v = is_clock<T>::value;
		1008	+
		1009	+#endif // HAS_VOID_T
		1010	+
		1011	+//----------------+
		1012	+// Implementation \|
		1013	+//----------------+
		1014	+
		1015	+// utilities
		1016	+namespace detail {
		1017	+
		1018	+template<class CharT, class Traits = std::char_traits<CharT>>
		1019	+class save_istream
		1020	+{
		1021	+protected:
		1022	+ std::basic_ios<CharT, Traits>& is_;
		1023	+ CharT fill_;
		1024	+ std::ios::fmtflags flags_;
		1025	+ std::streamsize precision_;
		1026	+ std::streamsize width_;
		1027	+ std::basic_ostream<CharT, Traits>* tie_;
		1028	+ std::locale loc_;
		1029	+
		1030	+public:
		1031	+ ~save_istream()
		1032	+ {
		1033	+ is_.fill(fill_);
		1034	+ is_.flags(flags_);
		1035	+ is_.precision(precision_);
		1036	+ is_.width(width_);
		1037	+ is_.imbue(loc_);
		1038	+ is_.tie(tie_);
		1039	+ }
		1040	+
		1041	+ save_istream(const save_istream&) = delete;
		1042	+ save_istream& operator=(const save_istream&) = delete;
		1043	+
		1044	+ explicit save_istream(std::basic_ios<CharT, Traits>& is)
		1045	+ : is_(is)
		1046	+ , fill_(is.fill())
		1047	+ , flags_(is.flags())
		1048	+ , precision_(is.precision())
		1049	+ , width_(is.width(0))
		1050	+ , tie_(is.tie(nullptr))
		1051	+ , loc_(is.getloc())
		1052	+ {
		1053	+ if (tie_ != nullptr)
		1054	+ tie_->flush();
		1055	+ }
		1056	+};
		1057	+
		1058	+template<class CharT, class Traits = std::char_traits<CharT>>
		1059	+class save_ostream
		1060	+ : private save_istream<CharT, Traits>
		1061	+{
		1062	+public:
		1063	+ ~save_ostream()
		1064	+ {
		1065	+ if ((this->flags_ & std::ios::unitbuf) &&
		1066	+#if HAS_UNCAUGHT_EXCEPTIONS
		1067	+ std::uncaught_exceptions() == 0 &&
		1068	+#else
		1069	+ !std::uncaught_exception() &&
		1070	+#endif
		1071	+ this->is_.good())
		1072	+ this->is_.rdbuf()->pubsync();
		1073	+ }
		1074	+
		1075	+ save_ostream(const save_ostream&) = delete;
		1076	+ save_ostream& operator=(const save_ostream&) = delete;
		1077	+
		1078	+ explicit save_ostream(std::basic_ios<CharT, Traits>& os)
		1079	+ : save_istream<CharT, Traits>(os)
		1080	+ {
		1081	+ }
		1082	+};
		1083	+
		1084	+template <class T>
		1085	+struct choose_trunc_type
		1086	+{
		1087	+ static const int digits = std::numeric_limits<T>::digits;
		1088	+ using type = typename std::conditional
		1089	+ <
		1090	+ digits < 32,
		1091	+ std::int32_t,
		1092	+ typename std::conditional
		1093	+ <
		1094	+ digits < 64,
		1095	+ std::int64_t,
		1096	+#ifdef __SIZEOF_INT128__
		1097	+ __int128
		1098	+#else
		1099	+ std::int64_t
		1100	+#endif
		1101	+ >::type
		1102	+ >::type;
		1103	+};
		1104	+
		1105	+template <class T>
		1106	+CONSTCD11
		1107	+inline
		1108	+typename std::enable_if
		1109	+<
		1110	+ !std::chrono::treat_as_floating_point<T>::value,
		1111	+ T
		1112	+>::type
		1113	+trunc(T t) NOEXCEPT
		1114	+{
		1115	+ return t;
		1116	+}
		1117	+
		1118	+template <class T>
		1119	+CONSTCD14
		1120	+inline
		1121	+typename std::enable_if
		1122	+<
		1123	+ std::chrono::treat_as_floating_point<T>::value,
		1124	+ T
		1125	+>::type
		1126	+trunc(T t) NOEXCEPT
		1127	+{
		1128	+ using std::numeric_limits;
		1129	+ using I = typename choose_trunc_type<T>::type;
		1130	+ CONSTDATA auto digits = numeric_limits<T>::digits;
		1131	+ static_assert(digits < numeric_limits<I>::digits, "");
		1132	+ CONSTDATA auto max = I{1} << (digits-1);
		1133	+ CONSTDATA auto min = -max;
		1134	+ const auto negative = t < T{0};
		1135	+ if (min <= t && t <= max && t != 0 && t == t)
		1136	+ {
		1137	+ t = static_cast<T>(static_cast<I>(t));
		1138	+ if (t == 0 && negative)
		1139	+ t = -t;
		1140	+ }
		1141	+ return t;
		1142	+}
		1143	+
		1144	+template <std::intmax_t Xp, std::intmax_t Yp>
		1145	+struct static_gcd
		1146	+{
		1147	+ static const std::intmax_t value = static_gcd<Yp, Xp % Yp>::value;
		1148	+};
		1149	+
		1150	+template <std::intmax_t Xp>
		1151	+struct static_gcd<Xp, 0>
		1152	+{
		1153	+ static const std::intmax_t value = Xp;
		1154	+};
		1155	+
		1156	+template <>
		1157	+struct static_gcd<0, 0>
		1158	+{
		1159	+ static const std::intmax_t value = 1;
		1160	+};
		1161	+
		1162	+template <class R1, class R2>
		1163	+struct no_overflow
		1164	+{
		1165	+private:
		1166	+ static const std::intmax_t gcd_n1_n2 = static_gcd<R1::num, R2::num>::value;
		1167	+ static const std::intmax_t gcd_d1_d2 = static_gcd<R1::den, R2::den>::value;
		1168	+ static const std::intmax_t n1 = R1::num / gcd_n1_n2;
		1169	+ static const std::intmax_t d1 = R1::den / gcd_d1_d2;
		1170	+ static const std::intmax_t n2 = R2::num / gcd_n1_n2;
		1171	+ static const std::intmax_t d2 = R2::den / gcd_d1_d2;
		1172	+#ifdef __cpp_constexpr
		1173	+ static const std::intmax_t max = std::numeric_limits<std::intmax_t>::max();
		1174	+#else
		1175	+ static const std::intmax_t max = LLONG_MAX;
		1176	+#endif
		1177	+
		1178	+ template <std::intmax_t Xp, std::intmax_t Yp, bool overflow>
		1179	+ struct mul // overflow == false
		1180	+ {
		1181	+ static const std::intmax_t value = Xp * Yp;
		1182	+ };
		1183	+
		1184	+ template <std::intmax_t Xp, std::intmax_t Yp>
		1185	+ struct mul<Xp, Yp, true>
		1186	+ {
		1187	+ static const std::intmax_t value = 1;
		1188	+ };
		1189	+
		1190	+public:
		1191	+ static const bool value = (n1 <= max / d2) && (n2 <= max / d1);
		1192	+ typedef std::ratio<mul<n1, d2, !value>::value,
		1193	+ mul<n2, d1, !value>::value> type;
		1194	+};
		1195	+
		1196	+} // detail
		1197	+
		1198	+// trunc towards zero
		1199	+template <class To, class Rep, class Period>
		1200	+CONSTCD11
		1201	+inline
		1202	+typename std::enable_if
		1203	+<
		1204	+ detail::no_overflow<Period, typename To::period>::value,
		1205	+ To
		1206	+>::type
		1207	+trunc(const std::chrono::duration<Rep, Period>& d)
		1208	+{
		1209	+ return To{detail::trunc(std::chrono::duration_cast<To>(d).count())};
		1210	+}
		1211	+
		1212	+template <class To, class Rep, class Period>
		1213	+CONSTCD11
		1214	+inline
		1215	+typename std::enable_if
		1216	+<
		1217	+ !detail::no_overflow<Period, typename To::period>::value,
		1218	+ To
		1219	+>::type
		1220	+trunc(const std::chrono::duration<Rep, Period>& d)
		1221	+{
		1222	+ using std::chrono::duration_cast;
		1223	+ using std::chrono::duration;
		1224	+ using rep = typename std::common_type<Rep, typename To::rep>::type;
		1225	+ return To{detail::trunc(duration_cast<To>(duration_cast<duration<rep>>(d)).count())};
		1226	+}
		1227	+
		1228	+#ifndef HAS_CHRONO_ROUNDING
		1229	+# if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 190023918 \|\| (_MSC_FULL_VER >= 190000000 && defined (__clang__)))
		1230	+# define HAS_CHRONO_ROUNDING 1
		1231	+# elif defined(__cpp_lib_chrono) && __cplusplus > 201402 && __cpp_lib_chrono >= 201510
		1232	+# define HAS_CHRONO_ROUNDING 1
		1233	+# elif defined(_LIBCPP_VERSION) && __cplusplus > 201402 && _LIBCPP_VERSION >= 3800
		1234	+# define HAS_CHRONO_ROUNDING 1
		1235	+# else
		1236	+# define HAS_CHRONO_ROUNDING 0
		1237	+# endif
		1238	+#endif // HAS_CHRONO_ROUNDING
		1239	+
		1240	+#if HAS_CHRONO_ROUNDING == 0
		1241	+
		1242	+// round down
		1243	+template <class To, class Rep, class Period>
		1244	+CONSTCD14
		1245	+inline
		1246	+typename std::enable_if
		1247	+<
		1248	+ detail::no_overflow<Period, typename To::period>::value,
		1249	+ To
		1250	+>::type
		1251	+floor(const std::chrono::duration<Rep, Period>& d)
		1252	+{
		1253	+ auto t = trunc<To>(d);
		1254	+ if (t > d)
		1255	+ return t - To{1};
		1256	+ return t;
		1257	+}
		1258	+
		1259	+template <class To, class Rep, class Period>
		1260	+CONSTCD14
		1261	+inline
		1262	+typename std::enable_if
		1263	+<
		1264	+ !detail::no_overflow<Period, typename To::period>::value,
		1265	+ To
		1266	+>::type
		1267	+floor(const std::chrono::duration<Rep, Period>& d)
		1268	+{
		1269	+ using rep = typename std::common_type<Rep, typename To::rep>::type;
		1270	+ return floor<To>(floor<std::chrono::duration<rep>>(d));
		1271	+}
		1272	+
		1273	+// round to nearest, to even on tie
		1274	+template <class To, class Rep, class Period>
		1275	+CONSTCD14
		1276	+inline
		1277	+To
		1278	+round(const std::chrono::duration<Rep, Period>& d)
		1279	+{
		1280	+ auto t0 = floor<To>(d);
		1281	+ auto t1 = t0 + To{1};
		1282	+ if (t1 == To{0} && t0 < To{0})
		1283	+ t1 = -t1;
		1284	+ auto diff0 = d - t0;
		1285	+ auto diff1 = t1 - d;
		1286	+ if (diff0 == diff1)
		1287	+ {
		1288	+ if (t0 - trunc<To>(t0/2)*2 == To{0})
		1289	+ return t0;
		1290	+ return t1;
		1291	+ }
		1292	+ if (diff0 < diff1)
		1293	+ return t0;
		1294	+ return t1;
		1295	+}
		1296	+
		1297	+// round up
		1298	+template <class To, class Rep, class Period>
		1299	+CONSTCD14
		1300	+inline
		1301	+To
		1302	+ceil(const std::chrono::duration<Rep, Period>& d)
		1303	+{
		1304	+ auto t = trunc<To>(d);
		1305	+ if (t < d)
		1306	+ return t + To{1};
		1307	+ return t;
		1308	+}
		1309	+
		1310	+template <class Rep, class Period,
		1311	+ class = typename std::enable_if
		1312	+ <
		1313	+ std::numeric_limits<Rep>::is_signed
		1314	+ >::type>
		1315	+CONSTCD11
		1316	+std::chrono::duration<Rep, Period>
		1317	+abs(std::chrono::duration<Rep, Period> d)
		1318	+{
		1319	+ return d >= d.zero() ? d : -d;
		1320	+}
		1321	+
		1322	+// round down
		1323	+template <class To, class Clock, class FromDuration>
		1324	+CONSTCD11
		1325	+inline
		1326	+std::chrono::time_point<Clock, To>
		1327	+floor(const std::chrono::time_point<Clock, FromDuration>& tp)
		1328	+{
		1329	+ using std::chrono::time_point;
		1330	+ return time_point<Clock, To>{date::floor<To>(tp.time_since_epoch())};
		1331	+}
		1332	+
		1333	+// round to nearest, to even on tie
		1334	+template <class To, class Clock, class FromDuration>
		1335	+CONSTCD11
		1336	+inline
		1337	+std::chrono::time_point<Clock, To>
		1338	+round(const std::chrono::time_point<Clock, FromDuration>& tp)
		1339	+{
		1340	+ using std::chrono::time_point;
		1341	+ return time_point<Clock, To>{round<To>(tp.time_since_epoch())};
		1342	+}
		1343	+
		1344	+// round up
		1345	+template <class To, class Clock, class FromDuration>
		1346	+CONSTCD11
		1347	+inline
		1348	+std::chrono::time_point<Clock, To>
		1349	+ceil(const std::chrono::time_point<Clock, FromDuration>& tp)
		1350	+{
		1351	+ using std::chrono::time_point;
		1352	+ return time_point<Clock, To>{ceil<To>(tp.time_since_epoch())};
		1353	+}
		1354	+
		1355	+#else // HAS_CHRONO_ROUNDING == 1
		1356	+
		1357	+using std::chrono::floor;
		1358	+using std::chrono::ceil;
		1359	+using std::chrono::round;
		1360	+using std::chrono::abs;
		1361	+
		1362	+#endif // HAS_CHRONO_ROUNDING
		1363	+
		1364	+namespace detail
		1365	+{
		1366	+
		1367	+template <class To, class Rep, class Period>
		1368	+CONSTCD14
		1369	+inline
		1370	+typename std::enable_if
		1371	+<
		1372	+ !std::chrono::treat_as_floating_point<typename To::rep>::value,
		1373	+ To
		1374	+>::type
		1375	+round_i(const std::chrono::duration<Rep, Period>& d)
		1376	+{
		1377	+ return round<To>(d);
		1378	+}
		1379	+
		1380	+template <class To, class Rep, class Period>
		1381	+CONSTCD14
		1382	+inline
		1383	+typename std::enable_if
		1384	+<
		1385	+ std::chrono::treat_as_floating_point<typename To::rep>::value,
		1386	+ To
		1387	+>::type
		1388	+round_i(const std::chrono::duration<Rep, Period>& d)
		1389	+{
		1390	+ return d;
		1391	+}
		1392	+
		1393	+template <class To, class Clock, class FromDuration>
		1394	+CONSTCD11
		1395	+inline
		1396	+std::chrono::time_point<Clock, To>
		1397	+round_i(const std::chrono::time_point<Clock, FromDuration>& tp)
		1398	+{
		1399	+ using std::chrono::time_point;
		1400	+ return time_point<Clock, To>{round_i<To>(tp.time_since_epoch())};
		1401	+}
		1402	+
		1403	+} // detail
		1404	+
		1405	+// trunc towards zero
		1406	+template <class To, class Clock, class FromDuration>
		1407	+CONSTCD11
		1408	+inline
		1409	+std::chrono::time_point<Clock, To>
		1410	+trunc(const std::chrono::time_point<Clock, FromDuration>& tp)
		1411	+{
		1412	+ using std::chrono::time_point;
		1413	+ return time_point<Clock, To>{trunc<To>(tp.time_since_epoch())};
		1414	+}
		1415	+
		1416	+// day
		1417	+
		1418	+CONSTCD11 inline day::day(unsigned d) NOEXCEPT : d_(static_cast<decltype(d_)>(d)) {}
		1419	+CONSTCD14 inline day& day::operator++() NOEXCEPT {++d_; return *this;}
		1420	+CONSTCD14 inline day day::operator++(int) NOEXCEPT {auto tmp(this); ++(this); return tmp;}
		1421	+CONSTCD14 inline day& day::operator--() NOEXCEPT {--d_; return *this;}
		1422	+CONSTCD14 inline day day::operator--(int) NOEXCEPT {auto tmp(this); --(this); return tmp;}
		1423	+CONSTCD14 inline day& day::operator+=(const days& d) NOEXCEPT {this = this + d; return *this;}
		1424	+CONSTCD14 inline day& day::operator-=(const days& d) NOEXCEPT {this = this - d; return *this;}
		1425	+CONSTCD11 inline day::operator unsigned() const NOEXCEPT {return d_;}
		1426	+CONSTCD11 inline bool day::ok() const NOEXCEPT {return 1 <= d_ && d_ <= 31;}
		1427	+
		1428	+CONSTCD11
		1429	+inline
		1430	+bool
		1431	+operator==(const day& x, const day& y) NOEXCEPT
		1432	+{
		1433	+ return static_cast<unsigned>(x) == static_cast<unsigned>(y);
		1434	+}
		1435	+
		1436	+CONSTCD11
		1437	+inline
		1438	+bool
		1439	+operator!=(const day& x, const day& y) NOEXCEPT
		1440	+{
		1441	+ return !(x == y);
		1442	+}
		1443	+
		1444	+CONSTCD11
		1445	+inline
		1446	+bool
		1447	+operator<(const day& x, const day& y) NOEXCEPT
		1448	+{
		1449	+ return static_cast<unsigned>(x) < static_cast<unsigned>(y);
		1450	+}
		1451	+
		1452	+CONSTCD11
		1453	+inline
		1454	+bool
		1455	+operator>(const day& x, const day& y) NOEXCEPT
		1456	+{
		1457	+ return y < x;
		1458	+}
		1459	+
		1460	+CONSTCD11
		1461	+inline
		1462	+bool
		1463	+operator<=(const day& x, const day& y) NOEXCEPT
		1464	+{
		1465	+ return !(y < x);
		1466	+}
		1467	+
		1468	+CONSTCD11
		1469	+inline
		1470	+bool
		1471	+operator>=(const day& x, const day& y) NOEXCEPT
		1472	+{
		1473	+ return !(x < y);
		1474	+}
		1475	+
		1476	+CONSTCD11
		1477	+inline
		1478	+days
		1479	+operator-(const day& x, const day& y) NOEXCEPT
		1480	+{
		1481	+ return days{static_cast<days::rep>(static_cast<unsigned>(x)
		1482	+ - static_cast<unsigned>(y))};
		1483	+}
		1484	+
		1485	+CONSTCD11
		1486	+inline
		1487	+day
		1488	+operator+(const day& x, const days& y) NOEXCEPT
		1489	+{
		1490	+ return day{static_cast<unsigned>(x) + static_cast<unsigned>(y.count())};
		1491	+}
		1492	+
		1493	+CONSTCD11
		1494	+inline
		1495	+day
		1496	+operator+(const days& x, const day& y) NOEXCEPT
		1497	+{
		1498	+ return y + x;
		1499	+}
		1500	+
		1501	+CONSTCD11
		1502	+inline
		1503	+day
		1504	+operator-(const day& x, const days& y) NOEXCEPT
		1505	+{
		1506	+ return x + -y;
		1507	+}
		1508	+
		1509	+namespace detail
		1510	+{
		1511	+
		1512	+template<class CharT, class Traits>
		1513	+std::basic_ostream<CharT, Traits>&
		1514	+low_level_fmt(std::basic_ostream<CharT, Traits>& os, const day& d)
		1515	+{
		1516	+ detail::save_ostream<CharT, Traits> _(os);
		1517	+ os.fill('0');
		1518	+ os.flags(std::ios::dec \| std::ios::right);
		1519	+ os.width(2);
		1520	+ os << static_cast<unsigned>(d);
		1521	+ return os;
		1522	+}
		1523	+
		1524	+} // namespace detail
		1525	+
		1526	+template<class CharT, class Traits>
		1527	+inline
		1528	+std::basic_ostream<CharT, Traits>&
		1529	+operator<<(std::basic_ostream<CharT, Traits>& os, const day& d)
		1530	+{
		1531	+ detail::low_level_fmt(os, d);
		1532	+ if (!d.ok())
		1533	+ os << " is not a valid day";
		1534	+ return os;
		1535	+}
		1536	+
		1537	+// month
		1538	+
		1539	+CONSTCD11 inline month::month(unsigned m) NOEXCEPT : m_(static_cast<decltype(m_)>(m)) {}
		1540	+CONSTCD14 inline month& month::operator++() NOEXCEPT {this += months{1}; return this;}
		1541	+CONSTCD14 inline month month::operator++(int) NOEXCEPT {auto tmp(this); ++(this); return tmp;}
		1542	+CONSTCD14 inline month& month::operator--() NOEXCEPT {this -= months{1}; return this;}
		1543	+CONSTCD14 inline month month::operator--(int) NOEXCEPT {auto tmp(this); --(this); return tmp;}
		1544	+
		1545	+CONSTCD14
		1546	+inline
		1547	+month&
		1548	+month::operator+=(const months& m) NOEXCEPT
		1549	+{
		1550	+ this = this + m;
		1551	+ return *this;
		1552	+}
		1553	+
		1554	+CONSTCD14
		1555	+inline
		1556	+month&
		1557	+month::operator-=(const months& m) NOEXCEPT
		1558	+{
		1559	+ this = this - m;
		1560	+ return *this;
		1561	+}
		1562	+
		1563	+CONSTCD11 inline month::operator unsigned() const NOEXCEPT {return m_;}
		1564	+CONSTCD11 inline bool month::ok() const NOEXCEPT {return 1 <= m_ && m_ <= 12;}
		1565	+
		1566	+CONSTCD11
		1567	+inline
		1568	+bool
		1569	+operator==(const month& x, const month& y) NOEXCEPT
		1570	+{
		1571	+ return static_cast<unsigned>(x) == static_cast<unsigned>(y);
		1572	+}
		1573	+
		1574	+CONSTCD11
		1575	+inline
		1576	+bool
		1577	+operator!=(const month& x, const month& y) NOEXCEPT
		1578	+{
		1579	+ return !(x == y);
		1580	+}
		1581	+
		1582	+CONSTCD11
		1583	+inline
		1584	+bool
		1585	+operator<(const month& x, const month& y) NOEXCEPT
		1586	+{
		1587	+ return static_cast<unsigned>(x) < static_cast<unsigned>(y);
		1588	+}
		1589	+
		1590	+CONSTCD11
		1591	+inline
		1592	+bool
		1593	+operator>(const month& x, const month& y) NOEXCEPT
		1594	+{
		1595	+ return y < x;
		1596	+}
		1597	+
		1598	+CONSTCD11
		1599	+inline
		1600	+bool
		1601	+operator<=(const month& x, const month& y) NOEXCEPT
		1602	+{
		1603	+ return !(y < x);
		1604	+}
		1605	+
		1606	+CONSTCD11
		1607	+inline
		1608	+bool
		1609	+operator>=(const month& x, const month& y) NOEXCEPT
		1610	+{
		1611	+ return !(x < y);
		1612	+}
		1613	+
		1614	+CONSTCD14
		1615	+inline
		1616	+months
		1617	+operator-(const month& x, const month& y) NOEXCEPT
		1618	+{
		1619	+ auto const d = static_cast<unsigned>(x) - static_cast<unsigned>(y);
		1620	+ return months(d <= 11 ? d : d + 12);
		1621	+}
		1622	+
		1623	+CONSTCD14
		1624	+inline
		1625	+month
		1626	+operator+(const month& x, const months& y) NOEXCEPT
		1627	+{
		1628	+ auto const mu = static_cast<long long>(static_cast<unsigned>(x)) + y.count() - 1;
		1629	+ auto const yr = (mu >= 0 ? mu : mu-11) / 12;
		1630	+ return month{static_cast<unsigned>(mu - yr * 12 + 1)};
		1631	+}
		1632	+
		1633	+CONSTCD14
		1634	+inline
		1635	+month
		1636	+operator+(const months& x, const month& y) NOEXCEPT
		1637	+{
		1638	+ return y + x;
		1639	+}
		1640	+
		1641	+CONSTCD14
		1642	+inline
		1643	+month
		1644	+operator-(const month& x, const months& y) NOEXCEPT
		1645	+{
		1646	+ return x + -y;
		1647	+}
		1648	+
		1649	+namespace detail
		1650	+{
		1651	+
		1652	+template<class CharT, class Traits>
		1653	+std::basic_ostream<CharT, Traits>&
		1654	+low_level_fmt(std::basic_ostream<CharT, Traits>& os, const month& m)
		1655	+{
		1656	+ if (m.ok())
		1657	+ {
		1658	+ CharT fmt[] = {'%', 'b', 0};
		1659	+ os << format(os.getloc(), fmt, m);
		1660	+ }
		1661	+ else
		1662	+ os << static_cast<unsigned>(m);
		1663	+ return os;
		1664	+}
		1665	+
		1666	+} // namespace detail
		1667	+
		1668	+template<class CharT, class Traits>
		1669	+inline
		1670	+std::basic_ostream<CharT, Traits>&
		1671	+operator<<(std::basic_ostream<CharT, Traits>& os, const month& m)
		1672	+{
		1673	+ detail::low_level_fmt(os, m);
		1674	+ if (!m.ok())
		1675	+ os << " is not a valid month";
		1676	+ return os;
		1677	+}
		1678	+
		1679	+// year
		1680	+
		1681	+CONSTCD11 inline year::year(int y) NOEXCEPT : y_(static_cast<decltype(y_)>(y)) {}
		1682	+CONSTCD14 inline year& year::operator++() NOEXCEPT {++y_; return *this;}
		1683	+CONSTCD14 inline year year::operator++(int) NOEXCEPT {auto tmp(this); ++(this); return tmp;}
		1684	+CONSTCD14 inline year& year::operator--() NOEXCEPT {--y_; return *this;}
		1685	+CONSTCD14 inline year year::operator--(int) NOEXCEPT {auto tmp(this); --(this); return tmp;}
		1686	+CONSTCD14 inline year& year::operator+=(const years& y) NOEXCEPT {this = this + y; return *this;}
		1687	+CONSTCD14 inline year& year::operator-=(const years& y) NOEXCEPT {this = this - y; return *this;}
		1688	+CONSTCD11 inline year year::operator-() const NOEXCEPT {return year{-y_};}
		1689	+CONSTCD11 inline year year::operator+() const NOEXCEPT {return *this;}
		1690	+
		1691	+CONSTCD11
		1692	+inline
		1693	+bool
		1694	+year::is_leap() const NOEXCEPT
		1695	+{
		1696	+ return y_ % 4 == 0 && (y_ % 100 != 0 \|\| y_ % 400 == 0);
		1697	+}
		1698	+
		1699	+CONSTCD11 inline year::operator int() const NOEXCEPT {return y_;}
		1700	+
		1701	+CONSTCD11
		1702	+inline
		1703	+bool
		1704	+year::ok() const NOEXCEPT
		1705	+{
		1706	+ return y_ != std::numeric_limits<short>::min();
		1707	+}
		1708	+
		1709	+CONSTCD11
		1710	+inline
		1711	+bool
		1712	+operator==(const year& x, const year& y) NOEXCEPT
		1713	+{
		1714	+ return static_cast<int>(x) == static_cast<int>(y);
		1715	+}
		1716	+
		1717	+CONSTCD11
		1718	+inline
		1719	+bool
		1720	+operator!=(const year& x, const year& y) NOEXCEPT
		1721	+{
		1722	+ return !(x == y);
		1723	+}
		1724	+
		1725	+CONSTCD11
		1726	+inline
		1727	+bool
		1728	+operator<(const year& x, const year& y) NOEXCEPT
		1729	+{
		1730	+ return static_cast<int>(x) < static_cast<int>(y);
		1731	+}
		1732	+
		1733	+CONSTCD11
		1734	+inline
		1735	+bool
		1736	+operator>(const year& x, const year& y) NOEXCEPT
		1737	+{
		1738	+ return y < x;
		1739	+}
		1740	+
		1741	+CONSTCD11
		1742	+inline
		1743	+bool
		1744	+operator<=(const year& x, const year& y) NOEXCEPT
		1745	+{
		1746	+ return !(y < x);
		1747	+}
		1748	+
		1749	+CONSTCD11
		1750	+inline
		1751	+bool
		1752	+operator>=(const year& x, const year& y) NOEXCEPT
		1753	+{
		1754	+ return !(x < y);
		1755	+}
		1756	+
		1757	+CONSTCD11
		1758	+inline
		1759	+years
		1760	+operator-(const year& x, const year& y) NOEXCEPT
		1761	+{
		1762	+ return years{static_cast<int>(x) - static_cast<int>(y)};
		1763	+}
		1764	+
		1765	+CONSTCD11
		1766	+inline
		1767	+year
		1768	+operator+(const year& x, const years& y) NOEXCEPT
		1769	+{
		1770	+ return year{static_cast<int>(x) + y.count()};
		1771	+}
		1772	+
		1773	+CONSTCD11
		1774	+inline
		1775	+year
		1776	+operator+(const years& x, const year& y) NOEXCEPT
		1777	+{
		1778	+ return y + x;
		1779	+}
		1780	+
		1781	+CONSTCD11
		1782	+inline
		1783	+year
		1784	+operator-(const year& x, const years& y) NOEXCEPT
		1785	+{
		1786	+ return year{static_cast<int>(x) - y.count()};
		1787	+}
		1788	+
		1789	+namespace detail
		1790	+{
		1791	+
		1792	+template<class CharT, class Traits>
		1793	+std::basic_ostream<CharT, Traits>&
		1794	+low_level_fmt(std::basic_ostream<CharT, Traits>& os, const year& y)
		1795	+{
		1796	+ detail::save_ostream<CharT, Traits> _(os);
		1797	+ os.fill('0');
		1798	+ os.flags(std::ios::dec \| std::ios::internal);
		1799	+ os.width(4 + (y < year{0}));
		1800	+ os.imbue(std::locale::classic());
		1801	+ os << static_cast<int>(y);
		1802	+ return os;
		1803	+}
		1804	+
		1805	+} // namespace detail
		1806	+
		1807	+template<class CharT, class Traits>
		1808	+inline
		1809	+std::basic_ostream<CharT, Traits>&
		1810	+operator<<(std::basic_ostream<CharT, Traits>& os, const year& y)
		1811	+{
		1812	+ detail::low_level_fmt(os, y);
		1813	+ if (!y.ok())
		1814	+ os << " is not a valid year";
		1815	+ return os;
		1816	+}
		1817	+
		1818	+// weekday
		1819	+
		1820	+CONSTCD14
		1821	+inline
		1822	+unsigned char
		1823	+weekday::weekday_from_days(int z) NOEXCEPT
		1824	+{
		1825	+ auto u = static_cast<unsigned>(z);
		1826	+ return static_cast<unsigned char>(z >= -4 ? (u+4) % 7 : u % 7);
		1827	+}
		1828	+
		1829	+CONSTCD11
		1830	+inline
		1831	+weekday::weekday(unsigned wd) NOEXCEPT
		1832	+ : wd_(static_cast<decltype(wd_)>(wd != 7 ? wd : 0))
		1833	+ {}
		1834	+
		1835	+CONSTCD14
		1836	+inline
		1837	+weekday::weekday(const sys_days& dp) NOEXCEPT
		1838	+ : wd_(weekday_from_days(dp.time_since_epoch().count()))
		1839	+ {}
		1840	+
		1841	+CONSTCD14
		1842	+inline
		1843	+weekday::weekday(const local_days& dp) NOEXCEPT
		1844	+ : wd_(weekday_from_days(dp.time_since_epoch().count()))
		1845	+ {}
		1846	+
		1847	+CONSTCD14 inline weekday& weekday::operator++() NOEXCEPT {this += days{1}; return this;}
		1848	+CONSTCD14 inline weekday weekday::operator++(int) NOEXCEPT {auto tmp(this); ++(this); return tmp;}
		1849	+CONSTCD14 inline weekday& weekday::operator--() NOEXCEPT {this -= days{1}; return this;}
		1850	+CONSTCD14 inline weekday weekday::operator--(int) NOEXCEPT {auto tmp(this); --(this); return tmp;}
		1851	+
		1852	+CONSTCD14
		1853	+inline
		1854	+weekday&
		1855	+weekday::operator+=(const days& d) NOEXCEPT
		1856	+{
		1857	+ this = this + d;
		1858	+ return *this;
		1859	+}
		1860	+
		1861	+CONSTCD14
		1862	+inline
		1863	+weekday&
		1864	+weekday::operator-=(const days& d) NOEXCEPT
		1865	+{
		1866	+ this = this - d;
		1867	+ return *this;
		1868	+}
		1869	+
		1870	+CONSTCD11 inline bool weekday::ok() const NOEXCEPT {return wd_ <= 6;}
		1871	+
		1872	+CONSTCD11
		1873	+inline
		1874	+unsigned weekday::c_encoding() const NOEXCEPT
		1875	+{
		1876	+ return unsigned{wd_};
		1877	+}
		1878	+
		1879	+CONSTCD11
		1880	+inline
		1881	+unsigned weekday::iso_encoding() const NOEXCEPT
		1882	+{
		1883	+ return unsigned{((wd_ == 0u) ? 7u : wd_)};
		1884	+}
		1885	+
		1886	+CONSTCD11
		1887	+inline
		1888	+bool
		1889	+operator==(const weekday& x, const weekday& y) NOEXCEPT
		1890	+{
		1891	+ return x.wd_ == y.wd_;
		1892	+}
		1893	+
		1894	+CONSTCD11
		1895	+inline
		1896	+bool
		1897	+operator!=(const weekday& x, const weekday& y) NOEXCEPT
		1898	+{
		1899	+ return !(x == y);
		1900	+}
		1901	+
		1902	+CONSTCD14
		1903	+inline
		1904	+days
		1905	+operator-(const weekday& x, const weekday& y) NOEXCEPT
		1906	+{
		1907	+ auto const wdu = x.wd_ - y.wd_;
		1908	+ auto const wk = (wdu >= 0 ? wdu : wdu-6) / 7;
		1909	+ return days{wdu - wk * 7};
		1910	+}
		1911	+
		1912	+CONSTCD14
		1913	+inline
		1914	+weekday
		1915	+operator+(const weekday& x, const days& y) NOEXCEPT
		1916	+{
		1917	+ auto const wdu = static_cast<long long>(static_cast<unsigned>(x.wd_)) + y.count();
		1918	+ auto const wk = (wdu >= 0 ? wdu : wdu-6) / 7;
		1919	+ return weekday{static_cast<unsigned>(wdu - wk * 7)};
		1920	+}
		1921	+
		1922	+CONSTCD14
		1923	+inline
		1924	+weekday
		1925	+operator+(const days& x, const weekday& y) NOEXCEPT
		1926	+{
		1927	+ return y + x;
		1928	+}
		1929	+
		1930	+CONSTCD14
		1931	+inline
		1932	+weekday
		1933	+operator-(const weekday& x, const days& y) NOEXCEPT
		1934	+{
		1935	+ return x + -y;
		1936	+}
		1937	+
		1938	+namespace detail
		1939	+{
		1940	+
		1941	+template<class CharT, class Traits>
		1942	+std::basic_ostream<CharT, Traits>&
		1943	+low_level_fmt(std::basic_ostream<CharT, Traits>& os, const weekday& wd)
		1944	+{
		1945	+ if (wd.ok())
		1946	+ {
		1947	+ CharT fmt[] = {'%', 'a', 0};
		1948	+ os << format(fmt, wd);
		1949	+ }
		1950	+ else
		1951	+ os << wd.c_encoding();
		1952	+ return os;
		1953	+}
		1954	+
		1955	+} // namespace detail
		1956	+
		1957	+template<class CharT, class Traits>
		1958	+inline
		1959	+std::basic_ostream<CharT, Traits>&
		1960	+operator<<(std::basic_ostream<CharT, Traits>& os, const weekday& wd)
		1961	+{
		1962	+ detail::low_level_fmt(os, wd);
		1963	+ if (!wd.ok())
		1964	+ os << " is not a valid weekday";
		1965	+ return os;
		1966	+}
		1967	+
		1968	+#if !defined(_MSC_VER) \|\| (_MSC_VER >= 1900)
		1969	+inline namespace literals
		1970	+{
		1971	+
		1972	+CONSTCD11
		1973	+inline
		1974	+date::day
		1975	+operator "" _d(unsigned long long d) NOEXCEPT
		1976	+{
		1977	+ return date::day{static_cast<unsigned>(d)};
		1978	+}
		1979	+
		1980	+CONSTCD11
		1981	+inline
		1982	+date::year
		1983	+operator "" _y(unsigned long long y) NOEXCEPT
		1984	+{
		1985	+ return date::year(static_cast<int>(y));
		1986	+}
		1987	+#endif // !defined(_MSC_VER) \|\| (_MSC_VER >= 1900)
		1988	+
		1989	+CONSTDATA date::last_spec last{};
		1990	+
		1991	+CONSTDATA date::month jan{1};
		1992	+CONSTDATA date::month feb{2};
		1993	+CONSTDATA date::month mar{3};
		1994	+CONSTDATA date::month apr{4};
		1995	+CONSTDATA date::month may{5};
		1996	+CONSTDATA date::month jun{6};
		1997	+CONSTDATA date::month jul{7};
		1998	+CONSTDATA date::month aug{8};
		1999	+CONSTDATA date::month sep{9};
		2000	+CONSTDATA date::month oct{10};
		2001	+CONSTDATA date::month nov{11};
		2002	+CONSTDATA date::month dec{12};
		2003	+
		2004	+CONSTDATA date::weekday sun{0u};
		2005	+CONSTDATA date::weekday mon{1u};
		2006	+CONSTDATA date::weekday tue{2u};
		2007	+CONSTDATA date::weekday wed{3u};
		2008	+CONSTDATA date::weekday thu{4u};
		2009	+CONSTDATA date::weekday fri{5u};
		2010	+CONSTDATA date::weekday sat{6u};
		2011	+
		2012	+#if !defined(_MSC_VER) \|\| (_MSC_VER >= 1900)
		2013	+} // inline namespace literals
		2014	+#endif
		2015	+
		2016	+CONSTDATA date::month January{1};
		2017	+CONSTDATA date::month February{2};
		2018	+CONSTDATA date::month March{3};
		2019	+CONSTDATA date::month April{4};
		2020	+CONSTDATA date::month May{5};
		2021	+CONSTDATA date::month June{6};
		2022	+CONSTDATA date::month July{7};
		2023	+CONSTDATA date::month August{8};
		2024	+CONSTDATA date::month September{9};
		2025	+CONSTDATA date::month October{10};
		2026	+CONSTDATA date::month November{11};
		2027	+CONSTDATA date::month December{12};
		2028	+
		2029	+CONSTDATA date::weekday Monday{1};
		2030	+CONSTDATA date::weekday Tuesday{2};
		2031	+CONSTDATA date::weekday Wednesday{3};
		2032	+CONSTDATA date::weekday Thursday{4};
		2033	+CONSTDATA date::weekday Friday{5};
		2034	+CONSTDATA date::weekday Saturday{6};
		2035	+CONSTDATA date::weekday Sunday{7};
		2036	+
		2037	+// weekday_indexed
		2038	+
		2039	+CONSTCD11
		2040	+inline
		2041	+weekday
		2042	+weekday_indexed::weekday() const NOEXCEPT
		2043	+{
		2044	+ return date::weekday{static_cast<unsigned>(wd_)};
		2045	+}
		2046	+
		2047	+CONSTCD11 inline unsigned weekday_indexed::index() const NOEXCEPT {return index_;}
		2048	+
		2049	+CONSTCD11
		2050	+inline
		2051	+bool
		2052	+weekday_indexed::ok() const NOEXCEPT
		2053	+{
		2054	+ return weekday().ok() && 1 <= index_ && index_ <= 5;
		2055	+}
		2056	+
		2057	+#ifdef __GNUC__
		2058	+# pragma GCC diagnostic push
		2059	+# pragma GCC diagnostic ignored "-Wconversion"
		2060	+#endif // __GNUC__
		2061	+
		2062	+CONSTCD11
		2063	+inline
		2064	+weekday_indexed::weekday_indexed(const date::weekday& wd, unsigned index) NOEXCEPT
		2065	+ : wd_(static_cast<decltype(wd_)>(static_cast<unsigned>(wd.wd_)))
		2066	+ , index_(static_cast<decltype(index_)>(index))
		2067	+ {}
		2068	+
		2069	+#ifdef __GNUC__
		2070	+# pragma GCC diagnostic pop
		2071	+#endif // __GNUC__
		2072	+
		2073	+namespace detail
		2074	+{
		2075	+
		2076	+template<class CharT, class Traits>
		2077	+std::basic_ostream<CharT, Traits>&
		2078	+low_level_fmt(std::basic_ostream<CharT, Traits>& os, const weekday_indexed& wdi)
		2079	+{
		2080	+ return low_level_fmt(os, wdi.weekday()) << '[' << wdi.index() << ']';
		2081	+}
		2082	+
		2083	+} // namespace detail
		2084	+
		2085	+template<class CharT, class Traits>
		2086	+inline
		2087	+std::basic_ostream<CharT, Traits>&
		2088	+operator<<(std::basic_ostream<CharT, Traits>& os, const weekday_indexed& wdi)
		2089	+{
		2090	+ detail::low_level_fmt(os, wdi);
		2091	+ if (!wdi.ok())
		2092	+ os << " is not a valid weekday_indexed";
		2093	+ return os;
		2094	+}
		2095	+
		2096	+CONSTCD11
		2097	+inline
		2098	+weekday_indexed
		2099	+weekday::operator[](unsigned index) const NOEXCEPT
		2100	+{
		2101	+ return {*this, index};
		2102	+}
		2103	+
		2104	+CONSTCD11
		2105	+inline
		2106	+bool
		2107	+operator==(const weekday_indexed& x, const weekday_indexed& y) NOEXCEPT
		2108	+{
		2109	+ return x.weekday() == y.weekday() && x.index() == y.index();
		2110	+}
		2111	+
		2112	+CONSTCD11
		2113	+inline
		2114	+bool
		2115	+operator!=(const weekday_indexed& x, const weekday_indexed& y) NOEXCEPT
		2116	+{
		2117	+ return !(x == y);
		2118	+}
		2119	+
		2120	+// weekday_last
		2121	+
		2122	+CONSTCD11 inline date::weekday weekday_last::weekday() const NOEXCEPT {return wd_;}
		2123	+CONSTCD11 inline bool weekday_last::ok() const NOEXCEPT {return wd_.ok();}
		2124	+CONSTCD11 inline weekday_last::weekday_last(const date::weekday& wd) NOEXCEPT : wd_(wd) {}
		2125	+
		2126	+CONSTCD11
		2127	+inline
		2128	+bool
		2129	+operator==(const weekday_last& x, const weekday_last& y) NOEXCEPT
		2130	+{
		2131	+ return x.weekday() == y.weekday();
		2132	+}
		2133	+
		2134	+CONSTCD11
		2135	+inline
		2136	+bool
		2137	+operator!=(const weekday_last& x, const weekday_last& y) NOEXCEPT
		2138	+{
		2139	+ return !(x == y);
		2140	+}
		2141	+
		2142	+namespace detail
		2143	+{
		2144	+
		2145	+template<class CharT, class Traits>
		2146	+std::basic_ostream<CharT, Traits>&
		2147	+low_level_fmt(std::basic_ostream<CharT, Traits>& os, const weekday_last& wdl)
		2148	+{
		2149	+ return low_level_fmt(os, wdl.weekday()) << "[last]";
		2150	+}
		2151	+
		2152	+} // namespace detail
		2153	+
		2154	+template<class CharT, class Traits>
		2155	+inline
		2156	+std::basic_ostream<CharT, Traits>&
		2157	+operator<<(std::basic_ostream<CharT, Traits>& os, const weekday_last& wdl)
		2158	+{
		2159	+ detail::low_level_fmt(os, wdl);
		2160	+ if (!wdl.ok())
		2161	+ os << " is not a valid weekday_last";
		2162	+ return os;
		2163	+}
		2164	+
		2165	+CONSTCD11
		2166	+inline
		2167	+weekday_last
		2168	+weekday::operator[](last_spec) const NOEXCEPT
		2169	+{
		2170	+ return weekday_last{*this};
		2171	+}
		2172	+
		2173	+// year_month
		2174	+
		2175	+CONSTCD11
		2176	+inline
		2177	+year_month::year_month(const date::year& y, const date::month& m) NOEXCEPT
		2178	+ : y_(y)
		2179	+ , m_(m)
		2180	+ {}
		2181	+
		2182	+CONSTCD11 inline year year_month::year() const NOEXCEPT {return y_;}
		2183	+CONSTCD11 inline month year_month::month() const NOEXCEPT {return m_;}
		2184	+CONSTCD11 inline bool year_month::ok() const NOEXCEPT {return y_.ok() && m_.ok();}
		2185	+
		2186	+template<class>
		2187	+CONSTCD14
		2188	+inline
		2189	+year_month&
		2190	+year_month::operator+=(const months& dm) NOEXCEPT
		2191	+{
		2192	+ this = this + dm;
		2193	+ return *this;
		2194	+}
		2195	+
		2196	+template<class>
		2197	+CONSTCD14
		2198	+inline
		2199	+year_month&
		2200	+year_month::operator-=(const months& dm) NOEXCEPT
		2201	+{
		2202	+ this = this - dm;
		2203	+ return *this;
		2204	+}
		2205	+
		2206	+CONSTCD14
		2207	+inline
		2208	+year_month&
		2209	+year_month::operator+=(const years& dy) NOEXCEPT
		2210	+{
		2211	+ this = this + dy;
		2212	+ return *this;
		2213	+}
		2214	+
		2215	+CONSTCD14
		2216	+inline
		2217	+year_month&
		2218	+year_month::operator-=(const years& dy) NOEXCEPT
		2219	+{
		2220	+ this = this - dy;
		2221	+ return *this;
		2222	+}
		2223	+
		2224	+CONSTCD11
		2225	+inline
		2226	+bool
		2227	+operator==(const year_month& x, const year_month& y) NOEXCEPT
		2228	+{
		2229	+ return x.year() == y.year() && x.month() == y.month();
		2230	+}
		2231	+
		2232	+CONSTCD11
		2233	+inline
		2234	+bool
		2235	+operator!=(const year_month& x, const year_month& y) NOEXCEPT
		2236	+{
		2237	+ return !(x == y);
		2238	+}
		2239	+
		2240	+CONSTCD11
		2241	+inline
		2242	+bool
		2243	+operator<(const year_month& x, const year_month& y) NOEXCEPT
		2244	+{
		2245	+ return x.year() < y.year() ? true
		2246	+ : (x.year() > y.year() ? false
		2247	+ : (x.month() < y.month()));
		2248	+}
		2249	+
		2250	+CONSTCD11
		2251	+inline
		2252	+bool
		2253	+operator>(const year_month& x, const year_month& y) NOEXCEPT
		2254	+{
		2255	+ return y < x;
		2256	+}
		2257	+
		2258	+CONSTCD11
		2259	+inline
		2260	+bool
		2261	+operator<=(const year_month& x, const year_month& y) NOEXCEPT
		2262	+{
		2263	+ return !(y < x);
		2264	+}
		2265	+
		2266	+CONSTCD11
		2267	+inline
		2268	+bool
		2269	+operator>=(const year_month& x, const year_month& y) NOEXCEPT
		2270	+{
		2271	+ return !(x < y);
		2272	+}
		2273	+
		2274	+template<class>
		2275	+CONSTCD14
		2276	+inline
		2277	+year_month
		2278	+operator+(const year_month& ym, const months& dm) NOEXCEPT
		2279	+{
		2280	+ auto dmi = static_cast<int>(static_cast<unsigned>(ym.month())) - 1 + dm.count();
		2281	+ auto dy = (dmi >= 0 ? dmi : dmi-11) / 12;
		2282	+ dmi = dmi - dy * 12 + 1;
		2283	+ return (ym.year() + years(dy)) / month(static_cast<unsigned>(dmi));
		2284	+}
		2285	+
		2286	+template<class>
		2287	+CONSTCD14
		2288	+inline
		2289	+year_month
		2290	+operator+(const months& dm, const year_month& ym) NOEXCEPT
		2291	+{
		2292	+ return ym + dm;
		2293	+}
		2294	+
		2295	+template<class>
		2296	+CONSTCD14
		2297	+inline
		2298	+year_month
		2299	+operator-(const year_month& ym, const months& dm) NOEXCEPT
		2300	+{
		2301	+ return ym + -dm;
		2302	+}
		2303	+
		2304	+CONSTCD11
		2305	+inline
		2306	+months
		2307	+operator-(const year_month& x, const year_month& y) NOEXCEPT
		2308	+{
		2309	+ return (x.year() - y.year()) +
		2310	+ months(static_cast<unsigned>(x.month()) - static_cast<unsigned>(y.month()));
		2311	+}
		2312	+
		2313	+CONSTCD11
		2314	+inline
		2315	+year_month
		2316	+operator+(const year_month& ym, const years& dy) NOEXCEPT
		2317	+{
		2318	+ return (ym.year() + dy) / ym.month();
		2319	+}
		2320	+
		2321	+CONSTCD11
		2322	+inline
		2323	+year_month
		2324	+operator+(const years& dy, const year_month& ym) NOEXCEPT
		2325	+{
		2326	+ return ym + dy;
		2327	+}
		2328	+
		2329	+CONSTCD11
		2330	+inline
		2331	+year_month
		2332	+operator-(const year_month& ym, const years& dy) NOEXCEPT
		2333	+{
		2334	+ return ym + -dy;
		2335	+}
		2336	+
		2337	+namespace detail
		2338	+{
		2339	+
		2340	+template<class CharT, class Traits>
		2341	+std::basic_ostream<CharT, Traits>&
		2342	+low_level_fmt(std::basic_ostream<CharT, Traits>& os, const year_month& ym)
		2343	+{
		2344	+ low_level_fmt(os, ym.year()) << '/';
		2345	+ return low_level_fmt(os, ym.month());
		2346	+}
		2347	+
		2348	+} // namespace detail
		2349	+
		2350	+template<class CharT, class Traits>
		2351	+inline
		2352	+std::basic_ostream<CharT, Traits>&
		2353	+operator<<(std::basic_ostream<CharT, Traits>& os, const year_month& ym)
		2354	+{
		2355	+ detail::low_level_fmt(os, ym);
		2356	+ if (!ym.ok())
		2357	+ os << " is not a valid year_month";
		2358	+ return os;
		2359	+}
		2360	+
		2361	+// month_day
		2362	+
		2363	+CONSTCD11
		2364	+inline
		2365	+month_day::month_day(const date::month& m, const date::day& d) NOEXCEPT
		2366	+ : m_(m)
		2367	+ , d_(d)
		2368	+ {}
		2369	+
		2370	+CONSTCD11 inline date::month month_day::month() const NOEXCEPT {return m_;}
		2371	+CONSTCD11 inline date::day month_day::day() const NOEXCEPT {return d_;}
		2372	+
		2373	+CONSTCD14
		2374	+inline
		2375	+bool
		2376	+month_day::ok() const NOEXCEPT
		2377	+{
		2378	+ CONSTDATA date::day d[] =
		2379	+ {
		2380	+ date::day(31), date::day(29), date::day(31),
		2381	+ date::day(30), date::day(31), date::day(30),
		2382	+ date::day(31), date::day(31), date::day(30),
		2383	+ date::day(31), date::day(30), date::day(31)
		2384	+ };
		2385	+ return m_.ok() && date::day{1} <= d_ && d_ <= d[static_cast<unsigned>(m_)-1];
		2386	+}
		2387	+
		2388	+CONSTCD11
		2389	+inline
		2390	+bool
		2391	+operator==(const month_day& x, const month_day& y) NOEXCEPT
		2392	+{
		2393	+ return x.month() == y.month() && x.day() == y.day();
		2394	+}
		2395	+
		2396	+CONSTCD11
		2397	+inline
		2398	+bool
		2399	+operator!=(const month_day& x, const month_day& y) NOEXCEPT
		2400	+{
		2401	+ return !(x == y);
		2402	+}
		2403	+
		2404	+CONSTCD11
		2405	+inline
		2406	+bool
		2407	+operator<(const month_day& x, const month_day& y) NOEXCEPT
		2408	+{
		2409	+ return x.month() < y.month() ? true
		2410	+ : (x.month() > y.month() ? false
		2411	+ : (x.day() < y.day()));
		2412	+}
		2413	+
		2414	+CONSTCD11
		2415	+inline
		2416	+bool
		2417	+operator>(const month_day& x, const month_day& y) NOEXCEPT
		2418	+{
		2419	+ return y < x;
		2420	+}
		2421	+
		2422	+CONSTCD11
		2423	+inline
		2424	+bool
		2425	+operator<=(const month_day& x, const month_day& y) NOEXCEPT
		2426	+{
		2427	+ return !(y < x);
		2428	+}
		2429	+
		2430	+CONSTCD11
		2431	+inline
		2432	+bool
		2433	+operator>=(const month_day& x, const month_day& y) NOEXCEPT
		2434	+{
		2435	+ return !(x < y);
		2436	+}
		2437	+
		2438	+namespace detail
		2439	+{
		2440	+
		2441	+template<class CharT, class Traits>
		2442	+std::basic_ostream<CharT, Traits>&
		2443	+low_level_fmt(std::basic_ostream<CharT, Traits>& os, const month_day& md)
		2444	+{
		2445	+ low_level_fmt(os, md.month()) << '/';
		2446	+ return low_level_fmt(os, md.day());
		2447	+}
		2448	+
		2449	+} // namespace detail
		2450	+
		2451	+template<class CharT, class Traits>
		2452	+inline
		2453	+std::basic_ostream<CharT, Traits>&
		2454	+operator<<(std::basic_ostream<CharT, Traits>& os, const month_day& md)
		2455	+{
		2456	+ detail::low_level_fmt(os, md);
		2457	+ if (!md.ok())
		2458	+ os << " is not a valid month_day";
		2459	+ return os;
		2460	+}
		2461	+
		2462	+// month_day_last
		2463	+
		2464	+CONSTCD11 inline month month_day_last::month() const NOEXCEPT {return m_;}
		2465	+CONSTCD11 inline bool month_day_last::ok() const NOEXCEPT {return m_.ok();}
		2466	+CONSTCD11 inline month_day_last::month_day_last(const date::month& m) NOEXCEPT : m_(m) {}
		2467	+
		2468	+CONSTCD11
		2469	+inline
		2470	+bool
		2471	+operator==(const month_day_last& x, const month_day_last& y) NOEXCEPT
		2472	+{
		2473	+ return x.month() == y.month();
		2474	+}
		2475	+
		2476	+CONSTCD11
		2477	+inline
		2478	+bool
		2479	+operator!=(const month_day_last& x, const month_day_last& y) NOEXCEPT
		2480	+{
		2481	+ return !(x == y);
		2482	+}
		2483	+
		2484	+CONSTCD11
		2485	+inline
		2486	+bool
		2487	+operator<(const month_day_last& x, const month_day_last& y) NOEXCEPT
		2488	+{
		2489	+ return x.month() < y.month();
		2490	+}
		2491	+
		2492	+CONSTCD11
		2493	+inline
		2494	+bool
		2495	+operator>(const month_day_last& x, const month_day_last& y) NOEXCEPT
		2496	+{
		2497	+ return y < x;
		2498	+}
		2499	+
		2500	+CONSTCD11
		2501	+inline
		2502	+bool
		2503	+operator<=(const month_day_last& x, const month_day_last& y) NOEXCEPT
		2504	+{
		2505	+ return !(y < x);
		2506	+}
		2507	+
		2508	+CONSTCD11
		2509	+inline
		2510	+bool
		2511	+operator>=(const month_day_last& x, const month_day_last& y) NOEXCEPT
		2512	+{
		2513	+ return !(x < y);
		2514	+}
		2515	+
		2516	+namespace detail
		2517	+{
		2518	+
		2519	+template<class CharT, class Traits>
		2520	+std::basic_ostream<CharT, Traits>&
		2521	+low_level_fmt(std::basic_ostream<CharT, Traits>& os, const month_day_last& mdl)
		2522	+{
		2523	+ return low_level_fmt(os, mdl.month()) << "/last";
		2524	+}
		2525	+
		2526	+} // namespace detail
		2527	+
		2528	+template<class CharT, class Traits>
		2529	+inline
		2530	+std::basic_ostream<CharT, Traits>&
		2531	+operator<<(std::basic_ostream<CharT, Traits>& os, const month_day_last& mdl)
		2532	+{
		2533	+ detail::low_level_fmt(os, mdl);
		2534	+ if (!mdl.ok())
		2535	+ os << " is not a valid month_day_last";
		2536	+ return os;
		2537	+}
		2538	+
		2539	+// month_weekday
		2540	+
		2541	+CONSTCD11
		2542	+inline
		2543	+month_weekday::month_weekday(const date::month& m,
		2544	+ const date::weekday_indexed& wdi) NOEXCEPT
		2545	+ : m_(m)
		2546	+ , wdi_(wdi)
		2547	+ {}
		2548	+
		2549	+CONSTCD11 inline month month_weekday::month() const NOEXCEPT {return m_;}
		2550	+
		2551	+CONSTCD11
		2552	+inline
		2553	+weekday_indexed
		2554	+month_weekday::weekday_indexed() const NOEXCEPT
		2555	+{
		2556	+ return wdi_;
		2557	+}
		2558	+
		2559	+CONSTCD11
		2560	+inline
		2561	+bool
		2562	+month_weekday::ok() const NOEXCEPT
		2563	+{
		2564	+ return m_.ok() && wdi_.ok();
		2565	+}
		2566	+
		2567	+CONSTCD11
		2568	+inline
		2569	+bool
		2570	+operator==(const month_weekday& x, const month_weekday& y) NOEXCEPT
		2571	+{
		2572	+ return x.month() == y.month() && x.weekday_indexed() == y.weekday_indexed();
		2573	+}
		2574	+
		2575	+CONSTCD11
		2576	+inline
		2577	+bool
		2578	+operator!=(const month_weekday& x, const month_weekday& y) NOEXCEPT
		2579	+{
		2580	+ return !(x == y);
		2581	+}
		2582	+
		2583	+namespace detail
		2584	+{
		2585	+
		2586	+template<class CharT, class Traits>
		2587	+std::basic_ostream<CharT, Traits>&
		2588	+low_level_fmt(std::basic_ostream<CharT, Traits>& os, const month_weekday& mwd)
		2589	+{
		2590	+ low_level_fmt(os, mwd.month()) << '/';
		2591	+ return low_level_fmt(os, mwd.weekday_indexed());
		2592	+}
		2593	+
		2594	+} // namespace detail
		2595	+
		2596	+template<class CharT, class Traits>
		2597	+inline
		2598	+std::basic_ostream<CharT, Traits>&
		2599	+operator<<(std::basic_ostream<CharT, Traits>& os, const month_weekday& mwd)
		2600	+{
		2601	+ detail::low_level_fmt(os, mwd);
		2602	+ if (!mwd.ok())
		2603	+ os << " is not a valid month_weekday";
		2604	+ return os;
		2605	+}
		2606	+
		2607	+// month_weekday_last
		2608	+
		2609	+CONSTCD11
		2610	+inline
		2611	+month_weekday_last::month_weekday_last(const date::month& m,
		2612	+ const date::weekday_last& wdl) NOEXCEPT
		2613	+ : m_(m)
		2614	+ , wdl_(wdl)
		2615	+ {}
		2616	+
		2617	+CONSTCD11 inline month month_weekday_last::month() const NOEXCEPT {return m_;}
		2618	+
		2619	+CONSTCD11
		2620	+inline
		2621	+weekday_last
		2622	+month_weekday_last::weekday_last() const NOEXCEPT
		2623	+{
		2624	+ return wdl_;
		2625	+}
		2626	+
		2627	+CONSTCD11
		2628	+inline
		2629	+bool
		2630	+month_weekday_last::ok() const NOEXCEPT
		2631	+{
		2632	+ return m_.ok() && wdl_.ok();
		2633	+}
		2634	+
		2635	+CONSTCD11
		2636	+inline
		2637	+bool
		2638	+operator==(const month_weekday_last& x, const month_weekday_last& y) NOEXCEPT
		2639	+{
		2640	+ return x.month() == y.month() && x.weekday_last() == y.weekday_last();
		2641	+}
		2642	+
		2643	+CONSTCD11
		2644	+inline
		2645	+bool
		2646	+operator!=(const month_weekday_last& x, const month_weekday_last& y) NOEXCEPT
		2647	+{
		2648	+ return !(x == y);
		2649	+}
		2650	+
		2651	+namespace detail
		2652	+{
		2653	+
		2654	+template<class CharT, class Traits>
		2655	+std::basic_ostream<CharT, Traits>&
		2656	+low_level_fmt(std::basic_ostream<CharT, Traits>& os, const month_weekday_last& mwdl)
		2657	+{
		2658	+ low_level_fmt(os, mwdl.month()) << '/';
		2659	+ return low_level_fmt(os, mwdl.weekday_last());
		2660	+}
		2661	+
		2662	+} // namespace detail
		2663	+
		2664	+template<class CharT, class Traits>
		2665	+inline
		2666	+std::basic_ostream<CharT, Traits>&
		2667	+operator<<(std::basic_ostream<CharT, Traits>& os, const month_weekday_last& mwdl)
		2668	+{
		2669	+ detail::low_level_fmt(os, mwdl);
		2670	+ if (!mwdl.ok())
		2671	+ os << " is not a valid month_weekday_last";
		2672	+ return os;
		2673	+}
		2674	+
		2675	+// year_month_day_last
		2676	+
		2677	+CONSTCD11
		2678	+inline
		2679	+year_month_day_last::year_month_day_last(const date::year& y,
		2680	+ const date::month_day_last& mdl) NOEXCEPT
		2681	+ : y_(y)
		2682	+ , mdl_(mdl)
		2683	+ {}
		2684	+
		2685	+template<class>
		2686	+CONSTCD14
		2687	+inline
		2688	+year_month_day_last&
		2689	+year_month_day_last::operator+=(const months& m) NOEXCEPT
		2690	+{
		2691	+ this = this + m;
		2692	+ return *this;
		2693	+}
		2694	+
		2695	+template<class>
		2696	+CONSTCD14
		2697	+inline
		2698	+year_month_day_last&
		2699	+year_month_day_last::operator-=(const months& m) NOEXCEPT
		2700	+{
		2701	+ this = this - m;
		2702	+ return *this;
		2703	+}
		2704	+
		2705	+CONSTCD14
		2706	+inline
		2707	+year_month_day_last&
		2708	+year_month_day_last::operator+=(const years& y) NOEXCEPT
		2709	+{
		2710	+ this = this + y;
		2711	+ return *this;
		2712	+}
		2713	+
		2714	+CONSTCD14
		2715	+inline
		2716	+year_month_day_last&
		2717	+year_month_day_last::operator-=(const years& y) NOEXCEPT
		2718	+{
		2719	+ this = this - y;
		2720	+ return *this;
		2721	+}
		2722	+
		2723	+CONSTCD11 inline year year_month_day_last::year() const NOEXCEPT {return y_;}
		2724	+CONSTCD11 inline month year_month_day_last::month() const NOEXCEPT {return mdl_.month();}
		2725	+
		2726	+CONSTCD11
		2727	+inline
		2728	+month_day_last
		2729	+year_month_day_last::month_day_last() const NOEXCEPT
		2730	+{
		2731	+ return mdl_;
		2732	+}
		2733	+
		2734	+CONSTCD14
		2735	+inline
		2736	+day
		2737	+year_month_day_last::day() const NOEXCEPT
		2738	+{
		2739	+ CONSTDATA date::day d[] =
		2740	+ {
		2741	+ date::day(31), date::day(28), date::day(31),
		2742	+ date::day(30), date::day(31), date::day(30),
		2743	+ date::day(31), date::day(31), date::day(30),
		2744	+ date::day(31), date::day(30), date::day(31)
		2745	+ };
		2746	+ return (month() != February \|\| !y_.is_leap()) && mdl_.ok() ?
		2747	+ d[static_cast<unsigned>(month()) - 1] : date::day{29};
		2748	+}
		2749	+
		2750	+CONSTCD14
		2751	+inline
		2752	+year_month_day_last::operator sys_days() const NOEXCEPT
		2753	+{
		2754	+ return sys_days(year()/month()/day());
		2755	+}
		2756	+
		2757	+CONSTCD14
		2758	+inline
		2759	+year_month_day_last::operator local_days() const NOEXCEPT
		2760	+{
		2761	+ return local_days(year()/month()/day());
		2762	+}
		2763	+
		2764	+CONSTCD11
		2765	+inline
		2766	+bool
		2767	+year_month_day_last::ok() const NOEXCEPT
		2768	+{
		2769	+ return y_.ok() && mdl_.ok();
		2770	+}
		2771	+
		2772	+CONSTCD11
		2773	+inline
		2774	+bool
		2775	+operator==(const year_month_day_last& x, const year_month_day_last& y) NOEXCEPT
		2776	+{
		2777	+ return x.year() == y.year() && x.month_day_last() == y.month_day_last();
		2778	+}
		2779	+
		2780	+CONSTCD11
		2781	+inline
		2782	+bool
		2783	+operator!=(const year_month_day_last& x, const year_month_day_last& y) NOEXCEPT
		2784	+{
		2785	+ return !(x == y);
		2786	+}
		2787	+
		2788	+CONSTCD11
		2789	+inline
		2790	+bool
		2791	+operator<(const year_month_day_last& x, const year_month_day_last& y) NOEXCEPT
		2792	+{
		2793	+ return x.year() < y.year() ? true
		2794	+ : (x.year() > y.year() ? false
		2795	+ : (x.month_day_last() < y.month_day_last()));
		2796	+}
		2797	+
		2798	+CONSTCD11
		2799	+inline
		2800	+bool
		2801	+operator>(const year_month_day_last& x, const year_month_day_last& y) NOEXCEPT
		2802	+{
		2803	+ return y < x;
		2804	+}
		2805	+
		2806	+CONSTCD11
		2807	+inline
		2808	+bool
		2809	+operator<=(const year_month_day_last& x, const year_month_day_last& y) NOEXCEPT
		2810	+{
		2811	+ return !(y < x);
		2812	+}
		2813	+
		2814	+CONSTCD11
		2815	+inline
		2816	+bool
		2817	+operator>=(const year_month_day_last& x, const year_month_day_last& y) NOEXCEPT
		2818	+{
		2819	+ return !(x < y);
		2820	+}
		2821	+
		2822	+namespace detail
		2823	+{
		2824	+
		2825	+template<class CharT, class Traits>
		2826	+std::basic_ostream<CharT, Traits>&
		2827	+low_level_fmt(std::basic_ostream<CharT, Traits>& os, const year_month_day_last& ymdl)
		2828	+{
		2829	+ low_level_fmt(os, ymdl.year()) << '/';
		2830	+ return low_level_fmt(os, ymdl.month_day_last());
		2831	+}
		2832	+
		2833	+} // namespace detail
		2834	+
		2835	+template<class CharT, class Traits>
		2836	+inline
		2837	+std::basic_ostream<CharT, Traits>&
		2838	+operator<<(std::basic_ostream<CharT, Traits>& os, const year_month_day_last& ymdl)
		2839	+{
		2840	+ detail::low_level_fmt(os, ymdl);
		2841	+ if (!ymdl.ok())
		2842	+ os << " is not a valid year_month_day_last";
		2843	+ return os;
		2844	+}
		2845	+
		2846	+template<class>
		2847	+CONSTCD14
		2848	+inline
		2849	+year_month_day_last
		2850	+operator+(const year_month_day_last& ymdl, const months& dm) NOEXCEPT
		2851	+{
		2852	+ return (ymdl.year() / ymdl.month() + dm) / last;
		2853	+}
		2854	+
		2855	+template<class>
		2856	+CONSTCD14
		2857	+inline
		2858	+year_month_day_last
		2859	+operator+(const months& dm, const year_month_day_last& ymdl) NOEXCEPT
		2860	+{
		2861	+ return ymdl + dm;
		2862	+}
		2863	+
		2864	+template<class>
		2865	+CONSTCD14
		2866	+inline
		2867	+year_month_day_last
		2868	+operator-(const year_month_day_last& ymdl, const months& dm) NOEXCEPT
		2869	+{
		2870	+ return ymdl + (-dm);
		2871	+}
		2872	+
		2873	+CONSTCD11
		2874	+inline
		2875	+year_month_day_last
		2876	+operator+(const year_month_day_last& ymdl, const years& dy) NOEXCEPT
		2877	+{
		2878	+ return {ymdl.year()+dy, ymdl.month_day_last()};
		2879	+}
		2880	+
		2881	+CONSTCD11
		2882	+inline
		2883	+year_month_day_last
		2884	+operator+(const years& dy, const year_month_day_last& ymdl) NOEXCEPT
		2885	+{
		2886	+ return ymdl + dy;
		2887	+}
		2888	+
		2889	+CONSTCD11
		2890	+inline
		2891	+year_month_day_last
		2892	+operator-(const year_month_day_last& ymdl, const years& dy) NOEXCEPT
		2893	+{
		2894	+ return ymdl + (-dy);
		2895	+}
		2896	+
		2897	+// year_month_day
		2898	+
		2899	+CONSTCD11
		2900	+inline
		2901	+year_month_day::year_month_day(const date::year& y, const date::month& m,
		2902	+ const date::day& d) NOEXCEPT
		2903	+ : y_(y)
		2904	+ , m_(m)
		2905	+ , d_(d)
		2906	+ {}
		2907	+
		2908	+CONSTCD14
		2909	+inline
		2910	+year_month_day::year_month_day(const year_month_day_last& ymdl) NOEXCEPT
		2911	+ : y_(ymdl.year())
		2912	+ , m_(ymdl.month())
		2913	+ , d_(ymdl.day())
		2914	+ {}
		2915	+
		2916	+CONSTCD14
		2917	+inline
		2918	+year_month_day::year_month_day(sys_days dp) NOEXCEPT
		2919	+ : year_month_day(from_days(dp.time_since_epoch()))
		2920	+ {}
		2921	+
		2922	+CONSTCD14
		2923	+inline
		2924	+year_month_day::year_month_day(local_days dp) NOEXCEPT
		2925	+ : year_month_day(from_days(dp.time_since_epoch()))
		2926	+ {}
		2927	+
		2928	+CONSTCD11 inline year year_month_day::year() const NOEXCEPT {return y_;}
		2929	+CONSTCD11 inline month year_month_day::month() const NOEXCEPT {return m_;}
		2930	+CONSTCD11 inline day year_month_day::day() const NOEXCEPT {return d_;}
		2931	+
		2932	+template<class>
		2933	+CONSTCD14
		2934	+inline
		2935	+year_month_day&
		2936	+year_month_day::operator+=(const months& m) NOEXCEPT
		2937	+{
		2938	+ this = this + m;
		2939	+ return *this;
		2940	+}
		2941	+
		2942	+template<class>
		2943	+CONSTCD14
		2944	+inline
		2945	+year_month_day&
		2946	+year_month_day::operator-=(const months& m) NOEXCEPT
		2947	+{
		2948	+ this = this - m;
		2949	+ return *this;
		2950	+}
		2951	+
		2952	+CONSTCD14
		2953	+inline
		2954	+year_month_day&
		2955	+year_month_day::operator+=(const years& y) NOEXCEPT
		2956	+{
		2957	+ this = this + y;
		2958	+ return *this;
		2959	+}
		2960	+
		2961	+CONSTCD14
		2962	+inline
		2963	+year_month_day&
		2964	+year_month_day::operator-=(const years& y) NOEXCEPT
		2965	+{
		2966	+ this = this - y;
		2967	+ return *this;
		2968	+}
		2969	+
		2970	+CONSTCD14
		2971	+inline
		2972	+days
		2973	+year_month_day::to_days() const NOEXCEPT
		2974	+{
		2975	+ static_assert(std::numeric_limits<unsigned>::digits >= 18,
		2976	+ "This algorithm has not been ported to a 16 bit unsigned integer");
		2977	+ static_assert(std::numeric_limits<int>::digits >= 20,
		2978	+ "This algorithm has not been ported to a 16 bit signed integer");
		2979	+ auto const y = static_cast<int>(y_) - (m_ <= February);
		2980	+ auto const m = static_cast<unsigned>(m_);
		2981	+ auto const d = static_cast<unsigned>(d_);
		2982	+ auto const era = (y >= 0 ? y : y-399) / 400;
		2983	+ auto const yoe = static_cast<unsigned>(y - era * 400); // [0, 399]
		2984	+ auto const doy = (153*(m > 2 ? m-3 : m+9) + 2)/5 + d-1; // [0, 365]
		2985	+ auto const doe = yoe * 365 + yoe/4 - yoe/100 + doy; // [0, 146096]
		2986	+ return days{era * 146097 + static_cast<int>(doe) - 719468};
		2987	+}
		2988	+
		2989	+CONSTCD14
		2990	+inline
		2991	+year_month_day::operator sys_days() const NOEXCEPT
		2992	+{
		2993	+ return sys_days{to_days()};
		2994	+}
		2995	+
		2996	+CONSTCD14
		2997	+inline
		2998	+year_month_day::operator local_days() const NOEXCEPT
		2999	+{
		3000	+ return local_days{to_days()};
		3001	+}
		3002	+
		3003	+CONSTCD14
		3004	+inline
		3005	+bool
		3006	+year_month_day::ok() const NOEXCEPT
		3007	+{
		3008	+ if (!(y_.ok() && m_.ok()))
		3009	+ return false;
		3010	+ return date::day{1} <= d_ && d_ <= (y_ / m_ / last).day();
		3011	+}
		3012	+
		3013	+CONSTCD11
		3014	+inline
		3015	+bool
		3016	+operator==(const year_month_day& x, const year_month_day& y) NOEXCEPT
		3017	+{
		3018	+ return x.year() == y.year() && x.month() == y.month() && x.day() == y.day();
		3019	+}
		3020	+
		3021	+CONSTCD11
		3022	+inline
		3023	+bool
		3024	+operator!=(const year_month_day& x, const year_month_day& y) NOEXCEPT
		3025	+{
		3026	+ return !(x == y);
		3027	+}
		3028	+
		3029	+CONSTCD11
		3030	+inline
		3031	+bool
		3032	+operator<(const year_month_day& x, const year_month_day& y) NOEXCEPT
		3033	+{
		3034	+ return x.year() < y.year() ? true
		3035	+ : (x.year() > y.year() ? false
		3036	+ : (x.month() < y.month() ? true
		3037	+ : (x.month() > y.month() ? false
		3038	+ : (x.day() < y.day()))));
		3039	+}
		3040	+
		3041	+CONSTCD11
		3042	+inline
		3043	+bool
		3044	+operator>(const year_month_day& x, const year_month_day& y) NOEXCEPT
		3045	+{
		3046	+ return y < x;
		3047	+}
		3048	+
		3049	+CONSTCD11
		3050	+inline
		3051	+bool
		3052	+operator<=(const year_month_day& x, const year_month_day& y) NOEXCEPT
		3053	+{
		3054	+ return !(y < x);
		3055	+}
		3056	+
		3057	+CONSTCD11
		3058	+inline
		3059	+bool
		3060	+operator>=(const year_month_day& x, const year_month_day& y) NOEXCEPT
		3061	+{
		3062	+ return !(x < y);
		3063	+}
		3064	+
		3065	+template<class CharT, class Traits>
		3066	+inline
		3067	+std::basic_ostream<CharT, Traits>&
		3068	+operator<<(std::basic_ostream<CharT, Traits>& os, const year_month_day& ymd)
		3069	+{
		3070	+ detail::save_ostream<CharT, Traits> _(os);
		3071	+ os.fill('0');
		3072	+ os.flags(std::ios::dec \| std::ios::right);
		3073	+ os.imbue(std::locale::classic());
		3074	+ os << static_cast<int>(ymd.year()) << '-';
		3075	+ os.width(2);
		3076	+ os << static_cast<unsigned>(ymd.month()) << '-';
		3077	+ os.width(2);
		3078	+ os << static_cast<unsigned>(ymd.day());
		3079	+ if (!ymd.ok())
		3080	+ os << " is not a valid year_month_day";
		3081	+ return os;
		3082	+}
		3083	+
		3084	+CONSTCD14
		3085	+inline
		3086	+year_month_day
		3087	+year_month_day::from_days(days dp) NOEXCEPT
		3088	+{
		3089	+ static_assert(std::numeric_limits<unsigned>::digits >= 18,
		3090	+ "This algorithm has not been ported to a 16 bit unsigned integer");
		3091	+ static_assert(std::numeric_limits<int>::digits >= 20,
		3092	+ "This algorithm has not been ported to a 16 bit signed integer");
		3093	+ auto const z = dp.count() + 719468;
		3094	+ auto const era = (z >= 0 ? z : z - 146096) / 146097;
		3095	+ auto const doe = static_cast<unsigned>(z - era * 146097); // [0, 146096]
		3096	+ auto const yoe = (doe - doe/1460 + doe/36524 - doe/146096) / 365; // [0, 399]
		3097	+ auto const y = static_cast<days::rep>(yoe) + era * 400;
		3098	+ auto const doy = doe - (365*yoe + yoe/4 - yoe/100); // [0, 365]
		3099	+ auto const mp = (5*doy + 2)/153; // [0, 11]
		3100	+ auto const d = doy - (153*mp+2)/5 + 1; // [1, 31]
		3101	+ auto const m = mp < 10 ? mp+3 : mp-9; // [1, 12]
		3102	+ return year_month_day{date::year{y + (m <= 2)}, date::month(m), date::day(d)};
		3103	+}
		3104	+
		3105	+template<class>
		3106	+CONSTCD14
		3107	+inline
		3108	+year_month_day
		3109	+operator+(const year_month_day& ymd, const months& dm) NOEXCEPT
		3110	+{
		3111	+ return (ymd.year() / ymd.month() + dm) / ymd.day();
		3112	+}
		3113	+
		3114	+template<class>
		3115	+CONSTCD14
		3116	+inline
		3117	+year_month_day
		3118	+operator+(const months& dm, const year_month_day& ymd) NOEXCEPT
		3119	+{
		3120	+ return ymd + dm;
		3121	+}
		3122	+
		3123	+template<class>
		3124	+CONSTCD14
		3125	+inline
		3126	+year_month_day
		3127	+operator-(const year_month_day& ymd, const months& dm) NOEXCEPT
		3128	+{
		3129	+ return ymd + (-dm);
		3130	+}
		3131	+
		3132	+CONSTCD11
		3133	+inline
		3134	+year_month_day
		3135	+operator+(const year_month_day& ymd, const years& dy) NOEXCEPT
		3136	+{
		3137	+ return (ymd.year() + dy) / ymd.month() / ymd.day();
		3138	+}
		3139	+
		3140	+CONSTCD11
		3141	+inline
		3142	+year_month_day
		3143	+operator+(const years& dy, const year_month_day& ymd) NOEXCEPT
		3144	+{
		3145	+ return ymd + dy;
		3146	+}
		3147	+
		3148	+CONSTCD11
		3149	+inline
		3150	+year_month_day
		3151	+operator-(const year_month_day& ymd, const years& dy) NOEXCEPT
		3152	+{
		3153	+ return ymd + (-dy);
		3154	+}
		3155	+
		3156	+// year_month_weekday
		3157	+
		3158	+CONSTCD11
		3159	+inline
		3160	+year_month_weekday::year_month_weekday(const date::year& y, const date::month& m,
		3161	+ const date::weekday_indexed& wdi)
		3162	+ NOEXCEPT
		3163	+ : y_(y)
		3164	+ , m_(m)
		3165	+ , wdi_(wdi)
		3166	+ {}
		3167	+
		3168	+CONSTCD14
		3169	+inline
		3170	+year_month_weekday::year_month_weekday(const sys_days& dp) NOEXCEPT
		3171	+ : year_month_weekday(from_days(dp.time_since_epoch()))
		3172	+ {}
		3173	+
		3174	+CONSTCD14
		3175	+inline
		3176	+year_month_weekday::year_month_weekday(const local_days& dp) NOEXCEPT
		3177	+ : year_month_weekday(from_days(dp.time_since_epoch()))
		3178	+ {}
		3179	+
		3180	+template<class>
		3181	+CONSTCD14
		3182	+inline
		3183	+year_month_weekday&
		3184	+year_month_weekday::operator+=(const months& m) NOEXCEPT
		3185	+{
		3186	+ this = this + m;
		3187	+ return *this;
		3188	+}
		3189	+
		3190	+template<class>
		3191	+CONSTCD14
		3192	+inline
		3193	+year_month_weekday&
		3194	+year_month_weekday::operator-=(const months& m) NOEXCEPT
		3195	+{
		3196	+ this = this - m;
		3197	+ return *this;
		3198	+}
		3199	+
		3200	+CONSTCD14
		3201	+inline
		3202	+year_month_weekday&
		3203	+year_month_weekday::operator+=(const years& y) NOEXCEPT
		3204	+{
		3205	+ this = this + y;
		3206	+ return *this;
		3207	+}
		3208	+
		3209	+CONSTCD14
		3210	+inline
		3211	+year_month_weekday&
		3212	+year_month_weekday::operator-=(const years& y) NOEXCEPT
		3213	+{
		3214	+ this = this - y;
		3215	+ return *this;
		3216	+}
		3217	+
		3218	+CONSTCD11 inline year year_month_weekday::year() const NOEXCEPT {return y_;}
		3219	+CONSTCD11 inline month year_month_weekday::month() const NOEXCEPT {return m_;}
		3220	+
		3221	+CONSTCD11
		3222	+inline
		3223	+weekday
		3224	+year_month_weekday::weekday() const NOEXCEPT
		3225	+{
		3226	+ return wdi_.weekday();
		3227	+}
		3228	+
		3229	+CONSTCD11
		3230	+inline
		3231	+unsigned
		3232	+year_month_weekday::index() const NOEXCEPT
		3233	+{
		3234	+ return wdi_.index();
		3235	+}
		3236	+
		3237	+CONSTCD11
		3238	+inline
		3239	+weekday_indexed
		3240	+year_month_weekday::weekday_indexed() const NOEXCEPT
		3241	+{
		3242	+ return wdi_;
		3243	+}
		3244	+
		3245	+CONSTCD14
		3246	+inline
		3247	+year_month_weekday::operator sys_days() const NOEXCEPT
		3248	+{
		3249	+ return sys_days{to_days()};
		3250	+}
		3251	+
		3252	+CONSTCD14
		3253	+inline
		3254	+year_month_weekday::operator local_days() const NOEXCEPT
		3255	+{
		3256	+ return local_days{to_days()};
		3257	+}
		3258	+
		3259	+CONSTCD14
		3260	+inline
		3261	+bool
		3262	+year_month_weekday::ok() const NOEXCEPT
		3263	+{
		3264	+ if (!y_.ok() \|\| !m_.ok() \|\| !wdi_.weekday().ok() \|\| wdi_.index() < 1)
		3265	+ return false;
		3266	+ if (wdi_.index() <= 4)
		3267	+ return true;
		3268	+ auto d2 = wdi_.weekday() - date::weekday(static_cast<sys_days>(y_/m_/1)) +
		3269	+ days((wdi_.index()-1)*7 + 1);
		3270	+ return static_cast<unsigned>(d2.count()) <= static_cast<unsigned>((y_/m_/last).day());
		3271	+}
		3272	+
		3273	+CONSTCD14
		3274	+inline
		3275	+year_month_weekday
		3276	+year_month_weekday::from_days(days d) NOEXCEPT
		3277	+{
		3278	+ sys_days dp{d};
		3279	+ auto const wd = date::weekday(dp);
		3280	+ auto const ymd = year_month_day(dp);
		3281	+ return {ymd.year(), ymd.month(), wd[(static_cast<unsigned>(ymd.day())-1)/7+1]};
		3282	+}
		3283	+
		3284	+CONSTCD14
		3285	+inline
		3286	+days
		3287	+year_month_weekday::to_days() const NOEXCEPT
		3288	+{
		3289	+ auto d = sys_days(y_/m_/1);
		3290	+ return (d + (wdi_.weekday() - date::weekday(d) + days{(wdi_.index()-1)*7})
		3291	+ ).time_since_epoch();
		3292	+}
		3293	+
		3294	+CONSTCD11
		3295	+inline
		3296	+bool
		3297	+operator==(const year_month_weekday& x, const year_month_weekday& y) NOEXCEPT
		3298	+{
		3299	+ return x.year() == y.year() && x.month() == y.month() &&
		3300	+ x.weekday_indexed() == y.weekday_indexed();
		3301	+}
		3302	+
		3303	+CONSTCD11
		3304	+inline
		3305	+bool
		3306	+operator!=(const year_month_weekday& x, const year_month_weekday& y) NOEXCEPT
		3307	+{
		3308	+ return !(x == y);
		3309	+}
		3310	+
		3311	+template<class CharT, class Traits>
		3312	+inline
		3313	+std::basic_ostream<CharT, Traits>&
		3314	+operator<<(std::basic_ostream<CharT, Traits>& os, const year_month_weekday& ymwdi)
		3315	+{
		3316	+ detail::low_level_fmt(os, ymwdi.year()) << '/';
		3317	+ detail::low_level_fmt(os, ymwdi.month()) << '/';
		3318	+ detail::low_level_fmt(os, ymwdi.weekday_indexed());
		3319	+ if (!ymwdi.ok())
		3320	+ os << " is not a valid year_month_weekday";
		3321	+ return os;
		3322	+}
		3323	+
		3324	+template<class>
		3325	+CONSTCD14
		3326	+inline
		3327	+year_month_weekday
		3328	+operator+(const year_month_weekday& ymwd, const months& dm) NOEXCEPT
		3329	+{
		3330	+ return (ymwd.year() / ymwd.month() + dm) / ymwd.weekday_indexed();
		3331	+}
		3332	+
		3333	+template<class>
		3334	+CONSTCD14
		3335	+inline
		3336	+year_month_weekday
		3337	+operator+(const months& dm, const year_month_weekday& ymwd) NOEXCEPT
		3338	+{
		3339	+ return ymwd + dm;
		3340	+}
		3341	+
		3342	+template<class>
		3343	+CONSTCD14
		3344	+inline
		3345	+year_month_weekday
		3346	+operator-(const year_month_weekday& ymwd, const months& dm) NOEXCEPT
		3347	+{
		3348	+ return ymwd + (-dm);
		3349	+}
		3350	+
		3351	+CONSTCD11
		3352	+inline
		3353	+year_month_weekday
		3354	+operator+(const year_month_weekday& ymwd, const years& dy) NOEXCEPT
		3355	+{
		3356	+ return {ymwd.year()+dy, ymwd.month(), ymwd.weekday_indexed()};
		3357	+}
		3358	+
		3359	+CONSTCD11
		3360	+inline
		3361	+year_month_weekday
		3362	+operator+(const years& dy, const year_month_weekday& ymwd) NOEXCEPT
		3363	+{
		3364	+ return ymwd + dy;
		3365	+}
		3366	+
		3367	+CONSTCD11
		3368	+inline
		3369	+year_month_weekday
		3370	+operator-(const year_month_weekday& ymwd, const years& dy) NOEXCEPT
		3371	+{
		3372	+ return ymwd + (-dy);
		3373	+}
		3374	+
		3375	+// year_month_weekday_last
		3376	+
		3377	+CONSTCD11
		3378	+inline
		3379	+year_month_weekday_last::year_month_weekday_last(const date::year& y,
		3380	+ const date::month& m,
		3381	+ const date::weekday_last& wdl) NOEXCEPT
		3382	+ : y_(y)
		3383	+ , m_(m)
		3384	+ , wdl_(wdl)
		3385	+ {}
		3386	+
		3387	+template<class>
		3388	+CONSTCD14
		3389	+inline
		3390	+year_month_weekday_last&
		3391	+year_month_weekday_last::operator+=(const months& m) NOEXCEPT
		3392	+{
		3393	+ this = this + m;
		3394	+ return *this;
		3395	+}
		3396	+
		3397	+template<class>
		3398	+CONSTCD14
		3399	+inline
		3400	+year_month_weekday_last&
		3401	+year_month_weekday_last::operator-=(const months& m) NOEXCEPT
		3402	+{
		3403	+ this = this - m;
		3404	+ return *this;
		3405	+}
		3406	+
		3407	+CONSTCD14
		3408	+inline
		3409	+year_month_weekday_last&
		3410	+year_month_weekday_last::operator+=(const years& y) NOEXCEPT
		3411	+{
		3412	+ this = this + y;
		3413	+ return *this;
		3414	+}
		3415	+
		3416	+CONSTCD14
		3417	+inline
		3418	+year_month_weekday_last&
		3419	+year_month_weekday_last::operator-=(const years& y) NOEXCEPT
		3420	+{
		3421	+ this = this - y;
		3422	+ return *this;
		3423	+}
		3424	+
		3425	+CONSTCD11 inline year year_month_weekday_last::year() const NOEXCEPT {return y_;}
		3426	+CONSTCD11 inline month year_month_weekday_last::month() const NOEXCEPT {return m_;}
		3427	+
		3428	+CONSTCD11
		3429	+inline
		3430	+weekday
		3431	+year_month_weekday_last::weekday() const NOEXCEPT
		3432	+{
		3433	+ return wdl_.weekday();
		3434	+}
		3435	+
		3436	+CONSTCD11
		3437	+inline
		3438	+weekday_last
		3439	+year_month_weekday_last::weekday_last() const NOEXCEPT
		3440	+{
		3441	+ return wdl_;
		3442	+}
		3443	+
		3444	+CONSTCD14
		3445	+inline
		3446	+year_month_weekday_last::operator sys_days() const NOEXCEPT
		3447	+{
		3448	+ return sys_days{to_days()};
		3449	+}
		3450	+
		3451	+CONSTCD14
		3452	+inline
		3453	+year_month_weekday_last::operator local_days() const NOEXCEPT
		3454	+{
		3455	+ return local_days{to_days()};
		3456	+}
		3457	+
		3458	+CONSTCD11
		3459	+inline
		3460	+bool
		3461	+year_month_weekday_last::ok() const NOEXCEPT
		3462	+{
		3463	+ return y_.ok() && m_.ok() && wdl_.ok();
		3464	+}
		3465	+
		3466	+CONSTCD14
		3467	+inline
		3468	+days
		3469	+year_month_weekday_last::to_days() const NOEXCEPT
		3470	+{
		3471	+ auto const d = sys_days(y_/m_/last);
		3472	+ return (d - (date::weekday{d} - wdl_.weekday())).time_since_epoch();
		3473	+}
		3474	+
		3475	+CONSTCD11
		3476	+inline
		3477	+bool
		3478	+operator==(const year_month_weekday_last& x, const year_month_weekday_last& y) NOEXCEPT
		3479	+{
		3480	+ return x.year() == y.year() && x.month() == y.month() &&
		3481	+ x.weekday_last() == y.weekday_last();
		3482	+}
		3483	+
		3484	+CONSTCD11
		3485	+inline
		3486	+bool
		3487	+operator!=(const year_month_weekday_last& x, const year_month_weekday_last& y) NOEXCEPT
		3488	+{
		3489	+ return !(x == y);
		3490	+}
		3491	+
		3492	+template<class CharT, class Traits>
		3493	+inline
		3494	+std::basic_ostream<CharT, Traits>&
		3495	+operator<<(std::basic_ostream<CharT, Traits>& os, const year_month_weekday_last& ymwdl)
		3496	+{
		3497	+ detail::low_level_fmt(os, ymwdl.year()) << '/';
		3498	+ detail::low_level_fmt(os, ymwdl.month()) << '/';
		3499	+ detail::low_level_fmt(os, ymwdl.weekday_last());
		3500	+ if (!ymwdl.ok())
		3501	+ os << " is not a valid year_month_weekday_last";
		3502	+ return os;
		3503	+}
		3504	+
		3505	+template<class>
		3506	+CONSTCD14
		3507	+inline
		3508	+year_month_weekday_last
		3509	+operator+(const year_month_weekday_last& ymwdl, const months& dm) NOEXCEPT
		3510	+{
		3511	+ return (ymwdl.year() / ymwdl.month() + dm) / ymwdl.weekday_last();
		3512	+}
		3513	+
		3514	+template<class>
		3515	+CONSTCD14
		3516	+inline
		3517	+year_month_weekday_last
		3518	+operator+(const months& dm, const year_month_weekday_last& ymwdl) NOEXCEPT
		3519	+{
		3520	+ return ymwdl + dm;
		3521	+}
		3522	+
		3523	+template<class>
		3524	+CONSTCD14
		3525	+inline
		3526	+year_month_weekday_last
		3527	+operator-(const year_month_weekday_last& ymwdl, const months& dm) NOEXCEPT
		3528	+{
		3529	+ return ymwdl + (-dm);
		3530	+}
		3531	+
		3532	+CONSTCD11
		3533	+inline
		3534	+year_month_weekday_last
		3535	+operator+(const year_month_weekday_last& ymwdl, const years& dy) NOEXCEPT
		3536	+{
		3537	+ return {ymwdl.year()+dy, ymwdl.month(), ymwdl.weekday_last()};
		3538	+}
		3539	+
		3540	+CONSTCD11
		3541	+inline
		3542	+year_month_weekday_last
		3543	+operator+(const years& dy, const year_month_weekday_last& ymwdl) NOEXCEPT
		3544	+{
		3545	+ return ymwdl + dy;
		3546	+}
		3547	+
		3548	+CONSTCD11
		3549	+inline
		3550	+year_month_weekday_last
		3551	+operator-(const year_month_weekday_last& ymwdl, const years& dy) NOEXCEPT
		3552	+{
		3553	+ return ymwdl + (-dy);
		3554	+}
		3555	+
		3556	+// year_month from operator/()
		3557	+
		3558	+CONSTCD11
		3559	+inline
		3560	+year_month
		3561	+operator/(const year& y, const month& m) NOEXCEPT
		3562	+{
		3563	+ return {y, m};
		3564	+}
		3565	+
		3566	+CONSTCD11
		3567	+inline
		3568	+year_month
		3569	+operator/(const year& y, int m) NOEXCEPT
		3570	+{
		3571	+ return y / month(static_cast<unsigned>(m));
		3572	+}
		3573	+
		3574	+// month_day from operator/()
		3575	+
		3576	+CONSTCD11
		3577	+inline
		3578	+month_day
		3579	+operator/(const month& m, const day& d) NOEXCEPT
		3580	+{
		3581	+ return {m, d};
		3582	+}
		3583	+
		3584	+CONSTCD11
		3585	+inline
		3586	+month_day
		3587	+operator/(const day& d, const month& m) NOEXCEPT
		3588	+{
		3589	+ return m / d;
		3590	+}
		3591	+
		3592	+CONSTCD11
		3593	+inline
		3594	+month_day
		3595	+operator/(const month& m, int d) NOEXCEPT
		3596	+{
		3597	+ return m / day(static_cast<unsigned>(d));
		3598	+}
		3599	+
		3600	+CONSTCD11
		3601	+inline
		3602	+month_day
		3603	+operator/(int m, const day& d) NOEXCEPT
		3604	+{
		3605	+ return month(static_cast<unsigned>(m)) / d;
		3606	+}
		3607	+
		3608	+CONSTCD11 inline month_day operator/(const day& d, int m) NOEXCEPT {return m / d;}
		3609	+
		3610	+// month_day_last from operator/()
		3611	+
		3612	+CONSTCD11
		3613	+inline
		3614	+month_day_last
		3615	+operator/(const month& m, last_spec) NOEXCEPT
		3616	+{
		3617	+ return month_day_last{m};
		3618	+}
		3619	+
		3620	+CONSTCD11
		3621	+inline
		3622	+month_day_last
		3623	+operator/(last_spec, const month& m) NOEXCEPT
		3624	+{
		3625	+ return m/last;
		3626	+}
		3627	+
		3628	+CONSTCD11
		3629	+inline
		3630	+month_day_last
		3631	+operator/(int m, last_spec) NOEXCEPT
		3632	+{
		3633	+ return month(static_cast<unsigned>(m))/last;
		3634	+}
		3635	+
		3636	+CONSTCD11
		3637	+inline
		3638	+month_day_last
		3639	+operator/(last_spec, int m) NOEXCEPT
		3640	+{
		3641	+ return m/last;
		3642	+}
		3643	+
		3644	+// month_weekday from operator/()
		3645	+
		3646	+CONSTCD11
		3647	+inline
		3648	+month_weekday
		3649	+operator/(const month& m, const weekday_indexed& wdi) NOEXCEPT
		3650	+{
		3651	+ return {m, wdi};
		3652	+}
		3653	+
		3654	+CONSTCD11
		3655	+inline
		3656	+month_weekday
		3657	+operator/(const weekday_indexed& wdi, const month& m) NOEXCEPT
		3658	+{
		3659	+ return m / wdi;
		3660	+}
		3661	+
		3662	+CONSTCD11
		3663	+inline
		3664	+month_weekday
		3665	+operator/(int m, const weekday_indexed& wdi) NOEXCEPT
		3666	+{
		3667	+ return month(static_cast<unsigned>(m)) / wdi;
		3668	+}
		3669	+
		3670	+CONSTCD11
		3671	+inline
		3672	+month_weekday
		3673	+operator/(const weekday_indexed& wdi, int m) NOEXCEPT
		3674	+{
		3675	+ return m / wdi;
		3676	+}
		3677	+
		3678	+// month_weekday_last from operator/()
		3679	+
		3680	+CONSTCD11
		3681	+inline
		3682	+month_weekday_last
		3683	+operator/(const month& m, const weekday_last& wdl) NOEXCEPT
		3684	+{
		3685	+ return {m, wdl};
		3686	+}
		3687	+
		3688	+CONSTCD11
		3689	+inline
		3690	+month_weekday_last
		3691	+operator/(const weekday_last& wdl, const month& m) NOEXCEPT
		3692	+{
		3693	+ return m / wdl;
		3694	+}
		3695	+
		3696	+CONSTCD11
		3697	+inline
		3698	+month_weekday_last
		3699	+operator/(int m, const weekday_last& wdl) NOEXCEPT
		3700	+{
		3701	+ return month(static_cast<unsigned>(m)) / wdl;
		3702	+}
		3703	+
		3704	+CONSTCD11
		3705	+inline
		3706	+month_weekday_last
		3707	+operator/(const weekday_last& wdl, int m) NOEXCEPT
		3708	+{
		3709	+ return m / wdl;
		3710	+}
		3711	+
		3712	+// year_month_day from operator/()
		3713	+
		3714	+CONSTCD11
		3715	+inline
		3716	+year_month_day
		3717	+operator/(const year_month& ym, const day& d) NOEXCEPT
		3718	+{
		3719	+ return {ym.year(), ym.month(), d};
		3720	+}
		3721	+
		3722	+CONSTCD11
		3723	+inline
		3724	+year_month_day
		3725	+operator/(const year_month& ym, int d) NOEXCEPT
		3726	+{
		3727	+ return ym / day(static_cast<unsigned>(d));
		3728	+}
		3729	+
		3730	+CONSTCD11
		3731	+inline
		3732	+year_month_day
		3733	+operator/(const year& y, const month_day& md) NOEXCEPT
		3734	+{
		3735	+ return y / md.month() / md.day();
		3736	+}
		3737	+
		3738	+CONSTCD11
		3739	+inline
		3740	+year_month_day
		3741	+operator/(int y, const month_day& md) NOEXCEPT
		3742	+{
		3743	+ return year(y) / md;
		3744	+}
		3745	+
		3746	+CONSTCD11
		3747	+inline
		3748	+year_month_day
		3749	+operator/(const month_day& md, const year& y) NOEXCEPT
		3750	+{
		3751	+ return y / md;
		3752	+}
		3753	+
		3754	+CONSTCD11
		3755	+inline
		3756	+year_month_day
		3757	+operator/(const month_day& md, int y) NOEXCEPT
		3758	+{
		3759	+ return year(y) / md;
		3760	+}
		3761	+
		3762	+// year_month_day_last from operator/()
		3763	+
		3764	+CONSTCD11
		3765	+inline
		3766	+year_month_day_last
		3767	+operator/(const year_month& ym, last_spec) NOEXCEPT
		3768	+{
		3769	+ return {ym.year(), month_day_last{ym.month()}};
		3770	+}
		3771	+
		3772	+CONSTCD11
		3773	+inline
		3774	+year_month_day_last
		3775	+operator/(const year& y, const month_day_last& mdl) NOEXCEPT
		3776	+{
		3777	+ return {y, mdl};
		3778	+}
		3779	+
		3780	+CONSTCD11
		3781	+inline
		3782	+year_month_day_last
		3783	+operator/(int y, const month_day_last& mdl) NOEXCEPT
		3784	+{
		3785	+ return year(y) / mdl;
		3786	+}
		3787	+
		3788	+CONSTCD11
		3789	+inline
		3790	+year_month_day_last
		3791	+operator/(const month_day_last& mdl, const year& y) NOEXCEPT
		3792	+{
		3793	+ return y / mdl;
		3794	+}
		3795	+
		3796	+CONSTCD11
		3797	+inline
		3798	+year_month_day_last
		3799	+operator/(const month_day_last& mdl, int y) NOEXCEPT
		3800	+{
		3801	+ return year(y) / mdl;
		3802	+}
		3803	+
		3804	+// year_month_weekday from operator/()
		3805	+
		3806	+CONSTCD11
		3807	+inline
		3808	+year_month_weekday
		3809	+operator/(const year_month& ym, const weekday_indexed& wdi) NOEXCEPT
		3810	+{
		3811	+ return {ym.year(), ym.month(), wdi};
		3812	+}
		3813	+
		3814	+CONSTCD11
		3815	+inline
		3816	+year_month_weekday
		3817	+operator/(const year& y, const month_weekday& mwd) NOEXCEPT
		3818	+{
		3819	+ return {y, mwd.month(), mwd.weekday_indexed()};
		3820	+}
		3821	+
		3822	+CONSTCD11
		3823	+inline
		3824	+year_month_weekday
		3825	+operator/(int y, const month_weekday& mwd) NOEXCEPT
		3826	+{
		3827	+ return year(y) / mwd;
		3828	+}
		3829	+
		3830	+CONSTCD11
		3831	+inline
		3832	+year_month_weekday
		3833	+operator/(const month_weekday& mwd, const year& y) NOEXCEPT
		3834	+{
		3835	+ return y / mwd;
		3836	+}
		3837	+
		3838	+CONSTCD11
		3839	+inline
		3840	+year_month_weekday
		3841	+operator/(const month_weekday& mwd, int y) NOEXCEPT
		3842	+{
		3843	+ return year(y) / mwd;
		3844	+}
		3845	+
		3846	+// year_month_weekday_last from operator/()
		3847	+
		3848	+CONSTCD11
		3849	+inline
		3850	+year_month_weekday_last
		3851	+operator/(const year_month& ym, const weekday_last& wdl) NOEXCEPT
		3852	+{
		3853	+ return {ym.year(), ym.month(), wdl};
		3854	+}
		3855	+
		3856	+CONSTCD11
		3857	+inline
		3858	+year_month_weekday_last
		3859	+operator/(const year& y, const month_weekday_last& mwdl) NOEXCEPT
		3860	+{
		3861	+ return {y, mwdl.month(), mwdl.weekday_last()};
		3862	+}
		3863	+
		3864	+CONSTCD11
		3865	+inline
		3866	+year_month_weekday_last
		3867	+operator/(int y, const month_weekday_last& mwdl) NOEXCEPT
		3868	+{
		3869	+ return year(y) / mwdl;
		3870	+}
		3871	+
		3872	+CONSTCD11
		3873	+inline
		3874	+year_month_weekday_last
		3875	+operator/(const month_weekday_last& mwdl, const year& y) NOEXCEPT
		3876	+{
		3877	+ return y / mwdl;
		3878	+}
		3879	+
		3880	+CONSTCD11
		3881	+inline
		3882	+year_month_weekday_last
		3883	+operator/(const month_weekday_last& mwdl, int y) NOEXCEPT
		3884	+{
		3885	+ return year(y) / mwdl;
		3886	+}
		3887	+
		3888	+template <class Duration>
		3889	+struct fields;
		3890	+
		3891	+template <class CharT, class Traits, class Duration>
		3892	+std::basic_ostream<CharT, Traits>&
		3893	+to_stream(std::basic_ostream<CharT, Traits>& os, const CharT* fmt,
		3894	+ const fields<Duration>& fds, const std::string* abbrev = nullptr,
		3895	+ const std::chrono::seconds* offset_sec = nullptr);
		3896	+
		3897	+template <class CharT, class Traits, class Duration, class Alloc>
		3898	+std::basic_istream<CharT, Traits>&
		3899	+from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt,
		3900	+ fields<Duration>& fds, std::basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
		3901	+ std::chrono::minutes* offset = nullptr);
		3902	+
		3903	+// hh_mm_ss
		3904	+
		3905	+namespace detail
		3906	+{
		3907	+
		3908	+struct undocumented {explicit undocumented() = default;};
		3909	+
		3910	+// width<n>::value is the number of fractional decimal digits in 1/n
		3911	+// width<0>::value and width<1>::value are defined to be 0
		3912	+// If 1/n takes more than 18 fractional decimal digits,
		3913	+// the result is truncated to 19.
		3914	+// Example: width<2>::value == 1
		3915	+// Example: width<3>::value == 19
		3916	+// Example: width<4>::value == 2
		3917	+// Example: width<10>::value == 1
		3918	+// Example: width<1000>::value == 3
		3919	+template <std::uint64_t n, std::uint64_t d, unsigned w = 0,
		3920	+ bool should_continue = n%d != 0 && (w < 19)>
		3921	+struct width
		3922	+{
		3923	+ static_assert(d > 0, "width called with zero denominator");
		3924	+ static CONSTDATA unsigned value = 1 + width<n%d*10, d, w+1>::value;
		3925	+};
		3926	+
		3927	+template <std::uint64_t n, std::uint64_t d, unsigned w>
		3928	+struct width<n, d, w, false>
		3929	+{
		3930	+ static CONSTDATA unsigned value = 0;
		3931	+};
		3932	+
		3933	+template <unsigned exp>
		3934	+struct static_pow10
		3935	+{
		3936	+private:
		3937	+ static CONSTDATA std::uint64_t h = static_pow10<exp/2>::value;
		3938	+public:
		3939	+ static CONSTDATA std::uint64_t value = h * h * (exp % 2 ? 10 : 1);
		3940	+};
		3941	+
		3942	+template <>
		3943	+struct static_pow10<0>
		3944	+{
		3945	+ static CONSTDATA std::uint64_t value = 1;
		3946	+};
		3947	+
		3948	+template <class Duration>
		3949	+class decimal_format_seconds
		3950	+{
		3951	+ using CT = typename std::common_type<Duration, std::chrono::seconds>::type;
		3952	+ using rep = typename CT::rep;
		3953	+ static unsigned CONSTDATA trial_width =
		3954	+ detail::width<CT::period::num, CT::period::den>::value;
		3955	+public:
		3956	+ static unsigned CONSTDATA width = trial_width < 19 ? trial_width : 6u;
		3957	+ using precision = std::chrono::duration<rep,
		3958	+ std::ratio<1, static_pow10<width>::value>>;
		3959	+
		3960	+private:
		3961	+ std::chrono::seconds s_;
		3962	+ precision sub_s_;
		3963	+
		3964	+public:
		3965	+ CONSTCD11 decimal_format_seconds()
		3966	+ : s_()
		3967	+ , sub_s_()
		3968	+ {}
		3969	+
		3970	+ CONSTCD11 explicit decimal_format_seconds(const Duration& d) NOEXCEPT
		3971	+ : s_(std::chrono::duration_cast<std::chrono::seconds>(d))
		3972	+ , sub_s_(std::chrono::duration_cast<precision>(d - s_))
		3973	+ {}
		3974	+
		3975	+ CONSTCD14 std::chrono::seconds& seconds() NOEXCEPT {return s_;}
		3976	+ CONSTCD11 std::chrono::seconds seconds() const NOEXCEPT {return s_;}
		3977	+ CONSTCD11 precision subseconds() const NOEXCEPT {return sub_s_;}
		3978	+
		3979	+ CONSTCD14 precision to_duration() const NOEXCEPT
		3980	+ {
		3981	+ return s_ + sub_s_;
		3982	+ }
		3983	+
		3984	+ CONSTCD11 bool in_conventional_range() const NOEXCEPT
		3985	+ {
		3986	+ return sub_s_ < std::chrono::seconds{1} && s_ < std::chrono::minutes{1};
		3987	+ }
		3988	+
		3989	+ template <class CharT, class Traits>
		3990	+ friend
		3991	+ std::basic_ostream<CharT, Traits>&
		3992	+ operator<<(std::basic_ostream<CharT, Traits>& os, const decimal_format_seconds& x)
		3993	+ {
		3994	+ return x.print(os, std::chrono::treat_as_floating_point<rep>{});
		3995	+ }
		3996	+
		3997	+ template <class CharT, class Traits>
		3998	+ std::basic_ostream<CharT, Traits>&
		3999	+ print(std::basic_ostream<CharT, Traits>& os, std::true_type) const
		4000	+ {
		4001	+ date::detail::save_ostream<CharT, Traits> _(os);
		4002	+ std::chrono::duration<rep> d = s_ + sub_s_;
		4003	+ if (d < std::chrono::seconds{10})
		4004	+ os << '0';
		4005	+ os.precision(width+6);
		4006	+ os << std::fixed << d.count();
		4007	+ return os;
		4008	+ }
		4009	+
		4010	+ template <class CharT, class Traits>
		4011	+ std::basic_ostream<CharT, Traits>&
		4012	+ print(std::basic_ostream<CharT, Traits>& os, std::false_type) const
		4013	+ {
		4014	+ date::detail::save_ostream<CharT, Traits> _(os);
		4015	+ os.fill('0');
		4016	+ os.flags(std::ios::dec \| std::ios::right);
		4017	+ os.width(2);
		4018	+ os << s_.count();
		4019	+ if (width > 0)
		4020	+ {
		4021	+#if !ONLY_C_LOCALE
		4022	+ os << std::use_facet<std::numpunct<CharT>>(os.getloc()).decimal_point();
		4023	+#else
		4024	+ os << '.';
		4025	+#endif
		4026	+ date::detail::save_ostream<CharT, Traits> _s(os);
		4027	+ os.imbue(std::locale::classic());
		4028	+ os.width(width);
		4029	+ os << sub_s_.count();
		4030	+ }
		4031	+ return os;
		4032	+ }
		4033	+};
		4034	+
		4035	+template <class Rep, class Period>
		4036	+inline
		4037	+CONSTCD11
		4038	+typename std::enable_if
		4039	+ <
		4040	+ std::numeric_limits<Rep>::is_signed,
		4041	+ std::chrono::duration<Rep, Period>
		4042	+ >::type
		4043	+abs(std::chrono::duration<Rep, Period> d)
		4044	+{
		4045	+ return d >= d.zero() ? +d : -d;
		4046	+}
		4047	+
		4048	+template <class Rep, class Period>
		4049	+inline
		4050	+CONSTCD11
		4051	+typename std::enable_if
		4052	+ <
		4053	+ !std::numeric_limits<Rep>::is_signed,
		4054	+ std::chrono::duration<Rep, Period>
		4055	+ >::type
		4056	+abs(std::chrono::duration<Rep, Period> d)
		4057	+{
		4058	+ return d;
		4059	+}
		4060	+
		4061	+} // namespace detail
		4062	+
		4063	+template <class Duration>
		4064	+class hh_mm_ss
		4065	+{
		4066	+ using dfs = detail::decimal_format_seconds<typename std::common_type<Duration,
		4067	+ std::chrono::seconds>::type>;
		4068	+
		4069	+ std::chrono::hours h_;
		4070	+ std::chrono::minutes m_;
		4071	+ dfs s_;
		4072	+ bool neg_;
		4073	+
		4074	+public:
		4075	+ static unsigned CONSTDATA fractional_width = dfs::width;
		4076	+ using precision = typename dfs::precision;
		4077	+
		4078	+ CONSTCD11 hh_mm_ss() NOEXCEPT
		4079	+ : hh_mm_ss(Duration::zero())
		4080	+ {}
		4081	+
		4082	+ CONSTCD11 explicit hh_mm_ss(Duration d) NOEXCEPT
		4083	+ : h_(std::chrono::duration_cast<std::chrono::hours>(detail::abs(d)))
		4084	+ , m_(std::chrono::duration_cast<std::chrono::minutes>(detail::abs(d)) - h_)
		4085	+ , s_(detail::abs(d) - h_ - m_)
		4086	+ , neg_(d < Duration::zero())
		4087	+ {}
		4088	+
		4089	+ CONSTCD11 std::chrono::hours hours() const NOEXCEPT {return h_;}
		4090	+ CONSTCD11 std::chrono::minutes minutes() const NOEXCEPT {return m_;}
		4091	+ CONSTCD11 std::chrono::seconds seconds() const NOEXCEPT {return s_.seconds();}
		4092	+ CONSTCD14 std::chrono::seconds&
		4093	+ seconds(detail::undocumented) NOEXCEPT {return s_.seconds();}
		4094	+ CONSTCD11 precision subseconds() const NOEXCEPT {return s_.subseconds();}
		4095	+ CONSTCD11 bool is_negative() const NOEXCEPT {return neg_;}
		4096	+
		4097	+ CONSTCD11 explicit operator precision() const NOEXCEPT {return to_duration();}
		4098	+ CONSTCD11 precision to_duration() const NOEXCEPT
		4099	+ {return (s_.to_duration() + m_ + h_) * (1-2*neg_);}
		4100	+
		4101	+ CONSTCD11 bool in_conventional_range() const NOEXCEPT
		4102	+ {
		4103	+ return !neg_ && h_ < days{1} && m_ < std::chrono::hours{1} &&
		4104	+ s_.in_conventional_range();
		4105	+ }
		4106	+
		4107	+private:
		4108	+
		4109	+ template <class charT, class traits>
		4110	+ friend
		4111	+ std::basic_ostream<charT, traits>&
		4112	+ operator<<(std::basic_ostream<charT, traits>& os, hh_mm_ss const& tod)
		4113	+ {
		4114	+ if (tod.is_negative())
		4115	+ os << '-';
		4116	+ if (tod.h_ < std::chrono::hours{10})
		4117	+ os << '0';
		4118	+ os << tod.h_.count() << ':';
		4119	+ if (tod.m_ < std::chrono::minutes{10})
		4120	+ os << '0';
		4121	+ os << tod.m_.count() << ':' << tod.s_;
		4122	+ return os;
		4123	+ }
		4124	+
		4125	+ template <class CharT, class Traits, class Duration2>
		4126	+ friend
		4127	+ std::basic_ostream<CharT, Traits>&
		4128	+ date::to_stream(std::basic_ostream<CharT, Traits>& os, const CharT* fmt,
		4129	+ const fields<Duration2>& fds, const std::string* abbrev,
		4130	+ const std::chrono::seconds* offset_sec);
		4131	+
		4132	+ template <class CharT, class Traits, class Duration2, class Alloc>
		4133	+ friend
		4134	+ std::basic_istream<CharT, Traits>&
		4135	+ date::from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt,
		4136	+ fields<Duration2>& fds,
		4137	+ std::basic_string<CharT, Traits, Alloc>* abbrev, std::chrono::minutes* offset);
		4138	+};
		4139	+
		4140	+inline
		4141	+CONSTCD14
		4142	+bool
		4143	+is_am(std::chrono::hours const& h) NOEXCEPT
		4144	+{
		4145	+ using std::chrono::hours;
		4146	+ return hours{0} <= h && h < hours{12};
		4147	+}
		4148	+
		4149	+inline
		4150	+CONSTCD14
		4151	+bool
		4152	+is_pm(std::chrono::hours const& h) NOEXCEPT
		4153	+{
		4154	+ using std::chrono::hours;
		4155	+ return hours{12} <= h && h < hours{24};
		4156	+}
		4157	+
		4158	+inline
		4159	+CONSTCD14
		4160	+std::chrono::hours
		4161	+make12(std::chrono::hours h) NOEXCEPT
		4162	+{
		4163	+ using std::chrono::hours;
		4164	+ if (h < hours{12})
		4165	+ {
		4166	+ if (h == hours{0})
		4167	+ h = hours{12};
		4168	+ }
		4169	+ else
		4170	+ {
		4171	+ if (h != hours{12})
		4172	+ h = h - hours{12};
		4173	+ }
		4174	+ return h;
		4175	+}
		4176	+
		4177	+inline
		4178	+CONSTCD14
		4179	+std::chrono::hours
		4180	+make24(std::chrono::hours h, bool is_pm) NOEXCEPT
		4181	+{
		4182	+ using std::chrono::hours;
		4183	+ if (is_pm)
		4184	+ {
		4185	+ if (h != hours{12})
		4186	+ h = h + hours{12};
		4187	+ }
		4188	+ else if (h == hours{12})
		4189	+ h = hours{0};
		4190	+ return h;
		4191	+}
		4192	+
		4193	+template <class Duration>
		4194	+using time_of_day = hh_mm_ss<Duration>;
		4195	+
		4196	+template <class Rep, class Period>
		4197	+CONSTCD11
		4198	+inline
		4199	+hh_mm_ss<std::chrono::duration<Rep, Period>>
		4200	+make_time(const std::chrono::duration<Rep, Period>& d)
		4201	+{
		4202	+ return hh_mm_ss<std::chrono::duration<Rep, Period>>(d);
		4203	+}
		4204	+
		4205	+template <class CharT, class Traits, class Duration>
		4206	+inline
		4207	+typename std::enable_if
		4208	+<
		4209	+ std::ratio_less<typename Duration::period, days::period>::value
		4210	+ , std::basic_ostream<CharT, Traits>&
		4211	+>::type
		4212	+operator<<(std::basic_ostream<CharT, Traits>& os, const sys_time<Duration>& tp)
		4213	+{
		4214	+ auto const dp = date::floor<days>(tp);
		4215	+ return os << year_month_day(dp) << ' ' << make_time(tp-dp);
		4216	+}
		4217	+
		4218	+template <class CharT, class Traits>
		4219	+inline
		4220	+std::basic_ostream<CharT, Traits>&
		4221	+operator<<(std::basic_ostream<CharT, Traits>& os, const sys_days& dp)
		4222	+{
		4223	+ return os << year_month_day(dp);
		4224	+}
		4225	+
		4226	+template <class CharT, class Traits, class Duration>
		4227	+inline
		4228	+std::basic_ostream<CharT, Traits>&
		4229	+operator<<(std::basic_ostream<CharT, Traits>& os, const local_time<Duration>& ut)
		4230	+{
		4231	+ return (os << sys_time<Duration>{ut.time_since_epoch()});
		4232	+}
		4233	+
		4234	+namespace detail
		4235	+{
		4236	+
		4237	+template <class CharT, std::size_t N>
		4238	+class string_literal;
		4239	+
		4240	+template <class CharT1, class CharT2, std::size_t N1, std::size_t N2>
		4241	+inline
		4242	+CONSTCD14
		4243	+string_literal<typename std::conditional<sizeof(CharT2) <= sizeof(CharT1), CharT1, CharT2>::type,
		4244	+ N1 + N2 - 1>
		4245	+operator+(const string_literal<CharT1, N1>& x, const string_literal<CharT2, N2>& y) NOEXCEPT;
		4246	+
		4247	+template <class CharT, std::size_t N>
		4248	+class string_literal
		4249	+{
		4250	+ CharT p_[N];
		4251	+
		4252	+ CONSTCD11 string_literal() NOEXCEPT
		4253	+ : p_{}
		4254	+ {}
		4255	+
		4256	+public:
		4257	+ using const_iterator = const CharT*;
		4258	+
		4259	+ string_literal(string_literal const&) = default;
		4260	+ string_literal& operator=(string_literal const&) = delete;
		4261	+
		4262	+ template <std::size_t N1 = 2,
		4263	+ class = typename std::enable_if<N1 == N>::type>
		4264	+ CONSTCD11 string_literal(CharT c) NOEXCEPT
		4265	+ : p_{c}
		4266	+ {
		4267	+ }
		4268	+
		4269	+ template <std::size_t N1 = 3,
		4270	+ class = typename std::enable_if<N1 == N>::type>
		4271	+ CONSTCD11 string_literal(CharT c1, CharT c2) NOEXCEPT
		4272	+ : p_{c1, c2}
		4273	+ {
		4274	+ }
		4275	+
		4276	+ template <std::size_t N1 = 4,
		4277	+ class = typename std::enable_if<N1 == N>::type>
		4278	+ CONSTCD11 string_literal(CharT c1, CharT c2, CharT c3) NOEXCEPT
		4279	+ : p_{c1, c2, c3}
		4280	+ {
		4281	+ }
		4282	+
		4283	+ CONSTCD14 string_literal(const CharT(&a)[N]) NOEXCEPT
		4284	+ : p_{}
		4285	+ {
		4286	+ for (std::size_t i = 0; i < N; ++i)
		4287	+ p_[i] = a[i];
		4288	+ }
		4289	+
		4290	+ template <class U = CharT,
		4291	+ class = typename std::enable_if<(1 < sizeof(U))>::type>
		4292	+ CONSTCD14 string_literal(const char(&a)[N]) NOEXCEPT
		4293	+ : p_{}
		4294	+ {
		4295	+ for (std::size_t i = 0; i < N; ++i)
		4296	+ p_[i] = a[i];
		4297	+ }
		4298	+
		4299	+ template <class CharT2,
		4300	+ class = typename std::enable_if<!std::is_same<CharT2, CharT>::value>::type>
		4301	+ CONSTCD14 string_literal(string_literal<CharT2, N> const& a) NOEXCEPT
		4302	+ : p_{}
		4303	+ {
		4304	+ for (std::size_t i = 0; i < N; ++i)
		4305	+ p_[i] = a[i];
		4306	+ }
		4307	+
		4308	+ CONSTCD11 const CharT* data() const NOEXCEPT {return p_;}
		4309	+ CONSTCD11 std::size_t size() const NOEXCEPT {return N-1;}
		4310	+
		4311	+ CONSTCD11 const_iterator begin() const NOEXCEPT {return p_;}
		4312	+ CONSTCD11 const_iterator end() const NOEXCEPT {return p_ + N-1;}
		4313	+
		4314	+ CONSTCD11 CharT const& operator[](std::size_t n) const NOEXCEPT
		4315	+ {
		4316	+ return p_[n];
		4317	+ }
		4318	+
		4319	+ template <class Traits>
		4320	+ friend
		4321	+ std::basic_ostream<CharT, Traits>&
		4322	+ operator<<(std::basic_ostream<CharT, Traits>& os, const string_literal& s)
		4323	+ {
		4324	+ return os << s.p_;
		4325	+ }
		4326	+
		4327	+ template <class CharT1, class CharT2, std::size_t N1, std::size_t N2>
		4328	+ friend
		4329	+ CONSTCD14
		4330	+ string_literal<typename std::conditional<sizeof(CharT2) <= sizeof(CharT1), CharT1, CharT2>::type,
		4331	+ N1 + N2 - 1>
		4332	+ operator+(const string_literal<CharT1, N1>& x, const string_literal<CharT2, N2>& y) NOEXCEPT;
		4333	+};
		4334	+
		4335	+template <class CharT>
		4336	+CONSTCD11
		4337	+inline
		4338	+string_literal<CharT, 3>
		4339	+operator+(const string_literal<CharT, 2>& x, const string_literal<CharT, 2>& y) NOEXCEPT
		4340	+{
		4341	+ return string_literal<CharT, 3>(x[0], y[0]);
		4342	+}
		4343	+
		4344	+template <class CharT>
		4345	+CONSTCD11
		4346	+inline
		4347	+string_literal<CharT, 4>
		4348	+operator+(const string_literal<CharT, 3>& x, const string_literal<CharT, 2>& y) NOEXCEPT
		4349	+{
		4350	+ return string_literal<CharT, 4>(x[0], x[1], y[0]);
		4351	+}
		4352	+
		4353	+template <class CharT1, class CharT2, std::size_t N1, std::size_t N2>
		4354	+CONSTCD14
		4355	+inline
		4356	+string_literal<typename std::conditional<sizeof(CharT2) <= sizeof(CharT1), CharT1, CharT2>::type,
		4357	+ N1 + N2 - 1>
		4358	+operator+(const string_literal<CharT1, N1>& x, const string_literal<CharT2, N2>& y) NOEXCEPT
		4359	+{
		4360	+ using CT = typename std::conditional<sizeof(CharT2) <= sizeof(CharT1), CharT1, CharT2>::type;
		4361	+
		4362	+ string_literal<CT, N1 + N2 - 1> r;
		4363	+ std::size_t i = 0;
		4364	+ for (; i < N1-1; ++i)
		4365	+ r.p_[i] = CT(x.p_[i]);
		4366	+ for (std::size_t j = 0; j < N2; ++j, ++i)
		4367	+ r.p_[i] = CT(y.p_[j]);
		4368	+
		4369	+ return r;
		4370	+}
		4371	+
		4372	+
		4373	+template <class CharT, class Traits, class Alloc, std::size_t N>
		4374	+inline
		4375	+std::basic_string<CharT, Traits, Alloc>
		4376	+operator+(std::basic_string<CharT, Traits, Alloc> x, const string_literal<CharT, N>& y)
		4377	+{
		4378	+ x.append(y.data(), y.size());
		4379	+ return x;
		4380	+}
		4381	+
		4382	+#if __cplusplus >= 201402 && (!defined(__EDG_VERSION__) \|\| __EDG_VERSION__ > 411) \
		4383	+ && (!defined(__SUNPRO_CC) \|\| __SUNPRO_CC > 0x5150)
		4384	+
		4385	+template <class CharT,
		4386	+ class = std::enable_if_t<std::is_same<CharT, char>::value \|\|
		4387	+ std::is_same<CharT, wchar_t>::value \|\|
		4388	+ std::is_same<CharT, char16_t>::value \|\|
		4389	+ std::is_same<CharT, char32_t>::value>>
		4390	+CONSTCD14
		4391	+inline
		4392	+string_literal<CharT, 2>
		4393	+msl(CharT c) NOEXCEPT
		4394	+{
		4395	+ return string_literal<CharT, 2>{c};
		4396	+}
		4397	+
		4398	+CONSTCD14
		4399	+inline
		4400	+std::size_t
		4401	+to_string_len(std::intmax_t i)
		4402	+{
		4403	+ std::size_t r = 0;
		4404	+ do
		4405	+ {
		4406	+ i /= 10;
		4407	+ ++r;
		4408	+ } while (i > 0);
		4409	+ return r;
		4410	+}
		4411	+
		4412	+template <std::intmax_t N>
		4413	+CONSTCD14
		4414	+inline
		4415	+std::enable_if_t
		4416	+<
		4417	+ N < 10,
		4418	+ string_literal<char, to_string_len(N)+1>
		4419	+>
		4420	+msl() NOEXCEPT
		4421	+{
		4422	+ return msl(char(N % 10 + '0'));
		4423	+}
		4424	+
		4425	+template <std::intmax_t N>
		4426	+CONSTCD14
		4427	+inline
		4428	+std::enable_if_t
		4429	+<
		4430	+ 10 <= N,
		4431	+ string_literal<char, to_string_len(N)+1>
		4432	+>
		4433	+msl() NOEXCEPT
		4434	+{
		4435	+ return msl<N/10>() + msl(char(N % 10 + '0'));
		4436	+}
		4437	+
		4438	+template <class CharT, std::intmax_t N, std::intmax_t D>
		4439	+CONSTCD14
		4440	+inline
		4441	+std::enable_if_t
		4442	+<
		4443	+ std::ratio<N, D>::type::den != 1,
		4444	+ string_literal<CharT, to_string_len(std::ratio<N, D>::type::num) +
		4445	+ to_string_len(std::ratio<N, D>::type::den) + 4>
		4446	+>
		4447	+msl(std::ratio<N, D>) NOEXCEPT
		4448	+{
		4449	+ using R = typename std::ratio<N, D>::type;
		4450	+ return msl(CharT{'['}) + msl<R::num>() + msl(CharT{'/'}) +
		4451	+ msl<R::den>() + msl(CharT{']'});
		4452	+}
		4453	+
		4454	+template <class CharT, std::intmax_t N, std::intmax_t D>
		4455	+CONSTCD14
		4456	+inline
		4457	+std::enable_if_t
		4458	+<
		4459	+ std::ratio<N, D>::type::den == 1,
		4460	+ string_literal<CharT, to_string_len(std::ratio<N, D>::type::num) + 3>
		4461	+>
		4462	+msl(std::ratio<N, D>) NOEXCEPT
		4463	+{
		4464	+ using R = typename std::ratio<N, D>::type;
		4465	+ return msl(CharT{'['}) + msl<R::num>() + msl(CharT{']'});
		4466	+}
		4467	+
		4468	+
		4469	+#else // __cplusplus < 201402 \|\| (defined(__EDG_VERSION__) && __EDG_VERSION__ <= 411)
		4470	+
		4471	+inline
		4472	+std::string
		4473	+to_string(std::uint64_t x)
		4474	+{
		4475	+ return std::to_string(x);
		4476	+}
		4477	+
		4478	+template <class CharT>
		4479	+inline
		4480	+std::basic_string<CharT>
		4481	+to_string(std::uint64_t x)
		4482	+{
		4483	+ auto y = std::to_string(x);
		4484	+ return std::basic_string<CharT>(y.begin(), y.end());
		4485	+}
		4486	+
		4487	+template <class CharT, std::intmax_t N, std::intmax_t D>
		4488	+inline
		4489	+typename std::enable_if
		4490	+<
		4491	+ std::ratio<N, D>::type::den != 1,
		4492	+ std::basic_string<CharT>
		4493	+>::type
		4494	+msl(std::ratio<N, D>)
		4495	+{
		4496	+ using R = typename std::ratio<N, D>::type;
		4497	+ return std::basic_string<CharT>(1, '[') + to_string<CharT>(R::num) + CharT{'/'} +
		4498	+ to_string<CharT>(R::den) + CharT{']'};
		4499	+}
		4500	+
		4501	+template <class CharT, std::intmax_t N, std::intmax_t D>
		4502	+inline
		4503	+typename std::enable_if
		4504	+<
		4505	+ std::ratio<N, D>::type::den == 1,
		4506	+ std::basic_string<CharT>
		4507	+>::type
		4508	+msl(std::ratio<N, D>)
		4509	+{
		4510	+ using R = typename std::ratio<N, D>::type;
		4511	+ return std::basic_string<CharT>(1, '[') + to_string<CharT>(R::num) + CharT{']'};
		4512	+}
		4513	+
		4514	+#endif // __cplusplus < 201402 \|\| (defined(__EDG_VERSION__) && __EDG_VERSION__ <= 411)
		4515	+
		4516	+template <class CharT>
		4517	+CONSTCD11
		4518	+inline
		4519	+string_literal<CharT, 2>
		4520	+msl(std::atto) NOEXCEPT
		4521	+{
		4522	+ return string_literal<CharT, 2>{'a'};
		4523	+}
		4524	+
		4525	+template <class CharT>
		4526	+CONSTCD11
		4527	+inline
		4528	+string_literal<CharT, 2>
		4529	+msl(std::femto) NOEXCEPT
		4530	+{
		4531	+ return string_literal<CharT, 2>{'f'};
		4532	+}
		4533	+
		4534	+template <class CharT>
		4535	+CONSTCD11
		4536	+inline
		4537	+string_literal<CharT, 2>
		4538	+msl(std::pico) NOEXCEPT
		4539	+{
		4540	+ return string_literal<CharT, 2>{'p'};
		4541	+}
		4542	+
		4543	+template <class CharT>
		4544	+CONSTCD11
		4545	+inline
		4546	+string_literal<CharT, 2>
		4547	+msl(std::nano) NOEXCEPT
		4548	+{
		4549	+ return string_literal<CharT, 2>{'n'};
		4550	+}
		4551	+
		4552	+template <class CharT>
		4553	+CONSTCD11
		4554	+inline
		4555	+typename std::enable_if
		4556	+<
		4557	+ std::is_same<CharT, char>::value,
		4558	+ string_literal<char, 3>
		4559	+>::type
		4560	+msl(std::micro) NOEXCEPT
		4561	+{
		4562	+ return string_literal<char, 3>{'\xC2', '\xB5'};
		4563	+}
		4564	+
		4565	+template <class CharT>
		4566	+CONSTCD11
		4567	+inline
		4568	+typename std::enable_if
		4569	+<
		4570	+ !std::is_same<CharT, char>::value,
		4571	+ string_literal<CharT, 2>
		4572	+>::type
		4573	+msl(std::micro) NOEXCEPT
		4574	+{
		4575	+ return string_literal<CharT, 2>{CharT{static_cast<unsigned char>('\xB5')}};
		4576	+}
		4577	+
		4578	+template <class CharT>
		4579	+CONSTCD11
		4580	+inline
		4581	+string_literal<CharT, 2>
		4582	+msl(std::milli) NOEXCEPT
		4583	+{
		4584	+ return string_literal<CharT, 2>{'m'};
		4585	+}
		4586	+
		4587	+template <class CharT>
		4588	+CONSTCD11
		4589	+inline
		4590	+string_literal<CharT, 2>
		4591	+msl(std::centi) NOEXCEPT
		4592	+{
		4593	+ return string_literal<CharT, 2>{'c'};
		4594	+}
		4595	+
		4596	+template <class CharT>
		4597	+CONSTCD11
		4598	+inline
		4599	+string_literal<CharT, 3>
		4600	+msl(std::deca) NOEXCEPT
		4601	+{
		4602	+ return string_literal<CharT, 3>{'d', 'a'};
		4603	+}
		4604	+
		4605	+template <class CharT>
		4606	+CONSTCD11
		4607	+inline
		4608	+string_literal<CharT, 2>
		4609	+msl(std::deci) NOEXCEPT
		4610	+{
		4611	+ return string_literal<CharT, 2>{'d'};
		4612	+}
		4613	+
		4614	+template <class CharT>
		4615	+CONSTCD11
		4616	+inline
		4617	+string_literal<CharT, 2>
		4618	+msl(std::hecto) NOEXCEPT
		4619	+{
		4620	+ return string_literal<CharT, 2>{'h'};
		4621	+}
		4622	+
		4623	+template <class CharT>
		4624	+CONSTCD11
		4625	+inline
		4626	+string_literal<CharT, 2>
		4627	+msl(std::kilo) NOEXCEPT
		4628	+{
		4629	+ return string_literal<CharT, 2>{'k'};
		4630	+}
		4631	+
		4632	+template <class CharT>
		4633	+CONSTCD11
		4634	+inline
		4635	+string_literal<CharT, 2>
		4636	+msl(std::mega) NOEXCEPT
		4637	+{
		4638	+ return string_literal<CharT, 2>{'M'};
		4639	+}
		4640	+
		4641	+template <class CharT>
		4642	+CONSTCD11
		4643	+inline
		4644	+string_literal<CharT, 2>
		4645	+msl(std::giga) NOEXCEPT
		4646	+{
		4647	+ return string_literal<CharT, 2>{'G'};
		4648	+}
		4649	+
		4650	+template <class CharT>
		4651	+CONSTCD11
		4652	+inline
		4653	+string_literal<CharT, 2>
		4654	+msl(std::tera) NOEXCEPT
		4655	+{
		4656	+ return string_literal<CharT, 2>{'T'};
		4657	+}
		4658	+
		4659	+template <class CharT>
		4660	+CONSTCD11
		4661	+inline
		4662	+string_literal<CharT, 2>
		4663	+msl(std::peta) NOEXCEPT
		4664	+{
		4665	+ return string_literal<CharT, 2>{'P'};
		4666	+}
		4667	+
		4668	+template <class CharT>
		4669	+CONSTCD11
		4670	+inline
		4671	+string_literal<CharT, 2>
		4672	+msl(std::exa) NOEXCEPT
		4673	+{
		4674	+ return string_literal<CharT, 2>{'E'};
		4675	+}
		4676	+
		4677	+template <class CharT, class Period>
		4678	+CONSTCD11
		4679	+inline
		4680	+auto
		4681	+get_units(Period p)
		4682	+ -> decltype(msl<CharT>(p) + string_literal<CharT, 2>{'s'})
		4683	+{
		4684	+ return msl<CharT>(p) + string_literal<CharT, 2>{'s'};
		4685	+}
		4686	+
		4687	+template <class CharT>
		4688	+CONSTCD11
		4689	+inline
		4690	+string_literal<CharT, 2>
		4691	+get_units(std::ratio<1>)
		4692	+{
		4693	+ return string_literal<CharT, 2>{'s'};
		4694	+}
		4695	+
		4696	+template <class CharT>
		4697	+CONSTCD11
		4698	+inline
		4699	+string_literal<CharT, 2>
		4700	+get_units(std::ratio<3600>)
		4701	+{
		4702	+ return string_literal<CharT, 2>{'h'};
		4703	+}
		4704	+
		4705	+template <class CharT>
		4706	+CONSTCD11
		4707	+inline
		4708	+string_literal<CharT, 4>
		4709	+get_units(std::ratio<60>)
		4710	+{
		4711	+ return string_literal<CharT, 4>{'m', 'i', 'n'};
		4712	+}
		4713	+
		4714	+template <class CharT>
		4715	+CONSTCD11
		4716	+inline
		4717	+string_literal<CharT, 2>
		4718	+get_units(std::ratio<86400>)
		4719	+{
		4720	+ return string_literal<CharT, 2>{'d'};
		4721	+}
		4722	+
		4723	+template <class CharT, class Traits = std::char_traits<CharT>>
		4724	+struct make_string;
		4725	+
		4726	+template <>
		4727	+struct make_string<char>
		4728	+{
		4729	+ template <class Rep>
		4730	+ static
		4731	+ std::string
		4732	+ from(Rep n)
		4733	+ {
		4734	+ return std::to_string(n);
		4735	+ }
		4736	+};
		4737	+
		4738	+template <class Traits>
		4739	+struct make_string<char, Traits>
		4740	+{
		4741	+ template <class Rep>
		4742	+ static
		4743	+ std::basic_string<char, Traits>
		4744	+ from(Rep n)
		4745	+ {
		4746	+ auto s = std::to_string(n);
		4747	+ return std::basic_string<char, Traits>(s.begin(), s.end());
		4748	+ }
		4749	+};
		4750	+
		4751	+template <>
		4752	+struct make_string<wchar_t>
		4753	+{
		4754	+ template <class Rep>
		4755	+ static
		4756	+ std::wstring
		4757	+ from(Rep n)
		4758	+ {
		4759	+ return std::to_wstring(n);
		4760	+ }
		4761	+};
		4762	+
		4763	+template <class Traits>
		4764	+struct make_string<wchar_t, Traits>
		4765	+{
		4766	+ template <class Rep>
		4767	+ static
		4768	+ std::basic_string<wchar_t, Traits>
		4769	+ from(Rep n)
		4770	+ {
		4771	+ auto s = std::to_wstring(n);
		4772	+ return std::basic_string<wchar_t, Traits>(s.begin(), s.end());
		4773	+ }
		4774	+};
		4775	+
		4776	+} // namespace detail
		4777	+
		4778	+// to_stream
		4779	+
		4780	+CONSTDATA year nanyear{-32768};
		4781	+
		4782	+template <class Duration>
		4783	+struct fields
		4784	+{
		4785	+ year_month_day ymd{nanyear/0/0};
		4786	+ weekday wd{8u};
		4787	+ hh_mm_ss<Duration> tod{};
		4788	+ bool has_tod = false;
		4789	+
		4790	+#if !defined(__clang__) && defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ <= 409)
		4791	+ fields() : ymd{nanyear/0/0}, wd{8u}, tod{}, has_tod{false} {}
		4792	+#else
		4793	+ fields() = default;
		4794	+#endif
		4795	+
		4796	+ fields(year_month_day ymd_) : ymd(ymd_) {}
		4797	+ fields(weekday wd_) : wd(wd_) {}
		4798	+ fields(hh_mm_ss<Duration> tod_) : tod(tod_), has_tod(true) {}
		4799	+
		4800	+ fields(year_month_day ymd_, weekday wd_) : ymd(ymd_), wd(wd_) {}
		4801	+ fields(year_month_day ymd_, hh_mm_ss<Duration> tod_) : ymd(ymd_), tod(tod_),
		4802	+ has_tod(true) {}
		4803	+
		4804	+ fields(weekday wd_, hh_mm_ss<Duration> tod_) : wd(wd_), tod(tod_), has_tod(true) {}
		4805	+
		4806	+ fields(year_month_day ymd_, weekday wd_, hh_mm_ss<Duration> tod_)
		4807	+ : ymd(ymd_)
		4808	+ , wd(wd_)
		4809	+ , tod(tod_)
		4810	+ , has_tod(true)
		4811	+ {}
		4812	+};
		4813	+
		4814	+namespace detail
		4815	+{
		4816	+
		4817	+template <class CharT, class Traits, class Duration>
		4818	+unsigned
		4819	+extract_weekday(std::basic_ostream<CharT, Traits>& os, const fields<Duration>& fds)
		4820	+{
		4821	+ if (!fds.ymd.ok() && !fds.wd.ok())
		4822	+ {
		4823	+ // fds does not contain a valid weekday
		4824	+ os.setstate(std::ios::failbit);
		4825	+ return 8;
		4826	+ }
		4827	+ weekday wd;
		4828	+ if (fds.ymd.ok())
		4829	+ {
		4830	+ wd = weekday{sys_days(fds.ymd)};
		4831	+ if (fds.wd.ok() && wd != fds.wd)
		4832	+ {
		4833	+ // fds.ymd and fds.wd are inconsistent
		4834	+ os.setstate(std::ios::failbit);
		4835	+ return 8;
		4836	+ }
		4837	+ }
		4838	+ else
		4839	+ wd = fds.wd;
		4840	+ return static_cast<unsigned>((wd - Sunday).count());
		4841	+}
		4842	+
		4843	+template <class CharT, class Traits, class Duration>
		4844	+unsigned
		4845	+extract_month(std::basic_ostream<CharT, Traits>& os, const fields<Duration>& fds)
		4846	+{
		4847	+ if (!fds.ymd.month().ok())
		4848	+ {
		4849	+ // fds does not contain a valid month
		4850	+ os.setstate(std::ios::failbit);
		4851	+ return 0;
		4852	+ }
		4853	+ return static_cast<unsigned>(fds.ymd.month());
		4854	+}
		4855	+
		4856	+} // namespace detail
		4857	+
		4858	+#if ONLY_C_LOCALE
		4859	+
		4860	+namespace detail
		4861	+{
		4862	+
		4863	+inline
		4864	+std::pair<const std::string, const std::string>
		4865	+weekday_names()
		4866	+{
		4867	+ static const std::string nm[] =
		4868	+ {
		4869	+ "Sunday",
		4870	+ "Monday",
		4871	+ "Tuesday",
		4872	+ "Wednesday",
		4873	+ "Thursday",
		4874	+ "Friday",
		4875	+ "Saturday",
		4876	+ "Sun",
		4877	+ "Mon",
		4878	+ "Tue",
		4879	+ "Wed",
		4880	+ "Thu",
		4881	+ "Fri",
		4882	+ "Sat"
		4883	+ };
		4884	+ return std::make_pair(nm, nm+sizeof(nm)/sizeof(nm[0]));
		4885	+}
		4886	+
		4887	+inline
		4888	+std::pair<const std::string, const std::string>
		4889	+month_names()
		4890	+{
		4891	+ static const std::string nm[] =
		4892	+ {
		4893	+ "January",
		4894	+ "February",
		4895	+ "March",
		4896	+ "April",
		4897	+ "May",
		4898	+ "June",
		4899	+ "July",
		4900	+ "August",
		4901	+ "September",
		4902	+ "October",
		4903	+ "November",
		4904	+ "December",
		4905	+ "Jan",
		4906	+ "Feb",
		4907	+ "Mar",
		4908	+ "Apr",
		4909	+ "May",
		4910	+ "Jun",
		4911	+ "Jul",
		4912	+ "Aug",
		4913	+ "Sep",
		4914	+ "Oct",
		4915	+ "Nov",
		4916	+ "Dec"
		4917	+ };
		4918	+ return std::make_pair(nm, nm+sizeof(nm)/sizeof(nm[0]));
		4919	+}
		4920	+
		4921	+inline
		4922	+std::pair<const std::string, const std::string>
		4923	+ampm_names()
		4924	+{
		4925	+ static const std::string nm[] =
		4926	+ {
		4927	+ "AM",
		4928	+ "PM"
		4929	+ };
		4930	+ return std::make_pair(nm, nm+sizeof(nm)/sizeof(nm[0]));
		4931	+}
		4932	+
		4933	+template <class CharT, class Traits, class FwdIter>
		4934	+FwdIter
		4935	+scan_keyword(std::basic_istream<CharT, Traits>& is, FwdIter kb, FwdIter ke)
		4936	+{
		4937	+ size_t nkw = static_cast<size_t>(std::distance(kb, ke));
		4938	+ const unsigned char doesnt_match = '\0';
		4939	+ const unsigned char might_match = '\1';
		4940	+ const unsigned char does_match = '\2';
		4941	+ unsigned char statbuf[100];
		4942	+ unsigned char* status = statbuf;
		4943	+ std::unique_ptr<unsigned char, void()(void)> stat_hold(0, free);
		4944	+ if (nkw > sizeof(statbuf))
		4945	+ {
		4946	+ status = (unsigned char*)std::malloc(nkw);
		4947	+ if (status == nullptr)
		4948	+ throw std::bad_alloc();
		4949	+ stat_hold.reset(status);
		4950	+ }
		4951	+ size_t n_might_match = nkw; // At this point, any keyword might match
		4952	+ size_t n_does_match = 0; // but none of them definitely do
		4953	+ // Initialize all statuses to might_match, except for "" keywords are does_match
		4954	+ unsigned char* st = status;
		4955	+ for (auto ky = kb; ky != ke; ++ky, ++st)
		4956	+ {
		4957	+ if (!ky->empty())
		4958	+ *st = might_match;
		4959	+ else
		4960	+ {
		4961	+ *st = does_match;
		4962	+ --n_might_match;
		4963	+ ++n_does_match;
		4964	+ }
		4965	+ }
		4966	+ // While there might be a match, test keywords against the next CharT
		4967	+ for (size_t indx = 0; is && n_might_match > 0; ++indx)
		4968	+ {
		4969	+ // Peek at the next CharT but don't consume it
		4970	+ auto ic = is.peek();
		4971	+ if (ic == EOF)
		4972	+ {
		4973	+ is.setstate(std::ios::eofbit);
		4974	+ break;
		4975	+ }
		4976	+ auto c = static_cast<char>(toupper(static_cast<unsigned char>(ic)));
		4977	+ bool consume = false;
		4978	+ // For each keyword which might match, see if the indx character is c
		4979	+ // If a match if found, consume c
		4980	+ // If a match is found, and that is the last character in the keyword,
		4981	+ // then that keyword matches.
		4982	+ // If the keyword doesn't match this character, then change the keyword
		4983	+ // to doesn't match
		4984	+ st = status;
		4985	+ for (auto ky = kb; ky != ke; ++ky, ++st)
		4986	+ {
		4987	+ if (*st == might_match)
		4988	+ {
		4989	+ if (c == static_cast<char>(toupper(static_cast<unsigned char>((*ky)[indx]))))
		4990	+ {
		4991	+ consume = true;
		4992	+ if (ky->size() == indx+1)
		4993	+ {
		4994	+ *st = does_match;
		4995	+ --n_might_match;
		4996	+ ++n_does_match;
		4997	+ }
		4998	+ }
		4999	+ else
		5000	+ {
		5001	+ *st = doesnt_match;
		5002	+ --n_might_match;
		5003	+ }
		5004	+ }
		5005	+ }
		5006	+ // consume if we matched a character
		5007	+ if (consume)
		5008	+ {
		5009	+ (void)is.get();
		5010	+ // If we consumed a character and there might be a matched keyword that
		5011	+ // was marked matched on a previous iteration, then such keywords
		5012	+ // are now marked as not matching.
		5013	+ if (n_might_match + n_does_match > 1)
		5014	+ {
		5015	+ st = status;
		5016	+ for (auto ky = kb; ky != ke; ++ky, ++st)
		5017	+ {
		5018	+ if (*st == does_match && ky->size() != indx+1)
		5019	+ {
		5020	+ *st = doesnt_match;
		5021	+ --n_does_match;
		5022	+ }
		5023	+ }
		5024	+ }
		5025	+ }
		5026	+ }
		5027	+ // We've exited the loop because we hit eof and/or we have no more "might matches".
		5028	+ // Return the first matching result
		5029	+ for (st = status; kb != ke; ++kb, ++st)
		5030	+ if (*st == does_match)
		5031	+ break;
		5032	+ if (kb == ke)
		5033	+ is.setstate(std::ios::failbit);
		5034	+ return kb;
		5035	+}
		5036	+
		5037	+} // namespace detail
		5038	+
		5039	+#endif // ONLY_C_LOCALE
		5040	+
		5041	+template <class CharT, class Traits, class Duration>
		5042	+std::basic_ostream<CharT, Traits>&
		5043	+to_stream(std::basic_ostream<CharT, Traits>& os, const CharT* fmt,
		5044	+ const fields<Duration>& fds, const std::string* abbrev,
		5045	+ const std::chrono::seconds* offset_sec)
		5046	+{
		5047	+#if ONLY_C_LOCALE
		5048	+ using detail::weekday_names;
		5049	+ using detail::month_names;
		5050	+ using detail::ampm_names;
		5051	+#endif
		5052	+ using detail::save_ostream;
		5053	+ using detail::get_units;
		5054	+ using detail::extract_weekday;
		5055	+ using detail::extract_month;
		5056	+ using std::ios;
		5057	+ using std::chrono::duration_cast;
		5058	+ using std::chrono::seconds;
		5059	+ using std::chrono::minutes;
		5060	+ using std::chrono::hours;
		5061	+ date::detail::save_ostream<CharT, Traits> ss(os);
		5062	+ os.fill(' ');
		5063	+ os.flags(std::ios::skipws \| std::ios::dec);
		5064	+ os.width(0);
		5065	+ tm tm{};
		5066	+ bool insert_negative = fds.has_tod && fds.tod.to_duration() < Duration::zero();
		5067	+#if !ONLY_C_LOCALE
		5068	+ auto& facet = std::use_facet<std::time_put<CharT>>(os.getloc());
		5069	+#endif
		5070	+ const CharT* command = nullptr;
		5071	+ CharT modified = CharT{};
		5072	+ for (; *fmt; ++fmt)
		5073	+ {
		5074	+ switch (*fmt)
		5075	+ {
		5076	+ case 'a':
		5077	+ case 'A':
		5078	+ if (command)
		5079	+ {
		5080	+ if (modified == CharT{})
		5081	+ {
		5082	+ tm.tm_wday = static_cast<int>(extract_weekday(os, fds));
		5083	+ if (os.fail())
		5084	+ return os;
		5085	+#if !ONLY_C_LOCALE
		5086	+ const CharT f[] = {'%', *fmt};
		5087	+ facet.put(os, os, os.fill(), &tm, std::begin(f), std::end(f));
		5088	+#else // ONLY_C_LOCALE
		5089	+ os << weekday_names().first[tm.tm_wday+7(fmt == 'a')];
		5090	+#endif // ONLY_C_LOCALE
		5091	+ }
		5092	+ else
		5093	+ {
		5094	+ os << CharT{'%'} << modified << *fmt;
		5095	+ modified = CharT{};
		5096	+ }
		5097	+ command = nullptr;
		5098	+ }
		5099	+ else
		5100	+ os << *fmt;
		5101	+ break;
		5102	+ case 'b':
		5103	+ case 'B':
		5104	+ case 'h':
		5105	+ if (command)
		5106	+ {
		5107	+ if (modified == CharT{})
		5108	+ {
		5109	+ tm.tm_mon = static_cast<int>(extract_month(os, fds)) - 1;
		5110	+#if !ONLY_C_LOCALE
		5111	+ const CharT f[] = {'%', *fmt};
		5112	+ facet.put(os, os, os.fill(), &tm, std::begin(f), std::end(f));
		5113	+#else // ONLY_C_LOCALE
		5114	+ os << month_names().first[tm.tm_mon+12(fmt != 'B')];
		5115	+#endif // ONLY_C_LOCALE
		5116	+ }
		5117	+ else
		5118	+ {
		5119	+ os << CharT{'%'} << modified << *fmt;
		5120	+ modified = CharT{};
		5121	+ }
		5122	+ command = nullptr;
		5123	+ }
		5124	+ else
		5125	+ os << *fmt;
		5126	+ break;
		5127	+ case 'c':
		5128	+ case 'x':
		5129	+ if (command)
		5130	+ {
		5131	+ if (modified == CharT{'O'})
		5132	+ os << CharT{'%'} << modified << *fmt;
		5133	+ else
		5134	+ {
		5135	+ if (!fds.ymd.ok())
		5136	+ os.setstate(std::ios::failbit);
		5137	+ if (*fmt == 'c' && !fds.has_tod)
		5138	+ os.setstate(std::ios::failbit);
		5139	+#if !ONLY_C_LOCALE
		5140	+ tm = std::tm{};
		5141	+ auto const& ymd = fds.ymd;
		5142	+ auto ld = local_days(ymd);
		5143	+ if (*fmt == 'c')
		5144	+ {
		5145	+ tm.tm_sec = static_cast<int>(fds.tod.seconds().count());
		5146	+ tm.tm_min = static_cast<int>(fds.tod.minutes().count());
		5147	+ tm.tm_hour = static_cast<int>(fds.tod.hours().count());
		5148	+ }
		5149	+ tm.tm_mday = static_cast<int>(static_cast<unsigned>(ymd.day()));
		5150	+ tm.tm_mon = static_cast<int>(extract_month(os, fds) - 1);
		5151	+ tm.tm_year = static_cast<int>(ymd.year()) - 1900;
		5152	+ tm.tm_wday = static_cast<int>(extract_weekday(os, fds));
		5153	+ if (os.fail())
		5154	+ return os;
		5155	+ tm.tm_yday = static_cast<int>((ld - local_days(ymd.year()/1/1)).count());
		5156	+ CharT f[3] = {'%'};
		5157	+ auto fe = std::begin(f) + 1;
		5158	+ if (modified == CharT{'E'})
		5159	+ *fe++ = modified;
		5160	+ fe++ = fmt;
		5161	+ facet.put(os, os, os.fill(), &tm, std::begin(f), fe);
		5162	+#else // ONLY_C_LOCALE
		5163	+ if (*fmt == 'c')
		5164	+ {
		5165	+ auto wd = static_cast<int>(extract_weekday(os, fds));
		5166	+ os << weekday_names().first[static_cast<unsigned>(wd)+7]
		5167	+ << ' ';
		5168	+ os << month_names().first[extract_month(os, fds)-1+12] << ' ';
		5169	+ auto d = static_cast<int>(static_cast<unsigned>(fds.ymd.day()));
		5170	+ if (d < 10)
		5171	+ os << ' ';
		5172	+ os << d << ' '
		5173	+ << make_time(duration_cast<seconds>(fds.tod.to_duration()))
		5174	+ << ' ' << fds.ymd.year();
		5175	+
		5176	+ }
		5177	+ else // *fmt == 'x'
		5178	+ {
		5179	+ auto const& ymd = fds.ymd;
		5180	+ save_ostream<CharT, Traits> _(os);
		5181	+ os.fill('0');
		5182	+ os.flags(std::ios::dec \| std::ios::right);
		5183	+ os.width(2);
		5184	+ os << static_cast<unsigned>(ymd.month()) << CharT{'/'};
		5185	+ os.width(2);
		5186	+ os << static_cast<unsigned>(ymd.day()) << CharT{'/'};
		5187	+ os.width(2);
		5188	+ os << static_cast<int>(ymd.year()) % 100;
		5189	+ }
		5190	+#endif // ONLY_C_LOCALE
		5191	+ }
		5192	+ command = nullptr;
		5193	+ modified = CharT{};
		5194	+ }
		5195	+ else
		5196	+ os << *fmt;
		5197	+ break;
		5198	+ case 'C':
		5199	+ if (command)
		5200	+ {
		5201	+ if (modified == CharT{'O'})
		5202	+ os << CharT{'%'} << modified << *fmt;
		5203	+ else
		5204	+ {
		5205	+ if (!fds.ymd.year().ok())
		5206	+ os.setstate(std::ios::failbit);
		5207	+ auto y = static_cast<int>(fds.ymd.year());
		5208	+#if !ONLY_C_LOCALE
		5209	+ if (modified == CharT{})
		5210	+#endif
		5211	+ {
		5212	+ save_ostream<CharT, Traits> _(os);
		5213	+ os.fill('0');
		5214	+ os.flags(std::ios::dec \| std::ios::right);
		5215	+ if (y >= 0)
		5216	+ {
		5217	+ os.width(2);
		5218	+ os << y/100;
		5219	+ }
		5220	+ else
		5221	+ {
		5222	+ os << CharT{'-'};
		5223	+ os.width(2);
		5224	+ os << -(y-99)/100;
		5225	+ }
		5226	+ }
		5227	+#if !ONLY_C_LOCALE
		5228	+ else if (modified == CharT{'E'})
		5229	+ {
		5230	+ tm.tm_year = y - 1900;
		5231	+ CharT f[3] = {'%', 'E', 'C'};
		5232	+ facet.put(os, os, os.fill(), &tm, std::begin(f), std::end(f));
		5233	+ }
		5234	+#endif
		5235	+ }
		5236	+ command = nullptr;
		5237	+ modified = CharT{};
		5238	+ }
		5239	+ else
		5240	+ os << *fmt;
		5241	+ break;
		5242	+ case 'd':
		5243	+ case 'e':
		5244	+ if (command)
		5245	+ {
		5246	+ if (modified == CharT{'E'})
		5247	+ os << CharT{'%'} << modified << *fmt;
		5248	+ else
		5249	+ {
		5250	+ if (!fds.ymd.day().ok())
		5251	+ os.setstate(std::ios::failbit);
		5252	+ auto d = static_cast<int>(static_cast<unsigned>(fds.ymd.day()));
		5253	+#if !ONLY_C_LOCALE
		5254	+ if (modified == CharT{})
		5255	+#endif
		5256	+ {
		5257	+ save_ostream<CharT, Traits> _(os);
		5258	+ if (*fmt == CharT{'d'})
		5259	+ os.fill('0');
		5260	+ else
		5261	+ os.fill(' ');
		5262	+ os.flags(std::ios::dec \| std::ios::right);
		5263	+ os.width(2);
		5264	+ os << d;
		5265	+ }
		5266	+#if !ONLY_C_LOCALE
		5267	+ else if (modified == CharT{'O'})
		5268	+ {
		5269	+ tm.tm_mday = d;
		5270	+ CharT f[3] = {'%', 'O', *fmt};
		5271	+ facet.put(os, os, os.fill(), &tm, std::begin(f), std::end(f));
		5272	+ }
		5273	+#endif
		5274	+ }
		5275	+ command = nullptr;
		5276	+ modified = CharT{};
		5277	+ }
		5278	+ else
		5279	+ os << *fmt;
		5280	+ break;
		5281	+ case 'D':
		5282	+ if (command)
		5283	+ {
		5284	+ if (modified == CharT{})
		5285	+ {
		5286	+ if (!fds.ymd.ok())
		5287	+ os.setstate(std::ios::failbit);
		5288	+ auto const& ymd = fds.ymd;
		5289	+ save_ostream<CharT, Traits> _(os);
		5290	+ os.fill('0');
		5291	+ os.flags(std::ios::dec \| std::ios::right);
		5292	+ os.width(2);
		5293	+ os << static_cast<unsigned>(ymd.month()) << CharT{'/'};
		5294	+ os.width(2);
		5295	+ os << static_cast<unsigned>(ymd.day()) << CharT{'/'};
		5296	+ os.width(2);
		5297	+ os << static_cast<int>(ymd.year()) % 100;
		5298	+ }
		5299	+ else
		5300	+ {
		5301	+ os << CharT{'%'} << modified << *fmt;
		5302	+ modified = CharT{};
		5303	+ }
		5304	+ command = nullptr;
		5305	+ }
		5306	+ else
		5307	+ os << *fmt;
		5308	+ break;
		5309	+ case 'F':
		5310	+ if (command)
		5311	+ {
		5312	+ if (modified == CharT{})
		5313	+ {
		5314	+ if (!fds.ymd.ok())
		5315	+ os.setstate(std::ios::failbit);
		5316	+ auto const& ymd = fds.ymd;
		5317	+ save_ostream<CharT, Traits> _(os);
		5318	+ os.imbue(std::locale::classic());
		5319	+ os.fill('0');
		5320	+ os.flags(std::ios::dec \| std::ios::right);
		5321	+ os.width(4);
		5322	+ os << static_cast<int>(ymd.year()) << CharT{'-'};
		5323	+ os.width(2);
		5324	+ os << static_cast<unsigned>(ymd.month()) << CharT{'-'};
		5325	+ os.width(2);
		5326	+ os << static_cast<unsigned>(ymd.day());
		5327	+ }
		5328	+ else
		5329	+ {
		5330	+ os << CharT{'%'} << modified << *fmt;
		5331	+ modified = CharT{};
		5332	+ }
		5333	+ command = nullptr;
		5334	+ }
		5335	+ else
		5336	+ os << *fmt;
		5337	+ break;
		5338	+ case 'g':
		5339	+ case 'G':
		5340	+ if (command)
		5341	+ {
		5342	+ if (modified == CharT{})
		5343	+ {
		5344	+ if (!fds.ymd.ok())
		5345	+ os.setstate(std::ios::failbit);
		5346	+ auto ld = local_days(fds.ymd);
		5347	+ auto y = year_month_day{ld + days{3}}.year();
		5348	+ auto start = local_days((y-years{1})/December/Thursday[last]) +
		5349	+ (Monday-Thursday);
		5350	+ if (ld < start)
		5351	+ --y;
		5352	+ if (*fmt == CharT{'G'})
		5353	+ os << y;
		5354	+ else
		5355	+ {
		5356	+ save_ostream<CharT, Traits> _(os);
		5357	+ os.fill('0');
		5358	+ os.flags(std::ios::dec \| std::ios::right);
		5359	+ os.width(2);
		5360	+ os << std::abs(static_cast<int>(y)) % 100;
		5361	+ }
		5362	+ }
		5363	+ else
		5364	+ {
		5365	+ os << CharT{'%'} << modified << *fmt;
		5366	+ modified = CharT{};
		5367	+ }
		5368	+ command = nullptr;
		5369	+ }
		5370	+ else
		5371	+ os << *fmt;
		5372	+ break;
		5373	+ case 'H':
		5374	+ case 'I':
		5375	+ if (command)
		5376	+ {
		5377	+ if (modified == CharT{'E'})
		5378	+ os << CharT{'%'} << modified << *fmt;
		5379	+ else
		5380	+ {
		5381	+ if (!fds.has_tod)
		5382	+ os.setstate(std::ios::failbit);
		5383	+ if (insert_negative)
		5384	+ {
		5385	+ os << '-';
		5386	+ insert_negative = false;
		5387	+ }
		5388	+ auto hms = fds.tod;
		5389	+#if !ONLY_C_LOCALE
		5390	+ if (modified == CharT{})
		5391	+#endif
		5392	+ {
		5393	+ auto h = *fmt == CharT{'I'} ? date::make12(hms.hours()) : hms.hours();
		5394	+ if (h < hours{10})
		5395	+ os << CharT{'0'};
		5396	+ os << h.count();
		5397	+ }
		5398	+#if !ONLY_C_LOCALE
		5399	+ else if (modified == CharT{'O'})
		5400	+ {
		5401	+ const CharT f[] = {'%', modified, *fmt};
		5402	+ tm.tm_hour = static_cast<int>(hms.hours().count());
		5403	+ facet.put(os, os, os.fill(), &tm, std::begin(f), std::end(f));
		5404	+ }
		5405	+#endif
		5406	+ }
		5407	+ modified = CharT{};
		5408	+ command = nullptr;
		5409	+ }
		5410	+ else
		5411	+ os << *fmt;
		5412	+ break;
		5413	+ case 'j':
		5414	+ if (command)
		5415	+ {
		5416	+ if (modified == CharT{})
		5417	+ {
		5418	+ if (fds.ymd.ok() \|\| fds.has_tod)
		5419	+ {
		5420	+ days doy;
		5421	+ if (fds.ymd.ok())
		5422	+ {
		5423	+ auto ld = local_days(fds.ymd);
		5424	+ auto y = fds.ymd.year();
		5425	+ doy = ld - local_days(y/January/1) + days{1};
		5426	+ }
		5427	+ else
		5428	+ {
		5429	+ doy = duration_cast<days>(fds.tod.to_duration());
		5430	+ }
		5431	+ save_ostream<CharT, Traits> _(os);
		5432	+ os.fill('0');
		5433	+ os.flags(std::ios::dec \| std::ios::right);
		5434	+ os.width(3);
		5435	+ os << doy.count();
		5436	+ }
		5437	+ else
		5438	+ {
		5439	+ os.setstate(std::ios::failbit);
		5440	+ }
		5441	+ }
		5442	+ else
		5443	+ {
		5444	+ os << CharT{'%'} << modified << *fmt;
		5445	+ modified = CharT{};
		5446	+ }
		5447	+ command = nullptr;
		5448	+ }
		5449	+ else
		5450	+ os << *fmt;
		5451	+ break;
		5452	+ case 'm':
		5453	+ if (command)
		5454	+ {
		5455	+ if (modified == CharT{'E'})
		5456	+ os << CharT{'%'} << modified << *fmt;
		5457	+ else
		5458	+ {
		5459	+ if (!fds.ymd.month().ok())
		5460	+ os.setstate(std::ios::failbit);
		5461	+ auto m = static_cast<unsigned>(fds.ymd.month());
		5462	+#if !ONLY_C_LOCALE
		5463	+ if (modified == CharT{})
		5464	+#endif
		5465	+ {
		5466	+ if (m < 10)
		5467	+ os << CharT{'0'};
		5468	+ os << m;
		5469	+ }
		5470	+#if !ONLY_C_LOCALE
		5471	+ else if (modified == CharT{'O'})
		5472	+ {
		5473	+ const CharT f[] = {'%', modified, *fmt};
		5474	+ tm.tm_mon = static_cast<int>(m-1);
		5475	+ facet.put(os, os, os.fill(), &tm, std::begin(f), std::end(f));
		5476	+ }
		5477	+#endif
		5478	+ }
		5479	+ modified = CharT{};
		5480	+ command = nullptr;
		5481	+ }
		5482	+ else
		5483	+ os << *fmt;
		5484	+ break;
		5485	+ case 'M':
		5486	+ if (command)
		5487	+ {
		5488	+ if (modified == CharT{'E'})
		5489	+ os << CharT{'%'} << modified << *fmt;
		5490	+ else
		5491	+ {
		5492	+ if (!fds.has_tod)
		5493	+ os.setstate(std::ios::failbit);
		5494	+ if (insert_negative)
		5495	+ {
		5496	+ os << '-';
		5497	+ insert_negative = false;
		5498	+ }
		5499	+#if !ONLY_C_LOCALE
		5500	+ if (modified == CharT{})
		5501	+#endif
		5502	+ {
		5503	+ if (fds.tod.minutes() < minutes{10})
		5504	+ os << CharT{'0'};
		5505	+ os << fds.tod.minutes().count();
		5506	+ }
		5507	+#if !ONLY_C_LOCALE
		5508	+ else if (modified == CharT{'O'})
		5509	+ {
		5510	+ const CharT f[] = {'%', modified, *fmt};
		5511	+ tm.tm_min = static_cast<int>(fds.tod.minutes().count());
		5512	+ facet.put(os, os, os.fill(), &tm, std::begin(f), std::end(f));
		5513	+ }
		5514	+#endif
		5515	+ }
		5516	+ modified = CharT{};
		5517	+ command = nullptr;
		5518	+ }
		5519	+ else
		5520	+ os << *fmt;
		5521	+ break;
		5522	+ case 'n':
		5523	+ if (command)
		5524	+ {
		5525	+ if (modified == CharT{})
		5526	+ os << CharT{'\n'};
		5527	+ else
		5528	+ {
		5529	+ os << CharT{'%'} << modified << *fmt;
		5530	+ modified = CharT{};
		5531	+ }
		5532	+ command = nullptr;
		5533	+ }
		5534	+ else
		5535	+ os << *fmt;
		5536	+ break;
		5537	+ case 'p':
		5538	+ if (command)
		5539	+ {
		5540	+ if (modified == CharT{})
		5541	+ {
		5542	+ if (!fds.has_tod)
		5543	+ os.setstate(std::ios::failbit);
		5544	+#if !ONLY_C_LOCALE
		5545	+ const CharT f[] = {'%', *fmt};
		5546	+ tm.tm_hour = static_cast<int>(fds.tod.hours().count());
		5547	+ facet.put(os, os, os.fill(), &tm, std::begin(f), std::end(f));
		5548	+#else
		5549	+ if (date::is_am(fds.tod.hours()))
		5550	+ os << ampm_names().first[0];
		5551	+ else
		5552	+ os << ampm_names().first[1];
		5553	+#endif
		5554	+ }
		5555	+ else
		5556	+ {
		5557	+ os << CharT{'%'} << modified << *fmt;
		5558	+ }
		5559	+ modified = CharT{};
		5560	+ command = nullptr;
		5561	+ }
		5562	+ else
		5563	+ os << *fmt;
		5564	+ break;
		5565	+ case 'Q':
		5566	+ case 'q':
		5567	+ if (command)
		5568	+ {
		5569	+ if (modified == CharT{})
		5570	+ {
		5571	+ if (!fds.has_tod)
		5572	+ os.setstate(std::ios::failbit);
		5573	+ auto d = fds.tod.to_duration();
		5574	+ if (*fmt == 'q')
		5575	+ os << get_units<CharT>(typename decltype(d)::period::type{});
		5576	+ else
		5577	+ os << d.count();
		5578	+ }
		5579	+ else
		5580	+ {
		5581	+ os << CharT{'%'} << modified << *fmt;
		5582	+ }
		5583	+ modified = CharT{};
		5584	+ command = nullptr;
		5585	+ }
		5586	+ else
		5587	+ os << *fmt;
		5588	+ break;
		5589	+ case 'r':
		5590	+ if (command)
		5591	+ {
		5592	+ if (modified == CharT{})
		5593	+ {
		5594	+ if (!fds.has_tod)
		5595	+ os.setstate(std::ios::failbit);
		5596	+#if !ONLY_C_LOCALE
		5597	+ const CharT f[] = {'%', *fmt};
		5598	+ tm.tm_hour = static_cast<int>(fds.tod.hours().count());
		5599	+ tm.tm_min = static_cast<int>(fds.tod.minutes().count());
		5600	+ tm.tm_sec = static_cast<int>(fds.tod.seconds().count());
		5601	+ facet.put(os, os, os.fill(), &tm, std::begin(f), std::end(f));
		5602	+#else
		5603	+ hh_mm_ss<seconds> tod(duration_cast<seconds>(fds.tod.to_duration()));
		5604	+ save_ostream<CharT, Traits> _(os);
		5605	+ os.fill('0');
		5606	+ os.width(2);
		5607	+ os << date::make12(tod.hours()).count() << CharT{':'};
		5608	+ os.width(2);
		5609	+ os << tod.minutes().count() << CharT{':'};
		5610	+ os.width(2);
		5611	+ os << tod.seconds().count() << CharT{' '};
		5612	+ if (date::is_am(tod.hours()))
		5613	+ os << ampm_names().first[0];
		5614	+ else
		5615	+ os << ampm_names().first[1];
		5616	+#endif
		5617	+ }
		5618	+ else
		5619	+ {
		5620	+ os << CharT{'%'} << modified << *fmt;
		5621	+ }
		5622	+ modified = CharT{};
		5623	+ command = nullptr;
		5624	+ }
		5625	+ else
		5626	+ os << *fmt;
		5627	+ break;
		5628	+ case 'R':
		5629	+ if (command)
		5630	+ {
		5631	+ if (modified == CharT{})
		5632	+ {
		5633	+ if (!fds.has_tod)
		5634	+ os.setstate(std::ios::failbit);
		5635	+ if (fds.tod.hours() < hours{10})
		5636	+ os << CharT{'0'};
		5637	+ os << fds.tod.hours().count() << CharT{':'};
		5638	+ if (fds.tod.minutes() < minutes{10})
		5639	+ os << CharT{'0'};
		5640	+ os << fds.tod.minutes().count();
		5641	+ }
		5642	+ else
		5643	+ {
		5644	+ os << CharT{'%'} << modified << *fmt;
		5645	+ modified = CharT{};
		5646	+ }
		5647	+ command = nullptr;
		5648	+ }
		5649	+ else
		5650	+ os << *fmt;
		5651	+ break;
		5652	+ case 'S':
		5653	+ if (command)
		5654	+ {
		5655	+ if (modified == CharT{'E'})
		5656	+ os << CharT{'%'} << modified << *fmt;
		5657	+ else
		5658	+ {
		5659	+ if (!fds.has_tod)
		5660	+ os.setstate(std::ios::failbit);
		5661	+ if (insert_negative)
		5662	+ {
		5663	+ os << '-';
		5664	+ insert_negative = false;
		5665	+ }
		5666	+#if !ONLY_C_LOCALE
		5667	+ if (modified == CharT{})
		5668	+#endif
		5669	+ {
		5670	+ os << fds.tod.s_;
		5671	+ }
		5672	+#if !ONLY_C_LOCALE
		5673	+ else if (modified == CharT{'O'})
		5674	+ {
		5675	+ const CharT f[] = {'%', modified, *fmt};
		5676	+ tm.tm_sec = static_cast<int>(fds.tod.s_.seconds().count());
		5677	+ facet.put(os, os, os.fill(), &tm, std::begin(f), std::end(f));
		5678	+ }
		5679	+#endif
		5680	+ }
		5681	+ modified = CharT{};
		5682	+ command = nullptr;
		5683	+ }
		5684	+ else
		5685	+ os << *fmt;
		5686	+ break;
		5687	+ case 't':
		5688	+ if (command)
		5689	+ {
		5690	+ if (modified == CharT{})
		5691	+ os << CharT{'\t'};
		5692	+ else
		5693	+ {
		5694	+ os << CharT{'%'} << modified << *fmt;
		5695	+ modified = CharT{};
		5696	+ }
		5697	+ command = nullptr;
		5698	+ }
		5699	+ else
		5700	+ os << *fmt;
		5701	+ break;
		5702	+ case 'T':
		5703	+ if (command)
		5704	+ {
		5705	+ if (modified == CharT{})
		5706	+ {
		5707	+ if (!fds.has_tod)
		5708	+ os.setstate(std::ios::failbit);
		5709	+ os << fds.tod;
		5710	+ }
		5711	+ else
		5712	+ {
		5713	+ os << CharT{'%'} << modified << *fmt;
		5714	+ modified = CharT{};
		5715	+ }
		5716	+ command = nullptr;
		5717	+ }
		5718	+ else
		5719	+ os << *fmt;
		5720	+ break;
		5721	+ case 'u':
		5722	+ if (command)
		5723	+ {
		5724	+ if (modified == CharT{'E'})
		5725	+ os << CharT{'%'} << modified << *fmt;
		5726	+ else
		5727	+ {
		5728	+ auto wd = extract_weekday(os, fds);
		5729	+#if !ONLY_C_LOCALE
		5730	+ if (modified == CharT{})
		5731	+#endif
		5732	+ {
		5733	+ os << (wd != 0 ? wd : 7u);
		5734	+ }
		5735	+#if !ONLY_C_LOCALE
		5736	+ else if (modified == CharT{'O'})
		5737	+ {
		5738	+ const CharT f[] = {'%', modified, *fmt};
		5739	+ tm.tm_wday = static_cast<int>(wd);
		5740	+ facet.put(os, os, os.fill(), &tm, std::begin(f), std::end(f));
		5741	+ }
		5742	+#endif
		5743	+ }
		5744	+ modified = CharT{};
		5745	+ command = nullptr;
		5746	+ }
		5747	+ else
		5748	+ os << *fmt;
		5749	+ break;
		5750	+ case 'U':
		5751	+ if (command)
		5752	+ {
		5753	+ if (modified == CharT{'E'})
		5754	+ os << CharT{'%'} << modified << *fmt;
		5755	+ else
		5756	+ {
		5757	+ auto const& ymd = fds.ymd;
		5758	+ if (!ymd.ok())
		5759	+ os.setstate(std::ios::failbit);
		5760	+ auto ld = local_days(ymd);
		5761	+#if !ONLY_C_LOCALE
		5762	+ if (modified == CharT{})
		5763	+#endif
		5764	+ {
		5765	+ auto st = local_days(Sunday[1]/January/ymd.year());
		5766	+ if (ld < st)
		5767	+ os << CharT{'0'} << CharT{'0'};
		5768	+ else
		5769	+ {
		5770	+ auto wn = duration_cast<weeks>(ld - st).count() + 1;
		5771	+ if (wn < 10)
		5772	+ os << CharT{'0'};
		5773	+ os << wn;
		5774	+ }
		5775	+ }
		5776	+ #if !ONLY_C_LOCALE
		5777	+ else if (modified == CharT{'O'})
		5778	+ {
		5779	+ const CharT f[] = {'%', modified, *fmt};
		5780	+ tm.tm_year = static_cast<int>(ymd.year()) - 1900;
		5781	+ tm.tm_wday = static_cast<int>(extract_weekday(os, fds));
		5782	+ if (os.fail())
		5783	+ return os;
		5784	+ tm.tm_yday = static_cast<int>((ld - local_days(ymd.year()/1/1)).count());
		5785	+ facet.put(os, os, os.fill(), &tm, std::begin(f), std::end(f));
		5786	+ }
		5787	+#endif
		5788	+ }
		5789	+ modified = CharT{};
		5790	+ command = nullptr;
		5791	+ }
		5792	+ else
		5793	+ os << *fmt;
		5794	+ break;
		5795	+ case 'V':
		5796	+ if (command)
		5797	+ {
		5798	+ if (modified == CharT{'E'})
		5799	+ os << CharT{'%'} << modified << *fmt;
		5800	+ else
		5801	+ {
		5802	+ if (!fds.ymd.ok())
		5803	+ os.setstate(std::ios::failbit);
		5804	+ auto ld = local_days(fds.ymd);
		5805	+#if !ONLY_C_LOCALE
		5806	+ if (modified == CharT{})
		5807	+#endif
		5808	+ {
		5809	+ auto y = year_month_day{ld + days{3}}.year();
		5810	+ auto st = local_days((y-years{1})/12/Thursday[last]) +
		5811	+ (Monday-Thursday);
		5812	+ if (ld < st)
		5813	+ {
		5814	+ --y;
		5815	+ st = local_days((y - years{1})/12/Thursday[last]) +
		5816	+ (Monday-Thursday);
		5817	+ }
		5818	+ auto wn = duration_cast<weeks>(ld - st).count() + 1;
		5819	+ if (wn < 10)
		5820	+ os << CharT{'0'};
		5821	+ os << wn;
		5822	+ }
		5823	+#if !ONLY_C_LOCALE
		5824	+ else if (modified == CharT{'O'})
		5825	+ {
		5826	+ const CharT f[] = {'%', modified, *fmt};
		5827	+ auto const& ymd = fds.ymd;
		5828	+ tm.tm_year = static_cast<int>(ymd.year()) - 1900;
		5829	+ tm.tm_wday = static_cast<int>(extract_weekday(os, fds));
		5830	+ if (os.fail())
		5831	+ return os;
		5832	+ tm.tm_yday = static_cast<int>((ld - local_days(ymd.year()/1/1)).count());
		5833	+ facet.put(os, os, os.fill(), &tm, std::begin(f), std::end(f));
		5834	+ }
		5835	+#endif
		5836	+ }
		5837	+ modified = CharT{};
		5838	+ command = nullptr;
		5839	+ }
		5840	+ else
		5841	+ os << *fmt;
		5842	+ break;
		5843	+ case 'w':
		5844	+ if (command)
		5845	+ {
		5846	+ auto wd = extract_weekday(os, fds);
		5847	+ if (os.fail())
		5848	+ return os;
		5849	+#if !ONLY_C_LOCALE
		5850	+ if (modified == CharT{})
		5851	+#else
		5852	+ if (modified != CharT{'E'})
		5853	+#endif
		5854	+ {
		5855	+ os << wd;
		5856	+ }
		5857	+#if !ONLY_C_LOCALE
		5858	+ else if (modified == CharT{'O'})
		5859	+ {
		5860	+ const CharT f[] = {'%', modified, *fmt};
		5861	+ tm.tm_wday = static_cast<int>(wd);
		5862	+ facet.put(os, os, os.fill(), &tm, std::begin(f), std::end(f));
		5863	+ }
		5864	+#endif
		5865	+ else
		5866	+ {
		5867	+ os << CharT{'%'} << modified << *fmt;
		5868	+ }
		5869	+ modified = CharT{};
		5870	+ command = nullptr;
		5871	+ }
		5872	+ else
		5873	+ os << *fmt;
		5874	+ break;
		5875	+ case 'W':
		5876	+ if (command)
		5877	+ {
		5878	+ if (modified == CharT{'E'})
		5879	+ os << CharT{'%'} << modified << *fmt;
		5880	+ else
		5881	+ {
		5882	+ auto const& ymd = fds.ymd;
		5883	+ if (!ymd.ok())
		5884	+ os.setstate(std::ios::failbit);
		5885	+ auto ld = local_days(ymd);
		5886	+#if !ONLY_C_LOCALE
		5887	+ if (modified == CharT{})
		5888	+#endif
		5889	+ {
		5890	+ auto st = local_days(Monday[1]/January/ymd.year());
		5891	+ if (ld < st)
		5892	+ os << CharT{'0'} << CharT{'0'};
		5893	+ else
		5894	+ {
		5895	+ auto wn = duration_cast<weeks>(ld - st).count() + 1;
		5896	+ if (wn < 10)
		5897	+ os << CharT{'0'};
		5898	+ os << wn;
		5899	+ }
		5900	+ }
		5901	+#if !ONLY_C_LOCALE
		5902	+ else if (modified == CharT{'O'})
		5903	+ {
		5904	+ const CharT f[] = {'%', modified, *fmt};
		5905	+ tm.tm_year = static_cast<int>(ymd.year()) - 1900;
		5906	+ tm.tm_wday = static_cast<int>(extract_weekday(os, fds));
		5907	+ if (os.fail())
		5908	+ return os;
		5909	+ tm.tm_yday = static_cast<int>((ld - local_days(ymd.year()/1/1)).count());
		5910	+ facet.put(os, os, os.fill(), &tm, std::begin(f), std::end(f));
		5911	+ }
		5912	+#endif
		5913	+ }
		5914	+ modified = CharT{};
		5915	+ command = nullptr;
		5916	+ }
		5917	+ else
		5918	+ os << *fmt;
		5919	+ break;
		5920	+ case 'X':
		5921	+ if (command)
		5922	+ {
		5923	+ if (modified == CharT{'O'})
		5924	+ os << CharT{'%'} << modified << *fmt;
		5925	+ else
		5926	+ {
		5927	+ if (!fds.has_tod)
		5928	+ os.setstate(std::ios::failbit);
		5929	+#if !ONLY_C_LOCALE
		5930	+ tm = std::tm{};
		5931	+ tm.tm_sec = static_cast<int>(fds.tod.seconds().count());
		5932	+ tm.tm_min = static_cast<int>(fds.tod.minutes().count());
		5933	+ tm.tm_hour = static_cast<int>(fds.tod.hours().count());
		5934	+ CharT f[3] = {'%'};
		5935	+ auto fe = std::begin(f) + 1;
		5936	+ if (modified == CharT{'E'})
		5937	+ *fe++ = modified;
		5938	+ fe++ = fmt;
		5939	+ facet.put(os, os, os.fill(), &tm, std::begin(f), fe);
		5940	+#else
		5941	+ os << fds.tod;
		5942	+#endif
		5943	+ }
		5944	+ command = nullptr;
		5945	+ modified = CharT{};
		5946	+ }
		5947	+ else
		5948	+ os << *fmt;
		5949	+ break;
		5950	+ case 'y':
		5951	+ if (command)
		5952	+ {
		5953	+ if (!fds.ymd.year().ok())
		5954	+ os.setstate(std::ios::failbit);
		5955	+ auto y = static_cast<int>(fds.ymd.year());
		5956	+#if !ONLY_C_LOCALE
		5957	+ if (modified == CharT{})
		5958	+ {
		5959	+#endif
		5960	+ y = std::abs(y) % 100;
		5961	+ if (y < 10)
		5962	+ os << CharT{'0'};
		5963	+ os << y;
		5964	+#if !ONLY_C_LOCALE
		5965	+ }
		5966	+ else
		5967	+ {
		5968	+ const CharT f[] = {'%', modified, *fmt};
		5969	+ tm.tm_year = y - 1900;
		5970	+ facet.put(os, os, os.fill(), &tm, std::begin(f), std::end(f));
		5971	+ }
		5972	+#endif
		5973	+ modified = CharT{};
		5974	+ command = nullptr;
		5975	+ }
		5976	+ else
		5977	+ os << *fmt;
		5978	+ break;
		5979	+ case 'Y':
		5980	+ if (command)
		5981	+ {
		5982	+ if (modified == CharT{'O'})
		5983	+ os << CharT{'%'} << modified << *fmt;
		5984	+ else
		5985	+ {
		5986	+ if (!fds.ymd.year().ok())
		5987	+ os.setstate(std::ios::failbit);
		5988	+ auto y = fds.ymd.year();
		5989	+#if !ONLY_C_LOCALE
		5990	+ if (modified == CharT{})
		5991	+#endif
		5992	+ {
		5993	+ save_ostream<CharT, Traits> _(os);
		5994	+ os.imbue(std::locale::classic());
		5995	+ os << y;
		5996	+ }
		5997	+#if !ONLY_C_LOCALE
		5998	+ else if (modified == CharT{'E'})
		5999	+ {
		6000	+ const CharT f[] = {'%', modified, *fmt};
		6001	+ tm.tm_year = static_cast<int>(y) - 1900;
		6002	+ facet.put(os, os, os.fill(), &tm, std::begin(f), std::end(f));
		6003	+ }
		6004	+#endif
		6005	+ }
		6006	+ modified = CharT{};
		6007	+ command = nullptr;
		6008	+ }
		6009	+ else
		6010	+ os << *fmt;
		6011	+ break;
		6012	+ case 'z':
		6013	+ if (command)
		6014	+ {
		6015	+ if (offset_sec == nullptr)
		6016	+ {
		6017	+ // Can not format %z with unknown offset
		6018	+ os.setstate(ios::failbit);
		6019	+ return os;
		6020	+ }
		6021	+ auto m = duration_cast<minutes>(*offset_sec);
		6022	+ auto neg = m < minutes{0};
		6023	+ m = date::abs(m);
		6024	+ auto h = duration_cast<hours>(m);
		6025	+ m -= h;
		6026	+ if (neg)
		6027	+ os << CharT{'-'};
		6028	+ else
		6029	+ os << CharT{'+'};
		6030	+ if (h < hours{10})
		6031	+ os << CharT{'0'};
		6032	+ os << h.count();
		6033	+ if (modified != CharT{})
		6034	+ os << CharT{':'};
		6035	+ if (m < minutes{10})
		6036	+ os << CharT{'0'};
		6037	+ os << m.count();
		6038	+ command = nullptr;
		6039	+ modified = CharT{};
		6040	+ }
		6041	+ else
		6042	+ os << *fmt;
		6043	+ break;
		6044	+ case 'Z':
		6045	+ if (command)
		6046	+ {
		6047	+ if (modified == CharT{})
		6048	+ {
		6049	+ if (abbrev == nullptr)
		6050	+ {
		6051	+ // Can not format %Z with unknown time_zone
		6052	+ os.setstate(ios::failbit);
		6053	+ return os;
		6054	+ }
		6055	+ for (auto c : *abbrev)
		6056	+ os << CharT(c);
		6057	+ }
		6058	+ else
		6059	+ {
		6060	+ os << CharT{'%'} << modified << *fmt;
		6061	+ modified = CharT{};
		6062	+ }
		6063	+ command = nullptr;
		6064	+ }
		6065	+ else
		6066	+ os << *fmt;
		6067	+ break;
		6068	+ case 'E':
		6069	+ case 'O':
		6070	+ if (command)
		6071	+ {
		6072	+ if (modified == CharT{})
		6073	+ {
		6074	+ modified = *fmt;
		6075	+ }
		6076	+ else
		6077	+ {
		6078	+ os << CharT{'%'} << modified << *fmt;
		6079	+ command = nullptr;
		6080	+ modified = CharT{};
		6081	+ }
		6082	+ }
		6083	+ else
		6084	+ os << *fmt;
		6085	+ break;
		6086	+ case '%':
		6087	+ if (command)
		6088	+ {
		6089	+ if (modified == CharT{})
		6090	+ {
		6091	+ os << CharT{'%'};
		6092	+ command = nullptr;
		6093	+ }
		6094	+ else
		6095	+ {
		6096	+ os << CharT{'%'} << modified << CharT{'%'};
		6097	+ command = nullptr;
		6098	+ modified = CharT{};
		6099	+ }
		6100	+ }
		6101	+ else
		6102	+ command = fmt;
		6103	+ break;
		6104	+ default:
		6105	+ if (command)
		6106	+ {
		6107	+ os << CharT{'%'};
		6108	+ command = nullptr;
		6109	+ }
		6110	+ if (modified != CharT{})
		6111	+ {
		6112	+ os << modified;
		6113	+ modified = CharT{};
		6114	+ }
		6115	+ os << *fmt;
		6116	+ break;
		6117	+ }
		6118	+ }
		6119	+ if (command)
		6120	+ os << CharT{'%'};
		6121	+ if (modified != CharT{})
		6122	+ os << modified;
		6123	+ return os;
		6124	+}
		6125	+
		6126	+template <class CharT, class Traits>
		6127	+inline
		6128	+std::basic_ostream<CharT, Traits>&
		6129	+to_stream(std::basic_ostream<CharT, Traits>& os, const CharT* fmt, const year& y)
		6130	+{
		6131	+ using CT = std::chrono::seconds;
		6132	+ fields<CT> fds{y/0/0};
		6133	+ return to_stream(os, fmt, fds);
		6134	+}
		6135	+
		6136	+template <class CharT, class Traits>
		6137	+inline
		6138	+std::basic_ostream<CharT, Traits>&
		6139	+to_stream(std::basic_ostream<CharT, Traits>& os, const CharT* fmt, const month& m)
		6140	+{
		6141	+ using CT = std::chrono::seconds;
		6142	+ fields<CT> fds{m/0/nanyear};
		6143	+ return to_stream(os, fmt, fds);
		6144	+}
		6145	+
		6146	+template <class CharT, class Traits>
		6147	+inline
		6148	+std::basic_ostream<CharT, Traits>&
		6149	+to_stream(std::basic_ostream<CharT, Traits>& os, const CharT* fmt, const day& d)
		6150	+{
		6151	+ using CT = std::chrono::seconds;
		6152	+ fields<CT> fds{d/0/nanyear};
		6153	+ return to_stream(os, fmt, fds);
		6154	+}
		6155	+
		6156	+template <class CharT, class Traits>
		6157	+inline
		6158	+std::basic_ostream<CharT, Traits>&
		6159	+to_stream(std::basic_ostream<CharT, Traits>& os, const CharT* fmt, const weekday& wd)
		6160	+{
		6161	+ using CT = std::chrono::seconds;
		6162	+ fields<CT> fds{wd};
		6163	+ return to_stream(os, fmt, fds);
		6164	+}
		6165	+
		6166	+template <class CharT, class Traits>
		6167	+inline
		6168	+std::basic_ostream<CharT, Traits>&
		6169	+to_stream(std::basic_ostream<CharT, Traits>& os, const CharT* fmt, const year_month& ym)
		6170	+{
		6171	+ using CT = std::chrono::seconds;
		6172	+ fields<CT> fds{ym/0};
		6173	+ return to_stream(os, fmt, fds);
		6174	+}
		6175	+
		6176	+template <class CharT, class Traits>
		6177	+inline
		6178	+std::basic_ostream<CharT, Traits>&
		6179	+to_stream(std::basic_ostream<CharT, Traits>& os, const CharT* fmt, const month_day& md)
		6180	+{
		6181	+ using CT = std::chrono::seconds;
		6182	+ fields<CT> fds{md/nanyear};
		6183	+ return to_stream(os, fmt, fds);
		6184	+}
		6185	+
		6186	+template <class CharT, class Traits>
		6187	+inline
		6188	+std::basic_ostream<CharT, Traits>&
		6189	+to_stream(std::basic_ostream<CharT, Traits>& os, const CharT* fmt,
		6190	+ const year_month_day& ymd)
		6191	+{
		6192	+ using CT = std::chrono::seconds;
		6193	+ fields<CT> fds{ymd};
		6194	+ return to_stream(os, fmt, fds);
		6195	+}
		6196	+
		6197	+template <class CharT, class Traits, class Rep, class Period>
		6198	+inline
		6199	+std::basic_ostream<CharT, Traits>&
		6200	+to_stream(std::basic_ostream<CharT, Traits>& os, const CharT* fmt,
		6201	+ const std::chrono::duration<Rep, Period>& d)
		6202	+{
		6203	+ using Duration = std::chrono::duration<Rep, Period>;
		6204	+ using CT = typename std::common_type<Duration, std::chrono::seconds>::type;
		6205	+ fields<CT> fds{hh_mm_ss<CT>{d}};
		6206	+ return to_stream(os, fmt, fds);
		6207	+}
		6208	+
		6209	+template <class CharT, class Traits, class Duration>
		6210	+std::basic_ostream<CharT, Traits>&
		6211	+to_stream(std::basic_ostream<CharT, Traits>& os, const CharT* fmt,
		6212	+ const local_time<Duration>& tp, const std::string* abbrev = nullptr,
		6213	+ const std::chrono::seconds* offset_sec = nullptr)
		6214	+{
		6215	+ using CT = typename std::common_type<Duration, std::chrono::seconds>::type;
		6216	+ auto ld = std::chrono::time_point_cast<days>(tp);
		6217	+ fields<CT> fds;
		6218	+ if (ld <= tp)
		6219	+ fds = fields<CT>{year_month_day{ld}, hh_mm_ss<CT>{tp-local_seconds{ld}}};
		6220	+ else
		6221	+ fds = fields<CT>{year_month_day{ld - days{1}},
		6222	+ hh_mm_ss<CT>{days{1} - (local_seconds{ld} - tp)}};
		6223	+ return to_stream(os, fmt, fds, abbrev, offset_sec);
		6224	+}
		6225	+
		6226	+template <class CharT, class Traits, class Duration>
		6227	+std::basic_ostream<CharT, Traits>&
		6228	+to_stream(std::basic_ostream<CharT, Traits>& os, const CharT* fmt,
		6229	+ const sys_time<Duration>& tp)
		6230	+{
		6231	+ using std::chrono::seconds;
		6232	+ using CT = typename std::common_type<Duration, seconds>::type;
		6233	+ const std::string abbrev("UTC");
		6234	+ CONSTDATA seconds offset{0};
		6235	+ auto sd = std::chrono::time_point_cast<days>(tp);
		6236	+ fields<CT> fds;
		6237	+ if (sd <= tp)
		6238	+ fds = fields<CT>{year_month_day{sd}, hh_mm_ss<CT>{tp-sys_seconds{sd}}};
		6239	+ else
		6240	+ fds = fields<CT>{year_month_day{sd - days{1}},
		6241	+ hh_mm_ss<CT>{days{1} - (sys_seconds{sd} - tp)}};
		6242	+ return to_stream(os, fmt, fds, &abbrev, &offset);
		6243	+}
		6244	+
		6245	+// format
		6246	+
		6247	+template <class CharT, class Streamable>
		6248	+auto
		6249	+format(const std::locale& loc, const CharT* fmt, const Streamable& tp)
		6250	+ -> decltype(to_stream(std::declval<std::basic_ostream<CharT>&>(), fmt, tp),
		6251	+ std::basic_string<CharT>{})
		6252	+{
		6253	+ std::basic_ostringstream<CharT> os;
		6254	+ os.exceptions(std::ios::failbit \| std::ios::badbit);
		6255	+ os.imbue(loc);
		6256	+ to_stream(os, fmt, tp);
		6257	+ return os.str();
		6258	+}
		6259	+
		6260	+template <class CharT, class Streamable>
		6261	+auto
		6262	+format(const CharT* fmt, const Streamable& tp)
		6263	+ -> decltype(to_stream(std::declval<std::basic_ostream<CharT>&>(), fmt, tp),
		6264	+ std::basic_string<CharT>{})
		6265	+{
		6266	+ std::basic_ostringstream<CharT> os;
		6267	+ os.exceptions(std::ios::failbit \| std::ios::badbit);
		6268	+ to_stream(os, fmt, tp);
		6269	+ return os.str();
		6270	+}
		6271	+
		6272	+template <class CharT, class Traits, class Alloc, class Streamable>
		6273	+auto
		6274	+format(const std::locale& loc, const std::basic_string<CharT, Traits, Alloc>& fmt,
		6275	+ const Streamable& tp)
		6276	+ -> decltype(to_stream(std::declval<std::basic_ostream<CharT, Traits>&>(), fmt.c_str(), tp),
		6277	+ std::basic_string<CharT, Traits, Alloc>{})
		6278	+{
		6279	+ std::basic_ostringstream<CharT, Traits, Alloc> os;
		6280	+ os.exceptions(std::ios::failbit \| std::ios::badbit);
		6281	+ os.imbue(loc);
		6282	+ to_stream(os, fmt.c_str(), tp);
		6283	+ return os.str();
		6284	+}
		6285	+
		6286	+template <class CharT, class Traits, class Alloc, class Streamable>
		6287	+auto
		6288	+format(const std::basic_string<CharT, Traits, Alloc>& fmt, const Streamable& tp)
		6289	+ -> decltype(to_stream(std::declval<std::basic_ostream<CharT, Traits>&>(), fmt.c_str(), tp),
		6290	+ std::basic_string<CharT, Traits, Alloc>{})
		6291	+{
		6292	+ std::basic_ostringstream<CharT, Traits, Alloc> os;
		6293	+ os.exceptions(std::ios::failbit \| std::ios::badbit);
		6294	+ to_stream(os, fmt.c_str(), tp);
		6295	+ return os.str();
		6296	+}
		6297	+
		6298	+// parse
		6299	+
		6300	+namespace detail
		6301	+{
		6302	+
		6303	+template <class CharT, class Traits>
		6304	+bool
		6305	+read_char(std::basic_istream<CharT, Traits>& is, CharT fmt, std::ios::iostate& err)
		6306	+{
		6307	+ auto ic = is.get();
		6308	+ if (Traits::eq_int_type(ic, Traits::eof()) \|\|
		6309	+ !Traits::eq(Traits::to_char_type(ic), fmt))
		6310	+ {
		6311	+ err \|= std::ios::failbit;
		6312	+ is.setstate(std::ios::failbit);
		6313	+ return false;
		6314	+ }
		6315	+ return true;
		6316	+}
		6317	+
		6318	+template <class CharT, class Traits>
		6319	+unsigned
		6320	+read_unsigned(std::basic_istream<CharT, Traits>& is, unsigned m = 1, unsigned M = 10)
		6321	+{
		6322	+ unsigned x = 0;
		6323	+ unsigned count = 0;
		6324	+ while (true)
		6325	+ {
		6326	+ auto ic = is.peek();
		6327	+ if (Traits::eq_int_type(ic, Traits::eof()))
		6328	+ break;
		6329	+ auto c = static_cast<char>(Traits::to_char_type(ic));
		6330	+ if (!('0' <= c && c <= '9'))
		6331	+ break;
		6332	+ (void)is.get();
		6333	+ ++count;
		6334	+ x = 10*x + static_cast<unsigned>(c - '0');
		6335	+ if (count == M)
		6336	+ break;
		6337	+ }
		6338	+ if (count < m)
		6339	+ is.setstate(std::ios::failbit);
		6340	+ return x;
		6341	+}
		6342	+
		6343	+template <class CharT, class Traits>
		6344	+int
		6345	+read_signed(std::basic_istream<CharT, Traits>& is, unsigned m = 1, unsigned M = 10)
		6346	+{
		6347	+ auto ic = is.peek();
		6348	+ if (!Traits::eq_int_type(ic, Traits::eof()))
		6349	+ {
		6350	+ auto c = static_cast<char>(Traits::to_char_type(ic));
		6351	+ if (('0' <= c && c <= '9') \|\| c == '-' \|\| c == '+')
		6352	+ {
		6353	+ if (c == '-' \|\| c == '+')
		6354	+ (void)is.get();
		6355	+ auto x = static_cast<int>(read_unsigned(is, std::max(m, 1u), M));
		6356	+ if (!is.fail())
		6357	+ {
		6358	+ if (c == '-')
		6359	+ x = -x;
		6360	+ return x;
		6361	+ }
		6362	+ }
		6363	+ }
		6364	+ if (m > 0)
		6365	+ is.setstate(std::ios::failbit);
		6366	+ return 0;
		6367	+}
		6368	+
		6369	+template <class CharT, class Traits>
		6370	+long double
		6371	+read_long_double(std::basic_istream<CharT, Traits>& is, unsigned m = 1, unsigned M = 10)
		6372	+{
		6373	+ unsigned count = 0;
		6374	+ unsigned fcount = 0;
		6375	+ unsigned long long i = 0;
		6376	+ unsigned long long f = 0;
		6377	+ bool parsing_fraction = false;
		6378	+#if ONLY_C_LOCALE
		6379	+ typename Traits::int_type decimal_point = '.';
		6380	+#else
		6381	+ auto decimal_point = Traits::to_int_type(
		6382	+ std::use_facet<std::numpunct<CharT>>(is.getloc()).decimal_point());
		6383	+#endif
		6384	+ while (true)
		6385	+ {
		6386	+ auto ic = is.peek();
		6387	+ if (Traits::eq_int_type(ic, Traits::eof()))
		6388	+ break;
		6389	+ if (Traits::eq_int_type(ic, decimal_point))
		6390	+ {
		6391	+ decimal_point = Traits::eof();
		6392	+ parsing_fraction = true;
		6393	+ }
		6394	+ else
		6395	+ {
		6396	+ auto c = static_cast<char>(Traits::to_char_type(ic));
		6397	+ if (!('0' <= c && c <= '9'))
		6398	+ break;
		6399	+ if (!parsing_fraction)
		6400	+ {
		6401	+ i = 10*i + static_cast<unsigned>(c - '0');
		6402	+ }
		6403	+ else
		6404	+ {
		6405	+ f = 10*f + static_cast<unsigned>(c - '0');
		6406	+ ++fcount;
		6407	+ }
		6408	+ }
		6409	+ (void)is.get();
		6410	+ if (++count == M)
		6411	+ break;
		6412	+ }
		6413	+ if (count < m)
		6414	+ {
		6415	+ is.setstate(std::ios::failbit);
		6416	+ return 0;
		6417	+ }
		6418	+ return static_cast<long double>(i) + static_cast<long double>(f)/std::pow(10.L, fcount);
		6419	+}
		6420	+
		6421	+struct rs
		6422	+{
		6423	+ int& i;
		6424	+ unsigned m;
		6425	+ unsigned M;
		6426	+};
		6427	+
		6428	+struct ru
		6429	+{
		6430	+ int& i;
		6431	+ unsigned m;
		6432	+ unsigned M;
		6433	+};
		6434	+
		6435	+struct rld
		6436	+{
		6437	+ long double& i;
		6438	+ unsigned m;
		6439	+ unsigned M;
		6440	+};
		6441	+
		6442	+template <class CharT, class Traits>
		6443	+void
		6444	+read(std::basic_istream<CharT, Traits>&)
		6445	+{
		6446	+}
		6447	+
		6448	+template <class CharT, class Traits, class ...Args>
		6449	+void
		6450	+read(std::basic_istream<CharT, Traits>& is, CharT a0, Args&& ...args);
		6451	+
		6452	+template <class CharT, class Traits, class ...Args>
		6453	+void
		6454	+read(std::basic_istream<CharT, Traits>& is, rs a0, Args&& ...args);
		6455	+
		6456	+template <class CharT, class Traits, class ...Args>
		6457	+void
		6458	+read(std::basic_istream<CharT, Traits>& is, ru a0, Args&& ...args);
		6459	+
		6460	+template <class CharT, class Traits, class ...Args>
		6461	+void
		6462	+read(std::basic_istream<CharT, Traits>& is, int a0, Args&& ...args);
		6463	+
		6464	+template <class CharT, class Traits, class ...Args>
		6465	+void
		6466	+read(std::basic_istream<CharT, Traits>& is, rld a0, Args&& ...args);
		6467	+
		6468	+template <class CharT, class Traits, class ...Args>
		6469	+void
		6470	+read(std::basic_istream<CharT, Traits>& is, CharT a0, Args&& ...args)
		6471	+{
		6472	+ // No-op if a0 == CharT{}
		6473	+ if (a0 != CharT{})
		6474	+ {
		6475	+ auto ic = is.peek();
		6476	+ if (Traits::eq_int_type(ic, Traits::eof()))
		6477	+ {
		6478	+ is.setstate(std::ios::failbit \| std::ios::eofbit);
		6479	+ return;
		6480	+ }
		6481	+ if (!Traits::eq(Traits::to_char_type(ic), a0))
		6482	+ {
		6483	+ is.setstate(std::ios::failbit);
		6484	+ return;
		6485	+ }
		6486	+ (void)is.get();
		6487	+ }
		6488	+ read(is, std::forward<Args>(args)...);
		6489	+}
		6490	+
		6491	+template <class CharT, class Traits, class ...Args>
		6492	+void
		6493	+read(std::basic_istream<CharT, Traits>& is, rs a0, Args&& ...args)
		6494	+{
		6495	+ auto x = read_signed(is, a0.m, a0.M);
		6496	+ if (is.fail())
		6497	+ return;
		6498	+ a0.i = x;
		6499	+ read(is, std::forward<Args>(args)...);
		6500	+}
		6501	+
		6502	+template <class CharT, class Traits, class ...Args>
		6503	+void
		6504	+read(std::basic_istream<CharT, Traits>& is, ru a0, Args&& ...args)
		6505	+{
		6506	+ auto x = read_unsigned(is, a0.m, a0.M);
		6507	+ if (is.fail())
		6508	+ return;
		6509	+ a0.i = static_cast<int>(x);
		6510	+ read(is, std::forward<Args>(args)...);
		6511	+}
		6512	+
		6513	+template <class CharT, class Traits, class ...Args>
		6514	+void
		6515	+read(std::basic_istream<CharT, Traits>& is, int a0, Args&& ...args)
		6516	+{
		6517	+ if (a0 != -1)
		6518	+ {
		6519	+ auto u = static_cast<unsigned>(a0);
		6520	+ CharT buf[std::numeric_limits<unsigned>::digits10+2u] = {};
		6521	+ auto e = buf;
		6522	+ do
		6523	+ {
		6524	+ *e++ = static_cast<CharT>(CharT(u % 10) + CharT{'0'});
		6525	+ u /= 10;
		6526	+ } while (u > 0);
		6527	+ std::reverse(buf, e);
		6528	+ for (auto p = buf; p != e && is.rdstate() == std::ios::goodbit; ++p)
		6529	+ read(is, *p);
		6530	+ }
		6531	+ if (is.rdstate() == std::ios::goodbit)
		6532	+ read(is, std::forward<Args>(args)...);
		6533	+}
		6534	+
		6535	+template <class CharT, class Traits, class ...Args>
		6536	+void
		6537	+read(std::basic_istream<CharT, Traits>& is, rld a0, Args&& ...args)
		6538	+{
		6539	+ auto x = read_long_double(is, a0.m, a0.M);
		6540	+ if (is.fail())
		6541	+ return;
		6542	+ a0.i = x;
		6543	+ read(is, std::forward<Args>(args)...);
		6544	+}
		6545	+
		6546	+template <class T, class CharT, class Traits>
		6547	+inline
		6548	+void
		6549	+checked_set(T& value, T from, T not_a_value, std::basic_ios<CharT, Traits>& is)
		6550	+{
		6551	+ if (!is.fail())
		6552	+ {
		6553	+ if (value == not_a_value)
		6554	+ value = std::move(from);
		6555	+ else if (value != from)
		6556	+ is.setstate(std::ios::failbit);
		6557	+ }
		6558	+}
		6559	+
		6560	+} // namespace detail;
		6561	+
		6562	+template <class CharT, class Traits, class Duration, class Alloc = std::allocator<CharT>>
		6563	+std::basic_istream<CharT, Traits>&
		6564	+from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt,
		6565	+ fields<Duration>& fds, std::basic_string<CharT, Traits, Alloc>* abbrev,
		6566	+ std::chrono::minutes* offset)
		6567	+{
		6568	+ using std::numeric_limits;
		6569	+ using std::ios;
		6570	+ using std::chrono::duration;
		6571	+ using std::chrono::duration_cast;
		6572	+ using std::chrono::seconds;
		6573	+ using std::chrono::minutes;
		6574	+ using std::chrono::hours;
		6575	+ using detail::round_i;
		6576	+ typename std::basic_istream<CharT, Traits>::sentry ok{is, true};
		6577	+ if (ok)
		6578	+ {
		6579	+ date::detail::save_istream<CharT, Traits> ss(is);
		6580	+ is.fill(' ');
		6581	+ is.flags(std::ios::skipws \| std::ios::dec);
		6582	+ is.width(0);
		6583	+#if !ONLY_C_LOCALE
		6584	+ auto& f = std::use_facet<std::time_get<CharT>>(is.getloc());
		6585	+ std::tm tm{};
		6586	+#endif
		6587	+ const CharT* command = nullptr;
		6588	+ auto modified = CharT{};
		6589	+ auto width = -1;
		6590	+
		6591	+ CONSTDATA int not_a_year = numeric_limits<short>::min();
		6592	+ CONSTDATA int not_a_2digit_year = 100;
		6593	+ CONSTDATA int not_a_century = not_a_year / 100;
		6594	+ CONSTDATA int not_a_month = 0;
		6595	+ CONSTDATA int not_a_day = 0;
		6596	+ CONSTDATA int not_a_hour = numeric_limits<int>::min();
		6597	+ CONSTDATA int not_a_hour_12_value = 0;
		6598	+ CONSTDATA int not_a_minute = not_a_hour;
		6599	+ CONSTDATA Duration not_a_second = Duration::min();
		6600	+ CONSTDATA int not_a_doy = -1;
		6601	+ CONSTDATA int not_a_weekday = 8;
		6602	+ CONSTDATA int not_a_week_num = 100;
		6603	+ CONSTDATA int not_a_ampm = -1;
		6604	+ CONSTDATA minutes not_a_offset = minutes::min();
		6605	+
		6606	+ int Y = not_a_year; // c, F, Y *
		6607	+ int y = not_a_2digit_year; // D, x, y *
		6608	+ int g = not_a_2digit_year; // g *
		6609	+ int G = not_a_year; // G *
		6610	+ int C = not_a_century; // C *
		6611	+ int m = not_a_month; // b, B, h, m, c, D, F, x *
		6612	+ int d = not_a_day; // c, d, D, e, F, x *
		6613	+ int j = not_a_doy; // j *
		6614	+ int wd = not_a_weekday; // a, A, u, w *
		6615	+ int H = not_a_hour; // c, H, R, T, X *
		6616	+ int I = not_a_hour_12_value; // I, r *
		6617	+ int p = not_a_ampm; // p, r *
		6618	+ int M = not_a_minute; // c, M, r, R, T, X *
		6619	+ Duration s = not_a_second; // c, r, S, T, X *
		6620	+ int U = not_a_week_num; // U *
		6621	+ int V = not_a_week_num; // V *
		6622	+ int W = not_a_week_num; // W *
		6623	+ std::basic_string<CharT, Traits, Alloc> temp_abbrev; // Z *
		6624	+ minutes temp_offset = not_a_offset; // z *
		6625	+
		6626	+ using detail::read;
		6627	+ using detail::rs;
		6628	+ using detail::ru;
		6629	+ using detail::rld;
		6630	+ using detail::checked_set;
		6631	+ for (; *fmt != CharT{} && !is.fail(); ++fmt)
		6632	+ {
		6633	+ switch (*fmt)
		6634	+ {
		6635	+ case 'a':
		6636	+ case 'A':
		6637	+ case 'u':
		6638	+ case 'w': // wd: a, A, u, w
		6639	+ if (command)
		6640	+ {
		6641	+ int trial_wd = not_a_weekday;
		6642	+ if (fmt == 'a' \|\| fmt == 'A')
		6643	+ {
		6644	+ if (modified == CharT{})
		6645	+ {
		6646	+#if !ONLY_C_LOCALE
		6647	+ ios::iostate err = ios::goodbit;
		6648	+ f.get(is, nullptr, is, err, &tm, command, fmt+1);
		6649	+ is.setstate(err);
		6650	+ if (!is.fail())
		6651	+ trial_wd = tm.tm_wday;
		6652	+#else
		6653	+ auto nm = detail::weekday_names();
		6654	+ auto i = detail::scan_keyword(is, nm.first, nm.second) - nm.first;
		6655	+ if (!is.fail())
		6656	+ trial_wd = i % 7;
		6657	+#endif
		6658	+ }
		6659	+ else
		6660	+ read(is, CharT{'%'}, width, modified, *fmt);
		6661	+ }
		6662	+ else // fmt == 'u' \|\| fmt == 'w'
		6663	+ {
		6664	+#if !ONLY_C_LOCALE
		6665	+ if (modified == CharT{})
		6666	+#else
		6667	+ if (modified != CharT{'E'})
		6668	+#endif
		6669	+ {
		6670	+ read(is, ru{trial_wd, 1, width == -1 ?
		6671	+ 1u : static_cast<unsigned>(width)});
		6672	+ if (!is.fail())
		6673	+ {
		6674	+ if (*fmt == 'u')
		6675	+ {
		6676	+ if (!(1 <= trial_wd && trial_wd <= 7))
		6677	+ {
		6678	+ trial_wd = not_a_weekday;
		6679	+ is.setstate(ios::failbit);
		6680	+ }
		6681	+ else if (trial_wd == 7)
		6682	+ trial_wd = 0;
		6683	+ }
		6684	+ else // *fmt == 'w'
		6685	+ {
		6686	+ if (!(0 <= trial_wd && trial_wd <= 6))
		6687	+ {
		6688	+ trial_wd = not_a_weekday;
		6689	+ is.setstate(ios::failbit);
		6690	+ }
		6691	+ }
		6692	+ }
		6693	+ }
		6694	+#if !ONLY_C_LOCALE
		6695	+ else if (modified == CharT{'O'})
		6696	+ {
		6697	+ ios::iostate err = ios::goodbit;
		6698	+ f.get(is, nullptr, is, err, &tm, command, fmt+1);
		6699	+ is.setstate(err);
		6700	+ if (!is.fail())
		6701	+ trial_wd = tm.tm_wday;
		6702	+ }
		6703	+#endif
		6704	+ else
		6705	+ read(is, CharT{'%'}, width, modified, *fmt);
		6706	+ }
		6707	+ if (trial_wd != not_a_weekday)
		6708	+ checked_set(wd, trial_wd, not_a_weekday, is);
		6709	+ }
		6710	+ else // !command
		6711	+ read(is, *fmt);
		6712	+ command = nullptr;
		6713	+ width = -1;
		6714	+ modified = CharT{};
		6715	+ break;
		6716	+ case 'b':
		6717	+ case 'B':
		6718	+ case 'h':
		6719	+ if (command)
		6720	+ {
		6721	+ if (modified == CharT{})
		6722	+ {
		6723	+ int ttm = not_a_month;
		6724	+#if !ONLY_C_LOCALE
		6725	+ ios::iostate err = ios::goodbit;
		6726	+ f.get(is, nullptr, is, err, &tm, command, fmt+1);
		6727	+ if ((err & ios::failbit) == 0)
		6728	+ ttm = tm.tm_mon + 1;
		6729	+ is.setstate(err);
		6730	+#else
		6731	+ auto nm = detail::month_names();
		6732	+ auto i = detail::scan_keyword(is, nm.first, nm.second) - nm.first;
		6733	+ if (!is.fail())
		6734	+ ttm = i % 12 + 1;
		6735	+#endif
		6736	+ checked_set(m, ttm, not_a_month, is);
		6737	+ }
		6738	+ else
		6739	+ read(is, CharT{'%'}, width, modified, *fmt);
		6740	+ command = nullptr;
		6741	+ width = -1;
		6742	+ modified = CharT{};
		6743	+ }
		6744	+ else
		6745	+ read(is, *fmt);
		6746	+ break;
		6747	+ case 'c':
		6748	+ if (command)
		6749	+ {
		6750	+ if (modified != CharT{'O'})
		6751	+ {
		6752	+#if !ONLY_C_LOCALE
		6753	+ ios::iostate err = ios::goodbit;
		6754	+ f.get(is, nullptr, is, err, &tm, command, fmt+1);
		6755	+ if ((err & ios::failbit) == 0)
		6756	+ {
		6757	+ checked_set(Y, tm.tm_year + 1900, not_a_year, is);
		6758	+ checked_set(m, tm.tm_mon + 1, not_a_month, is);
		6759	+ checked_set(d, tm.tm_mday, not_a_day, is);
		6760	+ checked_set(H, tm.tm_hour, not_a_hour, is);
		6761	+ checked_set(M, tm.tm_min, not_a_minute, is);
		6762	+ checked_set(s, duration_cast<Duration>(seconds{tm.tm_sec}),
		6763	+ not_a_second, is);
		6764	+ }
		6765	+ is.setstate(err);
		6766	+#else
		6767	+ // "%a %b %e %T %Y"
		6768	+ auto nm = detail::weekday_names();
		6769	+ auto i = detail::scan_keyword(is, nm.first, nm.second) - nm.first;
		6770	+ checked_set(wd, static_cast<int>(i % 7), not_a_weekday, is);
		6771	+ ws(is);
		6772	+ nm = detail::month_names();
		6773	+ i = detail::scan_keyword(is, nm.first, nm.second) - nm.first;
		6774	+ checked_set(m, static_cast<int>(i % 12 + 1), not_a_month, is);
		6775	+ ws(is);
		6776	+ int td = not_a_day;
		6777	+ read(is, rs{td, 1, 2});
		6778	+ checked_set(d, td, not_a_day, is);
		6779	+ ws(is);
		6780	+ using dfs = detail::decimal_format_seconds<Duration>;
		6781	+ CONSTDATA auto w = Duration::period::den == 1 ? 2 : 3 + dfs::width;
		6782	+ int tH;
		6783	+ int tM;
		6784	+ long double S{};
		6785	+ read(is, ru{tH, 1, 2}, CharT{':'}, ru{tM, 1, 2},
		6786	+ CharT{':'}, rld{S, 1, w});
		6787	+ checked_set(H, tH, not_a_hour, is);
		6788	+ checked_set(M, tM, not_a_minute, is);
		6789	+ checked_set(s, round_i<Duration>(duration<long double>{S}),
		6790	+ not_a_second, is);
		6791	+ ws(is);
		6792	+ int tY = not_a_year;
		6793	+ read(is, rs{tY, 1, 4u});
		6794	+ checked_set(Y, tY, not_a_year, is);
		6795	+#endif
		6796	+ }
		6797	+ else
		6798	+ read(is, CharT{'%'}, width, modified, *fmt);
		6799	+ command = nullptr;
		6800	+ width = -1;
		6801	+ modified = CharT{};
		6802	+ }
		6803	+ else
		6804	+ read(is, *fmt);
		6805	+ break;
		6806	+ case 'x':
		6807	+ if (command)
		6808	+ {
		6809	+ if (modified != CharT{'O'})
		6810	+ {
		6811	+#if !ONLY_C_LOCALE
		6812	+ ios::iostate err = ios::goodbit;
		6813	+ f.get(is, nullptr, is, err, &tm, command, fmt+1);
		6814	+ if ((err & ios::failbit) == 0)
		6815	+ {
		6816	+ checked_set(Y, tm.tm_year + 1900, not_a_year, is);
		6817	+ checked_set(m, tm.tm_mon + 1, not_a_month, is);
		6818	+ checked_set(d, tm.tm_mday, not_a_day, is);
		6819	+ }
		6820	+ is.setstate(err);
		6821	+#else
		6822	+ // "%m/%d/%y"
		6823	+ int ty = not_a_2digit_year;
		6824	+ int tm = not_a_month;
		6825	+ int td = not_a_day;
		6826	+ read(is, ru{tm, 1, 2}, CharT{'/'}, ru{td, 1, 2}, CharT{'/'},
		6827	+ rs{ty, 1, 2});
		6828	+ checked_set(y, ty, not_a_2digit_year, is);
		6829	+ checked_set(m, tm, not_a_month, is);
		6830	+ checked_set(d, td, not_a_day, is);
		6831	+#endif
		6832	+ }
		6833	+ else
		6834	+ read(is, CharT{'%'}, width, modified, *fmt);
		6835	+ command = nullptr;
		6836	+ width = -1;
		6837	+ modified = CharT{};
		6838	+ }
		6839	+ else
		6840	+ read(is, *fmt);
		6841	+ break;
		6842	+ case 'X':
		6843	+ if (command)
		6844	+ {
		6845	+ if (modified != CharT{'O'})
		6846	+ {
		6847	+#if !ONLY_C_LOCALE
		6848	+ ios::iostate err = ios::goodbit;
		6849	+ f.get(is, nullptr, is, err, &tm, command, fmt+1);
		6850	+ if ((err & ios::failbit) == 0)
		6851	+ {
		6852	+ checked_set(H, tm.tm_hour, not_a_hour, is);
		6853	+ checked_set(M, tm.tm_min, not_a_minute, is);
		6854	+ checked_set(s, duration_cast<Duration>(seconds{tm.tm_sec}),
		6855	+ not_a_second, is);
		6856	+ }
		6857	+ is.setstate(err);
		6858	+#else
		6859	+ // "%T"
		6860	+ using dfs = detail::decimal_format_seconds<Duration>;
		6861	+ CONSTDATA auto w = Duration::period::den == 1 ? 2 : 3 + dfs::width;
		6862	+ int tH = not_a_hour;
		6863	+ int tM = not_a_minute;
		6864	+ long double S{};
		6865	+ read(is, ru{tH, 1, 2}, CharT{':'}, ru{tM, 1, 2},
		6866	+ CharT{':'}, rld{S, 1, w});
		6867	+ checked_set(H, tH, not_a_hour, is);
		6868	+ checked_set(M, tM, not_a_minute, is);
		6869	+ checked_set(s, round_i<Duration>(duration<long double>{S}),
		6870	+ not_a_second, is);
		6871	+#endif
		6872	+ }
		6873	+ else
		6874	+ read(is, CharT{'%'}, width, modified, *fmt);
		6875	+ command = nullptr;
		6876	+ width = -1;
		6877	+ modified = CharT{};
		6878	+ }
		6879	+ else
		6880	+ read(is, *fmt);
		6881	+ break;
		6882	+ case 'C':
		6883	+ if (command)
		6884	+ {
		6885	+ int tC = not_a_century;
		6886	+#if !ONLY_C_LOCALE
		6887	+ if (modified == CharT{})
		6888	+ {
		6889	+#endif
		6890	+ read(is, rs{tC, 1, width == -1 ? 2u : static_cast<unsigned>(width)});
		6891	+#if !ONLY_C_LOCALE
		6892	+ }
		6893	+ else
		6894	+ {
		6895	+ ios::iostate err = ios::goodbit;
		6896	+ f.get(is, nullptr, is, err, &tm, command, fmt+1);
		6897	+ if ((err & ios::failbit) == 0)
		6898	+ {
		6899	+ auto tY = tm.tm_year + 1900;
		6900	+ tC = (tY >= 0 ? tY : tY-99) / 100;
		6901	+ }
		6902	+ is.setstate(err);
		6903	+ }
		6904	+#endif
		6905	+ checked_set(C, tC, not_a_century, is);
		6906	+ command = nullptr;
		6907	+ width = -1;
		6908	+ modified = CharT{};
		6909	+ }
		6910	+ else
		6911	+ read(is, *fmt);
		6912	+ break;
		6913	+ case 'D':
		6914	+ if (command)
		6915	+ {
		6916	+ if (modified == CharT{})
		6917	+ {
		6918	+ int tn = not_a_month;
		6919	+ int td = not_a_day;
		6920	+ int ty = not_a_2digit_year;
		6921	+ read(is, ru{tn, 1, 2}, CharT{'\0'}, CharT{'/'}, CharT{'\0'},
		6922	+ ru{td, 1, 2}, CharT{'\0'}, CharT{'/'}, CharT{'\0'},
		6923	+ rs{ty, 1, 2});
		6924	+ checked_set(y, ty, not_a_2digit_year, is);
		6925	+ checked_set(m, tn, not_a_month, is);
		6926	+ checked_set(d, td, not_a_day, is);
		6927	+ }
		6928	+ else
		6929	+ read(is, CharT{'%'}, width, modified, *fmt);
		6930	+ command = nullptr;
		6931	+ width = -1;
		6932	+ modified = CharT{};
		6933	+ }
		6934	+ else
		6935	+ read(is, *fmt);
		6936	+ break;
		6937	+ case 'F':
		6938	+ if (command)
		6939	+ {
		6940	+ if (modified == CharT{})
		6941	+ {
		6942	+ int tY = not_a_year;
		6943	+ int tn = not_a_month;
		6944	+ int td = not_a_day;
		6945	+ read(is, rs{tY, 1, width == -1 ? 4u : static_cast<unsigned>(width)},
		6946	+ CharT{'-'}, ru{tn, 1, 2}, CharT{'-'}, ru{td, 1, 2});
		6947	+ checked_set(Y, tY, not_a_year, is);
		6948	+ checked_set(m, tn, not_a_month, is);
		6949	+ checked_set(d, td, not_a_day, is);
		6950	+ }
		6951	+ else
		6952	+ read(is, CharT{'%'}, width, modified, *fmt);
		6953	+ command = nullptr;
		6954	+ width = -1;
		6955	+ modified = CharT{};
		6956	+ }
		6957	+ else
		6958	+ read(is, *fmt);
		6959	+ break;
		6960	+ case 'd':
		6961	+ case 'e':
		6962	+ if (command)
		6963	+ {
		6964	+#if !ONLY_C_LOCALE
		6965	+ if (modified == CharT{})
		6966	+#else
		6967	+ if (modified != CharT{'E'})
		6968	+#endif
		6969	+ {
		6970	+ int td = not_a_day;
		6971	+ read(is, rs{td, 1, width == -1 ? 2u : static_cast<unsigned>(width)});
		6972	+ checked_set(d, td, not_a_day, is);
		6973	+ }
		6974	+#if !ONLY_C_LOCALE
		6975	+ else if (modified == CharT{'O'})
		6976	+ {
		6977	+ ios::iostate err = ios::goodbit;
		6978	+ f.get(is, nullptr, is, err, &tm, command, fmt+1);
		6979	+ command = nullptr;
		6980	+ width = -1;
		6981	+ modified = CharT{};
		6982	+ if ((err & ios::failbit) == 0)
		6983	+ checked_set(d, tm.tm_mday, not_a_day, is);
		6984	+ is.setstate(err);
		6985	+ }
		6986	+#endif
		6987	+ else
		6988	+ read(is, CharT{'%'}, width, modified, *fmt);
		6989	+ command = nullptr;
		6990	+ width = -1;
		6991	+ modified = CharT{};
		6992	+ }
		6993	+ else
		6994	+ read(is, *fmt);
		6995	+ break;
		6996	+ case 'H':
		6997	+ if (command)
		6998	+ {
		6999	+#if !ONLY_C_LOCALE
		7000	+ if (modified == CharT{})
		7001	+#else
		7002	+ if (modified != CharT{'E'})
		7003	+#endif
		7004	+ {
		7005	+ int tH = not_a_hour;
		7006	+ read(is, ru{tH, 1, width == -1 ? 2u : static_cast<unsigned>(width)});
		7007	+ checked_set(H, tH, not_a_hour, is);
		7008	+ }
		7009	+#if !ONLY_C_LOCALE
		7010	+ else if (modified == CharT{'O'})
		7011	+ {
		7012	+ ios::iostate err = ios::goodbit;
		7013	+ f.get(is, nullptr, is, err, &tm, command, fmt+1);
		7014	+ if ((err & ios::failbit) == 0)
		7015	+ checked_set(H, tm.tm_hour, not_a_hour, is);
		7016	+ is.setstate(err);
		7017	+ }
		7018	+#endif
		7019	+ else
		7020	+ read(is, CharT{'%'}, width, modified, *fmt);
		7021	+ command = nullptr;
		7022	+ width = -1;
		7023	+ modified = CharT{};
		7024	+ }
		7025	+ else
		7026	+ read(is, *fmt);
		7027	+ break;
		7028	+ case 'I':
		7029	+ if (command)
		7030	+ {
		7031	+ if (modified == CharT{})
		7032	+ {
		7033	+ int tI = not_a_hour_12_value;
		7034	+ // reads in an hour into I, but most be in [1, 12]
		7035	+ read(is, rs{tI, 1, width == -1 ? 2u : static_cast<unsigned>(width)});
		7036	+ if (!(1 <= tI && tI <= 12))
		7037	+ is.setstate(ios::failbit);
		7038	+ checked_set(I, tI, not_a_hour_12_value, is);
		7039	+ }
		7040	+ else
		7041	+ read(is, CharT{'%'}, width, modified, *fmt);
		7042	+ command = nullptr;
		7043	+ width = -1;
		7044	+ modified = CharT{};
		7045	+ }
		7046	+ else
		7047	+ read(is, *fmt);
		7048	+ break;
		7049	+ case 'j':
		7050	+ if (command)
		7051	+ {
		7052	+ if (modified == CharT{})
		7053	+ {
		7054	+ int tj = not_a_doy;
		7055	+ read(is, ru{tj, 1, width == -1 ? 3u : static_cast<unsigned>(width)});
		7056	+ checked_set(j, tj, not_a_doy, is);
		7057	+ }
		7058	+ else
		7059	+ read(is, CharT{'%'}, width, modified, *fmt);
		7060	+ command = nullptr;
		7061	+ width = -1;
		7062	+ modified = CharT{};
		7063	+ }
		7064	+ else
		7065	+ read(is, *fmt);
		7066	+ break;
		7067	+ case 'M':
		7068	+ if (command)
		7069	+ {
		7070	+#if !ONLY_C_LOCALE
		7071	+ if (modified == CharT{})
		7072	+#else
		7073	+ if (modified != CharT{'E'})
		7074	+#endif
		7075	+ {
		7076	+ int tM = not_a_minute;
		7077	+ read(is, ru{tM, 1, width == -1 ? 2u : static_cast<unsigned>(width)});
		7078	+ checked_set(M, tM, not_a_minute, is);
		7079	+ }
		7080	+#if !ONLY_C_LOCALE
		7081	+ else if (modified == CharT{'O'})
		7082	+ {
		7083	+ ios::iostate err = ios::goodbit;
		7084	+ f.get(is, nullptr, is, err, &tm, command, fmt+1);
		7085	+ if ((err & ios::failbit) == 0)
		7086	+ checked_set(M, tm.tm_min, not_a_minute, is);
		7087	+ is.setstate(err);
		7088	+ }
		7089	+#endif
		7090	+ else
		7091	+ read(is, CharT{'%'}, width, modified, *fmt);
		7092	+ command = nullptr;
		7093	+ width = -1;
		7094	+ modified = CharT{};
		7095	+ }
		7096	+ else
		7097	+ read(is, *fmt);
		7098	+ break;
		7099	+ case 'm':
		7100	+ if (command)
		7101	+ {
		7102	+#if !ONLY_C_LOCALE
		7103	+ if (modified == CharT{})
		7104	+#else
		7105	+ if (modified != CharT{'E'})
		7106	+#endif
		7107	+ {
		7108	+ int tn = not_a_month;
		7109	+ read(is, rs{tn, 1, width == -1 ? 2u : static_cast<unsigned>(width)});
		7110	+ checked_set(m, tn, not_a_month, is);
		7111	+ }
		7112	+#if !ONLY_C_LOCALE
		7113	+ else if (modified == CharT{'O'})
		7114	+ {
		7115	+ ios::iostate err = ios::goodbit;
		7116	+ f.get(is, nullptr, is, err, &tm, command, fmt+1);
		7117	+ if ((err & ios::failbit) == 0)
		7118	+ checked_set(m, tm.tm_mon + 1, not_a_month, is);
		7119	+ is.setstate(err);
		7120	+ }
		7121	+#endif
		7122	+ else
		7123	+ read(is, CharT{'%'}, width, modified, *fmt);
		7124	+ command = nullptr;
		7125	+ width = -1;
		7126	+ modified = CharT{};
		7127	+ }
		7128	+ else
		7129	+ read(is, *fmt);
		7130	+ break;
		7131	+ case 'n':
		7132	+ case 't':
		7133	+ if (command)
		7134	+ {
		7135	+ if (modified == CharT{})
		7136	+ {
		7137	+ // %n matches a single white space character
		7138	+ // %t matches 0 or 1 white space characters
		7139	+ auto ic = is.peek();
		7140	+ if (Traits::eq_int_type(ic, Traits::eof()))
		7141	+ {
		7142	+ ios::iostate err = ios::eofbit;
		7143	+ if (*fmt == 'n')
		7144	+ err \|= ios::failbit;
		7145	+ is.setstate(err);
		7146	+ break;
		7147	+ }
		7148	+ if (isspace(ic))
		7149	+ {
		7150	+ (void)is.get();
		7151	+ }
		7152	+ else if (*fmt == 'n')
		7153	+ is.setstate(ios::failbit);
		7154	+ }
		7155	+ else
		7156	+ read(is, CharT{'%'}, width, modified, *fmt);
		7157	+ command = nullptr;
		7158	+ width = -1;
		7159	+ modified = CharT{};
		7160	+ }
		7161	+ else
		7162	+ read(is, *fmt);
		7163	+ break;
		7164	+ case 'p':
		7165	+ if (command)
		7166	+ {
		7167	+ if (modified == CharT{})
		7168	+ {
		7169	+ int tp = not_a_ampm;
		7170	+#if !ONLY_C_LOCALE
		7171	+ tm = std::tm{};
		7172	+ tm.tm_hour = 1;
		7173	+ ios::iostate err = ios::goodbit;
		7174	+ f.get(is, nullptr, is, err, &tm, command, fmt+1);
		7175	+ is.setstate(err);
		7176	+ if (tm.tm_hour == 1)
		7177	+ tp = 0;
		7178	+ else if (tm.tm_hour == 13)
		7179	+ tp = 1;
		7180	+ else
		7181	+ is.setstate(err);
		7182	+#else
		7183	+ auto nm = detail::ampm_names();
		7184	+ auto i = detail::scan_keyword(is, nm.first, nm.second) - nm.first;
		7185	+ tp = static_cast<decltype(tp)>(i);
		7186	+#endif
		7187	+ checked_set(p, tp, not_a_ampm, is);
		7188	+ }
		7189	+ else
		7190	+ read(is, CharT{'%'}, width, modified, *fmt);
		7191	+ command = nullptr;
		7192	+ width = -1;
		7193	+ modified = CharT{};
		7194	+ }
		7195	+ else
		7196	+ read(is, *fmt);
		7197	+
		7198	+ break;
		7199	+ case 'r':
		7200	+ if (command)
		7201	+ {
		7202	+ if (modified == CharT{})
		7203	+ {
		7204	+#if !ONLY_C_LOCALE
		7205	+ ios::iostate err = ios::goodbit;
		7206	+ f.get(is, nullptr, is, err, &tm, command, fmt+1);
		7207	+ if ((err & ios::failbit) == 0)
		7208	+ {
		7209	+ checked_set(H, tm.tm_hour, not_a_hour, is);
		7210	+ checked_set(M, tm.tm_min, not_a_hour, is);
		7211	+ checked_set(s, duration_cast<Duration>(seconds{tm.tm_sec}),
		7212	+ not_a_second, is);
		7213	+ }
		7214	+ is.setstate(err);
		7215	+#else
		7216	+ // "%I:%M:%S %p"
		7217	+ using dfs = detail::decimal_format_seconds<Duration>;
		7218	+ CONSTDATA auto w = Duration::period::den == 1 ? 2 : 3 + dfs::width;
		7219	+ long double S{};
		7220	+ int tI = not_a_hour_12_value;
		7221	+ int tM = not_a_minute;
		7222	+ read(is, ru{tI, 1, 2}, CharT{':'}, ru{tM, 1, 2},
		7223	+ CharT{':'}, rld{S, 1, w});
		7224	+ checked_set(I, tI, not_a_hour_12_value, is);
		7225	+ checked_set(M, tM, not_a_minute, is);
		7226	+ checked_set(s, round_i<Duration>(duration<long double>{S}),
		7227	+ not_a_second, is);
		7228	+ ws(is);
		7229	+ auto nm = detail::ampm_names();
		7230	+ auto i = detail::scan_keyword(is, nm.first, nm.second) - nm.first;
		7231	+ checked_set(p, static_cast<int>(i), not_a_ampm, is);
		7232	+#endif
		7233	+ }
		7234	+ else
		7235	+ read(is, CharT{'%'}, width, modified, *fmt);
		7236	+ command = nullptr;
		7237	+ width = -1;
		7238	+ modified = CharT{};
		7239	+ }
		7240	+ else
		7241	+ read(is, *fmt);
		7242	+ break;
		7243	+ case 'R':
		7244	+ if (command)
		7245	+ {
		7246	+ if (modified == CharT{})
		7247	+ {
		7248	+ int tH = not_a_hour;
		7249	+ int tM = not_a_minute;
		7250	+ read(is, ru{tH, 1, 2}, CharT{'\0'}, CharT{':'}, CharT{'\0'},
		7251	+ ru{tM, 1, 2}, CharT{'\0'});
		7252	+ checked_set(H, tH, not_a_hour, is);
		7253	+ checked_set(M, tM, not_a_minute, is);
		7254	+ }
		7255	+ else
		7256	+ read(is, CharT{'%'}, width, modified, *fmt);
		7257	+ command = nullptr;
		7258	+ width = -1;
		7259	+ modified = CharT{};
		7260	+ }
		7261	+ else
		7262	+ read(is, *fmt);
		7263	+ break;
		7264	+ case 'S':
		7265	+ if (command)
		7266	+ {
		7267	+ #if !ONLY_C_LOCALE
		7268	+ if (modified == CharT{})
		7269	+#else
		7270	+ if (modified != CharT{'E'})
		7271	+#endif
		7272	+ {
		7273	+ using dfs = detail::decimal_format_seconds<Duration>;
		7274	+ CONSTDATA auto w = Duration::period::den == 1 ? 2 : 3 + dfs::width;
		7275	+ long double S{};
		7276	+ read(is, rld{S, 1, width == -1 ? w : static_cast<unsigned>(width)});
		7277	+ checked_set(s, round_i<Duration>(duration<long double>{S}),
		7278	+ not_a_second, is);
		7279	+ }
		7280	+#if !ONLY_C_LOCALE
		7281	+ else if (modified == CharT{'O'})
		7282	+ {
		7283	+ ios::iostate err = ios::goodbit;
		7284	+ f.get(is, nullptr, is, err, &tm, command, fmt+1);
		7285	+ if ((err & ios::failbit) == 0)
		7286	+ checked_set(s, duration_cast<Duration>(seconds{tm.tm_sec}),
		7287	+ not_a_second, is);
		7288	+ is.setstate(err);
		7289	+ }
		7290	+#endif
		7291	+ else
		7292	+ read(is, CharT{'%'}, width, modified, *fmt);
		7293	+ command = nullptr;
		7294	+ width = -1;
		7295	+ modified = CharT{};
		7296	+ }
		7297	+ else
		7298	+ read(is, *fmt);
		7299	+ break;
		7300	+ case 'T':
		7301	+ if (command)
		7302	+ {
		7303	+ if (modified == CharT{})
		7304	+ {
		7305	+ using dfs = detail::decimal_format_seconds<Duration>;
		7306	+ CONSTDATA auto w = Duration::period::den == 1 ? 2 : 3 + dfs::width;
		7307	+ int tH = not_a_hour;
		7308	+ int tM = not_a_minute;
		7309	+ long double S{};
		7310	+ read(is, ru{tH, 1, 2}, CharT{':'}, ru{tM, 1, 2},
		7311	+ CharT{':'}, rld{S, 1, w});
		7312	+ checked_set(H, tH, not_a_hour, is);
		7313	+ checked_set(M, tM, not_a_minute, is);
		7314	+ checked_set(s, round_i<Duration>(duration<long double>{S}),
		7315	+ not_a_second, is);
		7316	+ }
		7317	+ else
		7318	+ read(is, CharT{'%'}, width, modified, *fmt);
		7319	+ command = nullptr;
		7320	+ width = -1;
		7321	+ modified = CharT{};
		7322	+ }
		7323	+ else
		7324	+ read(is, *fmt);
		7325	+ break;
		7326	+ case 'Y':
		7327	+ if (command)
		7328	+ {
		7329	+#if !ONLY_C_LOCALE
		7330	+ if (modified == CharT{})
		7331	+#else
		7332	+ if (modified != CharT{'O'})
		7333	+#endif
		7334	+ {
		7335	+ int tY = not_a_year;
		7336	+ read(is, rs{tY, 1, width == -1 ? 4u : static_cast<unsigned>(width)});
		7337	+ checked_set(Y, tY, not_a_year, is);
		7338	+ }
		7339	+#if !ONLY_C_LOCALE
		7340	+ else if (modified == CharT{'E'})
		7341	+ {
		7342	+ ios::iostate err = ios::goodbit;
		7343	+ f.get(is, nullptr, is, err, &tm, command, fmt+1);
		7344	+ if ((err & ios::failbit) == 0)
		7345	+ checked_set(Y, tm.tm_year + 1900, not_a_year, is);
		7346	+ is.setstate(err);
		7347	+ }
		7348	+#endif
		7349	+ else
		7350	+ read(is, CharT{'%'}, width, modified, *fmt);
		7351	+ command = nullptr;
		7352	+ width = -1;
		7353	+ modified = CharT{};
		7354	+ }
		7355	+ else
		7356	+ read(is, *fmt);
		7357	+ break;
		7358	+ case 'y':
		7359	+ if (command)
		7360	+ {
		7361	+#if !ONLY_C_LOCALE
		7362	+ if (modified == CharT{})
		7363	+#endif
		7364	+ {
		7365	+ int ty = not_a_2digit_year;
		7366	+ read(is, ru{ty, 1, width == -1 ? 2u : static_cast<unsigned>(width)});
		7367	+ checked_set(y, ty, not_a_2digit_year, is);
		7368	+ }
		7369	+#if !ONLY_C_LOCALE
		7370	+ else
		7371	+ {
		7372	+ ios::iostate err = ios::goodbit;
		7373	+ f.get(is, nullptr, is, err, &tm, command, fmt+1);
		7374	+ if ((err & ios::failbit) == 0)
		7375	+ checked_set(Y, tm.tm_year + 1900, not_a_year, is);
		7376	+ is.setstate(err);
		7377	+ }
		7378	+#endif
		7379	+ command = nullptr;
		7380	+ width = -1;
		7381	+ modified = CharT{};
		7382	+ }
		7383	+ else
		7384	+ read(is, *fmt);
		7385	+ break;
		7386	+ case 'g':
		7387	+ if (command)
		7388	+ {
		7389	+ if (modified == CharT{})
		7390	+ {
		7391	+ int tg = not_a_2digit_year;
		7392	+ read(is, ru{tg, 1, width == -1 ? 2u : static_cast<unsigned>(width)});
		7393	+ checked_set(g, tg, not_a_2digit_year, is);
		7394	+ }
		7395	+ else
		7396	+ read(is, CharT{'%'}, width, modified, *fmt);
		7397	+ command = nullptr;
		7398	+ width = -1;
		7399	+ modified = CharT{};
		7400	+ }
		7401	+ else
		7402	+ read(is, *fmt);
		7403	+ break;
		7404	+ case 'G':
		7405	+ if (command)
		7406	+ {
		7407	+ if (modified == CharT{})
		7408	+ {
		7409	+ int tG = not_a_year;
		7410	+ read(is, rs{tG, 1, width == -1 ? 4u : static_cast<unsigned>(width)});
		7411	+ checked_set(G, tG, not_a_year, is);
		7412	+ }
		7413	+ else
		7414	+ read(is, CharT{'%'}, width, modified, *fmt);
		7415	+ command = nullptr;
		7416	+ width = -1;
		7417	+ modified = CharT{};
		7418	+ }
		7419	+ else
		7420	+ read(is, *fmt);
		7421	+ break;
		7422	+ case 'U':
		7423	+ if (command)
		7424	+ {
		7425	+ if (modified == CharT{})
		7426	+ {
		7427	+ int tU = not_a_week_num;
		7428	+ read(is, ru{tU, 1, width == -1 ? 2u : static_cast<unsigned>(width)});
		7429	+ checked_set(U, tU, not_a_week_num, is);
		7430	+ }
		7431	+ else
		7432	+ read(is, CharT{'%'}, width, modified, *fmt);
		7433	+ command = nullptr;
		7434	+ width = -1;
		7435	+ modified = CharT{};
		7436	+ }
		7437	+ else
		7438	+ read(is, *fmt);
		7439	+ break;
		7440	+ case 'V':
		7441	+ if (command)
		7442	+ {
		7443	+ if (modified == CharT{})
		7444	+ {
		7445	+ int tV = not_a_week_num;
		7446	+ read(is, ru{tV, 1, width == -1 ? 2u : static_cast<unsigned>(width)});
		7447	+ checked_set(V, tV, not_a_week_num, is);
		7448	+ }
		7449	+ else
		7450	+ read(is, CharT{'%'}, width, modified, *fmt);
		7451	+ command = nullptr;
		7452	+ width = -1;
		7453	+ modified = CharT{};
		7454	+ }
		7455	+ else
		7456	+ read(is, *fmt);
		7457	+ break;
		7458	+ case 'W':
		7459	+ if (command)
		7460	+ {
		7461	+ if (modified == CharT{})
		7462	+ {
		7463	+ int tW = not_a_week_num;
		7464	+ read(is, ru{tW, 1, width == -1 ? 2u : static_cast<unsigned>(width)});
		7465	+ checked_set(W, tW, not_a_week_num, is);
		7466	+ }
		7467	+ else
		7468	+ read(is, CharT{'%'}, width, modified, *fmt);
		7469	+ command = nullptr;
		7470	+ width = -1;
		7471	+ modified = CharT{};
		7472	+ }
		7473	+ else
		7474	+ read(is, *fmt);
		7475	+ break;
		7476	+ case 'E':
		7477	+ case 'O':
		7478	+ if (command)
		7479	+ {
		7480	+ if (modified == CharT{})
		7481	+ {
		7482	+ modified = *fmt;
		7483	+ }
		7484	+ else
		7485	+ {
		7486	+ read(is, CharT{'%'}, width, modified, *fmt);
		7487	+ command = nullptr;
		7488	+ width = -1;
		7489	+ modified = CharT{};
		7490	+ }
		7491	+ }
		7492	+ else
		7493	+ read(is, *fmt);
		7494	+ break;
		7495	+ case '%':
		7496	+ if (command)
		7497	+ {
		7498	+ if (modified == CharT{})
		7499	+ read(is, *fmt);
		7500	+ else
		7501	+ read(is, CharT{'%'}, width, modified, *fmt);
		7502	+ command = nullptr;
		7503	+ width = -1;
		7504	+ modified = CharT{};
		7505	+ }
		7506	+ else
		7507	+ command = fmt;
		7508	+ break;
		7509	+ case 'z':
		7510	+ if (command)
		7511	+ {
		7512	+ int tH, tM;
		7513	+ minutes toff = not_a_offset;
		7514	+ bool neg = false;
		7515	+ auto ic = is.peek();
		7516	+ if (!Traits::eq_int_type(ic, Traits::eof()))
		7517	+ {
		7518	+ auto c = static_cast<char>(Traits::to_char_type(ic));
		7519	+ if (c == '-')
		7520	+ neg = true;
		7521	+ }
		7522	+ if (modified == CharT{})
		7523	+ {
		7524	+ read(is, rs{tH, 2, 2});
		7525	+ if (!is.fail())
		7526	+ toff = hours{std::abs(tH)};
		7527	+ if (is.good())
		7528	+ {
		7529	+ ic = is.peek();
		7530	+ if (!Traits::eq_int_type(ic, Traits::eof()))
		7531	+ {
		7532	+ auto c = static_cast<char>(Traits::to_char_type(ic));
		7533	+ if ('0' <= c && c <= '9')
		7534	+ {
		7535	+ read(is, ru{tM, 2, 2});
		7536	+ if (!is.fail())
		7537	+ toff += minutes{tM};
		7538	+ }
		7539	+ }
		7540	+ }
		7541	+ }
		7542	+ else
		7543	+ {
		7544	+ read(is, rs{tH, 1, 2});
		7545	+ if (!is.fail())
		7546	+ toff = hours{std::abs(tH)};
		7547	+ if (is.good())
		7548	+ {
		7549	+ ic = is.peek();
		7550	+ if (!Traits::eq_int_type(ic, Traits::eof()))
		7551	+ {
		7552	+ auto c = static_cast<char>(Traits::to_char_type(ic));
		7553	+ if (c == ':')
		7554	+ {
		7555	+ (void)is.get();
		7556	+ read(is, ru{tM, 2, 2});
		7557	+ if (!is.fail())
		7558	+ toff += minutes{tM};
		7559	+ }
		7560	+ }
		7561	+ }
		7562	+ }
		7563	+ if (neg)
		7564	+ toff = -toff;
		7565	+ checked_set(temp_offset, toff, not_a_offset, is);
		7566	+ command = nullptr;
		7567	+ width = -1;
		7568	+ modified = CharT{};
		7569	+ }
		7570	+ else
		7571	+ read(is, *fmt);
		7572	+ break;
		7573	+ case 'Z':
		7574	+ if (command)
		7575	+ {
		7576	+ if (modified == CharT{})
		7577	+ {
		7578	+ std::basic_string<CharT, Traits, Alloc> buf;
		7579	+ while (is.rdstate() == std::ios::goodbit)
		7580	+ {
		7581	+ auto i = is.rdbuf()->sgetc();
		7582	+ if (Traits::eq_int_type(i, Traits::eof()))
		7583	+ {
		7584	+ is.setstate(ios::eofbit);
		7585	+ break;
		7586	+ }
		7587	+ auto wc = Traits::to_char_type(i);
		7588	+ auto c = static_cast<char>(wc);
		7589	+ // is c a valid time zone name or abbreviation character?
		7590	+ if (!(CharT{1} < wc && wc < CharT{127}) \|\| !(isalnum(c) \|\|
		7591	+ c == '_' \|\| c == '/' \|\| c == '-' \|\| c == '+'))
		7592	+ break;
		7593	+ buf.push_back(c);
		7594	+ is.rdbuf()->sbumpc();
		7595	+ }
		7596	+ if (buf.empty())
		7597	+ is.setstate(ios::failbit);
		7598	+ checked_set(temp_abbrev, buf, {}, is);
		7599	+ }
		7600	+ else
		7601	+ read(is, CharT{'%'}, width, modified, *fmt);
		7602	+ command = nullptr;
		7603	+ width = -1;
		7604	+ modified = CharT{};
		7605	+ }
		7606	+ else
		7607	+ read(is, *fmt);
		7608	+ break;
		7609	+ default:
		7610	+ if (command)
		7611	+ {
		7612	+ if (width == -1 && modified == CharT{} && '0' <= fmt && fmt <= '9')
		7613	+ {
		7614	+ width = static_cast<char>(*fmt) - '0';
		7615	+ while ('0' <= fmt[1] && fmt[1] <= '9')
		7616	+ width = 10width + static_cast<char>(++fmt) - '0';
		7617	+ }
		7618	+ else
		7619	+ {
		7620	+ if (modified == CharT{})
		7621	+ read(is, CharT{'%'}, width, *fmt);
		7622	+ else
		7623	+ read(is, CharT{'%'}, width, modified, *fmt);
		7624	+ command = nullptr;
		7625	+ width = -1;
		7626	+ modified = CharT{};
		7627	+ }
		7628	+ }
		7629	+ else // !command
		7630	+ {
		7631	+ if (isspace(static_cast<unsigned char>(*fmt)))
		7632	+ {
		7633	+ // space matches 0 or more white space characters
		7634	+ if (is.good())
		7635	+ ws(is);
		7636	+ }
		7637	+ else
		7638	+ read(is, *fmt);
		7639	+ }
		7640	+ break;
		7641	+ }
		7642	+ }
		7643	+ // is.fail() \|\| *fmt == CharT{}
		7644	+ if (is.rdstate() == ios::goodbit && command)
		7645	+ {
		7646	+ if (modified == CharT{})
		7647	+ read(is, CharT{'%'}, width);
		7648	+ else
		7649	+ read(is, CharT{'%'}, width, modified);
		7650	+ }
		7651	+ if (!is.fail())
		7652	+ {
		7653	+ if (y != not_a_2digit_year)
		7654	+ {
		7655	+ // Convert y and an optional C to Y
		7656	+ if (!(0 <= y && y <= 99))
		7657	+ goto broken;
		7658	+ if (C == not_a_century)
		7659	+ {
		7660	+ if (Y == not_a_year)
		7661	+ {
		7662	+ if (y >= 69)
		7663	+ C = 19;
		7664	+ else
		7665	+ C = 20;
		7666	+ }
		7667	+ else
		7668	+ {
		7669	+ C = (Y >= 0 ? Y : Y-100) / 100;
		7670	+ }
		7671	+ }
		7672	+ int tY;
		7673	+ if (C >= 0)
		7674	+ tY = 100*C + y;
		7675	+ else
		7676	+ tY = 100*(C+1) - (y == 0 ? 100 : y);
		7677	+ if (Y != not_a_year && Y != tY)
		7678	+ goto broken;
		7679	+ Y = tY;
		7680	+ }
		7681	+ if (g != not_a_2digit_year)
		7682	+ {
		7683	+ // Convert g and an optional C to G
		7684	+ if (!(0 <= g && g <= 99))
		7685	+ goto broken;
		7686	+ if (C == not_a_century)
		7687	+ {
		7688	+ if (G == not_a_year)
		7689	+ {
		7690	+ if (g >= 69)
		7691	+ C = 19;
		7692	+ else
		7693	+ C = 20;
		7694	+ }
		7695	+ else
		7696	+ {
		7697	+ C = (G >= 0 ? G : G-100) / 100;
		7698	+ }
		7699	+ }
		7700	+ int tG;
		7701	+ if (C >= 0)
		7702	+ tG = 100*C + g;
		7703	+ else
		7704	+ tG = 100*(C+1) - (g == 0 ? 100 : g);
		7705	+ if (G != not_a_year && G != tG)
		7706	+ goto broken;
		7707	+ G = tG;
		7708	+ }
		7709	+ if (Y < static_cast<int>(year::min()) \|\| Y > static_cast<int>(year::max()))
		7710	+ Y = not_a_year;
		7711	+ bool computed = false;
		7712	+ if (G != not_a_year && V != not_a_week_num && wd != not_a_weekday)
		7713	+ {
		7714	+ year_month_day ymd_trial = sys_days(year{G-1}/December/Thursday[last]) +
		7715	+ (Monday-Thursday) + weeks{V-1} +
		7716	+ (weekday{static_cast<unsigned>(wd)}-Monday);
		7717	+ if (Y == not_a_year)
		7718	+ Y = static_cast<int>(ymd_trial.year());
		7719	+ else if (year{Y} != ymd_trial.year())
		7720	+ goto broken;
		7721	+ if (m == not_a_month)
		7722	+ m = static_cast<int>(static_cast<unsigned>(ymd_trial.month()));
		7723	+ else if (month(static_cast<unsigned>(m)) != ymd_trial.month())
		7724	+ goto broken;
		7725	+ if (d == not_a_day)
		7726	+ d = static_cast<int>(static_cast<unsigned>(ymd_trial.day()));
		7727	+ else if (day(static_cast<unsigned>(d)) != ymd_trial.day())
		7728	+ goto broken;
		7729	+ computed = true;
		7730	+ }
		7731	+ if (Y != not_a_year && U != not_a_week_num && wd != not_a_weekday)
		7732	+ {
		7733	+ year_month_day ymd_trial = sys_days(year{Y}/January/Sunday[1]) +
		7734	+ weeks{U-1} +
		7735	+ (weekday{static_cast<unsigned>(wd)} - Sunday);
		7736	+ if (Y == not_a_year)
		7737	+ Y = static_cast<int>(ymd_trial.year());
		7738	+ else if (year{Y} != ymd_trial.year())
		7739	+ goto broken;
		7740	+ if (m == not_a_month)
		7741	+ m = static_cast<int>(static_cast<unsigned>(ymd_trial.month()));
		7742	+ else if (month(static_cast<unsigned>(m)) != ymd_trial.month())
		7743	+ goto broken;
		7744	+ if (d == not_a_day)
		7745	+ d = static_cast<int>(static_cast<unsigned>(ymd_trial.day()));
		7746	+ else if (day(static_cast<unsigned>(d)) != ymd_trial.day())
		7747	+ goto broken;
		7748	+ computed = true;
		7749	+ }
		7750	+ if (Y != not_a_year && W != not_a_week_num && wd != not_a_weekday)
		7751	+ {
		7752	+ year_month_day ymd_trial = sys_days(year{Y}/January/Monday[1]) +
		7753	+ weeks{W-1} +
		7754	+ (weekday{static_cast<unsigned>(wd)} - Monday);
		7755	+ if (Y == not_a_year)
		7756	+ Y = static_cast<int>(ymd_trial.year());
		7757	+ else if (year{Y} != ymd_trial.year())
		7758	+ goto broken;
		7759	+ if (m == not_a_month)
		7760	+ m = static_cast<int>(static_cast<unsigned>(ymd_trial.month()));
		7761	+ else if (month(static_cast<unsigned>(m)) != ymd_trial.month())
		7762	+ goto broken;
		7763	+ if (d == not_a_day)
		7764	+ d = static_cast<int>(static_cast<unsigned>(ymd_trial.day()));
		7765	+ else if (day(static_cast<unsigned>(d)) != ymd_trial.day())
		7766	+ goto broken;
		7767	+ computed = true;
		7768	+ }
		7769	+ if (j != not_a_doy && Y != not_a_year)
		7770	+ {
		7771	+ auto ymd_trial = year_month_day{local_days(year{Y}/1/1) + days{j-1}};
		7772	+ if (m == not_a_month)
		7773	+ m = static_cast<int>(static_cast<unsigned>(ymd_trial.month()));
		7774	+ else if (month(static_cast<unsigned>(m)) != ymd_trial.month())
		7775	+ goto broken;
		7776	+ if (d == not_a_day)
		7777	+ d = static_cast<int>(static_cast<unsigned>(ymd_trial.day()));
		7778	+ else if (day(static_cast<unsigned>(d)) != ymd_trial.day())
		7779	+ goto broken;
		7780	+ j = not_a_doy;
		7781	+ }
		7782	+ auto ymd = year{Y}/m/d;
		7783	+ if (ymd.ok())
		7784	+ {
		7785	+ if (wd == not_a_weekday)
		7786	+ wd = static_cast<int>((weekday(sys_days(ymd)) - Sunday).count());
		7787	+ else if (wd != static_cast<int>((weekday(sys_days(ymd)) - Sunday).count()))
		7788	+ goto broken;
		7789	+ if (!computed)
		7790	+ {
		7791	+ if (G != not_a_year \|\| V != not_a_week_num)
		7792	+ {
		7793	+ sys_days sd = ymd;
		7794	+ auto G_trial = year_month_day{sd + days{3}}.year();
		7795	+ auto start = sys_days((G_trial - years{1})/December/Thursday[last]) +
		7796	+ (Monday - Thursday);
		7797	+ if (sd < start)
		7798	+ {
		7799	+ --G_trial;
		7800	+ if (V != not_a_week_num)
		7801	+ start = sys_days((G_trial - years{1})/December/Thursday[last])
		7802	+ + (Monday - Thursday);
		7803	+ }
		7804	+ if (G != not_a_year && G != static_cast<int>(G_trial))
		7805	+ goto broken;
		7806	+ if (V != not_a_week_num)
		7807	+ {
		7808	+ auto V_trial = duration_cast<weeks>(sd - start).count() + 1;
		7809	+ if (V != V_trial)
		7810	+ goto broken;
		7811	+ }
		7812	+ }
		7813	+ if (U != not_a_week_num)
		7814	+ {
		7815	+ auto start = sys_days(Sunday[1]/January/ymd.year());
		7816	+ auto U_trial = floor<weeks>(sys_days(ymd) - start).count() + 1;
		7817	+ if (U != U_trial)
		7818	+ goto broken;
		7819	+ }
		7820	+ if (W != not_a_week_num)
		7821	+ {
		7822	+ auto start = sys_days(Monday[1]/January/ymd.year());
		7823	+ auto W_trial = floor<weeks>(sys_days(ymd) - start).count() + 1;
		7824	+ if (W != W_trial)
		7825	+ goto broken;
		7826	+ }
		7827	+ }
		7828	+ }
		7829	+ fds.ymd = ymd;
		7830	+ if (I != not_a_hour_12_value)
		7831	+ {
		7832	+ if (!(1 <= I && I <= 12))
		7833	+ goto broken;
		7834	+ if (p != not_a_ampm)
		7835	+ {
		7836	+ // p is in [0, 1] == [AM, PM]
		7837	+ // Store trial H in I
		7838	+ if (I == 12)
		7839	+ --p;
		7840	+ I += p*12;
		7841	+ // Either set H from I or make sure H and I are consistent
		7842	+ if (H == not_a_hour)
		7843	+ H = I;
		7844	+ else if (I != H)
		7845	+ goto broken;
		7846	+ }
		7847	+ else // p == not_a_ampm
		7848	+ {
		7849	+ // if H, make sure H and I could be consistent
		7850	+ if (H != not_a_hour)
		7851	+ {
		7852	+ if (I == 12)
		7853	+ {
		7854	+ if (H != 0 && H != 12)
		7855	+ goto broken;
		7856	+ }
		7857	+ else if (!(I == H \|\| I == H+12))
		7858	+ {
		7859	+ goto broken;
		7860	+ }
		7861	+ }
		7862	+ else // I is ambiguous, AM or PM?
		7863	+ goto broken;
		7864	+ }
		7865	+ }
		7866	+ if (H != not_a_hour)
		7867	+ {
		7868	+ fds.has_tod = true;
		7869	+ fds.tod = hh_mm_ss<Duration>{hours{H}};
		7870	+ }
		7871	+ if (M != not_a_minute)
		7872	+ {
		7873	+ fds.has_tod = true;
		7874	+ fds.tod.m_ = minutes{M};
		7875	+ }
		7876	+ if (s != not_a_second)
		7877	+ {
		7878	+ fds.has_tod = true;
		7879	+ fds.tod.s_ = detail::decimal_format_seconds<Duration>{s};
		7880	+ }
		7881	+ if (j != not_a_doy)
		7882	+ {
		7883	+ fds.has_tod = true;
		7884	+ fds.tod.h_ += hours{days{j}};
		7885	+ }
		7886	+ if (wd != not_a_weekday)
		7887	+ fds.wd = weekday{static_cast<unsigned>(wd)};
		7888	+ if (abbrev != nullptr)
		7889	+ *abbrev = std::move(temp_abbrev);
		7890	+ if (offset != nullptr && temp_offset != not_a_offset)
		7891	+ *offset = temp_offset;
		7892	+ }
		7893	+ return is;
		7894	+ }
		7895	+broken:
		7896	+ is.setstate(ios::failbit);
		7897	+ return is;
		7898	+}
		7899	+
		7900	+template <class CharT, class Traits, class Alloc = std::allocator<CharT>>
		7901	+std::basic_istream<CharT, Traits>&
		7902	+from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt, year& y,
		7903	+ std::basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
		7904	+ std::chrono::minutes* offset = nullptr)
		7905	+{
		7906	+ using CT = std::chrono::seconds;
		7907	+ fields<CT> fds{};
		7908	+ date::from_stream(is, fmt, fds, abbrev, offset);
		7909	+ if (!fds.ymd.year().ok())
		7910	+ is.setstate(std::ios::failbit);
		7911	+ if (!is.fail())
		7912	+ y = fds.ymd.year();
		7913	+ return is;
		7914	+}
		7915	+
		7916	+template <class CharT, class Traits, class Alloc = std::allocator<CharT>>
		7917	+std::basic_istream<CharT, Traits>&
		7918	+from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt, month& m,
		7919	+ std::basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
		7920	+ std::chrono::minutes* offset = nullptr)
		7921	+{
		7922	+ using CT = std::chrono::seconds;
		7923	+ fields<CT> fds{};
		7924	+ date::from_stream(is, fmt, fds, abbrev, offset);
		7925	+ if (!fds.ymd.month().ok())
		7926	+ is.setstate(std::ios::failbit);
		7927	+ if (!is.fail())
		7928	+ m = fds.ymd.month();
		7929	+ return is;
		7930	+}
		7931	+
		7932	+template <class CharT, class Traits, class Alloc = std::allocator<CharT>>
		7933	+std::basic_istream<CharT, Traits>&
		7934	+from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt, day& d,
		7935	+ std::basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
		7936	+ std::chrono::minutes* offset = nullptr)
		7937	+{
		7938	+ using CT = std::chrono::seconds;
		7939	+ fields<CT> fds{};
		7940	+ date::from_stream(is, fmt, fds, abbrev, offset);
		7941	+ if (!fds.ymd.day().ok())
		7942	+ is.setstate(std::ios::failbit);
		7943	+ if (!is.fail())
		7944	+ d = fds.ymd.day();
		7945	+ return is;
		7946	+}
		7947	+
		7948	+template <class CharT, class Traits, class Alloc = std::allocator<CharT>>
		7949	+std::basic_istream<CharT, Traits>&
		7950	+from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt, weekday& wd,
		7951	+ std::basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
		7952	+ std::chrono::minutes* offset = nullptr)
		7953	+{
		7954	+ using CT = std::chrono::seconds;
		7955	+ fields<CT> fds{};
		7956	+ date::from_stream(is, fmt, fds, abbrev, offset);
		7957	+ if (!fds.wd.ok())
		7958	+ is.setstate(std::ios::failbit);
		7959	+ if (!is.fail())
		7960	+ wd = fds.wd;
		7961	+ return is;
		7962	+}
		7963	+
		7964	+template <class CharT, class Traits, class Alloc = std::allocator<CharT>>
		7965	+std::basic_istream<CharT, Traits>&
		7966	+from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt, year_month& ym,
		7967	+ std::basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
		7968	+ std::chrono::minutes* offset = nullptr)
		7969	+{
		7970	+ using CT = std::chrono::seconds;
		7971	+ fields<CT> fds{};
		7972	+ date::from_stream(is, fmt, fds, abbrev, offset);
		7973	+ if (!fds.ymd.month().ok())
		7974	+ is.setstate(std::ios::failbit);
		7975	+ if (!is.fail())
		7976	+ ym = fds.ymd.year()/fds.ymd.month();
		7977	+ return is;
		7978	+}
		7979	+
		7980	+template <class CharT, class Traits, class Alloc = std::allocator<CharT>>
		7981	+std::basic_istream<CharT, Traits>&
		7982	+from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt, month_day& md,
		7983	+ std::basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
		7984	+ std::chrono::minutes* offset = nullptr)
		7985	+{
		7986	+ using CT = std::chrono::seconds;
		7987	+ fields<CT> fds{};
		7988	+ date::from_stream(is, fmt, fds, abbrev, offset);
		7989	+ if (!fds.ymd.month().ok() \|\| !fds.ymd.day().ok())
		7990	+ is.setstate(std::ios::failbit);
		7991	+ if (!is.fail())
		7992	+ md = fds.ymd.month()/fds.ymd.day();
		7993	+ return is;
		7994	+}
		7995	+
		7996	+template <class CharT, class Traits, class Alloc = std::allocator<CharT>>
		7997	+std::basic_istream<CharT, Traits>&
		7998	+from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt,
		7999	+ year_month_day& ymd, std::basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
		8000	+ std::chrono::minutes* offset = nullptr)
		8001	+{
		8002	+ using CT = std::chrono::seconds;
		8003	+ fields<CT> fds{};
		8004	+ date::from_stream(is, fmt, fds, abbrev, offset);
		8005	+ if (!fds.ymd.ok())
		8006	+ is.setstate(std::ios::failbit);
		8007	+ if (!is.fail())
		8008	+ ymd = fds.ymd;
		8009	+ return is;
		8010	+}
		8011	+
		8012	+template <class Duration, class CharT, class Traits, class Alloc = std::allocator<CharT>>
		8013	+std::basic_istream<CharT, Traits>&
		8014	+from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt,
		8015	+ sys_time<Duration>& tp, std::basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
		8016	+ std::chrono::minutes* offset = nullptr)
		8017	+{
		8018	+ using CT = typename std::common_type<Duration, std::chrono::seconds>::type;
		8019	+ using detail::round_i;
		8020	+ std::chrono::minutes offset_local{};
		8021	+ auto offptr = offset ? offset : &offset_local;
		8022	+ fields<CT> fds{};
		8023	+ fds.has_tod = true;
		8024	+ date::from_stream(is, fmt, fds, abbrev, offptr);
		8025	+ if (!fds.ymd.ok() \|\| !fds.tod.in_conventional_range())
		8026	+ is.setstate(std::ios::failbit);
		8027	+ if (!is.fail())
		8028	+ tp = round_i<Duration>(sys_days(fds.ymd) - *offptr + fds.tod.to_duration());
		8029	+ return is;
		8030	+}
		8031	+
		8032	+template <class Duration, class CharT, class Traits, class Alloc = std::allocator<CharT>>
		8033	+std::basic_istream<CharT, Traits>&
		8034	+from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt,
		8035	+ local_time<Duration>& tp, std::basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
		8036	+ std::chrono::minutes* offset = nullptr)
		8037	+{
		8038	+ using CT = typename std::common_type<Duration, std::chrono::seconds>::type;
		8039	+ using detail::round_i;
		8040	+ fields<CT> fds{};
		8041	+ fds.has_tod = true;
		8042	+ date::from_stream(is, fmt, fds, abbrev, offset);
		8043	+ if (!fds.ymd.ok() \|\| !fds.tod.in_conventional_range())
		8044	+ is.setstate(std::ios::failbit);
		8045	+ if (!is.fail())
		8046	+ tp = round_i<Duration>(local_seconds{local_days(fds.ymd)} + fds.tod.to_duration());
		8047	+ return is;
		8048	+}
		8049	+
		8050	+template <class Rep, class Period, class CharT, class Traits, class Alloc = std::allocator<CharT>>
		8051	+std::basic_istream<CharT, Traits>&
		8052	+from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt,
		8053	+ std::chrono::duration<Rep, Period>& d,
		8054	+ std::basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
		8055	+ std::chrono::minutes* offset = nullptr)
		8056	+{
		8057	+ using Duration = std::chrono::duration<Rep, Period>;
		8058	+ using CT = typename std::common_type<Duration, std::chrono::seconds>::type;
		8059	+ using detail::round_i;
		8060	+ fields<CT> fds{};
		8061	+ date::from_stream(is, fmt, fds, abbrev, offset);
		8062	+ if (!fds.has_tod)
		8063	+ is.setstate(std::ios::failbit);
		8064	+ if (!is.fail())
		8065	+ d = round_i<Duration>(fds.tod.to_duration());
		8066	+ return is;
		8067	+}
		8068	+
		8069	+template <class Parsable, class CharT, class Traits = std::char_traits<CharT>,
		8070	+ class Alloc = std::allocator<CharT>>
		8071	+struct parse_manip
		8072	+{
		8073	+ const std::basic_string<CharT, Traits, Alloc> format_;
		8074	+ Parsable& tp_;
		8075	+ std::basic_string<CharT, Traits, Alloc>* abbrev_;
		8076	+ std::chrono::minutes* offset_;
		8077	+
		8078	+public:
		8079	+ parse_manip(std::basic_string<CharT, Traits, Alloc> format, Parsable& tp,
		8080	+ std::basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
		8081	+ std::chrono::minutes* offset = nullptr)
		8082	+ : format_(std::move(format))
		8083	+ , tp_(tp)
		8084	+ , abbrev_(abbrev)
		8085	+ , offset_(offset)
		8086	+ {}
		8087	+
		8088	+#if HAS_STRING_VIEW
		8089	+ parse_manip(const CharT* format, Parsable& tp,
		8090	+ std::basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
		8091	+ std::chrono::minutes* offset = nullptr)
		8092	+ : format_(format)
		8093	+ , tp_(tp)
		8094	+ , abbrev_(abbrev)
		8095	+ , offset_(offset)
		8096	+ {}
		8097	+
		8098	+ parse_manip(std::basic_string_view<CharT, Traits> format, Parsable& tp,
		8099	+ std::basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
		8100	+ std::chrono::minutes* offset = nullptr)
		8101	+ : format_(format)
		8102	+ , tp_(tp)
		8103	+ , abbrev_(abbrev)
		8104	+ , offset_(offset)
		8105	+ {}
		8106	+#endif // HAS_STRING_VIEW
		8107	+};
		8108	+
		8109	+template <class Parsable, class CharT, class Traits, class Alloc>
		8110	+std::basic_istream<CharT, Traits>&
		8111	+operator>>(std::basic_istream<CharT, Traits>& is,
		8112	+ const parse_manip<Parsable, CharT, Traits, Alloc>& x)
		8113	+{
		8114	+ return date::from_stream(is, x.format_.c_str(), x.tp_, x.abbrev_, x.offset_);
		8115	+}
		8116	+
		8117	+template <class Parsable, class CharT, class Traits, class Alloc>
		8118	+inline
		8119	+auto
		8120	+parse(const std::basic_string<CharT, Traits, Alloc>& format, Parsable& tp)
		8121	+ -> decltype(date::from_stream(std::declval<std::basic_istream<CharT, Traits>&>(),
		8122	+ format.c_str(), tp),
		8123	+ parse_manip<Parsable, CharT, Traits, Alloc>{format, tp})
		8124	+{
		8125	+ return {format, tp};
		8126	+}
		8127	+
		8128	+template <class Parsable, class CharT, class Traits, class Alloc>
		8129	+inline
		8130	+auto
		8131	+parse(const std::basic_string<CharT, Traits, Alloc>& format, Parsable& tp,
		8132	+ std::basic_string<CharT, Traits, Alloc>& abbrev)
		8133	+ -> decltype(date::from_stream(std::declval<std::basic_istream<CharT, Traits>&>(),
		8134	+ format.c_str(), tp, &abbrev),
		8135	+ parse_manip<Parsable, CharT, Traits, Alloc>{format, tp, &abbrev})
		8136	+{
		8137	+ return {format, tp, &abbrev};
		8138	+}
		8139	+
		8140	+template <class Parsable, class CharT, class Traits, class Alloc>
		8141	+inline
		8142	+auto
		8143	+parse(const std::basic_string<CharT, Traits, Alloc>& format, Parsable& tp,
		8144	+ std::chrono::minutes& offset)
		8145	+ -> decltype(date::from_stream(std::declval<std::basic_istream<CharT, Traits>&>(),
		8146	+ format.c_str(), tp,
		8147	+ std::declval<std::basic_string<CharT, Traits, Alloc>*>(),
		8148	+ &offset),
		8149	+ parse_manip<Parsable, CharT, Traits, Alloc>{format, tp, nullptr, &offset})
		8150	+{
		8151	+ return {format, tp, nullptr, &offset};
		8152	+}
		8153	+
		8154	+template <class Parsable, class CharT, class Traits, class Alloc>
		8155	+inline
		8156	+auto
		8157	+parse(const std::basic_string<CharT, Traits, Alloc>& format, Parsable& tp,
		8158	+ std::basic_string<CharT, Traits, Alloc>& abbrev, std::chrono::minutes& offset)
		8159	+ -> decltype(date::from_stream(std::declval<std::basic_istream<CharT, Traits>&>(),
		8160	+ format.c_str(), tp, &abbrev, &offset),
		8161	+ parse_manip<Parsable, CharT, Traits, Alloc>{format, tp, &abbrev, &offset})
		8162	+{
		8163	+ return {format, tp, &abbrev, &offset};
		8164	+}
		8165	+
		8166	+// const CharT* formats
		8167	+
		8168	+template <class Parsable, class CharT>
		8169	+inline
		8170	+auto
		8171	+parse(const CharT* format, Parsable& tp)
		8172	+ -> decltype(date::from_stream(std::declval<std::basic_istream<CharT>&>(), format, tp),
		8173	+ parse_manip<Parsable, CharT>{format, tp})
		8174	+{
		8175	+ return {format, tp};
		8176	+}
		8177	+
		8178	+template <class Parsable, class CharT, class Traits, class Alloc>
		8179	+inline
		8180	+auto
		8181	+parse(const CharT* format, Parsable& tp, std::basic_string<CharT, Traits, Alloc>& abbrev)
		8182	+ -> decltype(date::from_stream(std::declval<std::basic_istream<CharT, Traits>&>(), format,
		8183	+ tp, &abbrev),
		8184	+ parse_manip<Parsable, CharT, Traits, Alloc>{format, tp, &abbrev})
		8185	+{
		8186	+ return {format, tp, &abbrev};
		8187	+}
		8188	+
		8189	+template <class Parsable, class CharT>
		8190	+inline
		8191	+auto
		8192	+parse(const CharT* format, Parsable& tp, std::chrono::minutes& offset)
		8193	+ -> decltype(date::from_stream(std::declval<std::basic_istream<CharT>&>(), format,
		8194	+ tp, std::declval<std::basic_string<CharT>*>(), &offset),
		8195	+ parse_manip<Parsable, CharT>{format, tp, nullptr, &offset})
		8196	+{
		8197	+ return {format, tp, nullptr, &offset};
		8198	+}
		8199	+
		8200	+template <class Parsable, class CharT, class Traits, class Alloc>
		8201	+inline
		8202	+auto
		8203	+parse(const CharT* format, Parsable& tp,
		8204	+ std::basic_string<CharT, Traits, Alloc>& abbrev, std::chrono::minutes& offset)
		8205	+ -> decltype(date::from_stream(std::declval<std::basic_istream<CharT, Traits>&>(), format,
		8206	+ tp, &abbrev, &offset),
		8207	+ parse_manip<Parsable, CharT, Traits, Alloc>{format, tp, &abbrev, &offset})
		8208	+{
		8209	+ return {format, tp, &abbrev, &offset};
		8210	+}
		8211	+
		8212	+// duration streaming
		8213	+
		8214	+template <class CharT, class Traits, class Rep, class Period>
		8215	+inline
		8216	+std::basic_ostream<CharT, Traits>&
		8217	+operator<<(std::basic_ostream<CharT, Traits>& os,
		8218	+ const std::chrono::duration<Rep, Period>& d)
		8219	+{
		8220	+ return os << detail::make_string<CharT, Traits>::from(d.count()) +
		8221	+ detail::get_units<CharT>(typename Period::type{});
		8222	+}
		8223	+
		8224	+} // namespace date
		8225	+
		8226	+#ifdef _MSC_VER
		8227	+# pragma warning(pop)
		8228	+#endif
		8229	+
		8230	+#ifdef __GNUC__
		8231	+# pragma GCC diagnostic pop
		8232	+#endif
		8233	+
		8234	+#endif // DATE_H
		8235	+

src/errorcode.cpp 0 → 100644

View file @51becbd

		1	+++ a/src/errorcode.cpp
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#include "errorcode.h"
		20	+
		21	+// paho
		22	+#include <MQTTAsync.h>
		23	+
		24	+namespace osdev {
		25	+namespace components {
		26	+namespace mqtt {
		27	+
		28	+std::string pahoAsyncErrorCodeToString( int errorCode )
		29	+{
		30	+ if (MQTTASYNC_SUCCESS == errorCode) {
		31	+ return "MQTTASYNC_SUCCESS";
		32	+ }
		33	+ else if (MQTTASYNC_FAILURE == errorCode) {
		34	+ return "MQTTASYNC_FAILURE";
		35	+ }
		36	+ else if (MQTTASYNC_PERSISTENCE_ERROR == errorCode) {
		37	+ return "MQTTASYNC_PERSISTENCE_ERROR";
		38	+ }
		39	+ else if (MQTTASYNC_DISCONNECTED == errorCode) {
		40	+ return "MQTTASYNC_DISCONNECTED";
		41	+ }
		42	+ else if (MQTTASYNC_MAX_MESSAGES_INFLIGHT == errorCode) {
		43	+ return "MQTTASYNC_MAX_MESSAGES_INFLIGHT";
		44	+ }
		45	+ else if (MQTTASYNC_BAD_UTF8_STRING == errorCode) {
		46	+ return "MQTTASYNC_BAD_UTF8_STRING";
		47	+ }
		48	+ else if (MQTTASYNC_NULL_PARAMETER == errorCode) {
		49	+ return "MQTTASYNC_NULL_PARAMETER";
		50	+ }
		51	+ else if (MQTTASYNC_TOPICNAME_TRUNCATED == errorCode) {
		52	+ return "MQTTASYNC_TOPICNAME_TRUNCATED";
		53	+ }
		54	+ else if (MQTTASYNC_BAD_STRUCTURE == errorCode) {
		55	+ return "MQTTASYNC_BAD_STRUCTURE";
		56	+ }
		57	+ else if (MQTTASYNC_BAD_QOS == errorCode) {
		58	+ return "MQTTASYNC_BAD_QOS";
		59	+ }
		60	+ else if (MQTTASYNC_NO_MORE_MSGIDS == errorCode) {
		61	+ return "MQTTASYNC_NO_MORE_MSGIDS";
		62	+ }
		63	+ else if (MQTTASYNC_OPERATION_INCOMPLETE == errorCode) {
		64	+ return "MQTTASYNC_OPERATION_INCOMPLETE";
		65	+ }
		66	+ else if (MQTTASYNC_MAX_BUFFERED_MESSAGES == errorCode) {
		67	+ return "MQTTASYNC_MAX_BUFFERED_MESSAGES";
		68	+ }
		69	+ else if (MQTTASYNC_SSL_NOT_SUPPORTED == errorCode) {
		70	+ return "MQTTASYNC_SSL_NOT_SUPPORTED";
		71	+ }
		72	+ else if (MQTTASYNC_BAD_PROTOCOL == errorCode) {
		73	+ return "MQTTASYNC_BAD_PROTOCOL";
		74	+ }
		75	+#if defined MQTTASYNC_BAD_MQTT_OPTION // Not supported by centos7 paho-c
		76	+ else if (MQTTASYNC_BAD_MQTT_OPTION == errorCode) {
		77	+ return "MQTTASYNC_BAD_MQTT_OPTION";
		78	+ }
		79	+#endif
		80	+#if defined MQTTASYNC_WRONG_MQTT_VERSION // Not supported by centos7 paho-c
		81	+ else if (MQTTASYNC_WRONG_MQTT_VERSION == errorCode) {
		82	+ return "MQTTASYNC_WRONG_MQTT_VERSION";
		83	+ }
		84	+#endif
		85	+ return "Unknown(" + std::to_string(errorCode) + ")";
		86	+}
		87	+
		88	+} // End namespace mqtt
		89	+} // End namespace components
		90	+} // End namespace osdev

src/errorcode.h 0 → 100644

View file @51becbd

		1	+++ a/src/errorcode.h
		1	+#ifndef OSDEV_COMPONENTS_MQTT_ERRORCODE_H
		2	+#define OSDEV_COMPONENTS_MQTT_ERRORCODE_H
		3	+
		4	+// std
		5	+#include <string>
		6	+
		7	+namespace osdev {
		8	+namespace components {
		9	+namespace mqtt {
		10	+
		11	+/*!
		12	+ * \return A stringified paho error code...
		13	+ */
		14	+std::string pahoAsyncErrorCodeToString( int errorCode );
		15	+
		16	+
		17	+} // End namespace mqtt
		18	+} // End nnamespace components
		19	+} // End namesapce osdev
		20	+
		21	+#endif // OSDEV_COMPONENTS_MQTT_ERRORCODE_H

src/histogram.h 0 → 100644

View file @51becbd

		1	+++ a/src/histogram.h
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#ifndef OSDEV_COMPONENTS_MQTT_MEASUREMENT_HISTOGRAM_H
		20	+#define OSDEV_COMPONENTS_MQTT_MEASUREMENT_HISTOGRAM_H
		21	+
		22	+#include <atomic>
		23	+#include <cmath>
		24	+#include <limits>
		25	+#include <mutex>
		26	+#include <string>
		27	+#include <vector>
		28	+
		29	+#include "utils.h"
		30	+
		31	+#include "ihistogram.h"
		32	+
		33	+namespace osdev {
		34	+namespace components {
		35	+namespace mqtt {
		36	+namespace measurement {
		37	+
		38	+template <typename T>
		39	+double fabs(T val)
		40	+{
		41	+ return std::fabs(val);
		42	+}
		43	+
		44	+template <typename Rep, typename Dur>
		45	+double fabs(const std::chrono::duration<Rep, Dur>& dur)
		46	+{
		47	+ return std::fabs(dur.count());
		48	+}
		49	+
		50	+template <typename T>
		51	+double to_double(T val)
		52	+{
		53	+ return static_cast<double>(val);
		54	+}
		55	+
		56	+template <typename Rep, typename Dur>
		57	+double to_double(const std::chrono::duration<Rep, Dur>& dur)
		58	+{
		59	+ return static_cast<double>(dur.count());
		60	+}
		61	+
		62	+template <typename T>
		63	+std::string to_string(T val)
		64	+{
		65	+ return std::to_string(val);
		66	+}
		67	+
		68	+template <typename Rep, typename Dur>
		69	+std::string to_string(const std::chrono::duration<Rep, Dur>& dur)
		70	+{
		71	+ return std::to_string(dur.count());
		72	+}
		73	+
		74	+template <typename T>
		75	+T min(T)
		76	+{
		77	+ return std::numeric_limits<T>::min();
		78	+}
		79	+
		80	+template <typename Rep, typename Dur>
		81	+std::chrono::duration<Rep, Dur> min(const std::chrono::duration<Rep, Dur>&)
		82	+{
		83	+ return std::chrono::duration<Rep, Dur>::min();
		84	+}
		85	+
		86	+template <typename T>
		87	+T max(T)
		88	+{
		89	+ return std::numeric_limits<T>::max();
		90	+}
		91	+
		92	+template <typename Rep, typename Dur>
		93	+std::chrono::duration<Rep, Dur> max(const std::chrono::duration<Rep, Dur>&)
		94	+{
		95	+ return std::chrono::duration<Rep, Dur>::max();
		96	+}
		97	+
		98	+/**
		99	+ * @brief This class implements a histogram for typed values.
		100	+ * Outlier values to the left are counted on the first bin and to the right on the last bin.
		101	+ * @tparam T The value type. T must be default constructable.
		102	+ * @tparam Buckets The number of buckets to use for this histogram. Default is 10 buckets.
		103	+ */
		104	+template <typename T, std::size_t Buckets = 10>
		105	+class Histogram : public IHistogram
		106	+{
		107	+public:
		108	+ /**
		109	+ * @brief Construct a histogram.
		110	+ * @param id The histogram identification
		111	+ * @param minValue The minimum value of the histogram.
		112	+ * @param maxValue The maxmim value of the histogram.
		113	+ * @param unit The unit of the values that are collected in this histogram.
		114	+ */
		115	+ Histogram(const std::string& id, T minValue, T maxValue, const char* unit);
		116	+
		117	+ /**
		118	+ * @brief Set a value in the histogram.
		119	+ */
		120	+ void setValue(T value);
		121	+
		122	+ /**
		123	+ * @return true when values are added since the last time a snapshot was taken of the histogram or a reset was performed, false otherwise.
		124	+ */
		125	+ bool isUpdated() const;
		126	+
		127	+ /**
		128	+ * @brief Reset the histogram.
		129	+ * All counts are made zero and the smallest and largest recorded values are set to default.
		130	+ */
		131	+ void reset();
		132	+
		133	+ // IHistogram implementation
		134	+ virtual const std::string& id() const override;
		135	+ virtual std::size_t numBuckets() const override;
		136	+ virtual double bucketWidth() const override;
		137	+ virtual std::string minValueString() const override;
		138	+ virtual std::string maxValueString() const override;
		139	+ virtual const std::string& unit() const override;
		140	+ virtual HistogramData histogramData() const override;
		141	+ virtual std::size_t numberOfValuesSinceLastClear() const override;
		142	+ virtual std::string smallestValueSinceLastClear() const override;
		143	+ virtual std::string largestValueSinceLastClear() const override;
		144	+ virtual std::string averageValueSinceLastClear() const override;
		145	+ virtual void clearRunningValues() override;
		146	+ virtual std::string toString() const override;
		147	+
		148	+private:
		149	+ /**
		150	+ * @brief Get the index on which to count the given value.
		151	+ * The outliers to the left are counted on index 0 and to the right on index size() - 1.
		152	+ * @param value The value to get the index for.
		153	+ * @return the index in the histogram on which to count the given value.
		154	+ */
		155	+ inline std::size_t index(T value)
		156	+ {
		157	+ if (value > m_maxValue) {
		158	+ return m_histogram.size() - 1;
		159	+ }
		160	+ if (value < m_minValue) {
		161	+ return 0;
		162	+ }
		163	+
		164	+ return 1 + static_cast<std::size_t>(to_double((value - m_minValue) / m_bucketWidth));
		165	+ }
		166	+
		167	+ const std::string m_id;
		168	+ const std::string m_unit;
		169	+ const T m_minValue;
		170	+ const T m_maxValue;
		171	+ const double m_bucketWidth;
		172	+ T m_smallestValue;
		173	+ T m_largestValue;
		174	+ T m_smallestValueSinceLastClear;
		175	+ T m_largestValueSinceLastClear;
		176	+ T m_summedValueSinceLastClear;
		177	+ std::size_t m_numberOfValuesSinceLastClear;
		178	+ mutable std::mutex m_mutex;
		179	+ std::vector<std::size_t> m_histogram;
		180	+ mutable std::atomic_bool m_isUpdated;
		181	+};
		182	+
		183	+template <typename T, std::size_t Buckets>
		184	+Histogram<T, Buckets>::Histogram(const std::string& _id, T minValue, T maxValue, const char* _unit)
		185	+ : m_id(_id)
		186	+ , m_unit(_unit)
		187	+ , m_minValue(minValue)
		188	+ , m_maxValue(maxValue)
		189	+ , m_bucketWidth(fabs((m_maxValue - m_minValue)) / Buckets)
		190	+ , m_smallestValue{ max(maxValue) }
		191	+ , m_largestValue{ min(maxValue) }
		192	+ , m_smallestValueSinceLastClear{ max(maxValue) }
		193	+ , m_largestValueSinceLastClear{ min(maxValue) }
		194	+ , m_summedValueSinceLastClear{}
		195	+ , m_numberOfValuesSinceLastClear{}
		196	+ , m_mutex()
		197	+ , m_histogram(Buckets + 2) // + 2 for the out of bound buckets
		198	+ , m_isUpdated(false)
		199	+{
		200	+}
		201	+
		202	+template <typename T, std::size_t Buckets>
		203	+void Histogram<T, Buckets>::setValue(T value)
		204	+{
		205	+ std::lock_guard<std::mutex> lg(m_mutex);
		206	+ apply_unused_parameters(lg);
		207	+
		208	+ if (value > m_largestValueSinceLastClear) {
		209	+ m_largestValueSinceLastClear = value;
		210	+ }
		211	+
		212	+ if (value < m_smallestValueSinceLastClear) {
		213	+ m_smallestValueSinceLastClear = value;
		214	+ }
		215	+
		216	+ if (value > m_largestValue) {
		217	+ m_largestValue = value;
		218	+ }
		219	+
		220	+ if (value < m_smallestValue) {
		221	+ m_smallestValue = value;
		222	+ }
		223	+
		224	+ m_summedValueSinceLastClear += value;
		225	+ ++m_numberOfValuesSinceLastClear;
		226	+
		227	+ m_histogram[this->index(value)]++;
		228	+ m_isUpdated = true;
		229	+}
		230	+
		231	+template <typename T, std::size_t Buckets>
		232	+bool Histogram<T, Buckets>::isUpdated() const
		233	+{
		234	+ return m_isUpdated;
		235	+}
		236	+
		237	+template <typename T, std::size_t Buckets>
		238	+void Histogram<T, Buckets>::reset()
		239	+{
		240	+ std::lock_guard<std::mutex> lg(m_mutex);
		241	+ apply_unused_parameters(lg);
		242	+
		243	+ m_smallestValue = T{ max(m_maxValue) };
		244	+ m_largestValue = T{ min(m_maxValue) };
		245	+ m_smallestValueSinceLastClear = T{ max(m_maxValue) };
		246	+ m_largestValueSinceLastClear = T{ min(m_maxValue) };
		247	+ m_summedValueSinceLastClear = T{};
		248	+ m_numberOfValuesSinceLastClear = 0;
		249	+
		250	+ std::fill(m_histogram.begin(), m_histogram.end(), 0);
		251	+ m_isUpdated = false;
		252	+}
		253	+
		254	+template <typename T, std::size_t Buckets>
		255	+const std::string& Histogram<T, Buckets>::id() const
		256	+{
		257	+ return m_id;
		258	+}
		259	+
		260	+template <typename T, std::size_t Buckets>
		261	+std::size_t Histogram<T, Buckets>::numBuckets() const
		262	+{
		263	+ return Buckets;
		264	+}
		265	+
		266	+template <typename T, std::size_t Buckets>
		267	+double Histogram<T, Buckets>::bucketWidth() const
		268	+{
		269	+ return m_bucketWidth;
		270	+}
		271	+
		272	+template <typename T, std::size_t Buckets>
		273	+std::string Histogram<T, Buckets>::minValueString() const
		274	+{
		275	+ return to_string(m_minValue);
		276	+}
		277	+
		278	+template <typename T, std::size_t Buckets>
		279	+std::string Histogram<T, Buckets>::maxValueString() const
		280	+{
		281	+ return to_string(m_maxValue);
		282	+}
		283	+
		284	+template <typename T, std::size_t Buckets>
		285	+const std::string& Histogram<T, Buckets>::unit() const
		286	+{
		287	+ return m_unit;
		288	+}
		289	+
		290	+template <typename T, std::size_t Buckets>
		291	+HistogramData Histogram<T, Buckets>::histogramData() const
		292	+{
		293	+ std::lock_guard<std::mutex> lg(m_mutex);
		294	+ apply_unused_parameters(lg);
		295	+
		296	+ m_isUpdated = false;
		297	+ return HistogramData(to_string(m_smallestValue), to_string(m_largestValue),
		298	+ to_string(m_smallestValueSinceLastClear), to_string(m_largestValueSinceLastClear), averageValueSinceLastClear(),
		299	+ m_numberOfValuesSinceLastClear, m_histogram);
		300	+}
		301	+
		302	+template <typename T, std::size_t Buckets>
		303	+std::size_t Histogram<T, Buckets>::numberOfValuesSinceLastClear() const
		304	+{
		305	+ return m_numberOfValuesSinceLastClear;
		306	+}
		307	+
		308	+template <typename T, std::size_t Buckets>
		309	+std::string Histogram<T, Buckets>::smallestValueSinceLastClear() const
		310	+{
		311	+ return to_string(m_smallestValueSinceLastClear);
		312	+}
		313	+
		314	+template <typename T, std::size_t Buckets>
		315	+std::string Histogram<T, Buckets>::largestValueSinceLastClear() const
		316	+{
		317	+ return to_string(m_largestValueSinceLastClear);
		318	+}
		319	+
		320	+template <typename T, std::size_t Buckets>
		321	+std::string Histogram<T, Buckets>::averageValueSinceLastClear() const
		322	+{
		323	+ if (0 == m_numberOfValuesSinceLastClear) {
		324	+ return "undefined";
		325	+ }
		326	+ return to_string(to_double(m_summedValueSinceLastClear) / m_numberOfValuesSinceLastClear);
		327	+}
		328	+
		329	+template <typename T, std::size_t Buckets>
		330	+void Histogram<T, Buckets>::clearRunningValues()
		331	+{
		332	+ std::lock_guard<std::mutex> lg(m_mutex);
		333	+ apply_unused_parameters(lg);
		334	+
		335	+ m_smallestValueSinceLastClear = T{ max(m_maxValue) };
		336	+ m_largestValueSinceLastClear = T{ min(m_maxValue) };
		337	+ m_summedValueSinceLastClear = T{};
		338	+ m_numberOfValuesSinceLastClear = 0;
		339	+}
		340	+
		341	+template <typename T, std::size_t Buckets>
		342	+std::string Histogram<T, Buckets>::toString() const
		343	+{
		344	+ return visualizeHistogram(*this);
		345	+}
		346	+
		347	+} // End namespace measurement
		348	+} // End namespace mqtt
		349	+} // End namespace components
		350	+} // End namespace osdev
		351	+
		352	+#endif // OSDEV_COMPONENTS_MQTT_MEASUREMENT_HISTOGRAM_H

src/histogramprovider.h 0 → 100644

View file @51becbd

		1	+++ a/src/histogramprovider.h
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#ifndef OSDEV_COMPONENTS_MQTT_MEASUREMENT_HISTOGRAMPROVIDER_H
		20	+#define OSDEV_COMPONENTS_MQTT_MEASUREMENT_HISTOGRAMPROVIDER_H
		21	+
		22	+// std
		23	+#include <iostream>
		24	+#include <memory>
		25	+#include <string>
		26	+#include <unordered_map>
		27	+
		28	+#include "compat-c++14.h"
		29	+
		30	+// mlogic::common
		31	+#include "sharedreaderlock.h"
		32	+
		33	+#include "histogram.h"
		34	+
		35	+namespace osdev {
		36	+namespace components {
		37	+namespace mqtt {
		38	+namespace measurement {
		39	+
		40	+/**
		41	+ * @brief This class provides the user with Entry class for putting measurements in a histogram.
		42	+ * @tparam TContext A tag type that is used to give the HistogramProvider a user defined context.
		43	+ * @tparam TValue Defines the value type that the histograms of this provider use.
		44	+ * @tparam Buckets The number of buckets to use on creation of a Histogram. The default number of buckets is 10.
		45	+ *
		46	+ * The TValue type must define the following publically visible members.
		47	+ *
		48	+ * value_type - The underlying value type used in the histogram
		49	+ * const value_type minValue - The minimum value of the histogram
		50	+ * const value_type maxValue - The maximum value of the histogram
		51	+ * const char* unit - The value unit.
		52	+ */
		53	+template <typename TContext, typename TValue, std::size_t Buckets = 10>
		54	+class HistogramProvider
		55	+{
		56	+public:
		57	+ using HistogramType = Histogram<typename TValue::value_type, Buckets>;
		58	+
		59	+ /**
		60	+ * @brief Get the HistogramProvider instance.
		61	+ */
		62	+ static HistogramProvider& instance();
		63	+
		64	+ /**
		65	+ * @brief Add a value to the histogram identified by id.
		66	+ * @param id Identifies the histogram to add the value to.
		67	+ * @param value The value to add.
		68	+ */
		69	+ void addValue(const std::string& id, typename TValue::value_type value);
		70	+
		71	+ /**
		72	+ * @brief Log the histogram identified by id via the ILogger framework.
		73	+ * @param id The histogram to log. If no histogram is found no work is done.
		74	+ */
		75	+ void log(const std::string& id);
		76	+
		77	+ /**
		78	+ * @brief Log the histograms via the ILogger framework.
		79	+ * @param onlyChanged When set to true only log histograms that have changed. Default is false.
		80	+ */
		81	+ void logAll(bool onlyChanged = false);
		82	+
		83	+ /**
		84	+ * @brief Reset all the histograms.
		85	+ * @param logBeforeReset Flag that indicates whether the histogram needs to be logged before reset. Default is true.
		86	+ * @note Only changed histograms are logged.
		87	+ */
		88	+ void resetAll(bool logBeforeReset = true);
		89	+
		90	+ /**
		91	+ * @return The logOnDestroy flag value.
		92	+ */
		93	+ bool logOnDestroy() const { return m_logOnDestroy; }
		94	+
		95	+ /**
		96	+ * @brief Set the logOnDestroy flag.
		97	+ * @param logOnDest Log on destruction when true, do not log when set to false.
		98	+ */
		99	+ void setLogOnDestroy(bool logOnDest) { m_logOnDestroy = logOnDest; }
		100	+
		101	+private:
		102	+ HistogramProvider();
		103	+
		104	+ /**
		105	+ * @brief On destruction the provider will log all its histogram information to stdout.
		106	+ * Since the destruction will happen as one of the last things in the process, stdout is
		107	+ * used for logging.
		108	+ */
		109	+ ~HistogramProvider();
		110	+
		111	+ void log(const HistogramType& hist, bool onlyChanged);
		112	+
		113	+ SharedReaderLock m_sharedLock;
		114	+ std::unordered_map<std::string, std::unique_ptr<HistogramType>> m_histograms;
		115	+ bool m_logOnDestroy; ///< Default is true.
		116	+};
		117	+
		118	+// static
		119	+template <typename TContext, typename TValue, std::size_t Buckets>
		120	+HistogramProvider<TContext, TValue, Buckets>& HistogramProvider<TContext, TValue, Buckets>::instance()
		121	+{
		122	+ static HistogramProvider<TContext, TValue, Buckets> s_provider;
		123	+ return s_provider;
		124	+}
		125	+
		126	+template <typename TContext, typename TValue, std::size_t Buckets>
		127	+void HistogramProvider<TContext, TValue, Buckets>::addValue(const std::string& id, typename TValue::value_type value)
		128	+{
		129	+ OSDEV_COMPONENTS_SHAREDLOCK_SCOPE(m_sharedLock);
		130	+ auto it = m_histograms.find(id);
		131	+ if (m_histograms.end() == it) {
		132	+ OSDEV_COMPONENTS_EXCLUSIVELOCK_SCOPE(m_sharedLock);
		133	+ constexpr TValue val;
		134	+ it = (m_histograms.emplace(std::make_pair(id, std::make_unique<HistogramType>(id, val.minValue, val.maxValue, val.unit)))).first;
		135	+ }
		136	+ it->second->setValue(value);
		137	+}
		138	+
		139	+template <typename TContext, typename TValue, std::size_t Buckets>
		140	+void HistogramProvider<TContext, TValue, Buckets>::log(const std::string& id)
		141	+{
		142	+ OSDEV_COMPONENTS_SHAREDLOCK_SCOPE(m_sharedLock);
		143	+ auto it = m_histograms.find(id);
		144	+ if (m_histograms.end() != it) {
		145	+ log(*(it->second), false);
		146	+ }
		147	+}
		148	+
		149	+template <typename TContext, typename TValue, std::size_t Buckets>
		150	+void HistogramProvider<TContext, TValue, Buckets>::logAll(bool onlyChanged)
		151	+{
		152	+ OSDEV_COMPONENTS_SHAREDLOCK_SCOPE(m_sharedLock);
		153	+ for (const auto& h : m_histograms) {
		154	+ log(*h.second, onlyChanged);
		155	+ }
		156	+}
		157	+
		158	+template <typename TContext, typename TValue, std::size_t Buckets>
		159	+void HistogramProvider<TContext, TValue, Buckets>::resetAll(bool logBeforeReset)
		160	+{
		161	+ OSDEV_COMPONENTS_SHAREDLOCK_SCOPE(m_sharedLock);
		162	+ for (const auto& h : m_histograms) {
		163	+ if (logBeforeReset) {
		164	+ log(*h.second, true); // only log the histograms that have changed
		165	+ }
		166	+ h.second->reset();
		167	+ }
		168	+}
		169	+
		170	+template <typename TContext, typename TValue, std::size_t Buckets>
		171	+HistogramProvider<TContext, TValue, Buckets>::HistogramProvider()
		172	+ : m_sharedLock()
		173	+ , m_histograms()
		174	+ , m_logOnDestroy(true)
		175	+{
		176	+}
		177	+
		178	+template <typename TContext, typename TValue, std::size_t Buckets>
		179	+HistogramProvider<TContext, TValue, Buckets>::~HistogramProvider()
		180	+{
		181	+ if (m_logOnDestroy) {
		182	+ for (const auto& h : m_histograms) {
		183	+ std::cout << *h.second << std::endl;
		184	+ }
		185	+ }
		186	+}
		187	+
		188	+template <typename TContext, typename TValue, std::size_t Buckets>
		189	+void HistogramProvider<TContext, TValue, Buckets>::log(const HistogramType& hist, bool onlyChanged)
		190	+{
		191	+ if ((onlyChanged && hist.isUpdated()) \|\| !onlyChanged) {
		192	+ MLOGIC_COMMON_INFO("HistogramProvider", "%1", hist);
		193	+ }
		194	+}
		195	+
		196	+} // End namespace measurement
		197	+} // End namespace mqtt
		198	+} // End namespace components
		199	+} // End namespace osdev
		200	+
		201	+#endif // OSDEV_COMPONENTS_MQTT_MEASUREMENT_HISTOGRAMPROVIDER_H

src/ihistogram.cpp 0 → 100644

View file @51becbd

		1	+++ a/src/ihistogram.cpp
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#include "ihistogram.h"
		20	+
		21	+// std
		22	+#include <algorithm>
		23	+#include <iomanip>
		24	+#include <numeric>
		25	+#include <sstream>
		26	+
		27	+namespace osdev {
		28	+namespace components {
		29	+namespace mqtt {
		30	+namespace measurement {
		31	+
		32	+IHistogram::~IHistogram() = default;
		33	+
		34	+namespace {
		35	+
		36	+std::pair<int, std::size_t> largestValueUnderThreshold(const std::vector<std::size_t>& hist, double thresholdValue)
		37	+{
		38	+ int bin = -1;
		39	+ std::size_t maxValue = 0;
		40	+ // do not use the outlier bins for this calculation.
		41	+ for (std::size_t i = 1; i < hist.size() - 1; ++i) {
		42	+ if (hist[i] > maxValue && hist[i] < thresholdValue) {
		43	+ bin = static_cast<int>(i);
		44	+ maxValue = hist[i];
		45	+ }
		46	+ }
		47	+ return { bin, maxValue };
		48	+}
		49	+
		50	+} // namespace
		51	+
		52	+std::string visualizeHistogram(const IHistogram& histogram)
		53	+{
		54	+ const std::size_t diagramHeight = 10;
		55	+ auto histData = histogram.histogramData(); // take a snapshot of the histogram data.
		56	+ const auto& hist = histData.data();
		57	+
		58	+ std::ostringstream oss;
		59	+ oss << "Histogram for " << histogram.id() << "\\n";
		60	+ auto minmax = std::minmax_element(hist.begin(), hist.end());
		61	+
		62	+ auto minCountValueString = std::to_string(*minmax.first);
		63	+ auto maxCountValueString = std::to_string(*minmax.second);
		64	+
		65	+ auto countValueFieldWidth = static_cast<std::int32_t>(std::max(minCountValueString.size(), maxCountValueString.size()));
		66	+ auto verticalSize = (minmax.second - minmax.first) / static_cast<double>(diagramHeight);
		67	+
		68	+ auto totalMeasurements = std::accumulate(hist.begin(), hist.end(), 0);
		69	+ oss << "Total nr of measurements: " << totalMeasurements << ", Nr of buckets: " << histogram.numBuckets() << ", bucket width: " << histogram.bucketWidth() << ", vertical resolution: " << verticalSize << "\\n";
		70	+ auto binValuePair = largestValueUnderThreshold(hist, verticalSize);
		71	+ if (binValuePair.first >= 0) {
		72	+ oss << "Largest value under threshold: " << binValuePair.second << " in bin " << binValuePair.first << "\\n";
		73	+ }
		74	+ if (hist.front() > 0) {
		75	+ oss << "Outliers to the left: " << hist.front() << ", smallest value: " << histData.smallestValueString() << histogram.unit() << "\\n";
		76	+ }
		77	+ if (hist.back() > 0) {
		78	+ oss << "Outliers to the right: " << hist.back() << ", largest value: " << histData.largestValueString() << histogram.unit() << "\\n";
		79	+ }
		80	+
		81	+ oss << "\\nSince last clear:\\n"
		82	+ << " number of values : " << histData.numberOfValuesSinceLastClear() << "\\n"
		83	+ << " smallest value : " << histData.smallestValueSinceLastClearString() << histogram.unit() << "\\n"
		84	+ << " largest value : " << histData.largestValueSinceLastClearString() << histogram.unit() << "\\n"
		85	+ << " average value : " << histData.averageValueSinceLastClearString() << histogram.unit() << "\\n\\n";
		86	+
		87	+ oss << std::setw(countValueFieldWidth) << maxCountValueString << " \|";
		88	+ for (std::size_t line = 0; line < diagramHeight; ++line) {
		89	+ for (const auto& cnt : hist) {
		90	+ if ((cnt - minmax.first) > (diagramHeight - line - 1) verticalSize) {
		91	+ oss << '*';
		92	+ }
		93	+ else {
		94	+ oss << ' ';
		95	+ }
		96	+ }
		97	+ oss << "\|\\n";
		98	+ if (line + 1 < diagramHeight) {
		99	+ oss << std::setw(countValueFieldWidth + 2) << '\|';
		100	+ }
		101	+ }
		102	+ oss << std::setw(countValueFieldWidth) << minCountValueString << " \|/" << std::string(hist.size() - 2, '-') << "\\\| " << histogram.unit() << "\\n";
		103	+
		104	+ auto minValueString = histogram.minValueString();
		105	+ auto maxValueString = histogram.maxValueString();
		106	+ auto valueFieldWidth = std::max(minValueString.size(), maxValueString.size());
		107	+
		108	+ for (std::size_t line = 0; line < valueFieldWidth; ++line) {
		109	+ oss << std::setw(countValueFieldWidth + 3 + static_cast<int>(line)) << "";
		110	+ oss << (line < minValueString.size() ? minValueString[line] : ' ');
		111	+
		112	+ if (line < maxValueString.size()) {
		113	+ oss << std::string(histogram.numBuckets() - 1, ' ') << maxValueString[line];
		114	+ }
		115	+ oss << "\\n";
		116	+ }
		117	+
		118	+ // Add the non zero data to the log for later analysis
		119	+ // format: binnumber:value;binnumber:value;....
		120	+ bool first = true;
		121	+ for (std::size_t idx = 0; idx < hist.size(); ++idx) {
		122	+ if (hist[idx] > 0) {
		123	+ if (!first) {
		124	+ oss << ';';
		125	+ }
		126	+ else {
		127	+ oss << "\\n";
		128	+ first = false;
		129	+ }
		130	+ oss << idx << ':' << hist[idx];
		131	+ }
		132	+ }
		133	+
		134	+ return oss.str();
		135	+}
		136	+
		137	+std::ostream& operator<<(std::ostream& os, const IHistogram& rhs)
		138	+{
		139	+ return os << rhs.toString();
		140	+}
		141	+
		142	+} // End namespace measurement
		143	+} // End namespace mqtt
		144	+} // End namespace components
		145	+} // End namespace osdev

src/ihistogram.h 0 → 100644

View file @51becbd

		1	+++ a/src/ihistogram.h
		1	+#ifndef OSDEV_COMPONENTS_MQTT_MEASUREMENT_IHISTOGRAM_H
		2	+#define OSDEV_COMPONENTS_MQTT_MEASUREMENT_IHISTOGRAM_H
		3	+
		4	+// std
		5	+#include <ostream>
		6	+#include <string>
		7	+#include <vector>
		8	+
		9	+namespace osdev {
		10	+namespace components {
		11	+namespace mqtt {
		12	+namespace measurement {
		13	+
		14	+/**
		15	+ * @brief Class that holds the dynamic part of a histogram.
		16	+ * Used to take a snapshot of the histogram.
		17	+ */
		18	+class HistogramData
		19	+{
		20	+public:
		21	+ /**
		22	+ * @brief Construct dynamic histrogram data.
		23	+ * @param smallestValue A stringified version of the smallest recorded value since the last update.
		24	+ * @param largestValue A stringified version of the largest recorded value since the last update.
		25	+ * @param smallestValueSinceLastClear A stringified version of the smallest value as string since last clear.
		26	+ * @param largestValueSinceLastClear A stringified version of the largest value as string since last clear.
		27	+ * @param averageValueSinceLastClear A stringified version of the average value as string since last clear.
		28	+ * @param nrOfValuesSinceLastClear Number of values since last clear.
		29	+ * @param histCounts The histogram counts.
		30	+ */
		31	+ HistogramData(const std::string& smallestValue, const std::string& largestValue,
		32	+ const std::string& smallestValueSinceLastClear,
		33	+ const std::string& largestValueSinceLastClear,
		34	+ const std::string& averageValueSinceLastClear,
		35	+ std::size_t nrOfValuesSinceLastClear,
		36	+ const std::vector<std::size_t>& histCounts)
		37	+ : m_smallestValueString(smallestValue)
		38	+ , m_largestValueString(largestValue)
		39	+ , m_smallestValueSinceLastClearString(smallestValueSinceLastClear)
		40	+ , m_largestValueSinceLastClearString(largestValueSinceLastClear)
		41	+ , m_averageValueSinceLastClearString(averageValueSinceLastClear)
		42	+ , m_numberOfValuesSinceLastClear(nrOfValuesSinceLastClear)
		43	+ , m_data(histCounts)
		44	+ {
		45	+ }
		46	+
		47	+ /**
		48	+ * @return The smallest recorded value as a string.
		49	+ */
		50	+ const std::string& smallestValueString() const
		51	+ {
		52	+ return m_smallestValueString;
		53	+ }
		54	+
		55	+ /**
		56	+ * @return The largest recorded value as a string.
		57	+ */
		58	+ const std::string& largestValueString() const
		59	+ {
		60	+ return m_largestValueString;
		61	+ }
		62	+
		63	+ /**
		64	+ * @return The number of value since last clear.
		65	+ */
		66	+ std::size_t numberOfValuesSinceLastClear() const
		67	+ {
		68	+ return m_numberOfValuesSinceLastClear;
		69	+ }
		70	+
		71	+ /**
		72	+ * @return The smallest value since last clear as a string.
		73	+ */
		74	+ const std::string& smallestValueSinceLastClearString() const
		75	+ {
		76	+ return m_smallestValueSinceLastClearString;
		77	+ }
		78	+
		79	+ /**
		80	+ * @return The largest value since last clear as a string.
		81	+ */
		82	+ const std::string& largestValueSinceLastClearString() const
		83	+ {
		84	+ return m_largestValueSinceLastClearString;
		85	+ }
		86	+
		87	+ /**
		88	+ * @return The average value since last clear as a string.
		89	+ */
		90	+ const std::string& averageValueSinceLastClearString() const
		91	+ {
		92	+ return m_averageValueSinceLastClearString;
		93	+ }
		94	+
		95	+ /**
		96	+ * @return The histogram counts.
		97	+ */
		98	+ const std::vector<std::size_t>& data() const
		99	+ {
		100	+ return m_data;
		101	+ }
		102	+
		103	+private:
		104	+ std::string m_smallestValueString;
		105	+ std::string m_largestValueString;
		106	+ std::string m_smallestValueSinceLastClearString;
		107	+ std::string m_largestValueSinceLastClearString;
		108	+ std::string m_averageValueSinceLastClearString;
		109	+ std::size_t m_numberOfValuesSinceLastClear;
		110	+ std::vector<std::size_t> m_data;
		111	+};
		112	+
		113	+/**
		114	+ * @brief Interface for histogram classes
		115	+ * Can be used to store histograms in a container and visualize the histogram.
		116	+ */
		117	+class IHistogram
		118	+{
		119	+public:
		120	+ virtual ~IHistogram();
		121	+
		122	+ /**
		123	+ * @return The histogram identification (title).
		124	+ */
		125	+ virtual const std::string& id() const = 0;
		126	+
		127	+ /**
		128	+ * @return The number of buckets.
		129	+ */
		130	+ virtual std::size_t numBuckets() const = 0;
		131	+
		132	+ /**
		133	+ * @return The bucket width as a floating point value.
		134	+ */
		135	+ virtual double bucketWidth() const = 0;
		136	+
		137	+ /**
		138	+ * @return The minimum value of the histogram definition as a string.
		139	+ */
		140	+ virtual std::string minValueString() const = 0;
		141	+
		142	+ /**
		143	+ * @return The maximum value of the histogram definition as a string.
		144	+ */
		145	+ virtual std::string maxValueString() const = 0;
		146	+
		147	+ /**
		148	+ * @return The value unit as a a string.
		149	+ */
		150	+ virtual const std::string& unit() const = 0;
		151	+
		152	+ /**
		153	+ * @return The histogram data.
		154	+ * This takes a snapshot of the histogram data.
		155	+ */
		156	+ virtual HistogramData histogramData() const = 0;
		157	+
		158	+ /**
		159	+ * @return The number of value since last clear.
		160	+ */
		161	+ virtual std::size_t numberOfValuesSinceLastClear() const = 0;
		162	+
		163	+ /**
		164	+ * @return The smallest value since last clear as a string.
		165	+ */
		166	+ virtual std::string smallestValueSinceLastClear() const = 0;
		167	+
		168	+ /**
		169	+ * @return The largest value since last clear as a string.
		170	+ */
		171	+ virtual std::string largestValueSinceLastClear() const = 0;
		172	+
		173	+ /**
		174	+ * @return The average value since last clear as a string.
		175	+ */
		176	+ virtual std::string averageValueSinceLastClear() const = 0;
		177	+
		178	+ /**
		179	+ * @brief Clears the values that are kept between successive clearRunningValues calls.
		180	+ * These are:
		181	+ * smallestValueSinceLastClear
		182	+ * largestValueSinceLastClear
		183	+ * averageValueSinceLastClear
		184	+ */
		185	+ virtual void clearRunningValues() = 0;
		186	+
		187	+ /**
		188	+ * @return The ascii representation of the histogram.
		189	+ */
		190	+ virtual std::string toString() const = 0;
		191	+};
		192	+
		193	+/**
		194	+ * @brief Make an ascii visualisation of the given histogram data.
		195	+ * @param histogram The histogram to visualize.
		196	+ */
		197	+std::string visualizeHistogram(const IHistogram& histogram);
		198	+
		199	+/**
		200	+ * @brief Stream operator for IHistogram instances.
		201	+ */
		202	+std::ostream& operator<<(std::ostream& os, const IHistogram& rhs);
		203	+
		204	+} // End namespace measurement
		205	+} // End namespace mqtt
		206	+} // End namespace components
		207	+} // End namespace osdev
		208	+
		209	+#endif // OSDEV_COMPONENTS_MQTT_MEASUREMENT_IHISTOGRAM_H

src/imqttclient.h 0 → 100644

View file @51becbd

		1	+++ a/src/imqttclient.h
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#ifndef OSDEV_COMPONENTS_MQTT_IMQTTCLIENT_H
		20	+#define OSDEV_COMPONENTS_MQTT_IMQTTCLIENT_H
		21	+
		22	+// std
		23	+#include <chrono>
		24	+#include <functional>
		25	+#include <set>
		26	+#include <string>
		27	+
		28	+// boost
		29	+#include <boost/optional.hpp>
		30	+
		31	+// mlogic::client
		32	+#include "istatecallback.h"
		33	+
		34	+// mlogic::mqtt
		35	+#include "connectionstatus.h"
		36	+#include "credentials.h"
		37	+#include "mqttmessage.h"
		38	+#include "token.h"
		39	+
		40	+namespace osdev {
		41	+namespace components {
		42	+namespace mqtt {
		43	+
		44	+/**
		45	+ * @brief Interface that describes the minimal interface that a wrapper implementation needs to have in
		46	+ * order to coorporate with the MqttClient class.
		47	+ */
		48	+class IMqttClient : public virtual IStateCallback
		49	+{
		50	+public:
		51	+ virtual ~IMqttClient() {}
		52	+
		53	+ /**
		54	+ * @brief Connect to the endpoint
		55	+ * @param host The host name or ip address.
		56	+ * @param port The port to use.
		57	+ * @param credentials The credentials to use.
		58	+ */
		59	+ virtual void connect(const std::string& host, int port, const Credentials& credentials) = 0;
		60	+
		61	+ /**
		62	+ * @brief Connect to the endpoint
		63	+ * @param endpoint an uri endpoint description.
		64	+ */
		65	+ virtual void connect(const std::string& endpoint) = 0;
		66	+
		67	+ /**
		68	+ * @brief Disconnect the client from the broker
		69	+ */
		70	+ virtual void disconnect() = 0;
		71	+
		72	+ /**
		73	+ * @brief Publish a message with a given quality of service (0, 1 or 2).
		74	+ * @param message The message to publish.
		75	+ * @param qos The quality of service to use.
		76	+ * @return The token that identifies the publication (used in the deliveryCompleteCallback).
		77	+ */
		78	+ virtual Token publish(const MqttMessage& message, int qos) = 0;
		79	+
		80	+ /**
		81	+ * @brief Subscribe to a topic(filter).
		82	+ * The combination of topic and qos makes a subscription unique on a wrapper client. When a topic has overlap
		83	+ * with an existing subscription it is guaranteed that the given callback is only called once.
		84	+ * @param topic The topic to subscribe to (can have wildcards). The topic can have overlap with existing topic subscriptions.
		85	+ * @param qos The quality of service to use (0, 1 or 2).
		86	+ * @param cb The callback that is called when messages are received for this subscription.
		87	+ * @return A token that identifies the subscribe command.
		88	+ */
		89	+ virtual Token subscribe(const std::string& topic, int qos, const std::function<void(MqttMessage)>& cb) = 0;
		90	+
		91	+ /**
		92	+ * @brief Unsubscribe an existing subscription.
		93	+ * The combination of topic and qos can occur on multiple wrapper clients. All subscriptions that match are unsubscribed.
		94	+ * @param topic The topic to unsubscribe.
		95	+ * @param qos The quality of service of the subscription (0, 1 or 2).
		96	+ * @return A set of unsubscribe tokens identifying the unsubscribe commands. Usually the set will contain only one item.
		97	+ */
		98	+ virtual std::set<Token> unsubscribe(const std::string& topic, int qos) = 0;
		99	+
		100	+ /**
		101	+ * @brief Wait for all commands to complete.
		102	+ * @param waitFor The number of milliseconds to wait for completetion of all commands.
		103	+ * @return True when all commands have completed in time or false if not.
		104	+ */
		105	+ virtual bool waitForCompletion(std::chrono::milliseconds waitFor) const = 0;
		106	+
		107	+ /**
		108	+ * @brief Wait for a single command to complete.
		109	+ * @param waitFor The number of milliseconds to wait for completetion of the command.
		110	+ * @param token The token to wait for.
		111	+ * @return True when the command has completed in time or false if not.
		112	+ * @note Non existent tokens are also reported as completed.
		113	+ */
		114	+ virtual bool waitForCompletion(std::chrono::milliseconds waitFor, const Token& token) const = 0;
		115	+
		116	+ /**
		117	+ * @brief Wait for commands to complete.
		118	+ * This method enables the user to wait for a set of commands. An empty set means to wait for all commands to complete.
		119	+ * @param waitFor The number of milliseconds to wait for completetion of all commands.
		120	+ * @param tokens The tokens to wait for. An empty set means to wait for all commands to complete.
		121	+ * @return True when the commands have completed in time or false if not.
		122	+ * @note Non existent tokens are also reported as completed.
		123	+ */
		124	+ virtual bool waitForCompletion(std::chrono::milliseconds waitFor, const std::set<Token>& tokens) const = 0;
		125	+
		126	+ /**
		127	+ * @brief Get the result of a command.
		128	+ * @param token The token identifying the result.
		129	+ * @return The command result when available.
		130	+ */
		131	+ virtual boost::optional<bool> commandResult(const Token& token) const = 0;
		132	+
		133	+ /**
		134	+ * @return The endpoint uri.
		135	+ */
		136	+ virtual std::string endpoint() const = 0;
		137	+};
		138	+
		139	+} // End namespace mqtt
		140	+} // End namespace components
		141	+} // End namespace osdev
		142	+
		143	+#endif // OSDEV_COMPONENTS_MQTT_IMQTTCLIENT_H

src/imqttclientimpl.cpp 0 → 100644

View file @51becbd

		1	+++ a/src/imqttclientimpl.cpp
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#include "imqttclientimpl.h"
		20	+
		21	+using namespace osdev::components::mqtt;
		22	+
		23	+IMqttClientImpl::~IMqttClientImpl() = default;

src/imqttclientimpl.h 0 → 100644

View file @51becbd

		1	+++ a/src/imqttclientimpl.h
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#ifndef OSDEV_COMPONENTS_MQTT_IMQTTCLIENTIMPL_H
		20	+#define OSDEV_COMPONENTS_MQTT_IMQTTCLIENTIMPL_H
		21	+
		22	+// std
		23	+#include <chrono>
		24	+#include <functional>
		25	+#include <ostream>
		26	+#include <set>
		27	+#include <string>
		28	+#include <vector>
		29	+
		30	+// boost
		31	+#include <boost/optional.hpp>
		32	+
		33	+// mlogic::mqtt
		34	+#include "connectionstatus.h"
		35	+#include "mqttmessage.h"
		36	+
		37	+namespace osdev {
		38	+namespace components {
		39	+namespace mqtt {
		40	+
		41	+/**
		42	+ * @brief Interface that describes the minimal interface that a wrapper implementation needs to have in
		43	+ * order to coorporate with the MqttClient class.
		44	+ */
		45	+class IMqttClientImpl
		46	+{
		47	+public:
		48	+ virtual ~IMqttClientImpl();
		49	+
		50	+ /**
		51	+ * @return id of this client.
		52	+ */
		53	+ virtual std::string clientId() const = 0;
		54	+
		55	+ /**
		56	+ * @return The connection status of the wrapper.
		57	+ */
		58	+ virtual ConnectionStatus connectionStatus() const = 0;
		59	+
		60	+ /**
		61	+ * @brief Connect the wrapper to the endpoint.
		62	+ * @param wait A flag that indicates if the method should wait for a succesful connection.
		63	+ * @return the operation token.
		64	+ */
		65	+ virtual std::int32_t connect(bool wait) = 0;
		66	+
		67	+ /**
		68	+ * @brief Disconnect the wrapper.
		69	+ * @param wait A flag that indicates if the method should wait for a succesful disconnect. When true the method will wait for the timeoutMs value plus some additional time.
		70	+ * @param timeoutMs A timeout in milliseconds. The timeout is used to give in flight messages a chance to get delivered. After the timeout the disconnect command is sent.
		71	+ * @return the operation token.
		72	+ */
		73	+ virtual std::int32_t disconnect(bool wait, int timeoutMs) = 0;
		74	+
		75	+ /**
		76	+ * @brief Publish a message to an mqtt endpoint with a given quality of service.
		77	+ * When the connection is in state reconnect the publish is saved so that it can be published later.
		78	+ * @param message The message to send.
		79	+ * @param qos The quality of service to use (0, 1 or 2).
		80	+ * @return The message token. This token identifies the publication.
		81	+ */
		82	+ virtual std::int32_t publish(const MqttMessage& message, int qos) = 0;
		83	+
		84	+ /**
		85	+ * @brief Publish messages when client is reconnected.
		86	+ */
		87	+ virtual void publishPending() = 0;
		88	+
		89	+ /**
		90	+ * @brief Subscribe to a topic(filter).
		91	+ * The combination of topic and qos makes a subscription unique. Subscriptions with the same topic filter
		92	+ * but different qos are considered different, but they will overlap and cannot exist in the same wrapper.
		93	+ * @param topic The topic to subscribe to (can have wildcards). The topic cannot have overlap with existing topic subscriptions.
		94	+ * @param qos The quality of service to use (0, 1 or 2).
		95	+ * @param cb The callback that is called when messages are received for this subscription.
		96	+ * @return the operation token.
		97	+ */
		98	+ virtual std::int32_t subscribe(const std::string& topic, int qos, const std::function<void(MqttMessage msg)>& cb) = 0;
		99	+
		100	+ /**
		101	+ * @brief Resubscribe existing topicfilters.
		102	+ * This method should be called only after a reconnect when subscriptions need to be reinstated.
		103	+ */
		104	+ virtual void resubscribe() = 0;
		105	+
		106	+ /**
		107	+ * @brief Unsubscribe an existing subscription.
		108	+ * The combination of topic and qos make a subscription unique.
		109	+ * @param topic The topic to unsubscribe.
		110	+ * @param qos The quality of service of the subscription (0, 1 or 2).
		111	+ * @return the operation token.
		112	+ */
		113	+ virtual std::int32_t unsubscribe(const std::string& topic, int qos) = 0;
		114	+
		115	+ /**
		116	+ * @brief Unsubscribe all subscriptions.
		117	+ */
		118	+ virtual void unsubscribeAll() = 0;
		119	+
		120	+ /**
		121	+ * @brief Wait for commands to complete.
		122	+ * This method enables the user to wait for a set of tokens. An empty set means wait for all operations to complete.
		123	+ * @param waitFor The number of milliseconds to wait for completetion of all commands.
		124	+ * @param tokens The set of tokens to wait for.
		125	+ * @return The number of milliseconds left.
		126	+ */
		127	+ virtual std::chrono::milliseconds waitForCompletion(std::chrono::milliseconds waitFor, const std::set<std::int32_t>& tokens) const = 0;
		128	+
		129	+ /**
		130	+ * @brief Check if a topic overlaps with existing topic subscriptions.
		131	+ * @param topic The topic to test.
		132	+ * @return true when overlap is detected, false otherwise.
		133	+ */
		134	+ virtual bool isOverlapping(const std::string& topic) const = 0;
		135	+
		136	+ /**
		137	+ * @brief Check if a topic overlaps with existing topic subscriptions.
		138	+ * @param topic The topic to test.
		139	+ * @param[out] existingTopic Contains the topic on which overlap is detected.
		140	+ * @return true when overlap is detected. The existingTopic contains the topic on which overlap is detected, false otherwise.
		141	+ */
		142	+ virtual bool isOverlapping(const std::string& topic, std::string& existingTopic) const = 0;
		143	+
		144	+ /**
		145	+ * @return A vector with the pending operation tokens.
		146	+ */
		147	+ virtual std::vector<std::int32_t> pendingOperations() const = 0;
		148	+
		149	+ /**
		150	+ * @return true when client wrapper has pending subscriptions, false otherwise.
		151	+ */
		152	+ virtual bool hasPendingSubscriptions() const = 0;
		153	+
		154	+ /**
		155	+ * @return The operation result.
		156	+ * @retval true operation has succeeded.
		157	+ * @retval false operation has failed.
		158	+ */
		159	+ virtual boost::optional<bool> operationResult(std::int32_t token) const = 0;
		160	+};
		161	+
		162	+} // End namespace mqtt
		163	+} // End namespace components
		164	+} // End namespace osdev
		165	+
		166	+#endif // OSDEV_COMPONENTS_MQTT_IMQTTCLIENTIMPL_H

src/istatecallback.cpp 0 → 100644

View file @51becbd

		1	+++ a/src/istatecallback.cpp
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#include "istatecallback.h"
		20	+
		21	+#include <sstream>
		22	+
		23	+namespace osdev {
		24	+namespace components {
		25	+namespace mqtt {
		26	+
		27	+std::ostream& operator<<(std::ostream& os, StateEnum rhs)
		28	+{
		29	+ switch (rhs) {
		30	+ case StateEnum::Unknown:
		31	+ os << "Unknown";
		32	+ break;
		33	+ case StateEnum::CommunicationFailure:
		34	+ os << "CommunicationFailure";
		35	+ break;
		36	+ case StateEnum::GeneralFailure:
		37	+ os << "GeneralFailure";
		38	+ break;
		39	+ case StateEnum::Good:
		40	+ os << "Good";
		41	+ break;
		42	+ case StateEnum::Shutdown:
		43	+ os << "Shutdown";
		44	+ break;
		45	+ case StateEnum::ConnectionFailure:
		46	+ os << "ConnectionFailure";
		47	+ break;
		48	+ case StateEnum::Unregister:
		49	+ os << "Unregister";
		50	+ break;
		51	+ }
		52	+ return os;
		53	+}
		54	+
		55	+std::string createIdentifier(const std::string& idStatic, const ClientIdentifier& clientId, const IStateCallback* idDynamic)
		56	+{
		57	+ std::ostringstream oss;
		58	+ oss << idStatic;
		59	+ if (!clientId.m_id.empty()) {
		60	+ oss << "::" << clientId.m_id;
		61	+ }
		62	+ oss << " " << idDynamic;
		63	+ return oss.str();
		64	+}
		65	+
		66	+IStateCallback::~IStateCallback()
		67	+{
		68	+}
		69	+
		70	+} // End namespace mqtt
		71	+} // End namespace components
		72	+} // End namespace osdev

src/istatecallback.h 0 → 100644

View file @51becbd

		1	+++ a/src/istatecallback.h
		1	+#ifndef OSDEV_COMPONENTS_MQTT_ISTATECALLBACK_H
		2	+#define OSDEV_COMPONENTS_MQTT_ISTATECALLBACK_H
		3	+
		4	+// std
		5	+#include <ostream>
		6	+
		7	+// boost
		8	+#include <boost/signals2.hpp>
		9	+
		10	+namespace osdev {
		11	+namespace components {
		12	+namespace mqtt {
		13	+
		14	+/*!
		15	+ * \brief Struct introduces a typed client identifier.
		16	+ */
		17	+struct ClientIdentifier
		18	+{
		19	+ /*!
		20	+ * \brief Construct a ClientIdentifier
		21	+ * \param id The client id. Default is empty.
		22	+ */
		23	+ explicit ClientIdentifier(const std::string& id = "")
		24	+ : m_id(id)
		25	+ {
		26	+ }
		27	+
		28	+ const std::string m_id; ///< Client identifier
		29	+};
		30	+
		31	+/*!
		32	+ * \brief Enumeration of state codes.
		33	+ * The states Unknown, CommunicationFailure, GeneralFailure, Good
		34	+ * and Shutdown are used to communicate state about the server
		35	+ * that is connected to. The states ConnectionFailure and Unregister
		36	+ * communicate state about the client.
		37	+ */
		38	+enum class StateEnum
		39	+{
		40	+ Unknown, ///< State of underlying data source is unknown.
		41	+ CommunicationFailure, ///< No communication with underlying data source.
		42	+ GeneralFailure, ///< Some failure in the underlying data source.
		43	+ Good, ///< Underlying data source is available.
		44	+ Shutdown, ///< Underlying data source is shutting down.
		45	+ ConnectionFailure, ///< Client connection has failed.
		46	+ Unregister ///< Client is being unregistered.
		47	+};
		48	+
		49	+/*!
		50	+ * \brief Stream a StateEnum value
		51	+ */
		52	+std::ostream& operator<<(std::ostream& os, StateEnum rhs);
		53	+
		54	+/*!
		55	+ * \brief Type for identifying state change callbacks.
		56	+ */
		57	+using StateChangeCallbackHandle = std::uint32_t;
		58	+
		59	+class IStateCallback;
		60	+
		61	+/*!
		62	+ * \brief Create an id for an IStateCallback object.
		63	+ * \param idStatic - Static part of the id (name of the class).
		64	+ * \param clientId - Client identifier. Can contain information on how
		65	+ * the client is used for instance. If the id is empty
		66	+ * it is not used.
		67	+ * \param idDynamic - Dynamic part (object address).
		68	+ * \return identifier as string
		69	+ */
		70	+std::string createIdentifier(const std::string& idStatic, const ClientIdentifier& clientId, const IStateCallback* idDynamic);
		71	+
		72	+/*!
		73	+ * \brief State callback interface.
		74	+ * When a client implements this interface it can be registered on a
		75	+ * server in order to handle state changes from the underlying data source.
		76	+ * \note When the client is destroyed it is expected that it unregisters itself by calling
		77	+ * clearAllStateChangeCallbacks().
		78	+ */
		79	+class IStateCallback
		80	+{
		81	+public:
		82	+ using SigStateChange = boost::signals2::signal<void(const IStateCallback*, StateEnum)>;
		83	+ using SlotStateChange = SigStateChange::slot_type;
		84	+
		85	+ virtual ~IStateCallback();
		86	+
		87	+ /*!
		88	+ * \brief Get a string that identifies this interface.
		89	+ */
		90	+ virtual std::string clientId() const = 0;
		91	+
		92	+ /*!
		93	+ * \brief Register a callback function that is called when the status changes.
		94	+ * \param cb - The callback function to register.
		95	+ * \return handle to the registered callback.
		96	+ * \note Make sure that the callback function lives longer than the IStateCallback object.
		97	+ * Otherwise unregister callback function before it is destroyed.
		98	+ */
		99	+ virtual StateChangeCallbackHandle registerStateChangeCallback(const SlotStateChange& cb) = 0;
		100	+
		101	+ /*!
		102	+ * \brief Unregister a previously registered callback function.
		103	+ * If the callback function was not registered nothing happens.
		104	+ * \param handle - Identifies the callback function to to unregister.
		105	+ */
		106	+ virtual void unregisterStateChangeCallback(StateChangeCallbackHandle handle) = 0;
		107	+
		108	+ /*!
		109	+ * \brief Remove all the registered callback functions.
		110	+ */
		111	+ virtual void clearAllStateChangeCallbacks() = 0;
		112	+
		113	+ /*!
		114	+ * \brief retuns the latest state received.
		115	+ */
		116	+ virtual StateEnum state() const = 0;
		117	+};
		118	+
		119	+} // End namespace mqtt
		120	+} // End namespace components
		121	+} // End namespace osdev
		122	+
		123	+#endif // OSDEV_COMPONENTS_MQTT_ISTATECALLBACK_H

src/lockguard.h 0 → 100644

View file @51becbd

		1	+++ a/src/lockguard.h
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#ifndef OSDEV_COMPONENTS_MQTT_LOCKGUARD_H
		20	+#define OSDEV_COMPONENTS_MQTT_LOCKGUARD_H
		21	+
		22	+// std
		23	+#include <mutex>
		24	+
		25	+// osdev::components::mqtt::measurement
		26	+#include "measure.h"
		27	+#include "utils.h"
		28	+
		29	+/**
		30	+ * @brief Enable the lock measurements when macro MEASURE_LOCKS is defined.
		31	+ * If the macro is not defined the NOP versions of the measure macros are used.
		32	+ */
		33	+#ifdef MEASURE_LOCKS
		34	+#define OSDEV_COMPONENTS_MEASURELOCK OSDEV_COMPONENTS_MEASUREMENT_MEASURE
		35	+#define OSDEV_COMPONENTS_MEASURELOCK_SPECIFIC OSDEV_COMPONENTS_MEASUREMENT_MEASURE_SPECIFIC
		36	+#else
		37	+#define OSDEV_COMPONENTS_MEASURELOCK OSDEV_COMPONENTS_MEASUREMENT_MEASURE_NOP
		38	+#define OSDEV_COMPONENTS_MEASURELOCK_SPECIFIC OSDEV_COMPONENTS_MEASUREMENT_MEASURE_SPECIFIC_NOP
		39	+#endif
		40	+
		41	+/**
		42	+ * @brief Create a lockguard for a given mutex in a specific context.
		43	+ * @param mutexVariableName The name of the mutex.
		44	+ * @param mutexObtainer The mutex to lock. This can also be a function that returns a mutex.
		45	+ * If MEASURE_LOCKS is enabled this method uses a static histogram to record the timing of obtaining the lock for all instances.
		46	+ */
		47	+#define OSDEV_COMPONENTS_LOCKGUARD_OBTAINER(mutexVariableName, mutexObtainer) \
		48	+ OSDEV_COMPONENTS_MEASURELOCK(LOCKGUARD, std::lock_guard<std::mutex> Lock__Guard__##mutexVariableName##__(mutexObtainer), osdev::components::mqtt::measure_locking_tag, osdev::components::mqtt::MeasureLockingValue, 100) \
		49	+ osdev::components::mqtt::apply_unused_parameters(Lock__Guard__##mutexVariableName##__);
		50	+
		51	+/**
		52	+ * @brief Create a lockguard for a given mutex in a specific context.
		53	+ * @param mutexVariableName The name of the mutex.
		54	+ * @param mutexObtainer The mutex to lock. This can also be a function that returns a mutex.
		55	+ * @param id The id that identifies this specific lock guard. Used for measuring timings.
		56	+ * If MEASURE_LOCKS is enabled this method uses a specific histogram instance to record the timing of obtaining this lock.
		57	+ */
		58	+#define OSDEV_COMPONENTS_LOCKGUARD_SPECIFIC_OBTAINER(mutexVariableName, mutexObtainer, id) \
		59	+ OSDEV_COMPONENTS_MEASURELOCK_SPECIFIC(id, LOCKGUARD, std::lock_guard<std::mutex> Lock__Guard__##mutexVariableName##__(mutexObtainer), osdev::components::mqtt::measure_locking_tag, osdev::components::mqtt::MeasureLockingValue, 100) \
		60	+ osdev::components::mqtt::apply_unused_parameters(Lock__Guard__##mutexVariableName##__);
		61	+
		62	+/**
		63	+ * @brief Create a lockguard for a given recursive mutex in a specific context.
		64	+ * @param mutexVariableName The name of the mutex.
		65	+ * @param mutexObtainer The mutex to lock. This can also be a function that returns a mutex.
		66	+ * If MEASURE_LOCKS is enabled this method uses a static histogram to record the timing of obtaining the lock for all instances.
		67	+ */
		68	+#define OSDEV_COMPONENTS_RECURSIVELOCKGUARD_OBTAINER(mutexVariableName, mutexObtainer) \
		69	+ OSDEV_COMPONENTS_MEASURELOCK(RECURSIVELOCKGUARD, std::lock_guard<std::recursive_mutex> Lock__Guard__##mutexVariableName##__(mutexObtainer), osdev::components::mqtt::measure_locking_tag, osdev::components::mqtt::MeasureLockingValue, 100) \
		70	+ osdev::components::mqtt::apply_unused_parameters(Lock__Guard__##mutexVariableName##__);
		71	+
		72	+/**
		73	+ * @brief Create a lockguard for a given recursive mutex in a specific context.
		74	+ * @param mutexVariableName The name of the mutex.
		75	+ * @param mutexObtainer The mutex to lock. This can also be a function that returns a mutex.
		76	+ * @param id The id that identifies this specific lock guard. Used for measuring timings.
		77	+ * If MEASURE_LOCKS is enabled this method uses a specific histogram instance to record the timing of obtaining this lock.
		78	+ */
		79	+#define OSDEV_COMPONENTS_RECURSIVELOCKGUARD_SPECIFIC_OBTAINER(mutexVariableName, mutexObtainer, id) \
		80	+ OSDEV_COMPONENTS_MEASURELOCK_SPECIFIC(id, RECURSIVELOCKGUARD, std::lock_guard<std::recursive_mutex> Lock__Guard__##mutexVariableName##__(mutexVariableName), osdev::components::mqtt::measure_locking_tag, osdev::components::mqtt::MeasureLockingValue, 100) \
		81	+ osdev::components::mqtt::apply_unused_parameters(Lock__Guard__##mutexVariableName##__);
		82	+
		83	+/**
		84	+ * @brief Create a lockguard for a given bare mutex in a specific context.
		85	+ * @param mutexVariableName The name of the mutex.
		86	+ * If MEASURE_LOCKS is enabled this method uses a static histogram to record the timing of obtaining the lock for all instances.
		87	+ */
		88	+#define OSDEV_COMPONENTS_LOCKGUARD(mutexVariableName) \
		89	+ OSDEV_COMPONENTS_LOCKGUARD_OBTAINER(mutexVariableName, mutexVariableName)
		90	+
		91	+/**
		92	+ * @brief Create a lockguard for a given bare mutex in a specific context.
		93	+ * @param mutexVariableName The name of the mutex.
		94	+ * @param id The id that identifies this specific lock guard. Used for measuring timings.
		95	+ * If MEASURE_LOCKS is enabled this method uses a specific histogram instance to record the timing of obtaining this lock.
		96	+ */
		97	+#define OSDEV_COMPONENTS_LOCKGUARD_SPECIFIC(mutexVariableName, id) \
		98	+ OSDEV_COMPONENTS_LOCKGUARD_SPECIFIC_OBTAINER(mutexVariableName, mutexVariableName, id)
		99	+
		100	+/**
		101	+ * @brief Create a lockguard for a given bare recursive mutex in a specific context.
		102	+ * @param mutexVariableName The name of the mutex.
		103	+ * If MEASURE_LOCKS is enabled this method uses a static histogram to record the timing of obtaining the lock for all instances.
		104	+ */
		105	+#define OSDEV_COMPONENTS_RECURSIVELOCKGUARD(mutexVariableName) \
		106	+ OSDEV_COMPONENTS_RECURSIVELOCKGUARD_OBTAINER(mutexVariableName, mutexVariableName)
		107	+
		108	+/**
		109	+ * @brief Create a lockguard for a given bare recursive mutex in a specific context.
		110	+ * @param mutexVariableName The name of the mutex.
		111	+ * @param id The id that identifies this specific lock guard. Used for measuring timings.
		112	+ * If MEASURE_LOCKS is enabled this method uses a static histogram to record the timing of obtaining the lock for all instances.
		113	+ */
		114	+#define OSDEV_COMPONENTS_RECURSIVELOCKGUARD_SPECIFIC(mutexVariableName, id) \
		115	+ OSDEV_COMPONENTS_RECURSIVELOCKGUARD_SPECIFIC_OBTAINER(mutexVariableName, mutexVariableName, id)
		116	+
		117	+/**
		118	+ * @brief Defines the lock name that is used by the OSDEV_COMPONENTS_UNIQUELOCK_* macros
		119	+ */
		120	+#define OSDEV_COMPONENTS_UNIQUELOCK(mutexVariableName) Unique__Lock__##mutexVariableName##__
		121	+
		122	+/**
		123	+ * @brief Create a uniqeue lock for a given mutex.
		124	+ * @param mutexVariableName The name of the mutex.
		125	+ * @param mutexObtainer The mutex to lock. This can also be a function that returns a mutex.
		126	+ * If MEASURE_LOCKS is enabled this method uses a static histogram to record the timing of obtaining the lock for all instances.
		127	+ */
		128	+#define OSDEV_COMPONENTS_UNIQUELOCK_CREATE_OBTAINER(mutexVariableName, mutexObtainer) \
		129	+ OSDEV_COMPONENTS_MEASURELOCK(UNIQUELOCK_CREATE, std::unique_lock<std::mutex> OSDEV_COMPONENTS_UNIQUELOCK(mutexVariableName)(mutexObtainer), osdev::components::mqtt::measure_locking_tag, osdev::components::mqtt::MeasureLockingValue, 100) \
		130	+ osdev::components::mqtt::apply_unused_parameters(OSDEV_COMPONENTS_UNIQUELOCK(mutexVariableName));
		131	+
		132	+/**
		133	+ * @brief Create a uniqeue lock for a given mutex.
		134	+ * @param mutexVariableName The name of the mutex.
		135	+ * @param mutexObtainer The mutex to lock. This can also be a function that returns mutex.
		136	+ * @param id The id that identifies this specific lock guard. Used for measuring timings.
		137	+ * If MEASURE_LOCKS is enabled this method uses a specific histogram instance to record the timing of obtaining this lock.
		138	+ */
		139	+#define OSDEV_COMPONENTS_UNIQUELOCK_CREATE_SPECIFIC_OBTAINER(mutexVariableName, mutexObtainer, id) \
		140	+ OSDEV_COMPONENTS_MEASURELOCK_SPECIFIC(id, UNIQUELOCK_CREATE, std::unique_lock<std::mutex> OSDEV_COMPONENTS_UNIQUELOCK(mutexVariableName)(mutexObtainer), osdev::components::mqtt::measure_locking_tag, osdev::components::mqtt::MeasureLockingValue, 100) \
		141	+ osdev::components::mqtt::apply_unused_parameters(OSDEV_COMPONENTS_UNIQUELOCK(mutexVariableName));
		142	+
		143	+/**
		144	+ * @brief Create a uniqeue lock for a given bare mutex.
		145	+ * @param mutexVariableName The name of the mutex.
		146	+ * If MEASURE_LOCKS is enabled this method uses a static histogram to record the timing of obtaining the lock for all instances.
		147	+ */
		148	+#define OSDEV_COMPONENTS_UNIQUELOCK_CREATE(mutexVariableName) \
		149	+ OSDEV_COMPONENTS_UNIQUELOCK_CREATE_OBTAINER(mutexVariableName, mutexVariableName)
		150	+
		151	+/**
		152	+ * @brief Create a uniqeue lock for a given bare mutex.
		153	+ * @param mutexVariableName The name of the mutex.
		154	+ * @param id The id that identifies this specific unique lock. Used for measuring timings.
		155	+ * If MEASURE_LOCKS is enabled this method uses a specific histogram instance to record the timing of obtaining this lock.
		156	+ */
		157	+#define OSDEV_COMPONENTS_UNIQUELOCK_CREATE_SPECIFIC(mutexVariableName, id) \
		158	+ OSDEV_COMPONENTS_UNIQUELOCK_CREATE_SPECIFIC_OBTAINER(mutexVariableName, mutexVariableName, id)
		159	+
		160	+/**
		161	+ * @brief Lock a given uniqeue lock.
		162	+ * @param mutexVariableName The name of the mutex from which the lockname is derived.
		163	+ * If MEASURE_LOCKS is enabled this method uses a static histogram to record the timing of obtaining the lock for all instances.
		164	+ */
		165	+#define OSDEV_COMPONENTS_UNIQUELOCK_LOCK(mutexVariableName) \
		166	+ OSDEV_COMPONENTS_MEASURELOCK(UNIQUELOCK_LOCK, OSDEV_COMPONENTS_UNIQUELOCK(mutexVariableName).lock(), osdev::components::mqtt::measure_locking_tag, osdev::components::mqtt::MeasureLockingValue, 100)
		167	+
		168	+/**
		169	+ * @brief Lock a given uniqeue lock.
		170	+ * @param mutexVariableName The name of the mutex from which the lockname is derived.
		171	+ * @param id The id that identifies this specific unique lock guard. Used for measuring timings.
		172	+ * If MEASURE_LOCKS is enabled this method uses a specific histogram instance to record the timing of obtaining this lock.
		173	+ */
		174	+#define OSDEV_COMPONENTS_UNIQUELOCK_LOCK_SPECIFIC(mutexVariableName, id) \
		175	+ OSDEV_COMPONENTS_MEASURELOCK_SPECIFIC(id, UNIQUELOCK_LOCK, OSDEV_COMPONENTS_UNIQUELOCK(mutexVariableName).lock(), osdev::components::mqtt::measure_locking_tag, osdev::components::mqtt::MeasureLockingValue, 100)
		176	+
		177	+/**
		178	+ * @brief Unlock a given uniqeue lock.
		179	+ * @param mutexVariableName The name of the mutex from which the lockname is derived.
		180	+ */
		181	+#define OSDEV_COMPONENTS_UNIQUELOCK_UNLOCK(mutexVariableName) \
		182	+ OSDEV_COMPONENTS_UNIQUELOCK(mutexVariableName).unlock();
		183	+
		184	+/**
		185	+ * @brief Unlock a given uniqeue lock.
		186	+ * @param mutexVariableName The name of the mutex from which the lockname is derived.
		187	+ * @param id The id that identifies this specific unique lock guard. Can be used for measuring timings.
		188	+ */
		189	+#define OSDEV_COMPONENTS_UNIQUELOCK_UNLOCK_SPECIFIC(mutexVariableName, id) \
		190	+ OSDEV_COMPONENTS_UNIQUELOCK(mutexVariableName).unlock();
		191	+
		192	+namespace osdev {
		193	+namespace components {
		194	+namespace mqtt {
		195	+
		196	+/**
		197	+ * @brief Context tag type.
		198	+ */
		199	+struct measure_locking_tag
		200	+{
		201	+};
		202	+
		203	+/**
		204	+ * @brief Type for measuring lock timings
		205	+ * The unit is microseconds and the values are expected between 0 and 100 microseconds.
		206	+ * This type is used to construct a timing histogram.
		207	+ */
		208	+struct MeasureLockingValue
		209	+{
		210	+ /**
		211	+ * @brief The value type of the timing value.
		212	+ */
		213	+ using value_type = std::chrono::microseconds;
		214	+
		215	+ const value_type minValue = value_type(0); ///< Constant mininum value.
		216	+ const value_type maxValue = value_type(100); ///< Constant maximum value.
		217	+
		218	+ const char* unit = "us"; ///< The value unit.
		219	+};
		220	+
		221	+} // End namespace mqtt
		222	+} // End namespace components
		223	+} // End namespace osdev
		224	+
		225	+#endif // OSDEV_COMPONENTS_MQTT_LOCKGUARD_H

src/macrodefs.h 0 → 100644

View file @51becbd

		1	+++ a/src/macrodefs.h
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#ifndef OSDEV_COMPONENTS_MQTT_MACRODEFS_H
		20	+#define OSDEV_COMPONENTS_MQTT_MACRODEFS_H
		21	+
		22	+#include <type_traits>
		23	+
		24	+#include "compiletimestring.h"
		25	+
		26	+/// @brief Helper macro to stringify a symbol
		27	+#define OSDEV_COMPONENTS_STRINGIFY(x) #x
		28	+
		29	+/// @brief Use this macro to safely stringify a symbol
		30	+/// This will also work for nested macro's
		31	+#define OSDEV_COMPONENTS_TOSTRING(x) OSDEV_COMPONENTS_STRINGIFY(x)
		32	+
		33	+/// @brief Helper macro to combine two symbols
		34	+#define OSDEV_COMPONENTS_COMBINER(x, y) x##y
		35	+
		36	+/// @brief Use this macro to safely combine two symbols
		37	+/// This will also work for nested macro's
		38	+#define OSDEV_COMPONENTS_COMBINE(x, y) OSDEV_COMPONENTS_COMBINER(x, y)
		39	+
		40	+/// @brief Macro that reduces a path to the basename
		41	+#define OSDEV_COMPONENTS_MANAGEDBASEFILENAME \
		42	+ OSDEV_COMPONENTS_CSTRING_BOUNDED(__FILE__, osdev::components::rfind(__FILE__, '/') + 1, sizeof(__FILE__) - 1)
		43	+
		44	+/// @brief Compiletime test if an instance derives from a certain base class
		45	+#define OSDEV_COMPONENTS_DERIVESFROM(derived, baseType) \
		46	+ static_assert(std::is_base_of<baseType, \
		47	+ typename std::remove_pointer<typename std::remove_reference<decltype(derived)>::type>::type>::value, \
		48	+ OSDEV_COMPONENTS_TOSTRING(derived) " must be derived from " OSDEV_COMPONENTS_TOSTRING(baseType))
		49	+
		50	+#endif //OSDEV_COMPONENTS_MQTT_MACRODEFS_H

src/measure.h 0 → 100644

View file @51becbd

		1	+++ a/src/measure.h
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#ifndef OSDEV_COMPONENTS_MQTT_MEASUREMENT_MEASURE_H
		20	+#define OSDEV_COMPONENTS_MQTT_MEASUREMENT_MEASURE_H
		21	+
		22	+#include "macrodefs.h"
		23	+#include "histogramprovider.h"
		24	+#include "timemeasurement.h"
		25	+
		26	+namespace osdev {
		27	+namespace components {
		28	+namespace mqtt {
		29	+namespace measurement {
		30	+
		31	+inline std::string createId(const std::string& operationName, const std::string& dynamicId)
		32	+{
		33	+ return operationName + (dynamicId.empty() ? std::string{} : std::string(" ") + dynamicId);
		34	+}
		35	+
		36	+} // End namespace measurement
		37	+} // End namespace mqtt
		38	+} // End namespace components
		39	+} // End namespace osdev
		40	+
		41	+#define OSDEV_COMPONENTS_MEASUREMENT_LOCATION \
		42	+ (OSDEV_COMPONENTS_MANAGEDBASEFILENAME + OSDEV_COMPONENTS_CSTRING(":" OSDEV_COMPONENTS_TOSTRING(__LINE__))).chars
		43	+
		44	+/**
		45	+ * @brief Macro helper that sets up a TimeMeasurement on an operation.
		46	+ * The operation must have observable side effects otherwise the compiler might move the operation from in between the time measurements.
		47	+ * @param operationName The name of the operation. This is part of the id under which the measurements are registered.
		48	+ * @param dynamicId The dynamic identification of this measurement. This id makes different instances of the same operation unique.
		49	+ * The dynamicId must be an expression that yields a string like object. The dynamic id is part of the id under which the
		50	+ * measurements are registered.
		51	+ * @param operation The operation to perform.
		52	+ * @param context The context tag used to identify the HistogramProvider.
		53	+ * @param valueType A datatype that can be used by HistogramProvider.
		54	+ * @param numBuckets The number of buckets to use for the histogram.
		55	+ * @param boolOnDestroy Boolean value that makes the measurement measure on destruction.
		56	+ */
		57	+#define OSDEV_COMPONENTS_MEASUREMENT_MEASURE_HELPER(operationName, dynamicId, operation, context, valueType, numBuckets, boolOnDestroy) \
		58	+ static const std::string OSDEV_COMPONENTS_COMBINE(OSDEV_COMPONENTS_COMBINE(ID__, __LINE__), __) = \
		59	+ std::string(OSDEV_COMPONENTS_CSTRING(#operationName).chars); \
		60	+ osdev::components::mqtt::measurement::TimeMeasurement OSDEV_COMPONENTS_COMBINE( \
		61	+ OSDEV_COMPONENTS_COMBINE(TM__, __LINE__), __)( \
		62	+ osdev::components::mqtt::measurement::createId(OSDEV_COMPONENTS_COMBINE(OSDEV_COMPONENTS_COMBINE(ID__, __LINE__), __), dynamicId), \
		63	+ [](const std::string& id, std::chrono::steady_clock::time_point, std::chrono::microseconds, std::chrono::microseconds sinceLast) { \
		64	+ osdev::components::mqtt::measurement::HistogramProvider<context, valueType, numBuckets>::instance().addValue(id, sinceLast); \
		65	+ }, \
		66	+ boolOnDestroy); \
		67	+ operation;
		68	+
		69	+/**
		70	+ * @brief Make a measurement before and after an operation.
		71	+ * The operation must have observable side effects otherwise the compiler might move the operation from in between the time measurements.
		72	+ * @param operationName The name under which the measurements are registered.
		73	+ * @param operation The operation to perform.
		74	+ * @param context The context tag used to identify the HistogramProvider.
		75	+ * @param valueType A datatype that can be used by HistogramProvider.
		76	+ * @param numBuckets The number of buckets to use for the histogram.
		77	+ */
		78	+#define OSDEV_COMPONENTS_MEASUREMENT_MEASURE(operationName, operation, context, valueType, numBuckets) \
		79	+ OSDEV_COMPONENTS_MEASUREMENT_MEASURE_HELPER(operationName, OSDEV_COMPONENTS_MEASUREMENT_LOCATION, operation, context, valueType, numBuckets, false) \
		80	+ OSDEV_COMPONENTS_COMBINE(OSDEV_COMPONENTS_COMBINE(TM__, __LINE__), __).measure();
		81	+
		82	+/**
		83	+ * @brief Make a measurement on a return operation.
		84	+ * The operation must have observable side effects otherwise the compiler might move the operation from in between the time measurements.
		85	+ * @param operationName The name under which the measurements are registered.
		86	+ * @param operation The operation to perform.
		87	+ * @param context The context tag used to identify the HistogramProvider.
		88	+ * @param valueType A datatype that can be used by HistogramProvider.
		89	+ * @param numBuckets The number of buckets to use for the histogram.
		90	+ */
		91	+#define OSDEV_COMPONENTS_MEASUREMENT_MEASURE_ONDESTROY(operationName, operation, context, valueType, numBuckets) \
		92	+ OSDEV_COMPONENTS_MEASUREMENT_MEASURE_HELPER(operationName, OSDEV_COMPONENTS_MEASUREMENT_LOCATION, operation, context, valueType, numBuckets, true)
		93	+
		94	+/**
		95	+ * @brief Make a measurement on a return operation.
		96	+ * The operation must have observable side effects otherwise the compiler might move the operation from in between the time measurements.
		97	+ * @param operationName The name under which the measurements are registered.
		98	+ * @param dynamicId An extra identification to discern between instances of the same operation. The dynamicId must be an expression that
		99	+ * yields a string like object.
		100	+ * @param operation The operation to perform.
		101	+ * @param context The context tag used to identify the HistogramProvider.
		102	+ * @param valueType A datatype that can be used by HistogramProvider.
		103	+ * @param numBuckets The number of buckets to use for the histogram.
		104	+ */
		105	+#define OSDEV_COMPONENTS_MEASUREMENT_MEASURE_SPECIFIC_ONDESTROY(operationName, dynamicId, operation, context, valueType, numBuckets) \
		106	+ OSDEV_COMPONENTS_MEASUREMENT_MEASURE_HELPER(operationName, dynamicId, operation, context, valueType, numBuckets, true)
		107	+
		108	+/**
		109	+ * @brief Nop version that only performs the operation.
		110	+ */
		111	+#define OSDEV_COMPONENTS_MEASUREMENT_MEASURE_ONDESTROY_NOP(operationName, operation, context, valueType, numBuckets) operation;
		112	+
		113	+/**
		114	+ * @brief Nop version that only performs the operation.
		115	+ */
		116	+#define OSDEV_COMPONENTS_MEASUREMENT_MEASURE_NOP(operationName, operation, context, valueType, numBuckets) operation;
		117	+
		118	+/**
		119	+ * @brief Nop version that only performs the operation.
		120	+ */
		121	+#define OSDEV_COMPONENTS_MEASUREMENT_MEASURE_SPECIFIC_ONDESTROY_NOP(operationName, dynamicId, operation, context, valueType, numBuckets) operation;
		122	+
		123	+/**
		124	+ * @brief Make a measurement before and after an operation for a specific instance of the operation.
		125	+ * The operation must have observable side effects otherwise the compiler might move the operation from in between the time measurements.
		126	+ * @param dynamicId An extra identification to discern between instances of the same operation.
		127	+ * @param operationName The name under which the measurements are registered.
		128	+ * @param operation The operation to perform.
		129	+ * @param context The context tag used to identify the HistogramProvider.
		130	+ * @param valueType A datatype that can be used by HistogramProvider.
		131	+ * @param numBuckets The number of buckets to use for the histogram.
		132	+ */
		133	+#define OSDEV_COMPONENTS_MEASUREMENT_MEASURE_SPECIFIC(dynamicId, operationName, operation, context, valueType, numBuckets) \
		134	+ auto OSDEV_COMPONENTS_COMBINE(OSDEV_COMPONENTS_COMBINE(IDPREFIX__, __LINE__), __) = \
		135	+ OSDEV_COMPONENTS_MANAGEDBASEFILENAME + OSDEV_COMPONENTS_CSTRING(":" OSDEV_COMPONENTS_TOSTRING(__LINE__) ", function "); \
		136	+ auto OSDEV_COMPONENTS_COMBINE(OSDEV_COMPONENTS_COMBINE(IDPOSTFIX__, __LINE__), __) = OSDEV_COMPONENTS_CSTRING(", " #operationName " "); \
		137	+ static const std::string OSDEV_COMPONENTS_COMBINE(OSDEV_COMPONENTS_COMBINE(ID__, __LINE__), __) = \
		138	+ std::string(OSDEV_COMPONENTS_COMBINE(OSDEV_COMPONENTS_COMBINE(IDPREFIX__, __LINE__), __).chars) + \
		139	+ std::string(__func__) + \
		140	+ OSDEV_COMPONENTS_COMBINE(OSDEV_COMPONENTS_COMBINE(IDPOSTFIX__, __LINE__), __).chars; \
		141	+ osdev::components::mqtt::measurement::TimeMeasurement OSDEV_COMPONENTS_COMBINE(OSDEV_COMPONENTS_COMBINE(TM__, __LINE__), __)( \
		142	+ OSDEV_COMPONENTS_COMBINE(OSDEV_COMPONENTS_COMBINE(ID__, __LINE__), __) + dynamicId, \
		143	+ [](const std::string& id, std::chrono::steady_clock::time_point, std::chrono::microseconds, std::chrono::microseconds sinceLast) { \
		144	+ osdev::components::mqtt::measurement::HistogramProvider<context, valueType, numBuckets>::instance().addValue(id, sinceLast); \
		145	+ }, \
		146	+ false); \
		147	+ operation; \
		148	+ OSDEV_COMPONENTS_COMBINE(OSDEV_COMPONENTS_COMBINE(TM__, __LINE__), __).measure();
		149	+
		150	+/**
		151	+ * @brief Nop version that only performs the operation.
		152	+ */
		153	+#define OSDEV_COMPONENTS_MEASUREMENT_MEASURE_SPECIFIC_NOP(dynamicId, operationName, operation, context, valueType, numBuckets) operation;
		154	+
		155	+#endif // OSDEV_COMPONENTS_MEASUREMENT_MEASUREMENT_H

src/metaprogrammingdefs.h 0 → 100644

View file @51becbd

		1	+++ a/src/metaprogrammingdefs.h
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#ifndef OSDEV_COMPONENTS_MQTT_METAPROGRAMMINGDEFS_H
		20	+#define OSDEV_COMPONENTS_MQTT_METAPROGRAMMINGDEFS_H
		21	+
		22	+#include <cstddef> // for std::size_t
		23	+#include <sstream>
		24	+#include <string>
		25	+
		26	+#include "utils.h"
		27	+
		28	+/**
		29	+ * @brief Create a type trait that checks for the existence of a member in a struct.
		30	+ * @param memberName The member name
		31	+ *
		32	+ * A call such as OSDEV_COMPONENTS_HASMEMBER_TRAIT(onSuccess) leads to a type trait has_onSuccess.
		33	+ */
		34	+#define OSDEV_COMPONENTS_HASMEMBER_TRAIT(memberName) \
		35	+ template <typename T, typename = void> \
		36	+ struct has_##memberName : public std::false_type \
		37	+ { \
		38	+ }; \
		39	+ \
		40	+ template <typename T> \
		41	+ struct has_##memberName<T, osdev::components::mqtt::void_t<decltype(std::declval<T>().memberName)>> : public std::true_type \
		42	+ { \
		43	+ };
		44	+
		45	+/**
		46	+ * @brief Create a type trait that checks for the existence of a member method with no parameters.
		47	+ * @param methodName The method name
		48	+ * @param postfix An extra postfix that is added to the type trait struct.
		49	+ * This makes it possible create type traits that check for
		50	+ * overloaded methods.
		51	+ *
		52	+ * A call such as OSDEV_COMPONENTS_HASMETHOD_TRAIT(capacity,1) leads to a type trait has_capacity1.
		53	+ */
		54	+#define OSDEV_COMPONENTS_HASMETHOD_TRAIT(methodName, postfix) \
		55	+ template <typename T, typename = void> \
		56	+ struct has_##methodName##postfix : public std::false_type \
		57	+ { \
		58	+ }; \
		59	+ \
		60	+ template <typename T> \
		61	+ struct has_##methodName##postfix<T, osdev::components::mqtt::void_t<decltype(std::declval<T>().methodName())>> : public std::true_type \
		62	+ { \
		63	+ };
		64	+
		65	+/**
		66	+ * @brief Create a type trait that checks for the existence of a member method with 1 or more parameters.
		67	+ * @param methodName The method name
		68	+ * @param postfix An extra postfix that is added to the type trait struct.
		69	+ * This makes it possible create type traits that check for
		70	+ * overloaded methods.
		71	+ * @param ... Variable number of arguments. These can be values, but also declval constructs such as std::declval<MyClass>().
		72	+ *
		73	+ * A call such as OSDEV_COMPONENTS_HASMETHODWP_TRAIT(capacity,,"string") leads to a type trait has_capacity that
		74	+ * checks for the existence of a method capacity that accepts a const char pointer.
		75	+ */
		76	+#define OSDEV_COMPONENTS_HASMETHODWP_TRAIT(methodName, postfix, ...) \
		77	+ template <typename T, typename = void> \
		78	+ struct has_##methodName##postfix : public std::false_type \
		79	+ { \
		80	+ }; \
		81	+ \
		82	+ template <typename T> \
		83	+ struct has_##methodName##postfix<T, osdev::components::mqtt::void_t<decltype(std::declval<T>().methodName(__VA_ARGS__))>> : public std::true_type \
		84	+ { \
		85	+ };
		86	+
		87	+namespace osdev {
		88	+namespace components {
		89	+namespace mqtt {
		90	+
		91	+/**
		92	+ * @brief Used to detect ill formed types in a SFINAE context.
		93	+ * If the parameter pack Ts contains an invalid type, struct make_void cannot be expanded.
		94	+ */
		95	+template <typename... Ts>
		96	+struct make_void
		97	+{
		98	+ using type = void;
		99	+};
		100	+
		101	+/**
		102	+ * @brief Introduced in c++17 (but will also work in c++11)
		103	+ */
		104	+template <typename... Ts>
		105	+using void_t = typename make_void<Ts...>::type;
		106	+
		107	+/// @brief Build an index list that can be used to traverse another list (f.i. a char array).
		108	+/// Recursive definition.
		109	+/// Start with an empty indices list. Build the indices list recursively.
		110	+/// upper-1, indices... becomes the indices... in the next recursive call.
		111	+template <std::size_t lower, std::size_t upper,
		112	+ template <std::size_t...> class meta_functor, std::size_t... Is>
		113	+struct apply_bounded_range
		114	+{
		115	+ typedef typename apply_bounded_range<lower, upper - 1, meta_functor, upper - 1, Is...>::result result;
		116	+};
		117	+
		118	+/// @brief Terminator of apply_bounded_range.
		119	+/// Terminates when the upper bound (which runs) is equal to the lower bound.
		120	+template <std::size_t lower, template <std::size_t...> class meta_functor, std::size_t... Is>
		121	+struct apply_bounded_range<lower, lower, meta_functor, Is...>
		122	+{
		123	+ typedef typename meta_functor<Is...>::result result;
		124	+};
		125	+
		126	+/**
		127	+ * @brief Helper method to perform static_assert on the expected count of a parameter pack.
		128	+ */
		129	+template <std::size_t expectedCount, typename... Args>
		130	+void static_assert_count()
		131	+{
		132	+ constexpr std::size_t actualCount = sizeof...(Args);
		133	+ static_assert(expectedCount == actualCount, "Unexpected parameter count.");
		134	+}
		135	+
		136	+/**
		137	+ * @brief Helper method to convert a type to std::string.
		138	+ * @param d_first The output iterator to write the converted string to.
		139	+ * @param arg The argument to convert to std::string.
		140	+ */
		141	+template <typename OutputIt, typename T>
		142	+int apply_to_string_one(OutputIt d_first, const T& arg)
		143	+{
		144	+ std::ostringstream ss;
		145	+ ss << arg;
		146	+ *d_first++ = ss.str();
		147	+ return 0;
		148	+}
		149	+
		150	+/**
		151	+ * @brief Converts all parameters to std::string.
		152	+ * @param d_first The output iterator to write the converted strings to.
		153	+ * @param args The arguments to convert to std::string.
		154	+ */
		155	+template <typename OutputIt, typename... Args>
		156	+void apply_to_string(OutputIt d_first, Args&&... args)
		157	+{
		158	+ // d_first is not used when args parameter pack is empty.
		159	+ apply_unused_parameters(d_first);
		160	+
		161	+ // We need to use the expand_type trick in order to be able to use an initializer list
		162	+ // so that we can call the method for every variadic argument
		163	+ using expand_type = int[];
		164	+ // Array must be initialized with values. Add a single value so that the array can be initialized when the parameter pack is empty.
		165	+ expand_type et{ 0, apply_to_string_one(d_first, std::forward<Args>(args))... };
		166	+ apply_unused_parameters(et);
		167	+}
		168	+
		169	+/**
		170	+ * @brief Helper that removes const, volatile and reference from a type.
		171	+ * @note Defined in std C++20.
		172	+ */
		173	+template <typename T>
		174	+struct remove_cvref
		175	+{
		176	+ using type = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
		177	+};
		178	+
		179	+} // End namespace mqtt
		180	+} // End namespace components
		181	+} // End namespace osdev
		182	+
		183	+#endif // OSDEV_COMPONENTS_MQTT_METAPROGRAMMINGDEFS_H

src/mqttclient.cpp 0 → 100644

View file @51becbd

		1	+++ a/src/mqttclient.cpp
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#include "mqttclient.h"
		20	+
		21	+// osdev::components::mqtt
		22	+#include "clientpaho.h"
		23	+#include "mqttutil.h"
		24	+#include "mqttidgenerator.h"
		25	+#include "mqtttypeconverter.h"
		26	+
		27	+// mlogic::common
		28	+#include "lockguard.h"
		29	+#include "uriparser.h"
		30	+
		31	+// std
		32	+#include <numeric>
		33	+#include <iostream>
		34	+
		35	+using namespace osdev::components::mqtt;
		36	+
		37	+namespace {
		38	+/**
		39	+ * @brief Generate a unique client id so that a new client does not steal the connection from an existing client.
		40	+ * @param clientId The base client identifier.
		41	+ * @param clientNumber The next client that is derived from the base client identifier.
		42	+ * @return A unique client identifier string.
		43	+ */
		44	+std::string generateUniqueClientId(const std::string& clientId, std::size_t clientNumber)
		45	+{
		46	+ return clientId + "_" + std::to_string(clientNumber) + "_" + MqttTypeConverter::toStdString(MqttIdGenerator::generate());
		47	+}
		48	+
		49	+} // namespace
		50	+
		51	+MqttClient::MqttClient(const std::string& _clientId, const std::function<void(const Token& token)>& deliveryCompleteCallback)
		52	+ : m_interfaceMutex()
		53	+ , m_internalMutex()
		54	+ , m_endpoint()
		55	+ , m_clientId(_clientId)
		56	+ , m_activeTokens()
		57	+ , m_activeTokensCV()
		58	+ , m_deliveryCompleteCallback(deliveryCompleteCallback)
		59	+ , m_serverState(this)
		60	+ , m_principalClient()
		61	+ , m_additionalClients()
		62	+ , m_eventQueue(_clientId)
		63	+ , m_workerThread(std::thread(&MqttClient::eventHandler, this))
		64	+{
		65	+}
		66	+
		67	+MqttClient::~MqttClient()
		68	+{
		69	+ // DebugLogToFIle ("MqttClient", "%1 - dtor", m_clientId);
		70	+ {
		71	+ // DebugLogToFIle ("MqttClient", "%1 - disconnect", m_clientId);
		72	+ this->disconnect();
		73	+ decltype(m_principalClient) principalClient{};
		74	+
		75	+ OSDEV_COMPONENTS_LOCKGUARD(m_internalMutex);
		76	+ // DebugLogToFIle ("MqttClient", "%1 - cleanup principal client", m_clientId);
		77	+ m_principalClient.swap(principalClient);
		78	+ }
		79	+ // DebugLogToFIle ("MqttClient", "%1 - dtor stop queue", m_clientId);
		80	+ m_eventQueue.stop();
		81	+ if (m_workerThread.joinable()) {
		82	+ m_workerThread.join();
		83	+ }
		84	+ // DebugLogToFIle ("MqttClient", "%1 - dtor ready", m_clientId);
		85	+}
		86	+
		87	+std::string MqttClient::clientId() const
		88	+{
		89	+ return m_clientId;
		90	+}
		91	+
		92	+StateChangeCallbackHandle MqttClient::registerStateChangeCallback(const SlotStateChange& cb)
		93	+{
		94	+ OSDEV_COMPONENTS_LOCKGUARD(m_interfaceMutex);
		95	+ OSDEV_COMPONENTS_LOCKGUARD(m_internalMutex);
		96	+ return m_serverState.registerStateChangeCallback(cb);
		97	+}
		98	+
		99	+void MqttClient::unregisterStateChangeCallback(StateChangeCallbackHandle handle)
		100	+{
		101	+ OSDEV_COMPONENTS_LOCKGUARD(m_interfaceMutex);
		102	+ OSDEV_COMPONENTS_LOCKGUARD(m_internalMutex);
		103	+ m_serverState.unregisterStateChangeCallback(handle);
		104	+}
		105	+
		106	+void MqttClient::clearAllStateChangeCallbacks()
		107	+{
		108	+ OSDEV_COMPONENTS_LOCKGUARD(m_interfaceMutex);
		109	+ OSDEV_COMPONENTS_LOCKGUARD(m_internalMutex);
		110	+ m_serverState.clearAllStateChangeCallbacks();
		111	+}
		112	+
		113	+StateEnum MqttClient::state() const
		114	+{
		115	+ OSDEV_COMPONENTS_LOCKGUARD(m_interfaceMutex);
		116	+ OSDEV_COMPONENTS_LOCKGUARD(m_internalMutex);
		117	+ return m_serverState.state();
		118	+}
		119	+
		120	+void MqttClient::connect(const std::string& host, int port, const Credentials& credentials)
		121	+{
		122	+
		123	+ osdev::components::mqtt::ParsedUri _endpoint = {
		124	+ { "scheme", "tcp" },
		125	+ { "user", credentials.username() },
		126	+ { "password", credentials.password() },
		127	+ { "host", host },
		128	+ { "port", std::to_string(port) }
		129	+ };
		130	+ this->connect(UriParser::toString(_endpoint));
		131	+}
		132	+
		133	+void MqttClient::connect(const std::string& _endpoint)
		134	+{
		135	+ // InfoLogToFIle ("MqttClient", "%1 - Request connect", m_clientId);
		136	+ OSDEV_COMPONENTS_LOCKGUARD(m_interfaceMutex);
		137	+ IMqttClientImpl* client(nullptr);
		138	+ {
		139	+ OSDEV_COMPONENTS_LOCKGUARD(m_internalMutex);
		140	+ if (m_principalClient && m_principalClient->connectionStatus() != ConnectionStatus::Disconnected) {
		141	+ if (_endpoint == m_endpoint)
		142	+ {
		143	+ // idempotent
		144	+ return;
		145	+ }
		146	+ else
		147	+ {
		148	+ // ErrorLogToFIle ("MqttClient", "%1 - Cannot connect to different endpoint. Disconnect first.", m_clientId);
		149	+ // Normally a throw (Yuck!) (MqttException, "Cannot connect while already connected");
		150	+ }
		151	+ }
		152	+ m_endpoint = _endpoint;
		153	+ if (!m_principalClient) {
		154	+ std::string derivedClientId(generateUniqueClientId(m_clientId, 1));
		155	+ m_principalClient = std::make_unique<ClientPaho>(
		156	+ m_endpoint,
		157	+ derivedClientId,
		158	+ [this](const std::string& id, ConnectionStatus cs) { this->connectionStatusChanged(id, cs); },
		159	+ [this](std::string clientId, std::int32_t token) { this->deliveryComplete(clientId, token); });
		160	+ }
		161	+ client = m_principalClient.get();
		162	+ }
		163	+ client->connect(true);
		164	+}
		165	+
		166	+void MqttClient::disconnect()
		167	+{
		168	+ // InfoLogToFIle ("MqttClient", "%1 - Request disconnect", m_clientId);
		169	+ OSDEV_COMPONENTS_LOCKGUARD(m_interfaceMutex);
		170	+
		171	+ decltype(m_additionalClients) additionalClients{};
		172	+ std::vector<IMqttClientImpl*> clients{};
		173	+ {
		174	+ OSDEV_COMPONENTS_LOCKGUARD(m_internalMutex);
		175	+ if (!m_principalClient \|\| m_principalClient->connectionStatus() == ConnectionStatus::Disconnected \|\| m_principalClient->connectionStatus() == ConnectionStatus::DisconnectInProgress) {
		176	+ return;
		177	+ }
		178	+ m_additionalClients.swap(additionalClients);
		179	+
		180	+ for (const auto& c : additionalClients) {
		181	+ clients.push_back(c.get());
		182	+ }
		183	+ clients.push_back(m_principalClient.get());
		184	+ }
		185	+
		186	+ // DebugLogToFIle ("MqttClient", "%1 - Unsubscribe and disconnect clients", m_clientId);
		187	+ for (auto& cl : clients) {
		188	+ cl->unsubscribeAll();
		189	+ }
		190	+ this->waitForCompletionInternal(clients, std::chrono::milliseconds(2000), std::set<Token>{});
		191	+
		192	+ for (auto& cl : clients) {
		193	+ cl->disconnect(false, 2000);
		194	+ }
		195	+ this->waitForCompletionInternal(clients, std::chrono::milliseconds(3000), std::set<Token>{});
		196	+}
		197	+
		198	+Token MqttClient::publish(const MqttMessage& message, int qos)
		199	+{
		200	+ if (hasWildcard(message.topic()) \|\| !isValidTopic(message.topic())) {
		201	+ return Token(m_clientId, -1);
		202	+ }
		203	+ OSDEV_COMPONENTS_LOCKGUARD(m_interfaceMutex);
		204	+ IMqttClientImpl* client(nullptr);
		205	+ {
		206	+ OSDEV_COMPONENTS_LOCKGUARD(m_internalMutex);
		207	+ if (!m_principalClient \|\| m_principalClient->connectionStatus() == ConnectionStatus::Disconnected)
		208	+ {
		209	+ if( !m_principalClient )
		210	+ {
		211	+ std::cout << "Principal client not initialized" << std::endl;
		212	+ }
		213	+
		214	+ if( m_principalClient->connectionStatus() == ConnectionStatus::Disconnected )
		215	+ {
		216	+ std::cout << "Unable to publish, not connected.." << std::endl;
		217	+ }
		218	+ // ErrorLogToFIle ("MqttClient", "%1 - Unable to publish, not connected", m_clientId);
		219	+ // Throw (MqttException, "Not connected");
		220	+ }
		221	+ client = m_principalClient.get();
		222	+ }
		223	+ return Token(client->clientId(), client->publish(message, qos));
		224	+}
		225	+
		226	+Token MqttClient::subscribe(const std::string& topic, int qos, const std::function<void(MqttMessage)>& cb)
		227	+{
		228	+ // DebugLogToFIle ("MqttClient", "%1 - Subscribe to topic %2 with qos %3", m_clientId, topic, qos);
		229	+ // OSDEV_COMPONENTS_LOCKGUARD(m_interfaceMutex);
		230	+ bool clientFound = false;
		231	+ IMqttClientImpl* client(nullptr);
		232	+ {
		233	+ // OSDEV_COMPONENTS_LOCKGUARD(m_internalMutex);
		234	+ if (!m_principalClient \|\| m_principalClient->connectionStatus() == ConnectionStatus::Disconnected)
		235	+ {
		236	+ // ErrorLogToFIle ("MqttClient", "%1 - Unable to subscribe, not connected", m_clientId);
		237	+ // throw (?)(MqttException, "Not connected");
		238	+ }
		239	+ if (!m_principalClient->isOverlapping(topic)) {
		240	+ client = m_principalClient.get();
		241	+ clientFound = true;
		242	+ }
		243	+ else {
		244	+ for (const auto& c : m_additionalClients) {
		245	+ if (!c->isOverlapping(topic)) {
		246	+ client = c.get();
		247	+ clientFound = true;
		248	+ break;
		249	+ }
		250	+ }
		251	+ }
		252	+ if (!clientFound) {
		253	+ // DebugLogToFIle ("MqttClient", "%1 - Creating new ClientPaho instance for subscription on topic %2", m_clientId, topic);
		254	+ std::string derivedClientId(generateUniqueClientId(m_clientId, m_additionalClients.size() + 2)); // principal client is nr 1.
		255	+ m_additionalClients.emplace_back(std::make_unique<ClientPaho>(
		256	+ m_endpoint,
		257	+ derivedClientId,
		258	+ [this](const std::string& id, ConnectionStatus cs) { this->connectionStatusChanged(id, cs); },
		259	+ std::function<void(const std::string&, std::int32_t)>{}));
		260	+ client = m_additionalClients.back().get();
		261	+ }
		262	+ }
		263	+ if (!clientFound) {
		264	+ client->connect(true);
		265	+ }
		266	+ return Token{ client->clientId(), client->subscribe(topic, qos, cb) };
		267	+}
		268	+
		269	+std::set<Token> MqttClient::unsubscribe(const std::string& topic, int qos)
		270	+{
		271	+ // DebugLogToFIle ("MqttClient", "%1 - Unsubscribe from topic %2 with qos %3", m_clientId, topic, qos);
		272	+ OSDEV_COMPONENTS_LOCKGUARD(m_interfaceMutex);
		273	+ std::vector<IMqttClientImpl*> clients{};
		274	+ {
		275	+ OSDEV_COMPONENTS_LOCKGUARD(m_internalMutex);
		276	+ if (!m_principalClient \|\| m_principalClient->connectionStatus() == ConnectionStatus::Disconnected) {
		277	+ // ErrorLogToFIle ("MqttClient", "%1 - Unable to unsubscribe, not connected", m_clientId);
		278	+ // Throw (MqttException, "Not connected");
		279	+ }
		280	+ clients.push_back(m_principalClient.get());
		281	+ for (const auto& c : m_additionalClients) {
		282	+ clients.push_back(c.get());
		283	+ }
		284	+ }
		285	+ std::set<Token> tokens{};
		286	+ for (auto* c : clients) {
		287	+ auto token = c->unsubscribe(topic, qos);
		288	+ if (-1 != token) {
		289	+ tokens.emplace(Token{ c->clientId(), token });
		290	+ }
		291	+ }
		292	+ return tokens;
		293	+}
		294	+
		295	+bool MqttClient::waitForCompletion(std::chrono::milliseconds waitFor) const
		296	+{
		297	+ return this->waitForCompletion(waitFor, std::set<Token>{});
		298	+}
		299	+
		300	+bool MqttClient::waitForCompletion(std::chrono::milliseconds waitFor, const Token& token) const
		301	+{
		302	+ if (-1 == token.token()) {
		303	+ return false;
		304	+ }
		305	+ return this->waitForCompletion(waitFor, std::set<Token>{ token });
		306	+}
		307	+
		308	+bool MqttClient::waitForCompletion(std::chrono::milliseconds waitFor, const std::set<Token>& tokens) const
		309	+{
		310	+ OSDEV_COMPONENTS_LOCKGUARD(m_interfaceMutex);
		311	+ std::vector<IMqttClientImpl*> clients{};
		312	+ {
		313	+ OSDEV_COMPONENTS_LOCKGUARD(m_internalMutex);
		314	+ if (m_principalClient) {
		315	+ clients.push_back(m_principalClient.get());
		316	+ }
		317	+ for (const auto& c : m_additionalClients) {
		318	+ clients.push_back(c.get());
		319	+ }
		320	+ }
		321	+ return waitForCompletionInternal(clients, waitFor, tokens);
		322	+}
		323	+
		324	+boost::optional<bool> MqttClient::commandResult(const Token& token) const
		325	+{
		326	+ OSDEV_COMPONENTS_LOCKGUARD(m_interfaceMutex);
		327	+ std::vector<IMqttClientImpl*> clients{};
		328	+ {
		329	+ OSDEV_COMPONENTS_LOCKGUARD(m_internalMutex);
		330	+ if (m_principalClient) {
		331	+ clients.push_back(m_principalClient.get());
		332	+ }
		333	+ for (const auto& c : m_additionalClients) {
		334	+ clients.push_back(c.get());
		335	+ }
		336	+ }
		337	+ for (auto* c : clients) {
		338	+ if (token.clientId() == c->clientId()) {
		339	+ return c->operationResult(token.token());
		340	+ }
		341	+ }
		342	+ return boost::optional<bool>{};
		343	+}
		344	+
		345	+std::string MqttClient::endpoint() const
		346	+{
		347	+ auto ep = UriParser::parse(m_endpoint);
		348	+ if (ep.find("user") != ep.end()) {
		349	+ ep["user"].clear();
		350	+ }
		351	+ if (ep.find("password") != ep.end()) {
		352	+ ep["password"].clear();
		353	+ }
		354	+ return UriParser::toString(ep);
		355	+}
		356	+
		357	+void MqttClient::connectionStatusChanged(const std::string& id, ConnectionStatus cs)
		358	+{
		359	+ (void)id;
		360	+ (void)cs;
		361	+ // DebugLogToFIle ("MqttClient", "%1 - connection status of wrapped client %2 changed to %3", m_clientId, id, cs);
		362	+ IMqttClientImpl* principalClient{ nullptr };
		363	+ std::vector<IMqttClientImpl*> clients{};
		364	+ std::vector<ConnectionStatus> connectionStates{};
		365	+ {
		366	+ OSDEV_COMPONENTS_LOCKGUARD(m_internalMutex);
		367	+ if (!m_principalClient) {
		368	+ return;
		369	+ }
		370	+ if (m_principalClient) {
		371	+ principalClient = m_principalClient.get();
		372	+ clients.push_back(principalClient);
		373	+ connectionStates.push_back(m_principalClient->connectionStatus());
		374	+ }
		375	+ for (const auto& c : m_additionalClients) {
		376	+ clients.push_back(c.get());
		377	+ connectionStates.push_back(c->connectionStatus());
		378	+ }
		379	+ }
		380	+ auto newState = determineState(connectionStates);
		381	+ bool resubscribe = (StateEnum::ConnectionFailure == m_serverState.state() && StateEnum::Good == newState);
		382	+ if (resubscribe) {
		383	+ {
		384	+ OSDEV_COMPONENTS_LOCKGUARD(m_internalMutex);
		385	+ m_activeTokens.clear();
		386	+ }
		387	+ for (auto* cl : clients) {
		388	+ try {
		389	+ cl->resubscribe();
		390	+ }
		391	+ catch (const std::exception& e) {
		392	+ // ErrorLogToFIle ("MqttClient", "%1 - resubscribe on wrapped client %2 in context of connection status change in wrapped client %3 failed : %4", m_clientId, cl->clientId(), id, e.what());
		393	+ }
		394	+ }
		395	+ m_activeTokensCV.notify_all();
		396	+ }
		397	+
		398	+ // The server state change and a possible resubscription are done in the context of the MqttClient worker thread
		399	+ // The wrapper is free to pick up new work such as the acknowledment of the just recreated subscriptions.
		400	+ this->pushEvent([this, resubscribe, clients, principalClient, newState]() {
		401	+ if (resubscribe) {
		402	+ // Just wait for the subscription commands to complete. We do not use waitForCompletionInternal because that call will always timeout when there are active tokens.
		403	+ // Active tokens are removed typically by work done on the worker thread. The wait action is also performed on the worker thread.
		404	+ auto waitFor = std::chrono::milliseconds(1000);
		405	+ if (!waitForCompletionInternalClients(clients, waitFor, std::set<Token>{})) {
		406	+ if (std::accumulate(clients.begin(), clients.end(), false, [](bool hasPending, IMqttClientImpl* client) { return hasPending \|\| client->hasPendingSubscriptions(); })) {
		407	+ // WarnLogToFIle ("MqttClient", "%1 - subscriptions are not recovered within timeout.", m_clientId)
		408	+ }
		409	+ }
		410	+ if (principalClient) {
		411	+ try {
		412	+ principalClient->publishPending();
		413	+ }
		414	+ catch (const std::exception& e) {
		415	+ // ErrorLogToFIle ("MqttClient", "%1 - publishPending on wrapped client %2 failed : %3", m_clientId, principalClient->clientId(), e.what());
		416	+ }
		417	+ }
		418	+ }
		419	+ m_serverState.emitStateChanged(newState);
		420	+ });
		421	+}
		422	+
		423	+void MqttClient::deliveryComplete(const std::string& _clientId, std::int32_t token)
		424	+{
		425	+ if (!m_deliveryCompleteCallback) {
		426	+ return;
		427	+ }
		428	+
		429	+ Token t(_clientId, token);
		430	+ {
		431	+ OSDEV_COMPONENTS_LOCKGUARD(m_internalMutex);
		432	+ if (!m_activeTokens.insert(t).second) {
		433	+ // This should not happen. This means that some callback on the wrapper never came.
		434	+ // ErrorLogToFIle ("MqttClient", "%1 -deliveryComplete, token %1 is already active", m_clientId, t);
		435	+ }
		436	+ }
		437	+ this->pushEvent([this, t]() {
		438	+ OSDEV_COMPONENTS_SCOPEGUARD(m_activeTokens, [this, &t]() {
		439	+ {
		440	+ OSDEV_COMPONENTS_LOCKGUARD(m_internalMutex);
		441	+ m_activeTokens.erase(t);
		442	+ }
		443	+ m_activeTokensCV.notify_all();
		444	+ });
		445	+ m_deliveryCompleteCallback(t);
		446	+ });
		447	+}
		448	+
		449	+bool MqttClient::waitForCompletionInternal(const std::vector<IMqttClientImpl*>& clients, std::chrono::milliseconds waitFor, const std::set<Token>& tokens) const
		450	+{
		451	+ if (!waitForCompletionInternalClients(clients, waitFor, tokens)) {
		452	+ return false;
		453	+ }
		454	+ std::unique_lock<std::mutex> lck(m_internalMutex);
		455	+ return m_activeTokensCV.wait_for(lck, waitFor, [this, &tokens]() {
		456	+ if (tokens.empty()) { // wait for all operations to end
		457	+ return m_activeTokens.empty();
		458	+ }
		459	+ else if (tokens.size() == 1) {
		460	+ return m_activeTokens.find(*tokens.cbegin()) == m_activeTokens.end();
		461	+ }
		462	+ std::vector<Token> intersect{};
		463	+ std::set_intersection(m_activeTokens.begin(), m_activeTokens.end(), tokens.begin(), tokens.end(), std::back_inserter(intersect));
		464	+ return intersect.empty(); });
		465	+}
		466	+
		467	+bool MqttClient::waitForCompletionInternalClients(const std::vector<IMqttClientImpl*>& clients, std::chrono::milliseconds& waitFor, const std::set<Token>& tokens) const
		468	+{
		469	+ for (auto* c : clients) {
		470	+ std::set<std::int32_t> clientTokens{};
		471	+ for (const auto& token : tokens) {
		472	+ if (c->clientId() == token.clientId()) {
		473	+ clientTokens.insert(token.token());
		474	+ }
		475	+ }
		476	+ if (tokens.empty() \|\| !clientTokens.empty()) {
		477	+ waitFor -= c->waitForCompletion(waitFor, clientTokens);
		478	+ }
		479	+ }
		480	+ if (waitFor > std::chrono::milliseconds(0)) {
		481	+ return true;
		482	+ }
		483	+ waitFor = std::chrono::milliseconds(0);
		484	+ return false;
		485	+}
		486	+
		487	+StateEnum MqttClient::determineState(const std::vector<ConnectionStatus>& connectionStates)
		488	+{
		489	+ std::size_t unknownStates = 0;
		490	+ std::size_t goodStates = 0;
		491	+ std::size_t reconnectStates = 0;
		492	+ for (auto cst : connectionStates) {
		493	+ switch (cst) {
		494	+ case ConnectionStatus::Disconnected:
		495	+ ++unknownStates;
		496	+ break;
		497	+ case ConnectionStatus::DisconnectInProgress: // count as unknown because we don't want resubscribes to trigger when a wrapper is in this state.
		498	+ ++unknownStates;
		499	+ break;
		500	+ case ConnectionStatus::ConnectInProgress: // count as unknown because the wrapper is not connected yet.
		501	+ ++unknownStates;
		502	+ break;
		503	+ case ConnectionStatus::ReconnectInProgress:
		504	+ ++reconnectStates;
		505	+ break;
		506	+ case ConnectionStatus::Connected:
		507	+ ++goodStates;
		508	+ break;
		509	+ }
		510	+ }
		511	+ auto newState = StateEnum::Unknown;
		512	+ if (reconnectStates > 0) {
		513	+ newState = StateEnum::ConnectionFailure;
		514	+ }
		515	+ else if (unknownStates > 0) {
		516	+ newState = StateEnum::Unknown;
		517	+ }
		518	+ else if (connectionStates.size() == goodStates) {
		519	+ newState = StateEnum::Good;
		520	+ }
		521	+ return newState;
		522	+}
		523	+
		524	+void MqttClient::pushEvent(std::function<void()> ev)
		525	+{
		526	+ m_eventQueue.push(ev);
		527	+}
		528	+
		529	+void MqttClient::eventHandler()
		530	+{
		531	+ // InfoLogToFIle ("MqttClient", "%1 - starting event handler", m_clientId);
		532	+ for (;;) {
		533	+ std::vector<std::function<void()>> events;
		534	+ if (!m_eventQueue.pop(events))
		535	+ {
		536	+ break;
		537	+ }
		538	+ for (const auto& ev : events)
		539	+ {
		540	+ ev();
		541	+ }
		542	+ }
		543	+ // InfoLogToFIle ("MqttClient", "%1 - leaving event handler", m_clientId);
		544	+}

src/mqttclient.h 0 → 100644

View file @51becbd

		1	+++ a/src/mqttclient.h
		1	+#ifndef OSDEV_COMPONENTS_MQTT_MQTTCLIENT_H
		2	+#define OSDEV_COMPONENTS_MQTT_MQTTCLIENT_H
		3	+
		4	+// std
		5	+#include <condition_variable>
		6	+#include <memory>
		7	+#include <mutex>
		8	+#include <set>
		9	+#include <thread>
		10	+#include <vector>
		11	+
		12	+// osdev::components::mqtt
		13	+#include "synchronizedqueue.h"
		14	+#include "istatecallback.h"
		15	+#include "serverstate.h"
		16	+
		17	+#include "imqttclient.h"
		18	+
		19	+namespace osdev {
		20	+namespace components {
		21	+namespace mqtt {
		22	+
		23	+// Forward definition
		24	+class IMqttClientImpl;
		25	+
		26	+class MqttClient : public virtual IMqttClient
		27	+{
		28	+public:
		29	+ /*!
		30	+ * \brief Construct an instance of the MqttClient.
		31	+ * \param clientId The client identification used in the connection to the mqtt broker.
		32	+ * \param deliveryCompleteCallback Optional callback used to signal completion of a publication.
		33	+ */
		34	+ MqttClient( const std::string& clientId, const std::function<void(const Token& token)>& deliveryCompleteCallback = std::function<void(const Token& token)>{});
		35	+ virtual ~MqttClient() override;
		36	+
		37	+ // Non copyable, non movable
		38	+ MqttClient(const MqttClient&) = delete;
		39	+ MqttClient& operator=(const MqttClient&) = delete;
		40	+ MqttClient(MqttClient&&) = delete;
		41	+ MqttClient& operator=(MqttClient&&) = delete;
		42	+
		43	+ /**
		44	+ * @see IStateCallback
		45	+ */
		46	+ virtual std::string clientId() const override;
		47	+
		48	+ /**
		49	+ * @see IStateCallback
		50	+ */
		51	+ virtual StateChangeCallbackHandle registerStateChangeCallback(const SlotStateChange& cb) override;
		52	+
		53	+ /**
		54	+ * @see IStateCallback
		55	+ */
		56	+ virtual void unregisterStateChangeCallback(StateChangeCallbackHandle handle) override;
		57	+
		58	+ /**
		59	+ * @see IStateCallback
		60	+ */
		61	+ virtual void clearAllStateChangeCallbacks() override;
		62	+
		63	+ /**
		64	+ * @see IStateCallback
		65	+ */
		66	+ virtual StateEnum state() const override;
		67	+
		68	+ // MqttClient interface
		69	+
		70	+ /**
		71	+ * @see IMqttClient
		72	+ */
		73	+ virtual void connect(const std::string& host, int port, const Credentials& credentials) override;
		74	+
		75	+ /**
		76	+ * @see IMqttClient
		77	+ */
		78	+ virtual void connect(const std::string& endpoint) override;
		79	+
		80	+ /**
		81	+ * @see IMqttClient
		82	+ */
		83	+ virtual void disconnect() override;
		84	+
		85	+ /**
		86	+ * @see IMqttClient
		87	+ */
		88	+ virtual Token publish(const MqttMessage& message, int qos) override;
		89	+
		90	+ /**
		91	+ * @see IMqttClient
		92	+ * When an overlapping subscription is detected a new connection has to be created. This is a synchronous action
		93	+ * and this method will wait for the connection to be up.
		94	+ */
		95	+ virtual Token subscribe(const std::string& topic, int qos, const std::function<void(MqttMessage)>& cb) override;
		96	+
		97	+ /**
		98	+ * @see IMqttClient
		99	+ */
		100	+ virtual std::set<Token> unsubscribe(const std::string& topic, int qos) override;
		101	+
		102	+ /**
		103	+ * @see IMqttClient
		104	+ */
		105	+ virtual bool waitForCompletion(std::chrono::milliseconds waitFor) const override;
		106	+
		107	+ /**
		108	+ * @see IMqttClient
		109	+ */
		110	+ virtual bool waitForCompletion(std::chrono::milliseconds waitFor, const Token& token) const override;
		111	+
		112	+ /**
		113	+ * @see IMqttClient
		114	+ */
		115	+ virtual bool waitForCompletion(std::chrono::milliseconds waitFor, const std::set<Token>& tokens) const override;
		116	+
		117	+ /**
		118	+ * @see IMqttClient
		119	+ */
		120	+ virtual boost::optional<bool> commandResult(const Token& token) const override;
		121	+
		122	+ /**
		123	+ * @see IMqttClient
		124	+ */
		125	+ virtual std::string endpoint() const override;
		126	+
		127	+private:
		128	+ /*!
		129	+ * \brief Callback used to pick up the connection status of the wrappers.
		130	+ * \param id The client id.
		131	+ * \param cs The connection status.
		132	+ */
		133	+ void connectionStatusChanged( const std::string& id, ConnectionStatus cs );
		134	+
		135	+ /*!
		136	+ * \brief Callback for handling delivery complete.
		137	+ * \param clientId The identifier of the client on which the publish command is executed.
		138	+ * \param token The token identifies the publish command.
		139	+ */
		140	+ void deliveryComplete( const std::string& clientId, std::int32_t token );
		141	+
		142	+ /**
		143	+ * \brief Wait for commands to complete including active tokens in this client.
		144	+ * The interface mutex is not locked by this method.
		145	+ * First wait for client commands to complete (use method waitForCompletionInternalClients)
		146	+ * and then wait for publish delivery callbacks to complete.
		147	+ * \param clients - Vector with client wrapper pointers that need to be waited on.
		148	+ * \param[in,out] waitFor - The number of milliseconds to wait for completetion of all commands and delivery callbacks.
		149	+ * \param tokens - The tokens to wait for. An empty set means to wait for all commands on all clients to complete
		150	+ * including all publish delivery callbacks.
		151	+ * \return True when commands have completed in time including delivery callbacks or false if not.
		152	+ */
		153	+ bool waitForCompletionInternal(const std::vector<IMqttClientImpl*>& clients, std::chrono::milliseconds waitFor, const std::set<Token>& tokens) const;
		154	+
		155	+ /**
		156	+ * \brief Wait for commands on the wrapper clients to complete.
		157	+ * The interface mutex is not locked by this method.
		158	+ * \param clients - Vector with client wrapper pointers that need to be waited on.
		159	+ * \param[in,out] waitFor - The number of milliseconds to wait for completetion of all commands.
		160	+ * On return waitFor contains the time left.
		161	+ * \param tokens - The tokens to wait for. An empty set means to wait for all commands
		162	+ * on all clients to complete.
		163	+ * \return True when all commands have completed in time or false if not.
		164	+ */
		165	+ bool waitForCompletionInternalClients(const std::vector<IMqttClientImpl*>& clients, std::chrono::milliseconds& waitFor, const std::set<Token>& tokens) const;
		166	+
		167	+ /**
		168	+ * @brief Determine the state of this client based on the connection statusses of its client wrappers.
		169	+ * The states this client can communicate are:
		170	+ * Unknown : When at least one wrapper is in a different state then Connected or ReconnectInProgress or when no wrappers are available.
		171	+ * Good : When all wrappers are connected.
		172	+ * ConnectionFailure : When at least one wrapper attempts reconnection.
		173	+ * Unregister : When the serverstate instance is destroyed.
		174	+ *
		175	+ * The other states are about the information providers to the mqtt broker (the publishers) and we cannot say anything about them here.
		176	+ * The state "Good" is the exception. This state means in this case that this clients connection is ok and not that the underlying data
		177	+ * source (publisher) is ok.
		178	+ *
		179	+ * @param connectionStates A vector with the connection statusses of all client wrappers.
		180	+ */
		181	+ StateEnum determineState(const std::vector<ConnectionStatus>& connectionStates);
		182	+
		183	+ /**
		184	+ * @brief Add an event to the synchronized queue.
		185	+ * @param ev A function object that performs work in the context of this class.
		186	+ */
		187	+ void pushEvent(std::function<void()> ev);
		188	+
		189	+ /**
		190	+ * @brief Worker method that executes the events.
		191	+ */
		192	+ void eventHandler();
		193	+
		194	+ mutable std::mutex m_interfaceMutex; ///< Makes the interface mutual exclusive
		195	+ mutable std::mutex m_internalMutex; ///< Protect the internal state.
		196	+ std::string m_endpoint; ///< The endpoint uri.
		197	+ std::string m_clientId; ///< The main client identification.
		198	+ std::set<Token> m_activeTokens; ///< Set with active command tokens. Callbacks still need to be made for these tokens.
		199	+ mutable std::condition_variable m_activeTokensCV; ///< Wait on a condition to become true w.r.t. the active token set.
		200	+ std::function<void(const Token&)> m_deliveryCompleteCallback; ///< Optional callback for publish completion.
		201	+ ServerState m_serverState; ///< Records the state of the connection to the broker that this client is connected to.
		202	+ std::unique_ptr<IMqttClientImpl> m_principalClient; ///< The main wrapper client.
		203	+ std::vector<std::unique_ptr<IMqttClientImpl>> m_additionalClients; ///< A vector of additional wrapper clients.
		204	+ SynchronizedQueue<std::function<void()>> m_eventQueue; ///< Synchronized queue for scheduling additional work.
		205	+ std::thread m_workerThread; ///< A worker thread that is used to perform actions that cannot be done on the callback threads.
		206	+};
		207	+
		208	+} // End namespace mqtt
		209	+} // End namespace components
		210	+} // End namespace osdev
		211	+
		212	+#endif // OSDEV_COMPONENTS_MQTT_MQTTCLIENT_H

src/mqttfailure.cpp 0 → 100644

View file @51becbd

		1	+++ a/src/mqttfailure.cpp
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#include "mqttfailure.h"
		20	+
		21	+// osdev::components::mqtt
		22	+#include "errorcode.h"
		23	+
		24	+using namespace osdev::components::mqtt;
		25	+
		26	+MqttFailure::MqttFailure(const MQTTAsync_failureData* data)
		27	+ : m_token(data ? data->token : 0)
		28	+ , m_code(data ? data->code : MQTTASYNC_FAILURE)
		29	+ , m_message()
		30	+{
		31	+ if (!data) {
		32	+ m_message = "missing response data";
		33	+ }
		34	+ else if (!data->message) {
		35	+ m_message = "no message";
		36	+ }
		37	+ else {
		38	+ m_message = std::string(data->message);
		39	+ }
		40	+}
		41	+
		42	+std::string MqttFailure::codeToString() const
		43	+{
		44	+ if (m_code < 0) {
		45	+ return pahoAsyncErrorCodeToString(m_code);
		46	+ }
		47	+ else if (0x80 == m_code) {
		48	+ return "Failure";
		49	+ }
		50	+ return std::string("Unknown(") + std::to_string(m_code) + ")";
		51	+}

src/mqttfailure.h 0 → 100644

View file @51becbd

		1	+++ a/src/mqttfailure.h
		1	+#ifndef OSDEV_COMPONENTS_MQTT_MQTTFAILURE_H
		2	+#define OSDEV_COMPONENTS_MQTT_MQTTFAILURE_H
		3	+
		4	+// std
		5	+#include <string>
		6	+
		7	+// paho
		8	+#include <MQTTAsync.h>
		9	+
		10	+namespace osdev {
		11	+namespace components {
		12	+namespace mqtt {
		13	+
		14	+/*!
		15	+ * \brief Class for paho mqtt failure response data.
		16	+ */
		17	+class MqttFailure
		18	+{
		19	+public:
		20	+ /*!
		21	+ * \brief Construct MqttFailure instance by copying information from the paho failure struct.
		22	+ * \param data Paho response failure data.
		23	+ */
		24	+ explicit MqttFailure(const MQTTAsync_failureData* data);
		25	+
		26	+ /*!
		27	+ * \return The command token
		28	+ */
		29	+ MQTTAsync_token token() const { return m_token; }
		30	+
		31	+ /*!
		32	+ * \return The failure code.
		33	+ */
		34	+ int code() const { return m_code; }
		35	+
		36	+ /*!
		37	+ * \return The failure message.
		38	+ * \retval "no message" when no message is available.
		39	+ */
		40	+ const std::string& message() const { return m_message; }
		41	+
		42	+ /*!
		43	+ * \return string interpretation of the code.
		44	+ * \note negative codes are interpreted as paho error codes.
		45	+ */
		46	+ std::string codeToString() const;
		47	+
		48	+private:
		49	+ MQTTAsync_token m_token; ///< Command token.
		50	+ int m_code; ///< Failure code.
		51	+ std::string m_message; ///< Optional message. Equal to "no message" when message is not available.
		52	+};
		53	+
		54	+} // End namespace mqtt
		55	+} // End namespace components
		56	+} // End namespace osdev
		57	+
		58	+#endif // OSDEV_COMPONENTS_MQTT_MQTTFAILURE_H

src/mqttidgenerator.cpp 0 → 100644

View file @51becbd

		1	+++ a/src/mqttidgenerator.cpp
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#include "mqttidgenerator.h"
		20	+
		21	+// std
		22	+#include <chrono>
		23	+#include <mutex>
		24	+#include <thread>
		25	+#include <unistd.h>
		26	+
		27	+// boost
		28	+#include <boost/uuid/uuid_generators.hpp>
		29	+
		30	+#include "lockguard.h"
		31	+#include "commondefs.h"
		32	+
		33	+namespace {
		34	+
		35	+boost::uuids::basic_random_generator<boost::mt19937> createGenerator()
		36	+{
		37	+ static auto timeSeed = static_cast<boost::mt19937::result_type>(std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count());
		38	+ static auto pidSeed = static_cast<boost::mt19937::result_type>(getpid());
		39	+ static std::hash<std::thread::id> hasher;
		40	+ static auto threadSeed = static_cast<boost::mt19937::result_type>(hasher(std::this_thread::get_id()));
		41	+ static boost::mt19937 randomNumberGenerator;
		42	+ randomNumberGenerator.seed(timeSeed ^ pidSeed ^ threadSeed);
		43	+ return boost::uuids::basic_random_generator<boost::mt19937>(&randomNumberGenerator);
		44	+}
		45	+
		46	+} // namespace
		47	+
		48	+using namespace osdev::components::mqtt;
		49	+
		50	+const MqttId mqttNamespace = boost::lexical_cast<boost::uuids::uuid>("9c0f3730-cc4f-49eb-ab5b-079bc5b0e481");
		51	+
		52	+// static
		53	+MqttId MqttIdGenerator::generate()
		54	+{
		55	+ // From the boost design notes
		56	+ // Seeding is unqiue per random generator:
		57	+ // The boost::uuids::basic_random_generator class' default constructor seeds the random number generator
		58	+ // with a SHA-1 hash of a number of different values including std::time(0), std::clock(), uninitialized data,
		59	+ // value return from new unsigned int, etc..
		60	+ // Functions are reentrant:
		61	+ // All functions are re-entrant. Classes are as thread-safe as an int. That is an instance can not be shared
		62	+ // between threads without proper synchronization.
		63	+ static auto uuidGenerator = createGenerator();
		64	+ static std::mutex generatorMutex;
		65	+ OSDEV_COMPONENTS_LOCKGUARD(generatorMutex);
		66	+ return uuidGenerator();
		67	+}
		68	+
		69	+//static
		70	+MqttId MqttIdGenerator::nullId()
		71	+{
		72	+ return boost::uuids::nil_uuid();
		73	+}
		74	+
		75	+// static
		76	+MqttId MqttIdGenerator::nameId(MqttId namespaceUuid, const std::string& name)
		77	+{
		78	+ boost::uuids::name_generator gen(namespaceUuid);
		79	+ return gen(name.c_str());
		80	+}
		81	+
		82	+// static
		83	+MqttId MqttIdGenerator::nameId(const std::string& name)
		84	+{
		85	+ return MqttIdGenerator::nameId(mqttNamespace, name);
		86	+}

src/mqttidgenerator.h 0 → 100644

View file @51becbd

		1	+++ a/src/mqttidgenerator.h
		1	+#ifndef OSDEV_COMPONENTS_MQTT_MLOGICIDGENERATOR_H
		2	+#define OSDEV_COMPONENTS_MQTT_MLOGICIDGENERATOR_H
		3	+
		4	+// std
		5	+#include <string>
		6	+
		7	+// osdev::components::mqtt
		8	+#include "commondefs.h"
		9	+
		10	+namespace osdev {
		11	+namespace components {
		12	+namespace mqtt {
		13	+
		14	+class MqttIdGenerator
		15	+{
		16	+public:
		17	+ /**
		18	+ * @brief Generates a new MqttId, which is guaranteed to be unique.
		19	+ * @return A new unique MqttId.
		20	+ */
		21	+ static MqttId generate();
		22	+
		23	+ /**
		24	+ * @brief Returns an MqttId that represents null.
		25	+ * @return An MqttId that represents null.
		26	+ */
		27	+ static MqttId nullId();
		28	+
		29	+ /**
		30	+ * @brief Returns an MqttId based on a namespace uuid and a given string.
		31	+ * @param namespaceUuid The namespace in which the MqttId is generated.
		32	+ * @param name The name for which an MqttId is generated.
		33	+ */
		34	+ static MqttId nameId(MqttId namespaceUuid, const std::string& name);
		35	+
		36	+ /**
		37	+ * @brief Returns an MqttId in the MQTT namespace for a given string.
		38	+ * @param name The name for which an MqttId is generated.
		39	+ */
		40	+ static MqttId nameId(const std::string& name);
		41	+};
		42	+
		43	+} // End namespace mqtt
		44	+} // End namespace components
		45	+} // End namespace osdev
		46	+
		47	+#endif // OSDEV_COMPONENTS_MQTT_MLOGICIDGENERATOR_H

src/mqttmessage.cpp 0 → 100644

View file @51becbd

		1	+++ a/src/mqttmessage.cpp
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#include "mqttmessage.h"
		20	+
		21	+using namespace osdev::components::mqtt;
		22	+
		23	+MqttMessage::MqttMessage()
		24	+ : m_retained()
		25	+ , m_duplicate()
		26	+ , m_topic()
		27	+ , m_payload()
		28	+{}
		29	+
		30	+MqttMessage::MqttMessage(const std::string &_topic, const MQTTAsync_message &message)
		31	+ : m_retained( 0 != message.retained )
		32	+ , m_duplicate( 0 != message.dup )
		33	+ , m_topic( _topic )
		34	+ , m_payload()
		35	+{
		36	+ const char msg = reinterpret_cast<const char>(message.payload);
		37	+ m_payload = std::string( msg, msg + message.payloadlen );
		38	+}
		39	+
		40	+MqttMessage::MqttMessage( const std::string &_topic, bool retainedFlag, bool duplicateFlag, std::string thePayload )
		41	+ : m_retained( retainedFlag )
		42	+ , m_duplicate( duplicateFlag )
		43	+ , m_topic( _topic )
		44	+ , m_payload( thePayload )
		45	+{}
		46	+
		47	+MQTTAsync_message MqttMessage::toAsyncMessage() const
		48	+{
		49	+ MQTTAsync_message msg = MQTTAsync_message_initializer;
		50	+ msg.payload = reinterpret_cast<void>( const_cast<char>( m_payload.c_str() ) );
		51	+ msg.payloadlen = static_cast<int>( m_payload.size() );
		52	+ msg.qos = -1;
		53	+ msg.retained = static_cast<int>( m_retained );
		54	+
		55	+ return msg;
		56	+}

src/mqttmessage.h 0 → 100644

View file @51becbd

		1	+++ a/src/mqttmessage.h
		1	+#ifndef OSDEV_COMPONENTS_MQTT_MQTTMESSAGE_H
		2	+#define OSDEV_COMPONENTS_MQTT_MQTTMESSAGE_H
		3	+
		4	+// std
		5	+#include <string>
		6	+
		7	+// paho-c
		8	+#include <MQTTAsync.h>
		9	+
		10	+namespace osdev {
		11	+namespace components {
		12	+namespace mqtt {
		13	+
		14	+/*!
		15	+ * @brief Class for paho mqtt message data
		16	+ */
		17	+class MqttMessage
		18	+{
		19	+public:
		20	+ /*!
		21	+ * @brief Construct empty MqttMessage instance
		22	+ */
		23	+ MqttMessage();
		24	+
		25	+ /*!
		26	+ * @brief Construct MqttMessage instance by copying information gfrom the paho message struct
		27	+ * @param topic - Paho topic data (copied)
		28	+ * @param msg - Paho message data (copied)
		29	+ */
		30	+ MqttMessage( const std::string &topic, const MQTTAsync_message &msg );
		31	+
		32	+ /*!
		33	+ * @brief Construct MqttMessage instance.
		34	+ * @param topic - Topic String
		35	+ * @param retainedFlag - Flag that indicates if message is retained
		36	+ * @param duplicateFlag - Flag that indicates if message is duplicate.
		37	+ * @param thePayload - The message itself.
		38	+ */
		39	+ MqttMessage( const std::string &topic, bool retainedFlag, bool duplicateFlag, std::string thePayload );
		40	+
		41	+ /! @return The retained flag value. /
		42	+ bool retained() const { return m_retained; }
		43	+
		44	+ /! @return The duplicate flag value /
		45	+ bool duplicate() const { return m_duplicate; }
		46	+
		47	+ /! @return The topic on which the message is received. /
		48	+ const std::string& topic() const { return m_topic; }
		49	+
		50	+ /! @return The message payload. /
		51	+ const std::string& payload() const { return m_payload; }
		52	+
		53	+ /! @return This instance as a paho message /
		54	+ MQTTAsync_message toAsyncMessage() const;
		55	+
		56	+private:
		57	+ bool m_retained; ///< Retained flag. Not all brokers communicate this flag correctly. (emqx does not, mosquitto does.)
		58	+ bool m_duplicate; ///< Duplicate flag ( for qos 1? )
		59	+ std::string m_topic; ///< The topic on which the message is recieved.
		60	+ std::string m_payload; ///< The actual message data.
		61	+};
		62	+
		63	+
		64	+} // End namespace mqtt
		65	+} // End namespace components
		66	+} // End namespace osdev
		67	+
		68	+#endif // OSDEV_COMPONENTS_MQTT_MQTTMESSAGE_H

src/mqttstream.h 0 → 100644

View file @51becbd

		1	+++ a/src/mqttstream.h
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#ifndef OSDEV_COMPONENTS_MQTT_MQTTSTREAM_H
		20	+#define OSDEV_COMPONENTS_MQTT_MQTTSTREAM_H
		21	+
		22	+// This header is used in conjunction with mlogic/commmon/stringify.h to get output streaming of stl container types.
		23	+// The streaming operators are not suitable for marshalling because type information is lost!
		24	+
		25	+// std
		26	+#include <array>
		27	+#include <list>
		28	+#include <map>
		29	+#include <ostream>
		30	+#include <set>
		31	+#include <string>
		32	+#include <vector>
		33	+
		34	+namespace osdev {
		35	+namespace components {
		36	+namespace mqtt {
		37	+
		38	+/**
		39	+ * @brief Streams a container with content for which stream operators are available.
		40	+ * @note This function is meant for printing and not for marshalling!
		41	+ * @tparam Open The container opening character.
		42	+ * @tparam Close The container closing character.
		43	+ * @tparam T The container type.
		44	+ * @param os The stream to use.
		45	+ * @param rhs The container that is to be streamed.
		46	+ * @param sep The field separator. Default is ", "
		47	+ * @return reference to the stream object.
		48	+ */
		49	+template <char Open, char Close, typename T>
		50	+std::ostream& streamContainer(std::ostream& os, const T& rhs, const std::string& sep = ", ")
		51	+{
		52	+ os << Open;
		53	+ for (auto cit = rhs.cbegin(); rhs.cend() != cit; ++cit) {
		54	+ os << *cit;
		55	+ if (std::next(cit) != rhs.end()) {
		56	+ os << sep;
		57	+ }
		58	+ }
		59	+ os << Close;
		60	+
		61	+ return os;
		62	+}
		63	+
		64	+} // End namespace mqtt
		65	+} // End namespace components
		66	+} // End namespace osdev
		67	+
		68	+namespace std {
		69	+
		70	+/**
		71	+ * @brief Streams a list that contains values for which an output stream operator is available.
		72	+ */
		73	+template <typename T>
		74	+std::ostream& operator<<(std::ostream& os, const std::list<T>& rhs)
		75	+{
		76	+ return osdev::components::mqtt::streamContainer<'<', '>'>(os, rhs);
		77	+}
		78	+
		79	+/**
		80	+ * @brief Streams an array that contains values for which an output stream operator is available.
		81	+ */
		82	+template <typename T, std::size_t N>
		83	+std::ostream& operator<<(std::ostream& os, const std::array<T, N>& rhs)
		84	+{
		85	+ return osdev::components::mqtt::streamContainer<'[', ']'>(os, rhs);
		86	+}
		87	+
		88	+/**
		89	+ * @brief Streams a vector that contains values for which an output stream operator is available.
		90	+ */
		91	+template <typename T>
		92	+std::ostream& operator<<(std::ostream& os, const std::vector<T>& rhs)
		93	+{
		94	+ return osdev::components::mqtt::streamContainer<'[', ']'>(os, rhs);
		95	+}
		96	+
		97	+/**
		98	+ * @brief Streams a set that contains values for which an output stream operator is available.
		99	+ */
		100	+template <typename T>
		101	+std::ostream& operator<<(std::ostream& os, const std::set<T>& rhs)
		102	+{
		103	+ return osdev::components::mqtt::streamContainer<'{', '}'>(os, rhs);
		104	+}
		105	+
		106	+/**
		107	+ * @brief Streams a map that contains keys and values for which an output stream operator is available.
		108	+ */
		109	+template <typename TKey, typename TValue>
		110	+std::ostream& operator<<(std::ostream& os, const std::map<TKey, TValue>& rhs)
		111	+{
		112	+ return osdev::components::mqtt::streamContainer<'{', '}'>(os, rhs);
		113	+}
		114	+
		115	+/**
		116	+ * @brief Streams a pair that contains values for which an output stream operator is available.
		117	+ */
		118	+template <typename TFirst, typename TSecond>
		119	+std::ostream& operator<<(std::ostream& os, const std::pair<TFirst, TSecond>& rhs)
		120	+{
		121	+ os << "{" << rhs.first << " : " << rhs.second << "}";
		122	+ return os;
		123	+}
		124	+
		125	+} // End namespace std
		126	+
		127	+#endif // OSDEV_COMPONENTS_MQTT_MQTTSTREAM_H

src/mqttsuccess.cpp 0 → 100644

View file @51becbd

		1	+++ a/src/mqttsuccess.cpp
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#include "mqttsuccess.h"
		20	+
		21	+using namespace osdev::components::mqtt;
		22	+
		23	+ConnectionData::ConnectionData()
		24	+ : m_serverUri()
		25	+ , m_mqttVersion()
		26	+ , m_sessionPresent()
		27	+{
		28	+}
		29	+
		30	+ConnectionData::ConnectionData(char* _serverUri, int _mqttVersion, int _sessionPresent)
		31	+ : m_serverUri(_serverUri ? _serverUri : "unknown")
		32	+ , m_mqttVersion(_mqttVersion)
		33	+ , m_sessionPresent(0 != _sessionPresent)
		34	+{
		35	+}
		36	+
		37	+MqttSuccess::MqttSuccess(MQTTAsync_token _token)
		38	+ : m_token(_token)
		39	+ , m_data(Unspecified{})
		40	+{
		41	+}
		42	+
		43	+MqttSuccess::MqttSuccess(MQTTAsync_token _token, int _qos)
		44	+ : m_token(_token)
		45	+ , m_data(_qos)
		46	+{
		47	+}
		48	+
		49	+MqttSuccess::MqttSuccess(MQTTAsync_token _token, const std::vector<int>& _qosMany)
		50	+ : m_token(_token)
		51	+ , m_data(_qosMany)
		52	+{
		53	+}
		54	+
		55	+MqttSuccess::MqttSuccess(MQTTAsync_token _token, const MqttMessage& pubMsg)
		56	+ : m_token(_token)
		57	+ , m_data(pubMsg)
		58	+{
		59	+}
		60	+
		61	+MqttSuccess::MqttSuccess(MQTTAsync_token _token, const ConnectionData& connData)
		62	+ : m_token(_token)
		63	+ , m_data(connData)
		64	+{
		65	+}
		66	+
		67	+int MqttSuccess::qos() const
		68	+{
		69	+ return boost::get<int>(m_data);
		70	+}
		71	+
		72	+std::vector<int> MqttSuccess::qosMany() const
		73	+{
		74	+ return boost::get<std::vector<int>>(m_data);
		75	+}
		76	+
		77	+MqttMessage MqttSuccess::publishData() const
		78	+{
		79	+ return boost::get<MqttMessage>(m_data);
		80	+}
		81	+
		82	+ConnectionData MqttSuccess::connectionData() const
		83	+{
		84	+ return boost::get<ConnectionData>(m_data);
		85	+}

src/mqttsuccess.h 0 → 100644

View file @51becbd

		1	+++ a/src/mqttsuccess.h
		1	+#ifndef OSDEV_COMPONENTS_MQTT_MQTTSUCCESS_H
		2	+#define OSDEV_COMPONENTS_MQTT_MQTTSUCCESS_H
		3	+
		4	+// std
		5	+#include <string>
		6	+#include <vector>
		7	+
		8	+// boost
		9	+#include <boost/variant.hpp>
		10	+
		11	+// paho
		12	+#include <MQTTAsync.h>
		13	+
		14	+// osdev::components::mqtt
		15	+#include "mqttmessage.h"
		16	+
		17	+namespace osdev {
		18	+namespace components {
		19	+namespace mqtt {
		20	+
		21	+/**
		22	+ * @brief Class that holds paho connection data which is returned in the connect response.
		23	+ */
		24	+class ConnectionData
		25	+{
		26	+public:
		27	+ /*!
		28	+ * \brief Construct an empty ConnectData instance.
		29	+ */
		30	+ ConnectionData();
		31	+
		32	+ /*!
		33	+ * \brief Construct ConnectData based on incoming values from paho.
		34	+ * \param serverUri - The serverUri to which the connection is made (needs to be copied).
		35	+ * \param mqttVersion - The mqtt version used by the broker.
		36	+ * \param sessionPresent - Flag that indicates if a session was present for the given clientId.
		37	+ */
		38	+ ConnectionData(char* serverUri, int mqttVersion, int sessionPresent);
		39	+
		40	+ /*!
		41	+ * \return The server uri.
		42	+ */
		43	+ const std::string& serverUri() const { return m_serverUri; }
		44	+
		45	+ /*!
		46	+ * \return The mqtt version.
		47	+ */
		48	+ int mqttVersion() const { return m_mqttVersion; }
		49	+
		50	+ /*!
		51	+ * \return if a session was present for the given clientId.
		52	+ */
		53	+ bool sessionPresent() const { return m_sessionPresent; }
		54	+
		55	+private:
		56	+ std::string m_serverUri; ///< The broker server uri.
		57	+ int m_mqttVersion; ///< The mqtt version used by the broker.
		58	+ bool m_sessionPresent; ///< Flag that indicates whether a session was present for the client id used in the connect.
		59	+};
		60	+
		61	+struct Unspecified
		62	+{
		63	+};
		64	+
		65	+/*!
		66	+ * \brief Class for paho mqtt success response data.
		67	+ * The paho success response data uses a union and can have different information depending on the command.
		68	+ */
		69	+class MqttSuccess
		70	+{
		71	+public:
		72	+ /*!
		73	+ * \brief Response data for commands without specific data.
		74	+ * \param token The token that identifies to which command this response belongs.
		75	+ */
		76	+ explicit MqttSuccess(MQTTAsync_token token);
		77	+
		78	+ /*!
		79	+ * \brief Response data for a subscribe command.
		80	+ * \param token The token that identifies to which command this response belongs.
		81	+ * \param qos Actual quality of service of the subscription.
		82	+ */
		83	+ MqttSuccess(MQTTAsync_token token, int qos);
		84	+
		85	+ /*!
		86	+ * \brief Response data for a subscribe many command.
		87	+ * \param token The token that identifies to which command this response belongs.
		88	+ * \param qosMany Actual quality of service of the subscription for each topic filter.
		89	+ */
		90	+ MqttSuccess(MQTTAsync_token token, const std::vector<int>& qosMany);
		91	+
		92	+ /*!
		93	+ * \brief Response data for a publish command.
		94	+ * \param token The token that identifies to which command this response belongs.
		95	+ * \param pubMsg The message that was published.
		96	+ */
		97	+ MqttSuccess(MQTTAsync_token token, const MqttMessage& pubMsg);
		98	+
		99	+ /*!
		100	+ * \brief Response data for a connect command.
		101	+ * \param token The token that identifies to which command this response belongs.
		102	+ * \param connData The connection data.
		103	+ */
		104	+ MqttSuccess(MQTTAsync_token token, const ConnectionData& connData);
		105	+
		106	+ /*!
		107	+ * \return the command token.
		108	+ */
		109	+ MQTTAsync_token token() const { return m_token; }
		110	+
		111	+ /*!
		112	+ * \return the qos
		113	+ * \throw exception when command is not a subscribe command.
		114	+ */
		115	+ int qos() const;
		116	+
		117	+ /*!
		118	+ * \return a vector of qos values (matching the topics in the subscribe many command).
		119	+ * \throw exception when command is not a subscribe many command.
		120	+ */
		121	+ std::vector<int> qosMany() const;
		122	+
		123	+ /*!
		124	+ * \return Message that has been published.
		125	+ * \throw exception when command is not a publish command.
		126	+ */
		127	+ MqttMessage publishData() const;
		128	+
		129	+ /*!
		130	+ * return Connection data.
		131	+ * throw exception when command is not a connect command.
		132	+ */
		133	+ ConnectionData connectionData() const;
		134	+
		135	+private:
		136	+ MQTTAsync_token m_token; ///< Command token.
		137	+ boost::variant<int, std::vector<int>, MqttMessage, ConnectionData, Unspecified> m_data; ///< Data for the various commands.
		138	+};
		139	+
		140	+} // End namespace mqtt
		141	+} // End namespace components
		142	+} // End namespace osdev
		143	+
		144	+#endif // OSDEV_COMPONENTS_MQTT_MQTTSUCCESS_H

src/mqtttypeconverter.cpp 0 → 100644

View file @51becbd

		1	+++ a/src/mqtttypeconverter.cpp
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#include "mqtttypeconverter.h"
		20	+
		21	+// std
		22	+#include <chrono>
		23	+
		24	+// boost
		25	+#include <boost/lexical_cast.hpp>
		26	+#include <boost/uuid/uuid_io.hpp>
		27	+
		28	+// date
		29	+#include "date.h"
		30	+
		31	+#include "stringutils.h"
		32	+
		33	+using namespace osdev::components::mqtt;
		34	+
		35	+namespace osdev {
		36	+namespace components {
		37	+namespace mqtt {
		38	+namespace MqttTypeConverter {
		39	+
		40	+std::string toStdString(const MqttId& mqttId)
		41	+{
		42	+ return boost::lexical_cast<std::string>(mqttId);
		43	+}
		44	+
		45	+MqttId toMlogicId(const std::string& mqttId)
		46	+{
		47	+ return boost::lexical_cast<MqttId>(mqttId);
		48	+}
		49	+
		50	+StdTime toStdTime(const time_t& posixTime)
		51	+{
		52	+ return std::chrono::system_clock::from_time_t(posixTime);
		53	+}
		54	+
		55	+time_t toPosixTime(const StdTime& stdTime)
		56	+{
		57	+ return std::chrono::system_clock::to_time_t(stdTime);
		58	+}
		59	+
		60	+OptionalTime toOptionalTime(const std::string& posixTimeString)
		61	+{
		62	+ static const OptionalTime nonExisting;
		63	+
		64	+ try {
		65	+ auto lotPosixTime = boost::lexical_cast<std::time_t>(posixTimeString);
		66	+ return toStdTime(lotPosixTime);
		67	+ }
		68	+ catch (const boost::bad_lexical_cast&) {
		69	+ return nonExisting;
		70	+ }
		71	+}
		72	+
		73	+std::string toShortGuidAppendedString(const std::string& str, const MqttId& mqttId)
		74	+{
		75	+ std::string idStr = toStdString(mqttId);
		76	+ return str + "-" + idStr.substr(0, 4);
		77	+}
		78	+
		79	+} // End namespace MqttTypeConverter
		80	+} // End namespace mqtt
		81	+} // End namespace components
		82	+} // End namespace osdev

src/mqtttypeconverter.h 0 → 100644

View file @51becbd

		1	+++ a/src/mqtttypeconverter.h
		1	+#ifndef OSDEV_COMPONENTS_MQTT_MLOGICTYPECONVERTER_H
		2	+#define OSDEV_COMPONENTS_MQTT_MLOGICTYPECONVERTER_H
		3	+
		4	+// std
		5	+#include <chrono>
		6	+#include <ctime>
		7	+#include "date.h"
		8	+#include <string>
		9	+
		10	+// boost
		11	+#include <boost/uuid/uuid.hpp>
		12	+
		13	+#include "commondefs.h"
		14	+
		15	+namespace osdev {
		16	+namespace components {
		17	+namespace mqtt {
		18	+
		19	+/**
		20	+ * @brief Utility namespace to convert between mqtt common types and other frequently used types.
		21	+ */
		22	+namespace MqttTypeConverter {
		23	+
		24	+/**
		25	+ * @brief Converts from MqttId to std::string.
		26	+ * @param mqttId The mqttId to convert.
		27	+ * @return The std::string with contents of the provided mqttId. Format is 12345678-9abc-def0-1234-56789abcdef0.
		28	+ */
		29	+std::string toStdString(const MqttId& mqttId);
		30	+
		31	+/**
		32	+ * @brief Converts from system clock timepoint to std::string.
		33	+ * @tparam Duration std::chrono::duration instance.
		34	+ * Duration::Period is used to determine the precision
		35	+ * of the subsecond part of the returned ISO8601 string.
		36	+ * Uses the duration of the StdTime type by default.
		37	+ * @param tp The timepoint to converter.
		38	+ * @return ISO8601 string representation of stdTime.
		39	+ */
		40	+template <typename Duration>
		41	+std::string toStdString(const std::chrono::time_point<std::chrono::system_clock, Duration>& tp)
		42	+{
		43	+ return date::format("%FT%T%Ez", tp);
		44	+}
		45	+
		46	+/**
		47	+ * @brief Converts from std::string to MqttId.
		48	+ * @param mqttId The MqttId string to convert.
		49	+ * @return the converted string to MqttId.
		50	+ */
		51	+MqttId toMqttId(const std::string& mqttId);
		52	+
		53	+/**
		54	+ * @brief Creates a descriptive string based on the specified input parameters.
		55	+ * @param str The prefix of the string.
		56	+ * @param mqttId The id of which to use the first 4 characters.
		57	+ * @return str + "-" + <first 4 characters of mqttId>
		58	+ * Example: "Unassigned-a2c4".
		59	+ */
		60	+std::string toShortGuidAppendedString(const std::string& str, const MqttId& mqttId);
		61	+
		62	+/**
		63	+ * @brief Converts from PosixTime (time_t) to StdTime.
		64	+ * @param posixTime The Posix Time (time_t) to convert.
		65	+ * @return The StdTime with same value as the provided posixTime.
		66	+ */
		67	+StdTime toStdTime(const std::time_t& posixTime);
		68	+
		69	+/**
		70	+ * @brief Converts from StdTime to PosixTime (time_t).
		71	+ * @param stdTime The StdTime to convert.
		72	+ * @return The PosixTime with the same value as the provided stdTime.
		73	+ */
		74	+time_t toPosixTime(const osdev::components::mqtt::StdTime& stdTime);
		75	+
		76	+/**
		77	+ * @brief Converts the specified posixTimeString to an OptionalTime.
		78	+ * @param posixTimeString A posix time as string.
		79	+ * @return The converted posixTimeString.
		80	+ * @retval boost::none if the specified posixTimeString could not be converted to a StdTime.
		81	+ */
		82	+osdev::components::mqtt::OptionalTime toOptionalTime(const std::string& posixTimeString);
		83	+
		84	+} // End namespace MqttTypeConverter
		85	+} // End namespace mqtt
		86	+} // End namespace components
		87	+} // End namespace osdev
		88	+
		89	+#endif // OSDEV_COMPONENTS_MQTT_MQTTTYPECONVERTER_H

src/mqttutil.cpp 0 → 100644

View file @51becbd

		1	+++ a/src/mqttutil.cpp
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#include "mqttutil.h"
		20	+
		21	+// boost
		22	+#include <boost/algorithm/string/split.hpp>
		23	+#include <boost/regex.hpp>
		24	+
		25	+namespace osdev {
		26	+namespace components {
		27	+namespace mqtt {
		28	+
		29	+bool isValidTopic( const std::string &topic )
		30	+{
		31	+ if (topic.empty() \|\| topic.size() > 65535) {
		32	+ return false;
		33	+ }
		34	+
		35	+ auto posHash = topic.find('#');
		36	+ if (std::string::npos != posHash && posHash < topic.size() - 1) {
		37	+ return false;
		38	+ }
		39	+
		40	+ std::size_t pos = 0;
		41	+ while ((pos = topic.find('+', pos)) != std::string::npos) {
		42	+ if (pos > 0 && topic[pos - 1] != '/') {
		43	+ return false;
		44	+ }
		45	+ if (pos < topic.size() - 1 && topic[pos + 1] != '/') {
		46	+ return false;
		47	+ }
		48	+ ++pos;
		49	+ }
		50	+ return true;
		51	+}
		52	+
		53	+bool hasWildcard( const std::string &topic )
		54	+{
		55	+ return ( topic.size() > 0 && (topic.find( '+' ) != std::string::npos \|\| topic.size() - 1 == '#' ) );
		56	+}
		57	+
		58	+bool testForOverlap( const std::string &existingTopic, const std::string &newTopic )
		59	+{
		60	+ if (existingTopic == newTopic) {
		61	+ return true;
		62	+ }
		63	+
		64	+ // A topic that starts with a $ can never overlap with topic that does not start with a $.
		65	+ // Topics that start!!! with a $ are so called system reserved topics and not meant for users to publish to.
		66	+ if ((existingTopic[0] == '$' && newTopic[0] != '$') \|\|
		67	+ (existingTopic[0] != '$' && newTopic[0] == '$')) {
		68	+ return false;
		69	+ }
		70	+
		71	+ std::vector<std::string> existingTopicList;
		72	+ std::vector<std::string> newTopicList;
		73	+ boost::algorithm::split(existingTopicList, existingTopic, [](char ch) { return ch == '/'; });
		74	+ boost::algorithm::split(newTopicList, newTopic, [](char ch) { return ch == '/'; });
		75	+
		76	+ auto szExistingTopicList = existingTopicList.size();
		77	+ auto szNewTopicList = newTopicList.size();
		78	+ // Walk through the topic term by term until it is proved for certain that the topics either have no overlap
		79	+ // or do have overlap.
		80	+ for (std::size_t idx = 0; idx < std::minmax(szExistingTopicList, szNewTopicList).first; ++idx) {
		81	+ if ("#" == existingTopicList[idx] \|\| "#" == newTopicList[idx]) {
		82	+ return true; // Match all wildcard found so there is always a possible overlap.
		83	+ }
		84	+ else if ("+" == existingTopicList[idx] \|\| "+" == newTopicList[idx]) {
		85	+ // these terms can match each other based on wildcard.
		86	+ // Topics are still in the race for overlap, proceed to the next term
		87	+ }
		88	+ else if (existingTopicList[idx] != newTopicList[idx]) {
		89	+ return false; // no match possible because terms are not wildcards and differ from each other.
		90	+ }
		91	+ else {
		92	+ // term is an exact match. The topics are still in the race for overlap, proceed to the next term.
		93	+ }
		94	+ }
		95	+ // Still no certain prove of overlap. If the number of terms for both topics are the same at this point then they overlap.
		96	+ // If they are not the same than a match all wildcard on the longer topic can still make them match because of a special rule
		97	+ // that states that a topic with a match all wildcard also matches a topic without that term.
		98	+ // Example: topic /level/1 matches wildcard topic /level/1/#
		99	+ // A match single wildcard at the end or at the term before a match all wildcard must also be taken into account.
		100	+ // Example: /level/+ can overlap with /level/1/#
		101	+ // /level/1 can overlap with /level/+/#
		102	+ if (szNewTopicList != szExistingTopicList) {
		103	+ if (szNewTopicList == szExistingTopicList + 1 && "#" == newTopicList[szNewTopicList - 1]) {
		104	+ return (newTopicList[szNewTopicList - 2] == existingTopicList[szExistingTopicList - 1] \|\| "+" == existingTopicList[szExistingTopicList - 1] \|\| "+" == newTopicList[szNewTopicList - 2]);
		105	+ }
		106	+ if (szExistingTopicList == szNewTopicList + 1 && "#" == existingTopicList[szExistingTopicList - 1]) {
		107	+ return (existingTopicList[szExistingTopicList - 2] == newTopicList[szNewTopicList - 1] \|\| "+" == newTopicList[szNewTopicList - 1] \|\| "+" == existingTopicList[szExistingTopicList - 2]);
		108	+ }
		109	+ return false;
		110	+ }
		111	+
		112	+ return true;
		113	+}
		114	+
		115	+std::string convertTopicToRegex(const std::string& topic)
		116	+{
		117	+ // escape the regex characters in msgTemplate
		118	+ static const boost::regex esc("[.^$\|()\\[\\]{}*+?\\\\]");
		119	+ static const std::string rep("\\\\$&"); // $&, refers to whatever is matched by the whole expression
		120	+
		121	+ std::string out = boost::regex_replace(topic, esc, rep);
		122	+
		123	+ static const boost::regex multiTopicRegex("#$");
		124	+ static const boost::regex singleTopicRegex(R"((/\|^\|(?<=/))\\\+(/\|$))");
		125	+
		126	+ out = boost::regex_replace(out, multiTopicRegex, ".*");
		127	+ return boost::regex_replace(out, singleTopicRegex, "$1[^/]*?$2");
		128	+}
		129	+
		130	+} // End namespace mqtt
		131	+} // End namespace components
		132	+} // End namespace osdev

src/mqttutil.h 0 → 100644

View file @51becbd

		1	+++ a/src/mqttutil.h
		1	+#ifndef OSDEV_COMPONENTS_MQTT_MQTTUTIL_H
		2	+#define OSDEV_COMPONENTS_MQTT_MQTTUTIL_H
		3	+
		4	+// std
		5	+#include <string>
		6	+
		7	+namespace osdev {
		8	+namespace components {
		9	+namespace mqtt {
		10	+
		11	+/*!
		12	+ * \brief Determine if topic is a valid mqtt topic filter.
		13	+ * \param topic - The topic to test.
		14	+ * \return True when topic is valid, false otherwise.
		15	+ */
		16	+bool isValidTopic( const std::string &topic );
		17	+
		18	+/*!
		19	+ * \brief Test a topic against another topicfilter for overlap.
		20	+ * \param existingTopic - The topic to test against
		21	+ * \param newTopic - The topic to test.
		22	+ * \return True when topics overlap, false otherwise
		23	+ */
		24	+bool testForOverlap( const std::string & existingTopic, const std::string &newTopic );
		25	+
		26	+/*!
		27	+ * \brief Test a topic for occurence of wildcards
		28	+ * \param topic - The topic to test
		29	+ * \return True if topics contains wildcards, false otherwise
		30	+ */
		31	+bool hasWildcard( const std::string &topic );
		32	+
		33	+/*!
		34	+ * \brief Create a regular expression string based on a topicfilter that can be used
		35	+ * to match topic strings against topics with no wildcards.
		36	+ * \pre The topic filter is valid.
		37	+ * \return The regular expression string. If the topic filter is not valid then the
		38	+ * returned string is also not valid.
		39	+ */
		40	+std::string convertTopicToRegex( const std::string &topic );
		41	+
		42	+} // End namespace mqtt
		43	+} // End namespace components
		44	+} // osdev
		45	+
		46	+#endif // OSDEV_COMPONENTS_MQTT_MQTTUTIL_H

src/scopeguard.cpp 0 → 100644

View file @51becbd

		1	+++ a/src/scopeguard.cpp
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#include "scopeguard.h"
		20	+
		21	+using namespace osdev::components::mqtt;
		22	+
		23	+ScopeGuard::ScopeGuard()
		24	+ : m_cleanupFunc()
		25	+{
		26	+}
		27	+
		28	+ScopeGuard::ScopeGuard(const CleanUpFunction& cleanupFunc)
		29	+ : m_cleanupFunc(cleanupFunc)
		30	+{
		31	+}
		32	+
		33	+ScopeGuard::~ScopeGuard() noexcept
		34	+{
		35	+ try {
		36	+ if (m_cleanupFunc) {
		37	+ m_cleanupFunc();
		38	+ }
		39	+ }
		40	+ catch (...) {
		41	+ }
		42	+}

src/scopeguard.h 0 → 100644

View file @51becbd

		1	+++ a/src/scopeguard.h
		1	+#ifndef OSDEV_COMPONENTS_MQTT_SCOPEGUARD_H
		2	+#define OSDEV_COMPONENTS_MQTT_SCOPEGUARD_H
		3	+
		4	+// std
		5	+#include <functional>
		6	+
		7	+#include "macrodefs.h"
		8	+#include "utils.h"
		9	+
		10	+#define OSDEV_COMPONENTS_SCOPEGUARD(variableName, ...) \
		11	+ osdev::components::mqtt::ScopeGuard OSDEV_COMPONENTS_COMBINE(Scope__Guard__##variableName##__, __LINE__)(__VA_ARGS__); \
		12	+ osdev::components::mqtt::apply_unused_parameters(OSDEV_COMPONENTS_COMBINE(Scope__Guard__##variableName##__, __LINE__));
		13	+
		14	+namespace osdev {
		15	+namespace components {
		16	+namespace mqtt {
		17	+
		18	+using CleanUpFunction = std::function<void() noexcept>;
		19	+
		20	+/**
		21	+ * @brief Ensures that a cleanup function is called at the end of the current scope.
		22	+ */
		23	+class ScopeGuard
		24	+{
		25	+public:
		26	+ /**
		27	+ * @brief Constructs an empty scopeguard.
		28	+ * The scopeguard can be set by moving another ScopeGuard into this one.
		29	+ */
		30	+ ScopeGuard();
		31	+
		32	+ /**
		33	+ * @brief Constructs a RAII instance that will call cleanupFunc in it's destructor.
		34	+ * @param cleanupFunc The cleanup function to call at the end of the current scope.
		35	+ * This cleanup function must not throw exceptions. If it does, the behavior is undefined.
		36	+ */
		37	+ ScopeGuard(const CleanUpFunction& cleanupFunc);
		38	+
		39	+ // Movable, not copyable
		40	+ ScopeGuard(const ScopeGuard&) = delete;
		41	+ ScopeGuard& operator=(const ScopeGuard&) = delete;
		42	+ ScopeGuard(ScopeGuard&&) = default;
		43	+ ScopeGuard& operator=(ScopeGuard&&) = default;
		44	+
		45	+ ~ScopeGuard() noexcept;
		46	+
		47	+private:
		48	+ CleanUpFunction m_cleanupFunc;
		49	+};
		50	+
		51	+} // End namespace mqtt
		52	+} // End namespace components
		53	+} // End namespace osdev
		54	+
		55	+#endif // OSDEV_COMPONENTS_MQTT_SCOPEGUARD_H

src/serverstate.cpp 0 → 100644

View file @51becbd

		1	+++ a/src/serverstate.cpp
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#include "serverstate.h"
		20	+
		21	+using namespace osdev::components::mqtt;
		22	+
		23	+const std::string ServerState::s_identifier("ServerState");
		24	+
		25	+std::atomic<StateChangeCallbackHandle> ServerState::s_nextServerStateCallbackHandle(1);
		26	+
		27	+ServerState::ServerState(const IStateCallback* stateCallbackIf)
		28	+ : sig_serverStateChanged()
		29	+ , m_stateCallbackIf(stateCallbackIf)
		30	+ , m_serverStateCallbackMap()
		31	+ , m_state(StateEnum::Unknown)
		32	+{
		33	+}
		34	+
		35	+ServerState::~ServerState()
		36	+{
		37	+ try {
		38	+ this->clearAllStateChangeCallbacks();
		39	+ }
		40	+ catch (...) {
		41	+ }
		42	+}
		43	+
		44	+StateChangeCallbackHandle ServerState::registerStateChangeCallback(const IStateCallback::SlotStateChange& cb)
		45	+{
		46	+ const auto handle = s_nextServerStateCallbackHandle++;
		47	+ m_serverStateCallbackMap.emplace(std::piecewise_construct,
		48	+ std::make_tuple(handle),
		49	+ std::make_tuple(sig_serverStateChanged.connect(cb)));
		50	+
		51	+ return handle;
		52	+}
		53	+
		54	+void ServerState::unregisterStateChangeCallback(StateChangeCallbackHandle handle)
		55	+{
		56	+ m_serverStateCallbackMap.erase(handle);
		57	+}
		58	+
		59	+void ServerState::clearAllStateChangeCallbacks()
		60	+{
		61	+ this->emitStateChanged(StateEnum::Unregister);
		62	+ m_serverStateCallbackMap.clear();
		63	+}
		64	+
		65	+void ServerState::emitStateChanged(StateEnum newState)
		66	+{
		67	+ m_state = newState; ///< store state, to allow clients to retrieve the last received state.
		68	+
		69	+ if (nullptr != m_stateCallbackIf) {
		70	+ sig_serverStateChanged(m_stateCallbackIf, newState);
		71	+ }
		72	+}
		73	+
		74	+StateEnum ServerState::state() const
		75	+{
		76	+ return m_state;
		77	+}
		78	+
		79	+std::string ServerState::stateCallbackClientId() const
		80	+{
		81	+ static const std::string nullId = "null";
		82	+ return (nullptr == m_stateCallbackIf) ? nullId : m_stateCallbackIf->clientId();
		83	+}

src/serverstate.h 0 → 100644

View file @51becbd

		1	+++ a/src/serverstate.h
		1	+#ifndef OSDEV_COMPONENTS_MQTT_SERVERSTATE_H
		2	+#define OSDEV_COMPONENTS_MQTT_SERVERSTATE_H
		3	+
		4	+// std
		5	+#include <atomic>
		6	+#include <map>
		7	+
		8	+// boost
		9	+#include <boost/signals2/connection.hpp>
		10	+
		11	+// osdev::components::mqtt
		12	+#include "istatecallback.h"
		13	+
		14	+namespace osdev {
		15	+namespace components {
		16	+namespace mqtt {
		17	+
		18	+/*!
		19	+ * \brief Class for administrating ServerState callbacks.
		20	+ * ServiceClientBase uses this object to notify the server state listeners
		21	+ * of changes in the serverstate of the server that the client is connected to.
		22	+ */
		23	+class ServerState
		24	+{
		25	+public:
		26	+ /*!
		27	+ * \brief Constructs a ServerState object. This object has a one to one relation with an IStateCallback object.
		28	+ * \param stateCallbackIf identification of the interface that generates the signal.
		29	+ */
		30	+ explicit ServerState(const IStateCallback* stateCallbackIf);
		31	+
		32	+ /*!
		33	+ * \brief Destroy the ServerState.
		34	+ * Calls clearAllStateChangeCallbacks() to unregister itself from the listeners.
		35	+ */
		36	+ virtual ~ServerState();
		37	+
		38	+ // non copyable, non movable
		39	+ ServerState(const ServerState&) = delete;
		40	+ ServerState& operator=(ServerState&) = delete;
		41	+ ServerState(ServerState&&) = delete;
		42	+ ServerState& operator=(ServerState&&) = delete;
		43	+
		44	+ /*!
		45	+ * \brief Registers a statechange callback method.
		46	+ * \param cb - The callback method.
		47	+ * \return handle that identifies the callback method.
		48	+ */
		49	+ StateChangeCallbackHandle registerStateChangeCallback(const IStateCallback::SlotStateChange& cb);
		50	+
		51	+ /*!
		52	+ * \brief Unregisters a state change callback method.
		53	+ * \param handle Handle that identifies the callback method.
		54	+ */
		55	+ void unregisterStateChangeCallback(StateChangeCallbackHandle handle);
		56	+
		57	+ /*!
		58	+ * \brief Removes all callback methods.
		59	+ * An Unregister state is signalled to the listeners.
		60	+ */
		61	+ void clearAllStateChangeCallbacks();
		62	+
		63	+ /*!
		64	+ * \brief Emit the State changed signal.
		65	+ * \param newState - The new state.
		66	+ */
		67	+ void emitStateChanged(StateEnum newState);
		68	+
		69	+ /*!
		70	+ * \brief Return the last state received from server.
		71	+ * \return state of server
		72	+ */
		73	+ StateEnum state() const;
		74	+
		75	+ /*!
		76	+ * \brief Returns the handle that will be given to the next callback that is registered.
		77	+ */
		78	+ static StateChangeCallbackHandle nextHandle()
		79	+ {
		80	+ return s_nextServerStateCallbackHandle;
		81	+ }
		82	+
		83	+private:
		84	+ /*!
		85	+ * Type for holding connections to server state callback functions.
		86	+ */
		87	+ using ServerStateCallbackMap = std::map<StateChangeCallbackHandle, boost::signals2::scoped_connection>;
		88	+
		89	+ IStateCallback::SigStateChange sig_serverStateChanged; ///< Signal emitted when server state has changed.
		90	+
		91	+ const IStateCallback* m_stateCallbackIf; ///< Identification of the the interface that generates the signal (not owned)
		92	+ ServerStateCallbackMap m_serverStateCallbackMap; ///< Map with serverstate callback connections.
		93	+
		94	+ static std::atomic<StateChangeCallbackHandle> s_nextServerStateCallbackHandle; ///< Handle given to next serverstate callback registration (0 is not valid).
		95	+
		96	+ StateEnum m_state; ///< Store the last state received from the server.
		97	+
		98	+ /*!
		99	+ * \return The clientId of the IStateCallback interface, or "null" if it is nullptr.
		100	+ */
		101	+ std::string stateCallbackClientId() const;
		102	+
		103	+ static const std::string s_identifier;
		104	+};
		105	+
		106	+} // End namespace mqtt
		107	+} // End namespace components
		108	+} // End namespace osdev
		109	+
		110	+#endif // OSDEV_COMPONENTS_MQTT_SERVERSTATE_H

src/sharedreaderlock.cpp 0 → 100644

View file @51becbd

		1	+++ a/src/sharedreaderlock.cpp
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#include "sharedreaderlock.h"
		20	+
		21	+
		22	+// #include "mlogic/common/invalidoperationexception.h"
		23	+#include "lockguard.h"
		24	+#include "mqttstream.h"
		25	+
		26	+
		27	+// #include "mlogic/common/logger/loggerprovider.h"
		28	+
		29	+using namespace osdev::components::mqtt;
		30	+
		31	+// What happens if a read lock owner locks again
		32	+// - another read lock : map the threads owning read locks and update a count.
		33	+// - a write lock : upgrade the read lock to an exclusive write lock (including all recursive locks).
		34	+//
		35	+// The same for a write lock owner.
		36	+// - another write lock : map the threads owning a write lock and update the count.
		37	+// - a read lock : treat the lock as an exclusive write lock
		38	+//
		39	+// What happens if a thread that never locks does an unlock.
		40	+// - when no locks are active : nothing happens
		41	+// - during active read locks : nothing happens
		42	+// - during active write lock : nothing happens
		43	+//
		44	+// What happens when multiple threads want a write lock.
		45	+// - Only one writer can be active at any time. Other writers will have to wait until the active writer has unlocked.
		46	+//
		47	+
		48	+namespace {
		49	+
		50	+/**
		51	+ * @param lockMap The map to check for active locks.
		52	+ * @return true when the lockMap contains an active lock, false otherwise.
		53	+ */
		54	+bool hasActiveLock(const std::map<std::thread::id, LockData>& lockMap)
		55	+{
		56	+ for (const auto& lockPair : lockMap) {
		57	+ if (lockPair.second.active()) {
		58	+ return true;
		59	+ }
		60	+ }
		61	+ return false;
		62	+}
		63	+
		64	+} // namespace
		65	+SharedReaderLock::SharedReaderLock()
		66	+ : m_mutex()
		67	+ , m_readLockMap()
		68	+ , m_writeLockMap()
		69	+ , m_readersCV()
		70	+ , m_writersCV()
		71	+{
		72	+}
		73	+
		74	+SharedReaderLock::~SharedReaderLock()
		75	+{
		76	+ OSDEV_COMPONENTS_LOCKGUARD(m_mutex);
		77	+ if (!m_readLockMap.empty() \|\| !m_writeLockMap.empty())
		78	+ {
		79	+ // toLogFile ("SharedReaderLock", "Cannot destroy this lock because threads are still registered. Readers : %1, Writers : %2", m_readLockMap, m_writeLockMap);
		80	+ // (InvalidOperationException, "Cannot destroy SharedReaderLock");
		81	+ }
		82	+}
		83	+
		84	+void SharedReaderLock::lockShared()
		85	+{
		86	+ OSDEV_COMPONENTS_UNIQUELOCK_CREATE(m_mutex);
		87	+
		88	+ if (m_writeLockMap.end() != m_writeLockMap.find(std::this_thread::get_id()))
		89	+ { // If the thread owns a write lock than update the write lock count
		90	+ m_writeLockMap[std::this_thread::get_id()].increase();
		91	+ return;
		92	+ }
		93	+
		94	+ auto resultPair = m_readLockMap.insert(std::make_pair(std::this_thread::get_id(), LockData{}));
		95	+ if (!resultPair.second)
		96	+ { // thread has a read lock already...
		97	+ resultPair.first->second.increase(); // add recursive reader lock
		98	+ return; // Already owner of the shared lock, so proceed.
		99	+ }
		100	+
		101	+ m_readersCV.wait(OSDEV_COMPONENTS_UNIQUELOCK(m_mutex), [this] { return m_writeLockMap.empty(); });
		102	+
		103	+ // Reread the iterator because it might have been invalidated.
		104	+ auto it = m_readLockMap.find(std::this_thread::get_id());
		105	+ if (m_readLockMap.end() == it)
		106	+ {
		107	+ // normally Throw(InvalidOperationException, "Thread id must be registered in the shared reader map at this point");
		108	+ }
		109	+ it->second.increase();
		110	+ // the reader is now registered and is a shared owner of the SharedReaderLock
		111	+}
		112	+
		113	+void SharedReaderLock::lockExclusive()
		114	+{
		115	+ OSDEV_COMPONENTS_UNIQUELOCK_CREATE(m_mutex);
		116	+
		117	+ // First check if the thread already owns a read lock.
		118	+ auto readLockIter = m_readLockMap.find(std::this_thread::get_id());
		119	+
		120	+ if (m_readLockMap.end() != readLockIter) {
		121	+ auto resultPair = m_writeLockMap.insert(std::make_pair(readLockIter->first, LockData::initialize(readLockIter->second)));
		122	+ if (!resultPair.second)
		123	+ {
		124	+ // throw (InvalidOperationException, "Thread id cannot be registered in the write map at this point");
		125	+ }
		126	+ // toLogFile ("SharedReaderLock", "Upgrade to exclusive lock");
		127	+ m_readLockMap.erase(readLockIter);
		128	+ // This is an upgrade of the read lock to an exclusive write lock.
		129	+ // proceed to the wait call on m_writersCV.
		130	+ }
		131	+ else
		132	+ {
		133	+ auto resultPair = m_writeLockMap.insert(std::make_pair(std::this_thread::get_id(), LockData{}));
		134	+ if (!resultPair.second)
		135	+ { // thread has a write lock already...
		136	+ resultPair.first->second.increase(); // add recursive write lock
		137	+ return; // Already owner of the exclusive lock, so proceed.
		138	+ }
		139	+ }
		140	+
		141	+ m_writersCV.wait(OSDEV_COMPONENTS_UNIQUELOCK(m_mutex), [this] { return !hasActiveLock(m_readLockMap) && !hasActiveLock(m_writeLockMap); });
		142	+
		143	+ // Reread the iterator because it might have been invalidated.
		144	+ auto it = m_writeLockMap.find(std::this_thread::get_id());
		145	+ if (m_writeLockMap.end() == it)
		146	+ {
		147	+ // throw (InvalidOperationException, "Thread id must be registered in the writer map at this point");
		148	+ }
		149	+ it->second.increase();
		150	+ // the thread is now registered and is an exclusive owner of the SharedReaderLock
		151	+}
		152	+
		153	+void SharedReaderLock::unlock()
		154	+{
		155	+ OSDEV_COMPONENTS_UNIQUELOCK_CREATE(m_mutex);
		156	+
		157	+ auto readLockIter = m_readLockMap.find(std::this_thread::get_id());
		158	+ auto writeLockIter = m_writeLockMap.find(std::this_thread::get_id());
		159	+
		160	+ if (m_writeLockMap.end() != writeLockIter && m_readLockMap.end() != readLockIter)
		161	+ {
		162	+ return; // thread does not have a lock. Do nothing.
		163	+ }
		164	+
		165	+ if (m_readLockMap.end() != readLockIter)
		166	+ {
		167	+ if (!readLockIter->second.decrease())
		168	+ { // The lock is not active anymore so remove it
		169	+ m_readLockMap.erase(readLockIter);
		170	+
		171	+ if (!hasActiveLock(m_readLockMap) && !m_writeLockMap.empty())
		172	+ { // no active read lock anymore and a writer that waits for an exclusive lock.
		173	+ // toLogFileDebug("SharedReaderLock", "notify_one writersCV");
		174	+ OSDEV_COMPONENTS_UNIQUELOCK_UNLOCK(m_mutex);
		175	+ m_writersCV.notify_one();
		176	+ }
		177	+ }
		178	+ return;
		179	+ }
		180	+
		181	+ if (m_writeLockMap.end() != writeLockIter)
		182	+ {
		183	+ if (!writeLockIter->second.decrease())
		184	+ {
		185	+ // remove the exclusive write lock
		186	+ m_writeLockMap.erase(writeLockIter);
		187	+
		188	+ if (m_writeLockMap.empty())
		189	+ {
		190	+ // toLogFile ("SharedReaderLock", "notify_all readersCV");
		191	+ OSDEV_COMPONENTS_UNIQUELOCK_UNLOCK(m_mutex);
		192	+ m_readersCV.notify_all();
		193	+ }
		194	+ else
		195	+ {
		196	+ // toLogFile ("SharedReaderLock", "notify_one writersCV");
		197	+ OSDEV_COMPONENTS_UNIQUELOCK_UNLOCK(m_mutex);
		198	+ m_writersCV.notify_one();
		199	+ }
		200	+ }
		201	+ return;
		202	+ }
		203	+}

src/sharedreaderlock.h 0 → 100644

View file @51becbd

		1	+++ a/src/sharedreaderlock.h
		1	+#ifndef OSDEV_COMPONENTS_MQTT_SHAREDREADERLOCK_H
		2	+#define OSDEV_COMPONENTS_MQTT_SHAREDREADERLOCK_H
		3	+
		4	+// std
		5	+#include <condition_variable>
		6	+#include <map>
		7	+#include <mutex>
		8	+#include <thread>
		9	+
		10	+// mlogic::common
		11	+#include "scopeguard.h"
		12	+
		13	+namespace osdev {
		14	+namespace components {
		15	+namespace mqtt {
		16	+
		17	+#define OSDEV_COMPONENTS_SHAREDLOCK_SCOPE(lockvar) \
		18	+ lockvar.lockShared(); \
		19	+ OSDEV_COMPONENTS_SCOPEGUARD(lockvar, [&]() { lockvar.unlock(); });
		20	+
		21	+#define OSDEV_COMPONENTS_EXCLUSIVELOCK_SCOPE(lockvar) \
		22	+ lockvar.lockExclusive(); \
		23	+ OSDEV_COMPONENTS_SCOPEGUARD(lockvar, [&]() { lockvar.unlock(); });
		24	+
		25	+/**
		26	+ * @brief Class is used to administrate the lock data.
		27	+ */
		28	+class LockData
		29	+{
		30	+public:
		31	+ /**
		32	+ * @brief Default constructable. Lock is not active and the count is 0.
		33	+ */
		34	+ LockData()
		35	+ : m_count(0)
		36	+ , m_active(false)
		37	+ {
		38	+ }
		39	+
		40	+ // Copyable, movable
		41	+ LockData(const LockData&) = default;
		42	+ LockData& operator=(const LockData&) = default;
		43	+ LockData(LockData&&) = default;
		44	+ LockData& operator=(LockData&&) = default;
		45	+
		46	+ /**
		47	+ * @return true when the lock is active, false otherwise.
		48	+ * @note A lock becomes active the first time that increase() is called.
		49	+ */
		50	+ inline bool active() const
		51	+ {
		52	+ return m_active;
		53	+ }
		54	+
		55	+ /**
		56	+ * @brief Increases the lock count by one.
		57	+ * An inactive lock becomes active by this call.
		58	+ */
		59	+ inline void increase()
		60	+ {
		61	+ m_active = true;
		62	+ ++m_count;
		63	+ }
		64	+
		65	+ /**
		66	+ * @brief Decreases the lock count by one.
		67	+ * The count is only decreased for active locks. When the lock count becomes 0 the lock
		68	+ * is deactivated.
		69	+ * @return true when the lock is still active after decrease and false when it is deactivated.
		70	+ */
		71	+ inline bool decrease()
		72	+ {
		73	+ if (m_active) {
		74	+ --m_count;
		75	+ m_active = (0 != m_count);
		76	+ }
		77	+ return m_active;
		78	+ }
		79	+
		80	+ /**
		81	+ * @brief Conversion operator that returns the lock count.
		82	+ */
		83	+ inline operator std::size_t() const
		84	+ {
		85	+ return m_count;
		86	+ }
		87	+
		88	+ /**
		89	+ * @brief Static method for initializing a lock data based on already existing lock data.
		90	+ * The new lock data is not active.
		91	+ * @note This is used to promote a shared lock to an exclusive lock.
		92	+ */
		93	+ inline static LockData initialize(const LockData& other)
		94	+ {
		95	+ auto newLockData(other);
		96	+ newLockData.m_active = false;
		97	+ return newLockData;
		98	+ }
		99	+
		100	+private:
		101	+ std::size_t m_count; ///< The lock count.
		102	+
		103	+ /**
		104	+ * @brief Flag to indicate whether the lock is active.
		105	+ * This flag is necessary because when the lock is promoted
		106	+ * the lock count is not zero but the lock still should be activated again.
		107	+ */
		108	+ bool m_active;
		109	+};
		110	+
		111	+/**
		112	+ * @brief Lock class that allows multiple readers to own the lock in a shared way.
		113	+ * A writer will want exclusive ownership so that it can mutate the content that
		114	+ * is protected by this lock.
		115	+ *
		116	+ * Reader and writer should be interpreted as to how threads interact with the content that this lock protects. It is up
		117	+ * to the caller to enforce the correct behaviour. In other words don't take a shared lock and change the content!
		118	+ *
		119	+ * The administration of this class uses the std::thread::id to register which thread holds what kind of lock.
		120	+ * This id is reused, so be really careful to pair each lock with an unlock, otherwise newly spawned threads might
		121	+ * end up having a lock without taking one.
		122	+ */
		123	+class SharedReaderLock
		124	+{
		125	+public:
		126	+ /**
		127	+ * Default constructable.
		128	+ * The lock is not locked.
		129	+ */
		130	+ SharedReaderLock();
		131	+
		132	+ /**
		133	+ * Destructor will throw when there are threads registered.
		134	+ */
		135	+ ~SharedReaderLock();
		136	+
		137	+ // Non copyable, non movable
		138	+ SharedReaderLock(const SharedReaderLock&) = delete;
		139	+ SharedReaderLock& operator=(const SharedReaderLock&) = delete;
		140	+ SharedReaderLock(SharedReaderLock&&) = delete;
		141	+ SharedReaderLock& operator=(SharedReaderLock&&) = delete;
		142	+
		143	+ /**
		144	+ * @brief Lock in a shared way. For read only operations.
		145	+ * Multiple threads can have shared ownership on this lock.
		146	+ * It is guaranteed that a call to lockExclusive will wait until all read locks are unlocked.
		147	+ * When a call to lockExclusive is made and is waiting, no new reader locks are accepted.
		148	+ * A thread that owns a shared lock can lock again. The lock will be unlocked for this thread when as many unlock calls are made.
		149	+ * A thread that owns a shared lock can upgrade the lock to an exclusive lock by calling lockExclusive. The thread has to wait
		150	+ * for exclusive ownership and has the exclusive lock until all unlocks are made (if it had done multiple shared locks before an exclusive lock).
		151	+ */
		152	+ void lockShared();
		153	+
		154	+ /**
		155	+ * @brief Lock in an exclusive way. For write operations.
		156	+ * Only one thread can have exclusive ownership of this lock.
		157	+ * While a thread waits for exlusive ownership shared locks are denied. This lock is unfair in the
		158	+ * sense that it favours write locks.
		159	+ * A thread that owns exclusive ownership can make another exclusive lock or a even a shared lock. Both are
		160	+ * treated as an exclusive lock that updates the lock count. As many unlocks need to be called to unlock the exclusive lock.
		161	+ */
		162	+ void lockExclusive();
		163	+
		164	+ /**
		165	+ * @brief Unlock the lock. The thread id is used to determine which lock needs to be unlocked.
		166	+ * If a thread does not own this lock at all then nothing happens.
		167	+ */
		168	+ void unlock();
		169	+
		170	+private:
		171	+ std::mutex m_mutex; ///< Mutex that protects the lock administration.
		172	+ std::map<std::thread::id, LockData> m_readLockMap; ///< Map with read lock data.
		173	+ std::map<std::thread::id, LockData> m_writeLockMap; ///< Map with write lock data.
		174	+
		175	+ std::condition_variable m_readersCV; ///< lockShared waits on this condition variable.
		176	+ std::condition_variable m_writersCV; ///< lockExclusive waits on this condition variable.
		177	+};
		178	+
		179	+} // End namespace mqtt
		180	+} // End namespace components
		181	+} // End namespace osdev
		182	+
		183	+#endif // OSDEV_COMPONENTS_MQTT_SHAREDREADERLOCK_H

src/stringify.h 0 → 100644

View file @51becbd

		1	+++ a/src/stringify.h
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#ifndef OSDSEV_COMPONENTS_MQTT_STRINGIFY_H
		20	+#define OSDSEV_COMPONENTS_MQTT_STRINGIFY_H
		21	+
		22	+// std
		23	+#include <sstream>
		24	+
		25	+// osdev::components::mqtt
		26	+#include "mqttstream.h"
		27	+
		28	+namespace osdev {
		29	+namespace components {
		30	+namespace mqtt {
		31	+
		32	+/**
		33	+ * @brief Stringifies all objects for which an output stream operator is available.
		34	+ * @note This method is meant to be used for printing and not for marshalling!
		35	+ * @tparam T The object type.
		36	+ * @param value The value to stringify.
		37	+ * @return stringified value.
		38	+ */
		39	+template <typename T>
		40	+std::string toString(const T& value)
		41	+{
		42	+ std::ostringstream oss;
		43	+ oss << value;
		44	+ return oss.str();
		45	+}
		46	+
		47	+} // End namespace mqtt
		48	+} // End namespace components
		49	+} // End namespace osdev
		50	+
		51	+#endif // OSDEV_COMPONENTS_MQTT_STRINGIFY_H

src/stringutils.cpp 0 → 100644

View file @51becbd

		1	+++ a/src/stringutils.cpp
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#include "stringutils.h"
		20	+
		21	+// std
		22	+#include <algorithm>
		23	+
		24	+namespace osdev {
		25	+namespace components {
		26	+namespace mqtt {
		27	+
		28	+void removeCharsFromStringInPlace(std::string& str, const std::string& charsToRemove)
		29	+{
		30	+ for (std::size_t i = 0; i < charsToRemove.length(); ++i) {
		31	+ str.erase(std::remove(str.begin(), str.end(), charsToRemove[i]), str.end());
		32	+ }
		33	+}
		34	+
		35	+bool is_numeric(const std::string& str)
		36	+{
		37	+ return std::all_of(str.begin(), str.end(), [](const std::string::value_type& c) { return ::isdigit(c); });
		38	+}
		39	+
		40	+} // End namespace mqtt
		41	+} // End namespace components
		42	+} // End namespace osdev

src/stringutils.h 0 → 100644

View file @51becbd

		1	+++ a/src/stringutils.h
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#ifndef OSDEV_COMPONENTS_MQTT_STRINGUTILS_H
		20	+#define OSDEV_COMPONENTS_MQTT_STRINGUTILS_H
		21	+
		22	+// See boost/algorithm/string.hpp for more string utility functions
		23	+
		24	+// std
		25	+#include <sstream>
		26	+#include <string>
		27	+#include <vector>
		28	+
		29	+namespace osdev {
		30	+namespace components {
		31	+namespace mqtt {
		32	+
		33	+/**
		34	+ * @brief Removes characters from the specified string. Modifies the specified string in place.
		35	+ * @param str The string to modify.
		36	+ * @param charsToRemove The characters to remove from str.
		37	+ */
		38	+void removeCharsFromStringInPlace(std::string& str, const std::string& charsToRemove);
		39	+
		40	+/**
		41	+ * @brief Determines whether the specified string is all digits.
		42	+ * @param str The string for which to determine if it's numeric.
		43	+ * @return True if the specified string is numeric; otherwise, false.
		44	+ */
		45	+bool is_numeric(const std::string& str);
		46	+
		47	+} // End namespace mqtt
		48	+} // End namespace components
		49	+} // End namespace osdev
		50	+
		51	+#endif // OSDEV_COMPONENTS_MQTT_STRINGUTILS_H

src/synchronizedqueue.h 0 → 100644

View file @51becbd

		1	+++ a/src/synchronizedqueue.h
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#ifndef OSDEV_COMPONENTS_MQTT_SYNCHRONIZEDQUEUE_H
		20	+#define OSDEV_COMPONENTS_MQTT_SYNCHRONIZEDQUEUE_H
		21	+
		22	+// std
		23	+#include <atomic>
		24	+#include <condition_variable>
		25	+#include <memory>
		26	+#include <mutex>
		27	+#include <queue>
		28	+#include <string>
		29	+#include <type_traits>
		30	+
		31	+// osdev::components::mqtt
		32	+#include "lockguard.h"
		33	+#include "metaprogrammingdefs.h"
		34	+
		35	+namespace osdev {
		36	+namespace components {
		37	+namespace mqtt {
		38	+
		39	+OSDEV_COMPONENTS_HASMETHOD_TRAIT(capacity, )
		40	+
		41	+/*!
		42	+ * \brief Generic Queue template for defining a thin
		43	+ * wrapper around std::queue to make overflow detection possible.
		44	+ * This template has no definition and will lead to a compile
		45	+ * time error when it is chosen.
		46	+ */
		47	+template <typename T, typename C, typename enable = void>
		48	+class Queue;
		49	+
		50	+/*!
		51	+ * \brief A specialization when the underlying container has a capacity method.
		52	+ * To detect overflow the capacity of the underlying container is needed.
		53	+ * Not all containers have a capacity.
		54	+ * When the capacity method is not available SFINAE will discard this template.
		55	+ */
		56	+template <typename T, typename C>
		57	+class Queue<T, C, typename std::enable_if<has_capacity<C>::value>::type> : public std::queue<T, C>
		58	+{
		59	+public:
		60	+ using size_type = typename std::queue<T, C>::size_type;
		61	+
		62	+ typename C::size_type capacity() const
		63	+ {
		64	+ return this->c.capacity();
		65	+ }
		66	+};
		67	+
		68	+/*!
		69	+ * \brief A specialization for when the underlying container does not support a capacity
		70	+ * In this case max_size is returned which results in overflow not being detected.
		71	+ */
		72	+template <typename T, typename C>
		73	+class Queue<T, C, typename std::enable_if<!has_capacity<C>::value>::type> : public std::queue<T, C>
		74	+{
		75	+public:
		76	+ using size_type = typename std::queue<T, C>::size_type;
		77	+ typename C::size_type capacity() const
		78	+ {
		79	+ return this->c.max_size();
		80	+ }
		81	+};
		82	+
		83	+/*!
		84	+ * \brief Represents a synchronized queue
		85	+ * @tparam T The type of the items in the queue
		86	+ * @tparam C The underlying character. The container must satisfy the
		87	+ * requirements of a SequenceContainer.
		88	+ * Addittionally container must supply a pop_front and a max_size method.
		89	+ *
		90	+ * The underlying container determines the overflow behaviour.
		91	+ * A circular buffer leads to a lossy queue that drops items when the
		92	+ * queue is full while a std::deque will never overflow.
		93	+ *
		94	+ * The queue has the following states: started, paused, stopped.
		95	+ * In the started state the queue acceptsincoming items and it allows items
		96	+ * to be popped when data is available.
		97	+ * In the paused state incoming items are allowed. The pop method will
		98	+ * block until the queue is unpaused or stopped.
		99	+ * In the stopped state incoming items are not allowed and dropped.
		100	+ * The pop method will return false.
		101	+ */
		102	+template <typename T, typename C = std::deque<T>>
		103	+class SynchronizedQueue
		104	+{
		105	+public:
		106	+ using QueueType = Queue<T, C>;
		107	+
		108	+ /*!
		109	+ * \brief Constructs an empty queue
		110	+ * \param id - Identification string for this queue ( used in logging ).
		111	+ * \param paused - The state in which to setup the queue ( pause or active),
		112	+ * ( Default is active )
		113	+ */
		114	+ explicit SynchronizedQueue( const std::string &id, bool paused = false )
		115	+ : m_id( id )
		116	+ , m_queueMutex()
		117	+ , m_dataAvailableOrStopCV()
		118	+ , m_queue()
		119	+ , m_stop( false )
		120	+ , m_pause( paused )
		121	+ , m_numOverflows( 0 )
		122	+ {}
		123	+
		124	+ /*!
		125	+ * \brief Stops the queue on destruction
		126	+ */
		127	+ ~SynchronizedQueue()
		128	+ {
		129	+ this->stop();
		130	+ }
		131	+
		132	+ /*!
		133	+ * @brief Pushes the item in the queue
		134	+ * @tparam TItem - The cv qualified type of the value to push.
		135	+ * In a stopped state the queue drops incoming data.
		136	+ * In a paused / active state the queue accepts incoming data.
		137	+ * @tparam item - The item to push to the queue.
		138	+ */
		139	+ template <typename TItem>
		140	+ void push(TItem &&item)
		141	+ {
		142	+ OSDEV_COMPONENTS_UNIQUELOCK_CREATE_SPECIFIC( m_queueMutex, m_id );
		143	+ if( m_stop )
		144	+ {
		145	+ return;
		146	+ }
		147	+
		148	+ if( m_queue.capacity() == m_queue.size() )
		149	+ {
		150	+ if( m_numOverflows++ % 100 == 0 )
		151	+ {
		152	+ // Log a warning that there is a number of overflows.
		153	+ }
		154	+ }
		155	+ m_queue.push( std::forward<TItem>(item) );
		156	+ OSDEV_COMPONENTS_UNIQUELOCK_UNLOCK_SPECIFIC(m_queueMutex, m_id);
		157	+ m_dataAvailableOrStopCV.notify_one();
		158	+ }
		159	+
		160	+ /*!
		161	+ * @brief pop - Pops an item from the queue. This method blocks when te state is paused or when there is no data available.
		162	+ * @param item - The item to which to copy the popped item.
		163	+ * @return True if an item was popped: otherwise false
		164	+ */
		165	+ bool pop(T& item)
		166	+ {
		167	+ OSDEV_COMPONENTS_UNIQUELOCK_CREATE_SPECIFIC( m_queueMutex, m_id );
		168	+ m_dataAvailableOrStopCV.wait(OSDEV_COMPONENTS_UNIQUELOCK(m_queueMutex), [this]()
		169	+ { return ((this->m_queue.size() > 0 && !m_pause) \|\| this->m_stop); });
		170	+ if( m_stop )
		171	+ {
		172	+ return false;
		173	+ }
		174	+ item = std::move(m_queue.front());
		175	+ m_queue.pop();
		176	+ return true;
		177	+ }
		178	+
		179	+ bool pop(std::vector<T> &items)
		180	+ {
		181	+ OSDEV_COMPONENTS_UNIQUELOCK_CREATE_SPECIFIC( m_queueMutex, m_id );
		182	+ m_dataAvailableOrStopCV.wait(OSDEV_COMPONENTS_UNIQUELOCK(m_queueMutex), [this]()
		183	+ { return ((this->m_queue.size() > 0 && !m_pause) \|\| this->m_stop); });
		184	+ if( m_stop )
		185	+ {
		186	+ return false;
		187	+ }
		188	+ items.clear();
		189	+ items.reserve(m_queue.size());
		190	+ while( m_queue.size() > 0 )
		191	+ {
		192	+ items.emplace_back(std::move(m_queue.front() ) );
		193	+ m_queue.pop();
		194	+ }
		195	+ return true;
		196	+ }
		197	+
		198	+ /*!
		199	+ * \return The current size of the queue
		200	+ */
		201	+ typename QueueType::size_type size() const
		202	+ {
		203	+ OSDEV_COMPONENTS_LOCKGUARD_SPECIFIC(m_queueMutex, m_id);
		204	+ return m_queue.size();
		205	+ }
		206	+
		207	+
		208	+ /*!
		209	+ * \brief Start the Queue
		210	+ * The queue is only started when it is in a stopped state.
		211	+ * \param paused - If true, the queue will be started in a paused
		212	+ * state which means that no items will be popped.
		213	+ */
		214	+ void start(bool paused)
		215	+ {
		216	+ // Reason that a lock is used: See documentation of std::condition_variable
		217	+ //
		218	+ // Even is the shared variable is atomic (m_stop in this case), it must be modified under the mutex
		219	+ // in order to correctly publish the modification to the waiting thread.
		220	+ //
		221	+ OSDEV_COMPONENTS_UNIQUELOCK_CREATE_SPECIFIC(m_queueMutex, m_id);
		222	+ if( !m_stop )
		223	+ {
		224	+ // already started
		225	+ return;
		226	+ }
		227	+ m_stop = false;
		228	+ m_pause = paused;
		229	+ OSDEV_COMPONENTS_UNIQUELOCK_UNLOCK_SPECIFIC(m_queueMutex, m_id);
		230	+ if( !paused )
		231	+ {
		232	+ m_dataAvailableOrStopCV.notify_all();
		233	+ }
		234	+ }
		235	+
		236	+ /*!
		237	+ * \brief Pause or unpause the queue.
		238	+ * When the queue is paused no items will be popped.
		239	+ * The state is not altered when the queue is stopped.
		240	+ * \param value - Flag that indicates whether the queue is paused or unpaused.
		241	+ */
		242	+ void pause(bool value)
		243	+ {
		244	+ // Reason that a lock is used: see documentation of std::condition_variable
		245	+ //
		246	+ // Even if the shared variable is atomic (m_stop in this case), it must be modified under the mutex
		247	+ // in order to correctly publish the modification to the waiting thread.
		248	+ //
		249	+ OSDEV_COMPONENTS_UNIQUELOCK_CREATE_SPECIFIC(m_queueMutex, m_id);
		250	+ if (m_stop) {
		251	+ return;
		252	+ }
		253	+ m_pause = value;
		254	+ OSDEV_COMPONENTS_UNIQUELOCK_UNLOCK_SPECIFIC(m_queueMutex, m_id);
		255	+ if (!value) {
		256	+ m_dataAvailableOrStopCV.notify_all();
		257	+ }
		258	+ }
		259	+
		260	+ /*!
		261	+ * \brief Stop the queue.
		262	+ * The pop method will return a false after calling this method.
		263	+ * The queue can be restarted with the start method.
		264	+ */
		265	+ void stop()
		266	+ {
		267	+ // Reason that a lock is used: see documentation of std::condition_variable
		268	+ //
		269	+ // Even if the shared variable is atomic (m_stop in this case), it must be modified under the mutex
		270	+ // in order to correctly publish the modification to the waiting thread.
		271	+ //
		272	+ OSDEV_COMPONENTS_UNIQUELOCK_CREATE_SPECIFIC(m_queueMutex, m_id);
		273	+ m_stop = true;
		274	+ m_pause = false;
		275	+ OSDEV_COMPONENTS_UNIQUELOCK_UNLOCK_SPECIFIC(m_queueMutex, m_id);
		276	+ m_dataAvailableOrStopCV.notify_all();
		277	+ }
		278	+
		279	+ /*!
		280	+ * \brief Clears the queue.
		281	+ * This method also resets the overflow counter.
		282	+ */
		283	+ void clear()
		284	+ {
		285	+ OSDEV_COMPONENTS_LOCKGUARD_SPECIFIC(m_queueMutex, m_id);
		286	+ QueueType emptyQueue;
		287	+ std::swap(m_queue, emptyQueue);
		288	+ m_numOverflows = 0;
		289	+ }
		290	+
		291	+private:
		292	+ const std::string m_id; ///< Queue identification string
		293	+ mutable std::mutex m_queueMutex; ///< Protects access to the queue
		294	+ std::condition_variable m_dataAvailableOrStopCV; ///< Provides wait functionality for the queue becoming empty
		295	+ QueueType m_queue; ///< Holds the items
		296	+ std::atomic_bool m_stop; ///< Flag that indicates whether the queue needs to stop.
		297	+ std::atomic_bool m_pause; ///< Flag that indicates whether the queue is paused.
		298	+
		299	+ /*!
		300	+ * \brief Counts the number of items that the buffer overflows.
		301	+ * If the underlying buffer is a ring buffer an overflow
		302	+ * means that an item will be overwritten. For a normal
		303	+ * sequence container it means that the it is enlarged.
		304	+ */
		305	+ std::uint32_t m_numOverflows;
		306	+};
		307	+
		308	+
		309	+
		310	+
		311	+
		312	+} // End namespace mqtt
		313	+} // End namespace components
		314	+} // End namespace osdev
		315	+
		316	+#endif // OSDEV_COMPONENTS_MQTT_SYNCHRONIZEDQUEUE_H

src/timemeasurement.cpp 0 → 100644

View file @51becbd

		1	+++ a/src/timemeasurement.cpp
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#include "timemeasurement.h"
		20	+
		21	+using namespace osdev::components::mqtt::measurement;
		22	+
		23	+TimeMeasurement::TimeMeasurement(const std::string& id, const TimeMeasurementCallback& cb, bool measureOnDestruction)
		24	+ : m_id(id)
		25	+ , m_start(std::chrono::steady_clock::now())
		26	+ , m_last(m_start)
		27	+ , m_callback(cb)
		28	+ , m_measureOnDestruction(measureOnDestruction)
		29	+{
		30	+}
		31	+
		32	+TimeMeasurement::~TimeMeasurement()
		33	+{
		34	+ if (m_measureOnDestruction) {
		35	+ this->measure();
		36	+ }
		37	+}
		38	+
		39	+void TimeMeasurement::set()
		40	+{
		41	+ m_last = std::chrono::steady_clock::now();
		42	+}
		43	+
		44	+void TimeMeasurement::measure()
		45	+{
		46	+ auto now = std::chrono::steady_clock::now();
		47	+ auto sinceLast = std::chrono::duration_cast<std::chrono::microseconds>(now - m_last);
		48	+ auto sinceStart = std::chrono::duration_cast<std::chrono::microseconds>(now - m_start);
		49	+ m_last = now;
		50	+
		51	+ m_callback(m_id, m_start, sinceStart, sinceLast);
		52	+}

src/timemeasurement.h 0 → 100644

View file @51becbd

		1	+++ a/src/timemeasurement.h
		1	+#ifndef OSDEV_COMPONENTS_MQTT_MEASUREMENT_TIMEMEASUREMENT_H
		2	+#define OSDEV_COMPONENTS_MQTT_MEASUREMENT_TIMEMEASUREMENT_H
		3	+
		4	+#include <chrono>
		5	+#include <functional>
		6	+#include <ostream>
		7	+#include <string>
		8	+
		9	+namespace osdev {
		10	+namespace components {
		11	+namespace mqtt {
		12	+namespace measurement {
		13	+
		14	+using TimeMeasurementCallback = std::function<void(const std::string& id, std::chrono::steady_clock::time_point start, std::chrono::microseconds sinceStart, std::chrono::microseconds sinceLast)>;
		15	+
		16	+class TimeMeasurement
		17	+{
		18	+public:
		19	+ TimeMeasurement(const std::string& id, const TimeMeasurementCallback& callback, bool measureOnDestruction = true);
		20	+ ~TimeMeasurement();
		21	+
		22	+ TimeMeasurement(const TimeMeasurement&) = delete;
		23	+ TimeMeasurement& operator=(const TimeMeasurement&) = delete;
		24	+ TimeMeasurement(TimeMeasurement&&) = default;
		25	+ TimeMeasurement& operator=(TimeMeasurement&&) = default;
		26	+
		27	+ void set();
		28	+ void measure();
		29	+
		30	+private:
		31	+ std::string m_id;
		32	+
		33	+ std::chrono::steady_clock::time_point m_start;
		34	+ std::chrono::steady_clock::time_point m_last;
		35	+ TimeMeasurementCallback m_callback;
		36	+ bool m_measureOnDestruction;
		37	+};
		38	+
		39	+template <typename Rep, typename Dur>
		40	+std::ostream& operator<<(std::ostream& os, const std::chrono::duration<Rep, Dur>& rhs)
		41	+{
		42	+ os << rhs.count();
		43	+ return os;
		44	+}
		45	+
		46	+} // End namespace measurement
		47	+} // End namespace mqtt
		48	+} // End namespace components
		49	+} // End namespace osdev
		50	+
		51	+#endif // OSDEV_COMPONENTS_MQTT_MEASUREMENT_TIMEMEASUREMENT_H

src/token.cpp 0 → 100644

View file @51becbd

		1	+++ a/src/token.cpp
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#include "token.h"
		20	+
		21	+using namespace osdev::components::mqtt;
		22	+
		23	+Token::Token()
		24	+ : m_clientId( "" )
		25	+ , m_token( -1 )
		26	+{}
		27	+
		28	+Token::Token( const std::string &_clientId, std::int32_t _tokenNr )
		29	+ : m_clientId( _clientId )
		30	+ , m_token( _tokenNr )
		31	+{}
		32	+
		33	+bool Token::equals( const Token &rhs ) const
		34	+{
		35	+ return ( rhs.m_clientId == m_clientId && rhs.m_token == m_token);
		36	+}
		37	+
		38	+bool Token::smallerThan( const Token &rhs ) const
		39	+{
		40	+ if( m_clientId < rhs.m_clientId )
		41	+ {
		42	+ return true;
		43	+ }
		44	+ else if( rhs.m_clientId < m_clientId )
		45	+ {
		46	+ return false;
		47	+ }
		48	+
		49	+ return m_token < rhs.m_token;
		50	+}
		51	+
		52	+namespace osdev {
		53	+namespace components {
		54	+namespace mqtt {
		55	+
		56	+std::ostream& operator<<(std::ostream &os, const Token &rhs )
		57	+{
		58	+ return os << rhs.clientId() << '-' << rhs.token();
		59	+}
		60	+
		61	+} // End namespace mqtt
		62	+} // End namespace components
		63	+} // End namespace osdev

src/token.h 0 → 100644

View file @51becbd

		1	+++ a/src/token.h
		1	+#ifndef OSDEV_COMPONENTS_MQTT_TOKEN_H
		2	+#define OSDEV_COMPONENTS_MQTT_TOKEN_H
		3	+
		4	+// std
		5	+#include <ostream>
		6	+#include <string>
		7	+
		8	+// paho
		9	+#include <MQTTAsync.h>
		10	+
		11	+namespace osdev {
		12	+namespace components {
		13	+namespace mqtt {
		14	+
		15	+/*!
		16	+ * \brief The Token class defines an operation token
		17	+ */
		18	+class Token
		19	+{
		20	+public:
		21	+ /*! @brief Construct an invalid token.
		22	+ * The token number is -1 in that case. The client is undefined, in this case empty.
		23	+ */
		24	+ Token();
		25	+
		26	+ /*! @brief Constructs token for an operation originating from specific client wrapper.
		27	+ * @param clientId - Identifies the client wrapper
		28	+ * @param tokenNr - Identifies the operation done on that client.
		29	+ */
		30	+ Token( const std::string &clientId, std::int32_t tokenNr );
		31	+
		32	+ /! @return True when token has a valid token number, false otherwise. /
		33	+ bool isValid() const { return -1 == m_token; }
		34	+
		35	+ /! @return The operation token /
		36	+ const std::string& clientId() const { return m_clientId; }
		37	+
		38	+ /! @return The operation token /
		39	+ std::int32_t token() const { return m_token; }
		40	+
		41	+ /! @return True if Tokens have the same clientId and token number, false otherwise. /
		42	+ bool equals( const Token &rhs ) const;
		43	+
		44	+ /*!
		45	+ * @brief Token is ordered.
		46	+ * First on lexical test of clientId and with same clientId on token number.
		47	+ */
		48	+ bool smallerThan( const Token &rhs ) const;
		49	+
		50	+private:
		51	+ std::string m_clientId; ///< Identified the client
		52	+ std::int32_t m_token; ///< Identifies the operation on that client.
		53	+};
		54	+
		55	+/**
		56	+ * @return True if Tokens have the same clientId and token number, false otherwise.
		57	+ */
		58	+inline bool operator==( const Token &lhs, const Token &rhs )
		59	+{
		60	+ return lhs.equals( rhs );
		61	+}
		62	+
		63	+inline bool operator==( const Token &lhs, std::int32_t rhs )
		64	+{
		65	+ return lhs.token() == rhs;
		66	+}
		67	+
		68	+inline bool operator==( std::int32_t lhs, const Token &rhs )
		69	+{
		70	+ return lhs == rhs;
		71	+}
		72	+
		73	+template <typename TLeft, typename TRight>
		74	+inline bool operator!=( const TLeft &lhs, const TRight &rhs )
		75	+{
		76	+ return !( lhs == rhs );
		77	+}
		78	+
		79	+/*!
		80	+ * @return True if Token lhs is smaller than token rhs
		81	+ */
		82	+inline bool operator<( const Token &lhs, std::int32_t rhs )
		83	+{
		84	+ return lhs.token() < rhs;
		85	+}
		86	+
		87	+inline bool operator<( std::int32_t lhs, const Token &rhs )
		88	+{
		89	+ return lhs < rhs.token();
		90	+}
		91	+
		92	+inline bool operator<( const Token &lhs, const Token &rhs )
		93	+{
		94	+ return lhs.smallerThan( rhs );
		95	+}
		96	+
		97	+/*!
		98	+ * @brief Stream operator for a Token
		99	+ */
		100	+std::ostream& operator<<( std::ostream &os, const Token &rhs );
		101	+
		102	+} // End namespace mqtt
		103	+} // End namespace components
		104	+} // End namespace osdev
		105	+
		106	+#endif // OSDEV_COMPONENTS_MQTT_TOKEN_H

src/uriparser.cpp 0 → 100644

View file @51becbd

		1	+++ a/src/uriparser.cpp
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#include "uriparser.h"
		20	+
		21	+// std
		22	+#include <iostream>
		23	+#include <sstream>
		24	+#include <utility>
		25	+
		26	+// gnu-c
		27	+#include <netdb.h>
		28	+
		29	+// boost
		30	+#include <boost/algorithm/string/case_conv.hpp>
		31	+#include <boost/algorithm/string/split.hpp>
		32	+#include <boost/lexical_cast.hpp>
		33	+#include <boost/regex.hpp>
		34	+
		35	+// osdev::components::mqtt
		36	+#include "bimap.h"
		37	+#include "stringutils.h"
		38	+#include "uriutils.h"
		39	+
		40	+// mlogic::common::logger
		41	+// #include "mlogic/common/logger/loggerprovider.h"
		42	+// #include "mlogic/common/invalidargumentexception.h"
		43	+// #include "mlogic/common/nullptrexception.h"
		44	+// #include "mlogic/common/systemexception.h"
		45	+
		46	+
		47	+using namespace osdev::components::mqtt;
		48	+
		49	+namespace {
		50	+
		51	+/**
		52	+ * @brief Copies an item from the from container to the to container.
		53	+ * @tparam TFrom The type of the container from which to copy.
		54	+ * @tparam TTo The type of the container to which to copy.
		55	+ * @param itemName The name of the item to copy.
		56	+ * @param from The container from which to copy.
		57	+ * @param to The cointainer to which to copy.
		58	+ * @param transformation Apply transformation function to the input. Default no transformation.
		59	+ */
		60	+template <typename TFrom, typename TTo>
		61	+void copyItem(const std::string& itemName, const TFrom& from, TTo& to, const std::function<std::string(const std::string&)>& transformation = std::function<std::string(const std::string&)>())
		62	+{
		63	+ if (transformation) {
		64	+ to.insert(std::make_pair(itemName, transformation(from[itemName])));
		65	+ }
		66	+ else {
		67	+ to.insert(std::make_pair(itemName, from[itemName]));
		68	+ }
		69	+}
		70	+
		71	+const std::string& getItem(const std::map<std::string, std::string>& source, const std::string& itemName)
		72	+{
		73	+ static const std::string s_empty;
		74	+ const auto cit = source.find(itemName);
		75	+ if (cit != source.end()) {
		76	+ return cit->second;
		77	+ }
		78	+ return s_empty;
		79	+}
		80	+
		81	+static const boost::bimap<char, std::string>& getReservedCharacterMap()
		82	+{
		83	+ static const auto s_lookupTable = makeBimap<char, std::string>(
		84	+ { { ':', percentEncode<':'>() },
		85	+ { '/', percentEncode<'/'>() },
		86	+ { '?', percentEncode<'?'>() },
		87	+ { '#', percentEncode<'#'>() },
		88	+ { '[', percentEncode<'['>() },
		89	+ { ']', percentEncode<']'>() },
		90	+ { '@', percentEncode<'@'>() },
		91	+ { '!', percentEncode<'!'>() },
		92	+ { '$', percentEncode<'$'>() },
		93	+ { '&', percentEncode<'&'>() },
		94	+ { '\'', percentEncode<'\''>() },
		95	+ { '(', percentEncode<'('>() },
		96	+ { ')', percentEncode<')'>() },
		97	+ { '', percentEncode<''>() },
		98	+ { '+', percentEncode<'+'>() },
		99	+ { ',', percentEncode<','>() },
		100	+ { ';', percentEncode<';'>() },
		101	+ { '=', percentEncode<'='>() },
		102	+
		103	+ { '"', percentEncode<'"'>() },
		104	+ { '%', percentEncode<'%'>() },
		105	+ { '-', percentEncode<'-'>() },
		106	+ { '.', percentEncode<'.'>() },
		107	+ { '<', percentEncode<'<'>() },
		108	+ { '>', percentEncode<'>'>() },
		109	+ { '\\', percentEncode<'\\'>() },
		110	+ { '^', percentEncode<'^'>() },
		111	+ { '_', percentEncode<'_'>() },
		112	+ { '`', percentEncode<'`'>() },
		113	+ { '{', percentEncode<'{'>() },
		114	+ { '\|', percentEncode<'\|'>() },
		115	+ { '}', percentEncode<'}'>() },
		116	+ { '~', percentEncode<'~'>() } });
		117	+
		118	+ return s_lookupTable;
		119	+}
		120	+
		121	+std::string decode(const std::string& in)
		122	+{
		123	+ static constexpr size_t encodingTokenSize = 3; // example: %20 encodes a space character.
		124	+ const auto& reservedLookup = getReservedCharacterMap();
		125	+
		126	+ std::string out = in;
		127	+ std::size_t pos = 0;
		128	+ while ((pos = out.find('%', pos)) != std::string::npos) {
		129	+ if (pos + encodingTokenSize > out.size()) {
		130	+ // MLOGIC_COMMON_THROW(InvalidArgumentException, "Invalid encoding at end of string");
		131	+ }
		132	+ const auto cit = reservedLookup.right.find(out.substr(pos, 3));
		133	+ if (reservedLookup.right.end() != cit) {
		134	+ // string& replace (size_t pos, size_t len, size_t n, char c)
		135	+ // where n is the number of fill characters (1 in this case).
		136	+ out.replace(pos, encodingTokenSize, 1, cit->second);
		137	+ }
		138	+ ++pos;
		139	+ }
		140	+ return out;
		141	+}
		142	+
		143	+std::string encode(const std::string& in)
		144	+{
		145	+ const auto& reservedLookup = getReservedCharacterMap();
		146	+
		147	+ std::string out = in;
		148	+ for (size_t pos = 0; pos < out.size(); ++pos) {
		149	+ const auto cit = reservedLookup.left.find(out[pos]);
		150	+ if (reservedLookup.left.end() != cit) {
		151	+ out.replace(pos, 1, cit->second);
		152	+ pos += 2;
		153	+ }
		154	+ }
		155	+ return out;
		156	+}
		157	+
		158	+} // anonymous
		159	+
		160	+
		161	+// static
		162	+ParsedUri UriParser::parse(const std::string& uri)
		163	+{
		164	+ // Before turning to regular expressions, the following ibraries were evaluated to achieve this functionality:
		165	+ // Qt QUrlParser: http://doc.qt.io/qt-4.8/qurl.html
		166	+ // cpp-netlib: https://github.com/cpp-netlib/uri
		167	+ // uriparser: http://uriparser.sourceforge.net/
		168	+ // From the above, cpp-netlib was the most compelling because of its pending standardization for C++(17?).
		169	+ // However, none of these libraries could handle strings for port service names, so a custom implementation seems necessary.
		170	+ // As an additional validation step, one of the above libraries could be used after the port service name was replaced (see below).
		171	+ //
		172	+ // Split the uri in two stages. First break down the uri in its components: scheme (cannot be empty), authority (cannot be empty), path, query, fragment.
		173	+ // The path, query and fragment parts are optional. Because the scheme and authority part cannot be empty only a subset of uri's is handled by this function.
		174	+ // In the second stage the authority is parsed to get the hostname and the port. In order to use an ipv6 host address it must be
		175	+ // wrapped in brackets. The addresses are not validated whether they are correct. When a open bracket is found the part that is between brackets
		176	+ // must contain at least two colons. This is enough to discern something that resembles an ipv6 address from the other possibilities.
		177	+ static const std::string regexUriString(
		178	+ R"regex(^(?<scheme>[^:/?#]+)://(?<authority>[^/?#]+)(?<path>[^?#])(?<q1>\?(?<query>[^#]))?(?<f1>#(?<fragment>.*))?)regex");
		179	+
		180	+ // This regex only checks for non occurrence of the @ symbol since the input is the result from the regexUri where it is already validated that characters "/>#" do not exist
		181	+ // in the authority part. This regexAuthority uses the if then else construct "(?(?=regex)then\|else)" to choose between ipv6 or something else.
		182	+ static const std::string regexAuthorityString(
		183	+ R"regex(^((?<user>[^:@]+)(:(?<password>[^@]+))?@)?(?(?=(?<ipv6>\[))\[(?=(.:){2,}.)(?<host>[^@]+)\]\|(?<host>[^:@]+))(?<p1>:(?<port>[^:@]+))?$)regex");
		184	+
		185	+ static boost::regex uriRegex(regexUriString);
		186	+ boost::cmatch whatUri;
		187	+ auto uriMatches = boost::regex_match(
		188	+ uri.c_str(),
		189	+ whatUri,
		190	+ uriRegex);
		191	+ if (!uriMatches)
		192	+ {
		193	+ // ErrorLogToFile("UriParser", "Invalid uri: '%1'", uri);
		194	+ // throw (InvalidArgumentException, "No match for the specified uri.");
		195	+ }
		196	+
		197	+ static boost::regex authorityRegex(regexAuthorityString);
		198	+ boost::cmatch whatAuthority;
		199	+ std::string authority = whatUri["authority"];
		200	+ auto authorityMatches = boost::regex_match(
		201	+ authority.c_str(),
		202	+ whatAuthority,
		203	+ authorityRegex);
		204	+ if (!authorityMatches)
		205	+ {
		206	+ // ErrorToLogFile("UriParser", "Uri contains invalid authority part: %1", authority);
		207	+ // Throw (InvalidArgumentException, "Uri contains invalid authority part.");
		208	+ }
		209	+
		210	+ static const auto toLower = [](const std::string& in) -> std::string { return boost::to_lower_copy(in); };
		211	+
		212	+ ParsedUri parsedUri;
		213	+ copyItem("scheme", whatUri, parsedUri, toLower);
		214	+ copyItem("user", whatAuthority, parsedUri, &decode);
		215	+ copyItem("password", whatAuthority, parsedUri, &decode);
		216	+ copyItem("ipv6", whatAuthority, parsedUri); // Acts as a flag. Empty means not ipv6, not empty means ipv6 (this is not validated in the parse however!)
		217	+ copyItem("host", whatAuthority, parsedUri, toLower);
		218	+ copyItem("port", whatAuthority, parsedUri, toLower);
		219	+ copyItem("path", whatUri, parsedUri);
		220	+ copyItem("query", whatUri, parsedUri);
		221	+ copyItem("fragment", whatUri, parsedUri, &decode);
		222	+
		223	+ return parsedUri;
		224	+}
		225	+
		226	+// static
		227	+ParsedQuery UriParser::parseQuery(const ParsedUri& parsedUri)
		228	+{
		229	+ const auto cit = parsedUri.find("query");
		230	+ if (parsedUri.end() == cit) {
		231	+ return {};
		232	+ }
		233	+
		234	+ const auto& queryString = cit->second;
		235	+
		236	+ std::vector<std::string> keyValues;
		237	+ boost::algorithm::split(keyValues, queryString, [](char ch) { return ch == '&'; });
		238	+
		239	+ std::map<std::string, std::string> retval;
		240	+
		241	+ for (const auto& query : keyValues) {
		242	+ auto pos = query.find('=');
		243	+ if (std::string::npos != pos) {
		244	+ retval[decode(query.substr(0, pos))] = pos + 1 < query.size() ? decode(query.substr(pos + 1)) : "";
		245	+ }
		246	+ }
		247	+ return retval;
		248	+}
		249	+
		250	+// static
		251	+ParsedPath UriParser::parsePath(const ParsedUri& parsedUri)
		252	+{
		253	+ const auto cit = parsedUri.find("path");
		254	+ if (parsedUri.end() == cit) {
		255	+ return {};
		256	+ }
		257	+
		258	+ const auto& pathString = cit->second;
		259	+
		260	+ ParsedPath pathElements;
		261	+ if (!pathString.empty()) {
		262	+ const auto path = pathString.substr(1);
		263	+ boost::algorithm::split(pathElements, path, [](char ch) { return ch == '/'; }); // empty string will lead to a single pathElement
		264	+ std::transform(pathElements.begin(), pathElements.end(), pathElements.begin(), &decode);
		265	+ }
		266	+
		267	+ return pathElements;
		268	+}
		269	+
		270	+// static
		271	+std::string UriParser::normalize(const std::string& uri)
		272	+{
		273	+ auto parsedUri = parse(uri);
		274	+
		275	+ auto& portString = parsedUri["port"];
		276	+ if (!portString.empty() && !is_numeric(portString)) {
		277	+ auto portnumber = getPortnumber(portString);
		278	+ portString = boost::lexical_cast<std::string>(portnumber);
		279	+ }
		280	+
		281	+ return toString(parsedUri);
		282	+}
		283	+
		284	+// static
		285	+std::string UriParser::toString(const ParsedUri& parsedUri)
		286	+{
		287	+ const auto& schemeString = getItem(parsedUri, "scheme");
		288	+ const auto& hostString = getItem(parsedUri, "host");
		289	+
		290	+ if( schemeString.empty() )
		291	+ {
		292	+ // Do something sensible
		293	+ }
		294	+
		295	+ if( hostString.empty() )
		296	+ {
		297	+ // Do something sensible.
		298	+ }
		299	+
		300	+ const auto& user = getItem(parsedUri, "user");
		301	+ const auto& password = getItem(parsedUri, "password");
		302	+ const auto& portString = getItem(parsedUri, "port");
		303	+ const auto& pathString = getItem(parsedUri, "path");
		304	+ const auto& queryString = getItem(parsedUri, "query");
		305	+ const auto& fragmentString = getItem(parsedUri, "fragment");
		306	+
		307	+ // wrap hostname in brackets only if the incoming url uses them
		308	+ bool ipv6 = !getItem(parsedUri, "ipv6").empty();
		309	+
		310	+ std::ostringstream oss;
		311	+ oss << schemeString << "://";
		312	+
		313	+ if (!user.empty()) {
		314	+ oss << encode(user);
		315	+ if (!password.empty()) {
		316	+ oss << ":" << encode(password);
		317	+ }
		318	+ oss << "@";
		319	+ }
		320	+
		321	+ if (ipv6) {
		322	+ oss << '[';
		323	+ }
		324	+ oss << hostString;
		325	+ if (ipv6) {
		326	+ oss << ']';
		327	+ }
		328	+
		329	+ if (!portString.empty()) {
		330	+ oss << ':' << portString;
		331	+ }
		332	+
		333	+ if (!pathString.empty()) {
		334	+ auto pathElements = UriParser::parsePath(parsedUri);
		335	+ for (const auto& element : pathElements) {
		336	+ oss << "/" << encode(element);
		337	+ }
		338	+ }
		339	+ if (!queryString.empty()) {
		340	+ auto queryElements = UriParser::parseQuery(parsedUri);
		341	+ oss << '?';
		342	+ for (auto cit = queryElements.cbegin(); queryElements.cend() != cit; ++cit) {
		343	+ oss << encode(cit->first) << '=' << encode(cit->second);
		344	+ if (next(cit) != queryElements.cend()) {
		345	+ oss << '&';
		346	+ }
		347	+ }
		348	+ }
		349	+ if (!fragmentString.empty()) {
		350	+ oss << '#' << encode(fragmentString);
		351	+ }
		352	+ return oss.str();
		353	+}
		354	+
		355	+// static
		356	+int UriParser::getPortnumber(const std::string& service, const std::string& protocolName)
		357	+{
		358	+ const unsigned int bufSize = 1024;
		359	+ struct servent data;
		360	+ struct servent* result;
		361	+ char buf[bufSize]; // contains the strings that data points to
		362	+ ::getservbyname_r(service.c_str(), protocolName.c_str(), &data, buf, bufSize, &result);
		363	+ if (nullptr == result)
		364	+ {
		365	+ // ErrorLogToFile ("UriParser", "Could not determine the portnumber for the specified service: %1 for protocol: %2. Please check the portnumber configuration in /etc/services.", service, protocolName);
		366	+ // throw (?) (InvalidArgumentException, "Could not determine the portnumber for the specified service and/or protocol.");
		367	+ }
		368	+
		369	+// htonx functions need -Wold-style-cast disabled
		370	+#pragma GCC diagnostic push
		371	+#pragma GCC diagnostic ignored "-Wold-style-cast"
		372	+ return static_cast<int>(ntohs(static_cast<uint16_t>(data.s_port)));
		373	+#pragma GCC diagnostic pop
		374	+}

src/uriparser.h 0 → 100644

View file @51becbd

		1	+++ a/src/uriparser.h
		1	+#ifndef OSDEV_COMPONENTS_MQTT_URIPARSER_H
		2	+#define OSDEV_COMPONENTS_MQTT_URIPARSER_H
		3	+
		4	+// std
		5	+#include <string>
		6	+
		7	+#include "commondefs.h"
		8	+
		9	+namespace osdev {
		10	+namespace components {
		11	+namespace mqtt {
		12	+
		13	+/**
		14	+ * @brief Helper class to parse, normalize, and replace the port service name by portnumber in a uri.
		15	+ * example:
		16	+ * opc.tcp://user:secret\@processmodel:processmodel/path1/path2?query3=value4#fragment5
		17	+ * will result in
		18	+ * opc.tcp://user:secret\@processmodel:12345/path1/path2?query3=value4#fragment5
		19	+ * @note This assumes that the port service name was registered in the etc/services file under protocol tcp.
		20	+ * Lookup of a portnumber for protocols other than tcp are not supported.
		21	+ *
		22	+ * IPv6 addresses in a uri are only parsable when they are wrapped in brackets ([]) (RFC 3986, section 3.2.2)
		23	+ *
		24	+ * @note This class is designed to handle a subset of all possible uris. The scheme and the authority part are
		25	+ * expected not to be empty. The authority part can contain user and password information.
		26	+ *
		27	+ * @note Only scheme, hostname and port are converted to lowercase (see RFC 3986 6.2.2.1. Case Normalization)
		28	+ *
		29	+ * @note Special characters are escaped with percent encoding. This applies to user, password, path, query and fragment parts.
		30	+ * The path and query part is escaped on a per element basis. This means that ParsedUri contains the raw query and path strings.
		31	+ * The decoding is done when the methods parseQuery and parsePath are called.
		32	+ */
		33	+class UriParser
		34	+{
		35	+public:
		36	+ /**
		37	+ * @brief Parses the specified uri string.
		38	+ * @param uri The uri string to parse.
		39	+ * @return A map containing the parsed uri.
		40	+ * @note The path and query parts can still contain percent encoded special characters.
		41	+ */
		42	+ static ParsedUri parse(const std::string& uri);
		43	+
		44	+ /**
		45	+ * @brief Parse the query part of a parsed uri. Percent encoded special characters are decoded.
		46	+ * @param parsedUri A ParsedUri object.
		47	+ * @return key/value map.
		48	+ */
		49	+ static ParsedQuery parseQuery(const ParsedUri& parsedUri);
		50	+
		51	+ /**
		52	+ * @brief Parse the path part of a parsed uri. Percent encoded special characters are decoded.
		53	+ * @param parsedUri A ParsedUri object.
		54	+ * @return vector of path elements.
		55	+ */
		56	+ static ParsedPath parsePath(const ParsedUri& parsedUri);
		57	+
		58	+ /**
		59	+ * @brief Parses, normalizes, and replaces the port service name by portnumber in the specified uri string.
		60	+ * @param uri The uri string to parse and normalize.
		61	+ * @return The normalized uri string, with the port service name replaced by the portnumber.
		62	+ */
		63	+ static std::string normalize(const std::string& uri);
		64	+
		65	+ /**
		66	+ * @brief Converts a parsed uri back to a string.
		67	+ * @param parsedUri The parsed uri to convert to string.
		68	+ * @return The uri as string.
		69	+ */
		70	+ static std::string toString(const ParsedUri& parsedUri);
		71	+
		72	+ /**
		73	+ * @brief Get portnumber associated with a service.
		74	+ * @param serviceName Name of the service for which a portnumber is searched.
		75	+ * @param protocolName Name of the protocol for which the portname was registered.
		76	+ * @return portnumber.
		77	+ * @throws InvalidArgumentException when service is unknown.
		78	+ * @throws SystemException when underlying systemcall fails.
		79	+ */
		80	+ static int getPortnumber(const std::string& serviceName, const std::string& protocolName = "tcp");
		81	+};
		82	+
		83	+} // End namespace mqtt
		84	+} // End namespace components
		85	+} // End namespace osdev
		86	+
		87	+#endif // OSDEV_COMPONENTS_MQTT_URIPARSER_H

src/uriutils.h 0 → 100644

View file @51becbd

		1	+++ a/src/uriutils.h
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#ifndef OSDEV_COMPONENTS_MQTT_URIUTILS_H
		20	+#define OSDEV_COMPONENTS_MQTT_URIUTILS_H
		21	+
		22	+// std
		23	+#include <string>
		24	+
		25	+#include "compiletimedigits.h"
		26	+
		27	+namespace osdev {
		28	+namespace components {
		29	+namespace mqtt {
		30	+
		31	+/**
		32	+ * @brief Get the percent encoded string for a given character.
		33	+ * @tparam N The character to encode.
		34	+ * @return pointer to the encoded character string.
		35	+ */
		36	+template <unsigned N>
		37	+inline const char* percentEncode()
		38	+{
		39	+ static const auto* s_code =
		40	+ (compiletime_string<'%'>{} + typename apply_bounded_range< //
		41	+ 0, //
		42	+ numberOfDigits<16>(N), //
		43	+ string_builder< //
		44	+ adapt_for_string_builder< //
		45	+ ProduceDigits<N, 16>>>::template produce>::result{})
		46	+ .chars;
		47	+ return s_code;
		48	+}
		49	+
		50	+} // End namespace mqtt
		51	+} // End namespace components
		52	+} // End namespace osdev
		53	+
		54	+#endif // OSDEV_COMPONENTS_MQTT_URIUTILS_H

src/utils.cpp 0 → 100644

View file @51becbd

		1	+++ a/src/utils.cpp
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#include "utils.h"
		20	+
		21	+// std
		22	+#include <libgen.h>
		23	+#include <unistd.h>
		24	+#include <sstream>
		25	+
		26	+#include <linux/limits.h>
		27	+
		28	+using namespace osdev::components::mqtt;
		29	+
		30	+std::string getPathToBinary(int pid)
		31	+{
		32	+ static const int sMaxPath = PATH_MAX;
		33	+ pid_t p = pid;
		34	+ if (-1 == pid)
		35	+ {
		36	+ p = getpid();
		37	+ }
		38	+ std::ostringstream oss;
		39	+ oss << "/proc/" << p << "/exe";
		40	+ char buf[sMaxPath] = { 0 };
		41	+ ssize_t r = readlink(oss.str().c_str(), buf, sMaxPath);
		42	+ if (-1 == r)
		43	+ {
		44	+ // "readlink failed"
		45	+ }
		46	+ if (r >= sMaxPath)
		47	+ {
		48	+ buf[sMaxPath - 1] = '\0'; // make the buffer 0 terminated
		49	+ // "path is too long"
		50	+ }
		51	+ return dirname(buf);
		52	+}

src/utils.h 0 → 100644

View file @51becbd

		1	+++ a/src/utils.h
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#ifndef OSDEV_COMPONENTS_MQTT_UTILS_H
		20	+#define OSDEV_COMPONENTS_MQTT_UTILS_H
		21	+
		22	+// std
		23	+#include <algorithm>
		24	+#include <functional>
		25	+#include <memory>
		26	+#include <vector>
		27	+
		28	+namespace osdev {
		29	+namespace components {
		30	+namespace mqtt {
		31	+
		32	+/**
		33	+ * @brief Does nothing.
		34	+ * Utility template function to explicitly use parameters, that would otherwise be unused.
		35	+ * This helps to prevent the -Wunused-parameter warning.
		36	+ */
		37	+template <typename... Args>
		38	+void apply_unused_parameters(const Args&...)
		39	+{
		40	+}
		41	+
		42	+/**
		43	+ * @brief Converts (dynamic_cast) a std::unique_ptr from TFrom to TTo.
		44	+ * @param from The std::unique_ptr to convert from TFrom to TTo.
		45	+ * @return The converted std::unique_ptr.
		46	+ */
		47	+template <typename TTo, typename TFrom>
		48	+std::unique_ptr<TTo> dynamic_unique_ptr_cast(std::unique_ptr<TFrom>&& from)
		49	+{
		50	+ auto to = dynamic_cast<TTo*>(from.get());
		51	+ if (nullptr == to) {
		52	+ return std::unique_ptr<TTo>(nullptr);
		53	+ }
		54	+
		55	+ from.release();
		56	+ return std::unique_ptr<TTo>(to);
		57	+}
		58	+
		59	+/**
		60	+ * @brief Converts (dynamic_cast) a std::unique_ptr from TFrom to TTo.
		61	+ * @param from The std::unique_ptr to convert from TFrom to TTo.
		62	+ * @return The converted std::unique_ptr.
		63	+ */
		64	+template <typename TTo, typename TFrom, typename TDeleter>
		65	+std::unique_ptr<TTo, TDeleter> dynamic_unique_ptr_cast(std::unique_ptr<TFrom, TDeleter>&& from)
		66	+{
		67	+ auto to = dynamic_cast<TTo*>(from.get());
		68	+ if (nullptr == to) {
		69	+ return std::unique_ptr<TTo, TDeleter>(nullptr, from.get_deleter());
		70	+ }
		71	+
		72	+ from.release();
		73	+ return std::unique_ptr<TTo, TDeleter>(to, std::move(from.get_deleter()));
		74	+}
		75	+
		76	+/**
		77	+ * @brief Helper class for iteration of keys of a map.
		78	+ */
		79	+template <typename TMap>
		80	+class KeyIterator : public TMap::iterator
		81	+{
		82	+public:
		83	+ typedef typename TMap::iterator MapIterator;
		84	+ typedef typename MapIterator::value_type::first_type KeyType;
		85	+
		86	+ KeyIterator(const MapIterator& other)
		87	+ : TMap::iterator(other)
		88	+ {
		89	+ }
		90	+
		91	+ KeyType& operator*()
		92	+ {
		93	+ return TMap::iterator::operator*().first;
		94	+ }
		95	+};
		96	+
		97	+/**
		98	+ * @brief Helper function to get the begin KeyIterator from a map.
		99	+ */
		100	+template <typename MapType>
		101	+KeyIterator<MapType> KeyBegin(MapType& map)
		102	+{
		103	+ return KeyIterator<MapType>(map.begin());
		104	+}
		105	+
		106	+/**
		107	+ * @brief Helper function to get the end KeyIterator from a map.
		108	+ */
		109	+template <typename MapType>
		110	+KeyIterator<MapType> KeyEnd(MapType& map)
		111	+{
		112	+ return KeyIterator<MapType>(map.end());
		113	+}
		114	+
		115	+/**
		116	+ * @brief Helper class for iteration of keys of a const map.
		117	+ */
		118	+template <typename TMap>
		119	+class KeyConstIterator : public TMap::const_iterator
		120	+{
		121	+ typedef typename TMap::const_iterator TMapIterator;
		122	+ typedef typename TMapIterator::value_type::first_type TKeyType;
		123	+
		124	+public:
		125	+ KeyConstIterator(const TMapIterator& other)
		126	+ : TMapIterator(other)
		127	+ {
		128	+ }
		129	+
		130	+ const TKeyType& operator*()
		131	+ {
		132	+ return TMapIterator::operator*().first;
		133	+ }
		134	+};
		135	+
		136	+/**
		137	+ * @brief Helper function to get the cbegin KeyConstIterator from a const map.
		138	+ */
		139	+template <typename TMap>
		140	+KeyConstIterator<TMap> KeyBegin(const TMap& map)
		141	+{
		142	+ return KeyConstIterator<TMap>(map.cbegin());
		143	+}
		144	+
		145	+/**
		146	+ * @brief Helper function to get the cend KeyConstIterator from a const map.
		147	+ */
		148	+template <typename TMap>
		149	+KeyConstIterator<TMap> KeyEnd(const TMap& map)
		150	+{
		151	+ return KeyConstIterator<TMap>(map.cend());
		152	+}
		153	+
		154	+/**
		155	+ * @brief Helper function to get the difference of the keys in two maps.
		156	+ * @param map1 The first map for which to examine the keys.
		157	+ * @param map2 The second map for which to examine the keys.
		158	+ * @return Collection of keys present in map1, but not in map2.
		159	+ * @note The types of the keys in the maps must be identical.
		160	+ */
		161	+template <typename TMap1, typename TMap2>
		162	+std::vector<typename TMap1::key_type> keyDifference(
		163	+ const TMap1& map1,
		164	+ const TMap2& map2,
		165	+ const std::function<bool(const typename TMap1::key_type& key1, const typename TMap1::key_type& key2)>& keyCompare = std::less<typename TMap1::key_type>())
		166	+{
		167	+ static_assert(std::is_same<
		168	+ typename TMap1::key_type,
		169	+ typename TMap2::key_type>::value,
		170	+ "Inconsistent key types.");
		171	+
		172	+ typedef typename TMap1::key_type Key;
		173	+ std::vector<Key> onlyInMap1;
		174	+ std::set_difference(
		175	+ KeyBegin(map1),
		176	+ KeyEnd(map1),
		177	+ KeyBegin(map2),
		178	+ KeyEnd(map2),
		179	+ std::inserter(onlyInMap1, onlyInMap1.begin()),
		180	+ keyCompare);
		181	+ return onlyInMap1;
		182	+}
		183	+
		184	+/**
		185	+ * @brief Helper function to get the intersection of the keys in two maps.
		186	+ * @param map1 The first map for which to examine the keys.
		187	+ * @param map2 The second map for which to examine the keys.
		188	+ * @return Collection of keys present in both maps.
		189	+ * @note The types of the keys in the maps must be identical.
		190	+ */
		191	+template <typename TMap1, typename TMap2>
		192	+std::vector<typename TMap1::key_type> keyIntersection(
		193	+ const TMap1& map1,
		194	+ const TMap2& map2,
		195	+ const std::function<bool(const typename TMap1::key_type& key1, const typename TMap1::key_type& key2)>& keyCompare = std::less<typename TMap1::key_type>())
		196	+{
		197	+ static_assert(std::is_same<
		198	+ typename TMap1::key_type,
		199	+ typename TMap2::key_type>::value,
		200	+ "Inconsistent key types.");
		201	+
		202	+ typedef typename TMap1::key_type Key;
		203	+ std::vector<Key> inBothMaps;
		204	+ std::set_intersection(
		205	+ KeyBegin(map1),
		206	+ KeyEnd(map1),
		207	+ KeyBegin(map2),
		208	+ KeyEnd(map2),
		209	+ std::inserter(inBothMaps, inBothMaps.begin()),
		210	+ keyCompare);
		211	+ return inBothMaps;
		212	+}
		213	+
		214	+/**
		215	+ * @brief Determine the absolute path of the binary that belongs to a process.
		216	+ * @param pid Process Id ifor which to determine the path to the binary. If pid equals -1 then the pid of the current process is used.
		217	+ * @return Absolute path to the binary.
		218	+ * @throw SystemException if call to readlink fails.
		219	+ * @throw PathException if path is to long.
		220	+ * @note Works only for processes owned by the user that is calling this function.
		221	+ */
		222	+std::string getPathToBinary(int pid = -1);
		223	+
		224	+} // End namespace mqtt
		225	+} // End namespace components
		226	+} // End namespace osdev
		227	+
		228	+#endif // OSDEV_COMPONENTS_MQTT_UTILS_H

tests/CMakeLists.txt 0 → 100644

View file @51becbd

+++ a/tests/CMakeLists.txt

tests/pub/CMakeLists.txt 0 → 100644

View file @51becbd

		1	+++ a/tests/pub/CMakeLists.txt
		1	+cmake_minimum_required(VERSION 3.0)
		2	+LIST(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../cmake)
		3	+
		4	+include(projectheader)
		5	+project_header(test_mqtt_pub)
		6	+
		7	+include_directories( SYSTEM
		8	+ ${CMAKE_CURRENT_SOURCE_DIR}/../../src
		9	+)
		10	+
		11	+include(compiler)
		12	+set(SRC_LIST
		13	+ ${CMAKE_CURRENT_SOURCE_DIR}/publisher.cpp
		14	+ ${CMAKE_CURRENT_SOURCE_DIR}/publisher.h
		15	+ ${CMAKE_CURRENT_SOURCE_DIR}/main.cpp
		16	+)
		17	+
		18	+add_executable( ${PROJECT_NAME}
		19	+ ${SRC_LIST}
		20	+)
		21	+
		22	+target_link_libraries(
		23	+ ${PROJECT_NAME}
		24	+ mqtt
		25	+)
		26	+
		27	+set_target_properties( ${PROJECT_NAME} PROPERTIES
		28	+ RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
		29	+ LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
		30	+ ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/archive
		31	+)
		32	+
		33	+include(installation)
		34	+install_application()

tests/pub/main.cpp 0 → 100644

View file @51becbd

		1	+++ a/tests/pub/main.cpp
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+
		20	+// std
		21	+#include <iostream>
		22	+#include <unistd.h>
		23	+#include <chrono>
		24	+
		25	+#include "publisher.h"
		26	+
		27	+enum TIME_RES
		28	+{
		29	+ T_MICRO,
		30	+ T_MILLI,
		31	+ T_SECONDS
		32	+};
		33	+
		34	+std::uint64_t getEpochUSecs()
		35	+{
		36	+ auto tsUSec =std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
		37	+ return static_cast<std::uint64_t>(tsUSec.time_since_epoch().count());
		38	+}
		39	+
		40	+
		41	+void sleepcp( int number, TIME_RES resolution = T_MILLI ) // Cross-platform sleep function
		42	+{
		43	+ int factor = 0; // Should not happen..
		44	+
		45	+ switch( resolution )
		46	+ {
		47	+ case T_MICRO:
		48	+ factor = 1;
		49	+ break;
		50	+
		51	+ case T_MILLI:
		52	+ factor = 1000;
		53	+ break;
		54	+
		55	+ case T_SECONDS:
		56	+ factor = 1000000;
		57	+ break;
		58	+ }
		59	+
		60	+ usleep( number * factor );
		61	+}
		62	+
		63	+int main( int argc, char* argv[] )
		64	+{
		65	+ // We're not using the command parameters, so we just want to keep the compiler happy.
		66	+ (void)argc;
		67	+ (void)argv;
		68	+
		69	+ uint64_t messageNumber = 0;
		70	+
		71	+ // Create the publisher, run it and publish a message every 0.001 sec.
		72	+ std::cout << "Create the publisher object : ";
		73	+ Publisher *pPublisher = new Publisher();
		74	+ if( pPublisher != nullptr )
		75	+ {
		76	+ std::cout << "{OK}" << std::endl;
		77	+ std::cout << "Connecting to the broker : ";
		78	+ pPublisher->connect( "localhost", 1883, "", "" );
		79	+
		80	+ // Assume we are connected now, start publishing.
		81	+ while( 1 )
		82	+ {
		83	+ std::string payload = "<Timestamp value=\"" + std::to_string( getEpochUSecs() ) + "\" /><MessageNumber value=\"" + std::to_string( messageNumber ) + "\" />" ;
		84	+ pPublisher->publish( std::string( "test/publisher/TestPublisher" ), payload );
		85	+
		86	+ sleepcp( 1, T_SECONDS );
		87	+ if( messageNumber > 2000000000 )
		88	+ messageNumber = -1;
		89	+
		90	+ messageNumber++;
		91	+ }
		92	+ }
		93	+ else
		94	+ return -1;
		95	+
		96	+}

tests/pub/publisher.cpp 0 → 100644

View file @51becbd

		1	+++ a/tests/pub/publisher.cpp
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+
		20	+// osdev::components::mqtt
		21	+#include "token.h"
		22	+
		23	+// mqtt_tests
		24	+#include "publisher.h"
		25	+
		26	+Publisher::Publisher()
		27	+ : m_mqtt_client( "TestPublisher" )
		28	+{
		29	+
		30	+}
		31	+
		32	+void Publisher::connect( const std::string &hostname, int portnumber, const std::string &username, const std::string &password )
		33	+{
		34	+ m_mqtt_client.connect( hostname, portnumber, osdev::components::mqtt::Credentials( username, password ) );
		35	+ std::cout << "Client state : " << m_mqtt_client.state() << std::endl;
		36	+}
		37	+
		38	+void Publisher::publish( const std::string &message_topic, const std::string &message_payload )
		39	+{
		40	+ osdev::components::mqtt::MqttMessage message( message_topic, true, false, message_payload );
		41	+ std::cout << "[Publisher::publish] - Publising message : " << message_payload << " to topic : " << message_topic << std::endl;
		42	+ osdev::components::mqtt::Token t_result = m_mqtt_client.publish( message, 0 );
		43	+}

tests/pub/publisher.h 0 → 100644

View file @51becbd

		1	+++ a/tests/pub/publisher.h
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#pragma once
		20	+
		21	+// std
		22	+#include <memory>
		23	+#include <string>
		24	+
		25	+// osdev::components::mqtt
		26	+#include "mqttclient.h"
		27	+#include "compat-c++14.h"
		28	+
		29	+class Publisher
		30	+{
		31	+public:
		32	+ Publisher();
		33	+
		34	+ virtual ~Publisher() {}
		35	+
		36	+ void connect( const std::string &hostname, int portnumber = 1883, const std::string &username = std::string(), const std::string &password = std::string() );
		37	+
		38	+ void publish( const std::string &message_topic, const std::string &message_payload );
		39	+
		40	+private:
		41	+ osdev::components::mqtt::MqttClient m_mqtt_client;
		42	+};

tests/sub/CMakeLists.txt 0 → 100644

View file @51becbd

		1	+++ a/tests/sub/CMakeLists.txt
		1	+cmake_minimum_required(VERSION 3.0)
		2	+LIST(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../cmake)
		3	+
		4	+include(projectheader)
		5	+project_header(test_mqtt_sub)
		6	+
		7	+include_directories( SYSTEM
		8	+ ${CMAKE_CURRENT_SOURCE_DIR}/../../src
		9	+)
		10	+
		11	+include(compiler)
		12	+set(SRC_LIST
		13	+ ${CMAKE_CURRENT_SOURCE_DIR}/subscriber.cpp
		14	+ ${CMAKE_CURRENT_SOURCE_DIR}/subscriber.h
		15	+ ${CMAKE_CURRENT_SOURCE_DIR}/main.cpp
		16	+)
		17	+
		18	+add_executable( ${PROJECT_NAME}
		19	+ ${SRC_LIST}
		20	+)
		21	+
		22	+target_link_libraries(
		23	+ ${PROJECT_NAME}
		24	+ mqtt
		25	+)
		26	+
		27	+set_target_properties( ${PROJECT_NAME} PROPERTIES
		28	+ RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
		29	+ LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
		30	+ ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/archive
		31	+)
		32	+
		33	+include(installation)
		34	+install_application()

tests/sub/main.cpp 0 → 100644

View file @51becbd

		1	+++ a/tests/sub/main.cpp
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+
		20	+// std
		21	+#include <iostream>
		22	+#include <unistd.h>
		23	+#include <chrono>
		24	+
		25	+#include "subscriber.h"
		26	+
		27	+enum TIME_RES
		28	+{
		29	+ T_MICRO,
		30	+ T_MILLI,
		31	+ T_SECONDS
		32	+};
		33	+
		34	+std::uint64_t getEpochUSecs()
		35	+{
		36	+ auto tsUSec =std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
		37	+ return static_cast<std::uint64_t>(tsUSec.time_since_epoch().count());
		38	+}
		39	+
		40	+
		41	+void sleepcp( int number, TIME_RES resolution = T_MILLI ) // Cross-platform sleep function
		42	+{
		43	+ int factor = 0; // Should not happen..
		44	+
		45	+ switch( resolution )
		46	+ {
		47	+ case T_MICRO:
		48	+ factor = 1;
		49	+ break;
		50	+
		51	+ case T_MILLI:
		52	+ factor = 1000;
		53	+ break;
		54	+
		55	+ case T_SECONDS:
		56	+ factor = 1000000;
		57	+ break;
		58	+ }
		59	+
		60	+ usleep( number * factor );
		61	+}
		62	+
		63	+int main( int argc, char* argv[] )
		64	+{
		65	+ // Satisfy the compiler
		66	+ (void)argc;
		67	+ (void)argv;
		68	+
		69	+ std::cout << "Creating the subscriber : ";
		70	+ // Create the subscriber
		71	+ Subscriber *pSubscriber = new Subscriber();
		72	+ if( pSubscriber != nullptr )
		73	+ {
		74	+ std::cout << "[OK]" << std::endl;
		75	+ std::cout << "Connecting to the test-broker : " << std::endl;
		76	+ pSubscriber->connect( "localhost", 1883, "", "" );
		77	+ std::cout << "Subscribing to the test-topic....." << std::endl;
		78	+ pSubscriber->subscribe( "test/publisher/TestPublisher" );
		79	+
		80	+ // Start a loop to give the subscriber the possibility to do its work.
		81	+ while( 1 )
		82	+ {
		83	+ sleepcp( 1, T_SECONDS ); // Sleep 1 Sec to give the scheduler the change to interfene.
		84	+ }
		85	+ }
		86	+ else
		87	+ {
		88	+ std::cout << "[FAILED]" << std::endl;
		89	+ return -1;
		90	+ }
		91	+ return 0;
		92	+}

tests/sub/subscriber.cpp 0 → 100644

View file @51becbd

		1	+++ a/tests/sub/subscriber.cpp
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#include "subscriber.h"
		20	+#include "mqttmessage.h"
		21	+#include "credentials.h"
		22	+
		23	+Subscriber::Subscriber()
		24	+ : m_mqtt_client( "TestSubscriber" )
		25	+{
		26	+
		27	+}
		28	+
		29	+void Subscriber::connect( const std::string &hostname, int portnumber, const std::string &username, const std::string &password )
		30	+{
		31	+ m_mqtt_client.connect( hostname, portnumber, osdev::components::mqtt::Credentials( username, password ) );
		32	+ std::cout << "Client state : " << m_mqtt_client.state() << std::endl;
		33	+}
		34	+
		35	+void Subscriber::subscribe( const std::string &message_topic )
		36	+{
		37	+ m_mqtt_client.subscribe( message_topic, 1, [this](const osdev::components::mqtt::MqttMessage &message)
		38	+ {
		39	+ this->receive_data(message.topic(), message.payload() );
		40	+ });
		41	+}
		42	+
		43	+void Subscriber::receive_data( const std::string &message_topic, const std::string &message_payload )
		44	+{
		45	+ std::cout << "[Subscriber::receive_data] - Received message : " << message_payload << " from topic : " << message_topic << std::endl;
		46	+}

tests/sub/subscriber.h 0 → 100644

View file @51becbd

		1	+++ a/tests/sub/subscriber.h
		1	+/* Copyright (C) 2019
		2	+ *
		3	+ * This file is part of the osdev components suite
		4	+ *
		5	+ * This program is free software; you can redistribute it and/or modify it
		6	+ * under the terms of the GNU General Public License as published by the
		7	+ * Free Software Foundation; either version 2, or (at your option) any
		8	+ * later version.
		9	+ *
		10	+ * This program is distributed in the hope that it will be useful,
		11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	+ * GNU General Public License for more details.
		14	+ *
		15	+ * You should have received a copy of the GNU General Public License
		16	+ * along with this program; if not, write to the Free Software
		17	+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
		18	+ */
		19	+#pragma once
		20	+
		21	+// std
		22	+#include <memory>
		23	+#include <string>
		24	+
		25	+// osdev::components::mqtt
		26	+#include "mqttclient.h"
		27	+#include "compat-c++14.h"
		28	+
		29	+class Subscriber
		30	+{
		31	+public:
		32	+ Subscriber();
		33	+
		34	+ virtual ~Subscriber() {}
		35	+
		36	+ void connect( const std::string &hostname, int portnumber, const std::string &username, const std::string &password );
		37	+
		38	+ void subscribe( const std::string &message_topic );
		39	+
		40	+private:
		41	+ void receive_data( const std::string &message_topic, const std::string &message_payload );
		42	+
		43	+private:
		44	+ osdev::components::mqtt::MqttClient m_mqtt_client;
		45	+};