robot/include/asio2/mqtt/protocol_v4.hpp

/*
 * Copyright (c) 2017-2023 zhllxt
 *
 * author   : zhllxt
 * email    : 37792738@qq.com
 *
 * chinese : http://blog.mcxiaoke.com/mqtt/protocol/MQTT-3.1.1-CN.html
 * english : http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html
 * 
 * Distributed under the Boost Software License, Version 1.0. (See accompanying
 * file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 */

#ifndef __ASIO2_MQTT_PROTOCOL_V4_HPP__
#define __ASIO2_MQTT_PROTOCOL_V4_HPP__

#if defined(_MSC_VER) && (_MSC_VER >= 1200)
#pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)

#include <asio2/mqtt/core.hpp>

namespace asio2::mqtt::v4
{
	static constexpr std::uint8_t version_number = asio2::detail::to_underlying(mqtt::version::v4);

	enum class connect_reason_code : std::uint8_t
	{
		/* 0	0x00	Connection Accepted : */ success						 = 0,
		/* 1	0x01	Connection Refused  : */ unacceptable_protocol_version	 = 1,
		/* 2	0x02	Connection Refused  : */ identifier_rejected			 = 2,
		/* 3	0x03	Connection Refused  : */ server_unavailable				 = 3,
		/* 4	0x04	Connection Refused  : */ bad_user_name_or_password		 = 4,
		/* 5	0x05	Connection Refused  : */ not_authorized					 = 5,
		/* 6 - 255		Reserved for future use */
	};

	/**
	 * CONNECT - Client requests a connection to a Server
	 * 
	 * After a Network Connection is established by a Client to a Server, the first packet sent from the
	 * Client to the Server MUST be a CONNECT packet [MQTT-3.1.0-1].
	 * 
	 * A Client can only send the CONNECT Packet once over a Network Connection. The Server MUST process
	 * a second CONNECT Packet sent from a Client as a protocol violation and disconnect the Client
	 * 
	 * http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html#_Toc398718028
	 */
	class connect : public fixed_header<version_number>
	{
	public:
		connect() : fixed_header(control_packet_type::connect)
		{
			update_remain_length();
		}

		connect(utf8_string::value_type clientid) : fixed_header(control_packet_type::connect)
		{
			client_id(std::move(clientid));
			update_remain_length();
		}

		inline std::size_t required_size() const
		{
			return (fixed_header::required_size() + fixed_header::remain_length());
		}

		/*
		 * The Container is usually a std::string, std::vector<char>, ...
		 */
		template<class Container>
		inline connect& serialize(Container& buffer)
		{
			fixed_header::serialize(buffer);

			protocol_name_                   .serialize(buffer);
			protocol_version_                .serialize(buffer);
			connect_flags_.byte              .serialize(buffer);
			keep_alive_                      .serialize(buffer);
			client_id_                       .serialize(buffer);
			if (will_topic_  ) will_topic_  ->serialize(buffer);
			if (will_payload_) will_payload_->serialize(buffer);
			if (username_    ) username_    ->serialize(buffer);
			if (password_    ) password_    ->serialize(buffer);

			return (*this);
		}

		inline connect& deserialize(std::string_view& data)
		{
			fixed_header::deserialize(data);

			protocol_name_          .deserialize(data);
			protocol_version_       .deserialize(data);
			connect_flags_.byte     .deserialize(data);
			keep_alive_             .deserialize(data);
			client_id_              .deserialize(data);

			if (has_will())
			{
				utf8_string will_topic{};
				will_topic.deserialize(data);
				will_topic_ = std::move(will_topic);

				binary_data will_payload{};
				will_payload.deserialize(data);
				will_payload_ = std::move(will_payload);
			}

			if (has_username())
			{
				utf8_string username{};
				username.deserialize(data);
				username_ = std::move(username);
			}

			if (has_password())
			{
				binary_data password{};
				password.deserialize(data);
				password_ = std::move(password);
			}

			update_remain_length();

			return (*this);
		}

		inline std::uint8_t protocol_version() const { return                      (protocol_version_                ); }
		inline bool         clean_start     () const { return                      (connect_flags_.bits.clean_session); }
		inline bool         clean_session   () const { return                      (connect_flags_.bits.clean_session); }
		inline bool         has_will        () const { return                      (connect_flags_.bits.will_flag    ); }
		inline qos_type     will_qos        () const { return static_cast<qos_type>(connect_flags_.bits.will_qos     ); }
		inline bool         will_retain     () const { return                      (connect_flags_.bits.will_retain  ); }
		inline bool         has_password    () const { return                      (connect_flags_.bits.password_flag); }
		inline bool         has_username    () const { return                      (connect_flags_.bits.username_flag); }

		inline connect&     clean_start     (bool v) { connect_flags_.bits.clean_session = v; return (*this); }
		inline connect&     clean_session   (bool v) { connect_flags_.bits.clean_session = v; return (*this); }

		inline two_byte_integer::value_type keep_alive        () const { return keep_alive_               ; }
		inline utf8_string::view_type       client_id         () const { return client_id_    .data_view(); }
		inline utf8_string::view_type       will_topic        () const { return will_topic_   ? will_topic_  ->data_view() : ""; }
		inline binary_data::view_type       will_payload      () const { return will_payload_ ? will_payload_->data_view() : ""; }
		inline utf8_string::view_type       username          () const { return username_     ? username_    ->data_view() : ""; }
		inline binary_data::view_type       password          () const { return password_     ? password_    ->data_view() : ""; }

		inline connect& keep_alive(two_byte_integer::value_type   v)
		{
			keep_alive_ = std::move(v);
			return (*this);
		}
		template<class String>
		inline connect& client_id(String&& v)
		{
			client_id_ = std::forward<String>(v);
			update_remain_length();
			return (*this);
		}
		template<class String>
		inline connect& username(String&& v)
		{
			username_ = std::forward<String>(v);
			connect_flags_.bits.username_flag = true;
			update_remain_length();
			return (*this);
		}
		inline connect& password(binary_data::value_type   v)
		{
			password_ = std::move(v);
			connect_flags_.bits.password_flag = true;
			update_remain_length();
			return (*this);
		}
		template<class String1, class String2, class QosOrInt>
		inline connect& will_attributes(String1&& topic, String2&& payload,
			QosOrInt qos = qos_type::at_most_once, bool retain = false)
		{
			will_topic_   = std::forward<String1>(topic);
			will_payload_ = std::forward<String2>(payload);
			connect_flags_.bits.will_flag   = true;
			connect_flags_.bits.will_qos    = static_cast<std::uint8_t>(qos);
			connect_flags_.bits.will_retain = retain;
			update_remain_length();
			return (*this);
		}

		inline bool will_topic_has_value() const noexcept { return will_topic_.has_value(); }
		inline bool username_has_value  () const noexcept { return username_  .has_value(); }
		inline bool password_has_value  () const noexcept { return password_  .has_value(); }

		inline connect& update_remain_length()
		{
			remain_length_ = static_cast<std::int32_t>(0
				+ protocol_name_                 .required_size()
				+ protocol_version_              .required_size()
				+ connect_flags_.byte            .required_size()
				+ keep_alive_                    .required_size()
				+ client_id_                     .required_size()
				+ (will_topic_   ? will_topic_  ->required_size() : 0)
				+ (will_payload_ ? will_payload_->required_size() : 0)
				+ (username_     ? username_    ->required_size() : 0)
				+ (password_     ? password_    ->required_size() : 0)
				);

			return (*this);
		}

	protected:
		// The Protocol Name is a UTF-8 Encoded String that represents the protocol name "MQTT". 
		// The string, its offset and length will not be changed by future versions of the MQTT specification.
		utf8_string      protocol_name_{ "MQTT" };

		// The 8 bit unsigned value that represents the revision level of the protocol used by the Client. 
		// The value of the Protocol Level field for the version 3.1.1 of the protocol is 4 (0x04).
		one_byte_integer protocol_version_{ 0x04 };

		union
		{
			one_byte_integer byte{ 0 };	// all connect flags
		#if ASIO2_ENDIAN_BIG_BYTE
			struct
			{
				bool         username_flag : 1; // User Name Flag
				bool         password_flag : 1; // Password Flag
				bool         will_retain   : 1; // will retain setting
				std::uint8_t will_qos      : 2; // will QoS value
				bool         will_flag     : 1; // will flag
				bool         clean_session : 1; // Clean Session flag
				std::uint8_t reserved      : 1; // unused
			} bits;
		#else
			struct
			{
				std::uint8_t reserved      : 1; // unused
				bool         clean_session : 1; // Clean Session flag
				bool         will_flag     : 1; // will flag
				std::uint8_t will_qos      : 2; // will QoS value
				bool         will_retain   : 1; // will retain setting
				bool         password_flag : 1; // Password Flag
				bool         username_flag : 1; // User Name Flag
			} bits;
		#endif
		} connect_flags_{};                     // connect flags byte

		// The Keep Alive is a time interval measured in seconds. Expressed as a 16-bit word
		// Default to 60 seconds
		two_byte_integer               keep_alive_  { 60 };

		// The Client Identifier (ClientID) identifies the Client to the Server. 
		// Each Client connecting to the Server has a unique ClientID. 
		utf8_string                    client_id_   {};

		// If the Will Flag is set to 1, the Will Topic is the next field in the Payload.
		std::optional<utf8_string>     will_topic_  {};

		// If the Will Flag is set to 1 the Will Payload is the next field in the Payload. 
		std::optional<binary_data>     will_payload_{};

		// If the User Name Flag is set to 1, the User Name is the next field in the Payload.
		std::optional<utf8_string>     username_    {};

		// If the Password Flag is set to 1, the Password is the next field in the Payload.
		std::optional<binary_data>     password_    {};
	};

	/**
	 * CONNACK - Acknowledge connection request
	 * 
	 * http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html#_Toc398718033
	 */
	class connack : public fixed_header<version_number>
	{
	public:
		connack() : fixed_header(control_packet_type::connack)
		{
			update_remain_length();
		}

		explicit connack(bool session_present, std::uint8_t reason_code)
			: fixed_header(control_packet_type::connack)
			, reason_code_(reason_code)
		{
			connack_flags_.bits.session_present = session_present;
			update_remain_length();
		}

		explicit connack(bool session_present, connect_reason_code reason_code)
			: fixed_header(control_packet_type::connack)
			, reason_code_(asio2::detail::to_underlying(reason_code))
		{
			connack_flags_.bits.session_present = session_present;
			update_remain_length();
		}

		inline std::size_t required_size() const
		{
			return (fixed_header::required_size() + fixed_header::remain_length());
		}

		/*
		 * The Container is usually a std::string, std::vector<char>, ...
		 */
		template<class Container>
		inline connack& serialize(Container& buffer)
		{
			fixed_header::serialize(buffer);

			connack_flags_.byte      .serialize(buffer);
			reason_code_             .serialize(buffer);

			return (*this);
		}

		inline connack& deserialize(std::string_view& data)
		{
			fixed_header::deserialize(data);

			connack_flags_.byte     .deserialize(data);
			reason_code_            .deserialize(data);

			update_remain_length();

			return (*this);
		}

		inline bool                session_present() const { return connack_flags_.bits.session_present; }
		inline connect_reason_code reason_code    () const { return static_cast<connect_reason_code>(reason_code_.value()); }

		inline connack       & session_present(bool         v) { connack_flags_.bits.session_present = v; return (*this); }
		inline connack       & reason_code    (std::uint8_t v) { reason_code_                        = v; return (*this); }
		inline connack       & reason_code    (connect_reason_code v)
		{ reason_code_ = asio2::detail::to_underlying(v); return (*this); }

		inline connack& update_remain_length()
		{
			remain_length_ = static_cast<std::int32_t>(0
				+ connack_flags_.byte    .required_size()
				+ reason_code_           .required_size()
				);

			return (*this);
		}
	protected:
		union
		{
			one_byte_integer byte{ 0 }; // all connack flags
		#if ASIO2_ENDIAN_BIG_BYTE
			struct
			{
				std::uint8_t reserved : 7;
				bool  session_present : 1; // session found on the server?
			} bits;
		#else
			struct
			{
				bool  session_present : 1; // session found on the server?
				std::uint8_t reserved : 7;
			} bits;
		#endif
		} connack_flags_{};	               // connack flags

		// Byte 2 in the Variable Header is the Connect Reason Code.
		one_byte_integer reason_code_{ 0 };
	};

	/**
	 * PUBLISH - Publish message
	 * 
	 * A PUBLISH packet is sent from a Client to a Server or from a Server to a Client to transport an Application Message.
	 * 
	 * http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html#_Toc398718037
	 */
	class publish : public fixed_header<version_number>
	{
	public:
		publish() : fixed_header(control_packet_type::publish)
		{
			update_remain_length();
		}

		template<class String1, class String2, class QosOrInt, std::enable_if_t<
			asio2::detail::is_character_string_v<String1>, int> = 0>
		explicit publish(String1&& topic_name, String2&& payload, QosOrInt qos,
			bool dup = false, bool retain = false)
			: fixed_header(control_packet_type::publish)
			, topic_name_ (std::forward<String1>(topic_name))
			, payload_    (std::forward<String2>(payload   ))
		{
			type_and_flags_.bits.dup    = dup;
			type_and_flags_.bits.qos    = static_cast<std::uint8_t>(qos);
			type_and_flags_.bits.retain = retain;

			update_remain_length();
		}

		template<class String1, class String2, class QosOrInt, std::enable_if_t<
			asio2::detail::is_character_string_v<String1>, int> = 0>
		explicit publish(std::uint16_t pid, String1&& topic_name, String2&& payload, QosOrInt qos,
			bool dup = false, bool retain = false)
			: fixed_header(control_packet_type::publish)
			, topic_name_ (std::forward<String1>(topic_name))
			, packet_id_  (pid)
			, payload_    (std::forward<String2>(payload   ))
		{
			type_and_flags_.bits.dup    = dup;
			type_and_flags_.bits.qos    = static_cast<std::uint8_t>(qos);
			type_and_flags_.bits.retain = retain;

			ASIO2_ASSERT(type_and_flags_.bits.qos > std::uint8_t(0));

			update_remain_length();
		}

		inline std::size_t required_size() const
		{
			return (fixed_header::required_size() + fixed_header::remain_length());
		}

		/*
		 * The Container is usually a std::string, std::vector<char>, ...
		 */
		template<class Container>
		inline publish& serialize(Container& buffer)
		{
			fixed_header::serialize(buffer);

			// The Packet Identifier field is only present in PUBLISH packets where the QoS level is 1 or 2.
			// A PUBLISH packet MUST NOT contain a Packet Identifier if its QoS value is set to 0
			if ((type_and_flags_.bits.qos == std::uint8_t(0) &&  packet_id_.has_value()) ||
				(type_and_flags_.bits.qos >  std::uint8_t(0) && !packet_id_.has_value()))
			{
				ASIO2_ASSERT(false);
				asio2::set_last_error(mqtt::make_error_code(mqtt::error::malformed_packet));
			}

			topic_name_.serialize(buffer);
			if (type_and_flags_.bits.qos > std::uint8_t(0) && packet_id_.has_value())
			{
				packet_id_->serialize(buffer);
			}
			payload_.serialize(buffer);

			return (*this);
		}

		inline publish& deserialize(std::string_view& data)
		{
			fixed_header::deserialize(data);

			topic_name_.deserialize(data);
			// A PUBLISH Packet MUST NOT contain a Packet Identifier if its QoS value is set to 0 [MQTT-2.3.1-5].
			if (type_and_flags_.bits.qos == 1 || type_and_flags_.bits.qos == 2)
			{
				two_byte_integer packet_id{};
				packet_id.deserialize(data);
				packet_id_ = packet_id;
			}
			payload_   .deserialize(data);

			update_remain_length();

			return (*this);
		}

		inline bool                dup   () const { return                      (type_and_flags_.bits.dup   ); }
		inline qos_type            qos   () const { return static_cast<qos_type>(type_and_flags_.bits.qos   ); }
		inline bool                retain() const { return                      (type_and_flags_.bits.retain); }

		inline publish       &     dup   (bool     v) { type_and_flags_.bits.dup    = v;                            return (*this); }
		template<class QosOrInt>
		inline publish       &     qos   (QosOrInt v) { type_and_flags_.bits.qos    = static_cast<std::uint8_t>(v); return (*this); }
		inline publish       &     retain(bool     v) { type_and_flags_.bits.retain = v;                            return (*this); }

		inline utf8_string::view_type          topic_name() const { return topic_name_.data_view(); }
		inline two_byte_integer::value_type    packet_id () const { return packet_id_ ? packet_id_->value() : 0; }
		inline application_message::view_type  payload   () const { return payload_.data_view()   ; }

		inline publish       &  packet_id (std::uint16_t    v) { packet_id_  = v                      ; update_remain_length(); return (*this); }
		template<class String>
		inline publish       &  topic_name(String&&         v) { topic_name_ = std::forward<String>(v); update_remain_length(); return (*this); }
		template<class String>
		inline publish       &  payload   (String&&         v) { payload_    = std::forward<String>(v); update_remain_length(); return (*this); }

		inline bool has_packet_id() const noexcept { return packet_id_.has_value(); }

		inline publish& update_remain_length()
		{
			remain_length_ = static_cast<std::int32_t>(0
				+               topic_name_.required_size()
				+ (packet_id_ ? packet_id_->required_size() : 0)
				+               payload_   .required_size()
				);

			return (*this);
		}
	protected:
		// The Topic Name identifies the information channel to which Payload data is published.
		utf8_string                     topic_name_{};

		// The Packet Identifier field is only present in PUBLISH packets where the QoS level is 1 or 2.
		// a Two Byte Integer Packet Identifier.
		std::optional<two_byte_integer> packet_id_ {};

		// The Payload contains the Application Message that is being published.
		// The content and format of the data is application specific.
		// The length of the Payload can be calculated by subtracting the length of the Variable Header
		// from the Remaining Length field that is in the Fixed Header.
		// It is valid for a PUBLISH packet to contain a zero length Payload.
		application_message             payload_   {};
	};

	/**
	 * PUBACK - Publish acknowledgement
	 * 
	 * A PUBACK Packet is the response to a PUBLISH Packet with QoS level 1.
	 * 
	 * http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html#_Toc398718043
	 */
	class puback : public fixed_header<version_number>
	{
	public:
		puback() : fixed_header(control_packet_type::puback)
		{
			update_remain_length();
		}

		explicit puback(std::uint16_t packet_id)
			: fixed_header(control_packet_type::puback)
			, packet_id_  (packet_id)
		{
			update_remain_length();
		}

		inline std::size_t required_size() const
		{
			return (fixed_header::required_size() + fixed_header::remain_length());
		}

		/*
		 * The Container is usually a std::string, std::vector<char>, ...
		 */
		template<class Container>
		inline puback& serialize(Container& buffer)
		{
			fixed_header::serialize(buffer);

			packet_id_  .serialize(buffer);

			return (*this);
		}

		inline puback& deserialize(std::string_view& data)
		{
			fixed_header::deserialize(data);

			packet_id_  .deserialize(data);

			update_remain_length();

			return (*this);
		}

		inline two_byte_integer::value_type    packet_id  () const { return packet_id_  .value()   ; }

		inline puback       &  packet_id  (std::uint16_t v) { packet_id_   = v; return (*this); }

		inline puback& update_remain_length()
		{
			remain_length_ = static_cast<std::int32_t>(0
				+ packet_id_  .required_size()
				);

			return (*this);
		}
	protected:
		// This contains the Packet Identifier from the PUBLISH Packet that is being acknowledged.
		two_byte_integer                packet_id_ {};
	};

	/**
	 * PUBREC - Publish received (QoS 2 publish received, part 1)
	 * 
	 * A PUBREC Packet is the response to a PUBLISH Packet with QoS 2.
	 * It is the second packet of the QoS 2 protocol exchange.
	 * 
	 * http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html#_Toc398718048
	 */
	class pubrec : public fixed_header<version_number>
	{
	public:
		pubrec() : fixed_header(control_packet_type::pubrec)
		{
			update_remain_length();
		}

		explicit pubrec(std::uint16_t packet_id)
			: fixed_header(control_packet_type::pubrec)
			, packet_id_  (packet_id)
		{
			update_remain_length();
		}

		inline std::size_t required_size() const
		{
			return (fixed_header::required_size() + fixed_header::remain_length());
		}

		/*
		 * The Container is usually a std::string, std::vector<char>, ...
		 */
		template<class Container>
		inline pubrec& serialize(Container& buffer)
		{
			fixed_header::serialize(buffer);

			packet_id_  .serialize(buffer);

			return (*this);
		}

		inline pubrec& deserialize(std::string_view& data)
		{
			fixed_header::deserialize(data);

			packet_id_  .deserialize(data);

			update_remain_length();

			return (*this);
		}

		inline two_byte_integer::value_type    packet_id  () const { return packet_id_  .value()   ; }

		inline pubrec       &  packet_id  (std::uint16_t v) { packet_id_   = v; return (*this); }

		inline pubrec& update_remain_length()
		{
			remain_length_ = static_cast<std::int32_t>(0
				+ packet_id_  .required_size()
				);

			return (*this);
		}
	protected:
		// The variable header contains the Packet Identifier from the PUBLISH Packet that is being acknowledged.
		two_byte_integer                packet_id_ {};
	};

	/**
	 * PUBREL - Publish release (QoS 2 publish received, part 2)
	 * 
	 * A PUBREL Packet is the response to a PUBREC Packet.
	 * It is the third packet of the QoS 2 protocol exchange.
	 * 
	 * http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html#_Toc398718053
	 */
	class pubrel : public fixed_header<version_number>
	{
	public:
		pubrel() : fixed_header(control_packet_type::pubrel)
		{
			// Bits 3,2,1 and 0 of the Fixed Header in the PUBREL packet are reserved and MUST be
			// set to 0,0,1 and 0 respectively.
			// The Server MUST treat any other value as malformed and close the Network Connection [MQTT-3.6.1-1].
			type_and_flags_.reserved.bit1 = 1;

			update_remain_length();
		}

		explicit pubrel(std::uint16_t packet_id)
			: fixed_header(control_packet_type::pubrel)
			, packet_id_  (packet_id)
		{
			type_and_flags_.reserved.bit1 = 1;

			update_remain_length();
		}

		inline std::size_t required_size() const
		{
			return (fixed_header::required_size() + fixed_header::remain_length());
		}

		/*
		 * The Container is usually a std::string, std::vector<char>, ...
		 */
		template<class Container>
		inline pubrel& serialize(Container& buffer)
		{
			fixed_header::serialize(buffer);

			packet_id_  .serialize(buffer);

			return (*this);
		}

		inline pubrel& deserialize(std::string_view& data)
		{
			fixed_header::deserialize(data);

			packet_id_  .deserialize(data);

			update_remain_length();

			return (*this);
		}

		inline two_byte_integer::value_type    packet_id  () const { return packet_id_  .value()   ; }

		inline pubrel       &  packet_id  (std::uint16_t v) { packet_id_   = v; return (*this); }

		inline pubrel& update_remain_length()
		{
			remain_length_ = static_cast<std::int32_t>(0
				+ packet_id_  .required_size()
				);

			return (*this);
		}
	protected:
		// The variable header contains the same Packet Identifier as the PUBREC Packet that is being acknowledged.
		two_byte_integer                packet_id_ {};
	};

	/**
	 * PUBCOMP - Publish complete (QoS 2 publish received, part 3)
	 * 
	 * The PUBCOMP Packet is the response to a PUBREL Packet.
	 * It is the fourth and final packet of the QoS 2 protocol exchange.
	 * 
	 * http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html#_Toc398718058
	 */
	class pubcomp : public fixed_header<version_number>
	{
	public:
		pubcomp() : fixed_header(control_packet_type::pubcomp)
		{
			update_remain_length();
		}

		explicit pubcomp(std::uint16_t packet_id)
			: fixed_header(control_packet_type::pubcomp)
			, packet_id_  (packet_id)
		{
			update_remain_length();
		}

		inline std::size_t required_size() const
		{
			return (fixed_header::required_size() + fixed_header::remain_length());
		}

		/*
		 * The Container is usually a std::string, std::vector<char>, ...
		 */
		template<class Container>
		inline pubcomp& serialize(Container& buffer)
		{
			fixed_header::serialize(buffer);

			packet_id_  .serialize(buffer);

			return (*this);
		}

		inline pubcomp& deserialize(std::string_view& data)
		{
			fixed_header::deserialize(data);

			packet_id_  .deserialize(data);

			update_remain_length();

			return (*this);
		}

		inline two_byte_integer::value_type    packet_id  () const { return packet_id_  .value()   ; }

		inline pubcomp       &  packet_id  (std::uint16_t v) { packet_id_   = v; return (*this); }

		inline pubcomp& update_remain_length()
		{
			remain_length_ = static_cast<std::int32_t>(0
				+ packet_id_  .required_size()
				);

			return (*this);
		}
	protected:
		// The variable header contains the same Packet Identifier as the PUBREL Packet that is being acknowledged.
		two_byte_integer                packet_id_ {};
	};

	/**
	 * SUBSCRIBE - Subscribe to topics
	 * 
	 * The SUBSCRIBE Packet is sent from the Client to the Server to create one or more Subscriptions.
	 * Each Subscription registers a Client's interest in one or more Topics.
	 * The Server sends PUBLISH Packets to the Client in order to forward Application Messages that were
	 * published to Topics that match these Subscriptions.
	 * The SUBSCRIBE Packet also specifies (for each Subscription) the maximum QoS with which the Server
	 * can send Application Messages to the Client.
	 * 
	 * http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html#_Toc398718063
	 */
	class subscribe : public fixed_header<version_number>
	{
	public:
		subscribe() : fixed_header(control_packet_type::subscribe)
		{
			// Bits 3,2,1 and 0 of the fixed header of the SUBSCRIBE Control Packet are reserved and MUST be
			// set to 0,0,1 and 0 respectively. The Server MUST treat any other value as malformed and close
			// the Network Connection [MQTT-3.8.1-1].
			type_and_flags_.reserved.bit1 = 1;

			update_remain_length();
		}

		explicit subscribe(std::uint16_t packet_id)
			: fixed_header(control_packet_type::subscribe)
			, packet_id_  (packet_id)
		{
			type_and_flags_.reserved.bit1 = 1;

			update_remain_length();
		}

		inline std::size_t required_size() const
		{
			return (fixed_header::required_size() + fixed_header::remain_length());
		}

		/*
		 * The Container is usually a std::string, std::vector<char>, ...
		 */
		template<class Container>
		inline subscribe& serialize(Container& buffer)
		{
			update_remain_length();

			fixed_header::serialize(buffer);

			packet_id_    .serialize(buffer);
			subscriptions_.serialize(buffer);

			return (*this);
		}

		inline subscribe& deserialize(std::string_view& data)
		{
			fixed_header::deserialize(data);

			packet_id_    .deserialize(data);
			subscriptions_.deserialize(data);

			update_remain_length();

			return (*this);
		}

		inline two_byte_integer::value_type    packet_id    () const { return packet_id_  .value()   ; }
		inline subscriptions_set&              subscriptions()       { return subscriptions_         ; }
		inline subscriptions_set const&        subscriptions() const { return subscriptions_         ; }

		inline subscribe       &  packet_id  (std::uint16_t v) { packet_id_   = v; return (*this); }

		template<class... Subscriptions>
		inline subscribe& add_subscriptions(Subscriptions&&... Subscripts)
		{
			subscriptions_.add(std::forward<Subscriptions>(Subscripts)...);
			update_remain_length();
			return (*this);
		}

		inline subscribe& erase_subscription(std::string_view topic_filter)
		{
			subscriptions_.erase(topic_filter);
			update_remain_length();
			return (*this);
		}

		inline subscribe& update_remain_length()
		{
			remain_length_ = static_cast<std::int32_t>(0
				+ packet_id_    .required_size()
				+ subscriptions_.required_size()
				);

			return (*this);
		}
	protected:
		// The variable header contains a Packet Identifier.
		two_byte_integer                packet_id_    {};

		// The payload of a SUBSCRIBE Packet contains a list of Topic Filters indicating the Topics
		// to which the Client wants to subscribe. The Topic Filters in a SUBSCRIBE packet payload
		// MUST be UTF-8 encoded strings as defined in Section 1.5.3 [MQTT-3.8.3-1]. A Server SHOULD
		// support Topic filters that contain the wildcard characters defined in Section 4.7.1. If
		// it chooses not to support topic filters that contain wildcard characters it MUST reject 
		// any Subscription request whose filter contains them [MQTT-3.8.3-2]. Each filter is
		// followed by a byte called the Requested QoS. This gives the maximum QoS level at which 
		// the Server can send Application Messages to the Client.
		subscriptions_set               subscriptions_{};
	};

	/**
	 * SUBACK - Subscribe acknowledgement
	 * 
	 * A SUBACK Packet is sent by the Server to the Client to confirm receipt and processing of a SUBSCRIBE Packet.
	 * 
	 * http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html#_Toc398718068
	 */
	class suback : public fixed_header<version_number>
	{
	public:
		suback() : fixed_header(control_packet_type::suback)
		{
			update_remain_length();
		}

		explicit suback(std::uint16_t packet_id)
			: fixed_header(control_packet_type::suback)
			, packet_id_  (packet_id)
		{
			update_remain_length();
		}

		inline std::size_t required_size() const
		{
			return (fixed_header::required_size() + fixed_header::remain_length());
		}

		/*
		 * The Container is usually a std::string, std::vector<char>, ...
		 */
		template<class Container>
		inline suback& serialize(Container& buffer)
		{
			update_remain_length();

			fixed_header::serialize(buffer);

			packet_id_    .serialize(buffer);
			reason_codes_ .serialize(buffer);

			return (*this);
		}

		inline suback& deserialize(std::string_view& data)
		{
			fixed_header::deserialize(data);

			packet_id_    .deserialize(data);
			reason_codes_ .deserialize(data);

			update_remain_length();

			return (*this);
		}

		inline two_byte_integer::value_type    packet_id    () const { return packet_id_  .value()   ; }
		inline one_byte_integer_set  &         reason_codes ()       { return reason_codes_          ; }
		inline one_byte_integer_set const&     reason_codes () const { return reason_codes_          ; }

		inline suback       &  packet_id  (std::uint16_t v) { packet_id_   = v; return (*this); }

		template<class... Integers>
		inline suback& add_reason_codes(Integers... Ints)
		{
			reason_codes_.add(static_cast<one_byte_integer::value_type>(Ints)...);
			update_remain_length();
			return (*this);
		}

		inline suback& erase_reason_code(std::size_t index)
		{
			reason_codes_.erase(index);
			update_remain_length();
			return (*this);
		}

		inline suback& update_remain_length()
		{
			remain_length_ = static_cast<std::int32_t>(0
				+ packet_id_    .required_size()
				+ reason_codes_ .required_size()
				);

			return (*this);
		}
	protected:
		// The variable header contains the Packet Identifier from the SUBSCRIBE Packet that is being acknowledged. 
		two_byte_integer                packet_id_   {};

		// The payload contains a list of return codes. Each return code corresponds to a Topic Filter
		// in the SUBSCRIBE Packet being acknowledged. The order of return codes in the SUBACK Packet
		// MUST match the order of Topic Filters in the SUBSCRIBE Packet [MQTT-3.9.3-1].
		one_byte_integer_set            reason_codes_{};
	};

	/**
	 * UNSUBSCRIBE - Unsubscribe from topics
	 * 
	 * An UNSUBSCRIBE Packet is sent by the Client to the Server, to unsubscribe from topics.
	 * 
	 * http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html#_Toc398718072
	 */
	class unsubscribe : public fixed_header<version_number>
	{
	public:
		unsubscribe() : fixed_header(control_packet_type::unsubscribe)
		{
			// Bits 3,2,1 and 0 of the Fixed Header of the UNSUBSCRIBE packet are reserved and MUST
			// be set to 0,0,1 and 0 respectively. The Server MUST treat any other value as malformed
			// and close the Network Connection [MQTT-3.10.1-1].
			type_and_flags_.reserved.bit1 = 1;

			update_remain_length();
		}

		template<class... Strings>
		explicit unsubscribe(std::uint16_t packet_id, Strings&&... topic_filters)
			: fixed_header  (control_packet_type::unsubscribe)
			, packet_id_    (packet_id)
			, topic_filters_(std::forward<Strings>(topic_filters)...)
		{
			type_and_flags_.reserved.bit1 = 1;

			update_remain_length();
		}

		inline std::size_t required_size() const
		{
			return (fixed_header::required_size() + fixed_header::remain_length());
		}

		/*
		 * The Container is usually a std::string, std::vector<char>, ...
		 */
		template<class Container>
		inline unsubscribe& serialize(Container& buffer)
		{
			update_remain_length();

			fixed_header::serialize(buffer);

			packet_id_    .serialize(buffer);
			topic_filters_.serialize(buffer);

			return (*this);
		}

		inline unsubscribe& deserialize(std::string_view& data)
		{
			fixed_header::deserialize(data);

			packet_id_    .deserialize(data);
			topic_filters_.deserialize(data);

			update_remain_length();

			return (*this);
		}

		inline two_byte_integer::value_type    packet_id    () const { return packet_id_  .value()   ; }
		inline utf8_string_set  &              topic_filters()       { return topic_filters_         ; }
		inline utf8_string_set  const&         topic_filters() const { return topic_filters_         ; }

		inline unsubscribe       &  packet_id  (std::uint16_t v) { packet_id_   = v; return (*this); }

		template<class... Strings>
		inline unsubscribe& add_topic_filters(Strings&&... Strs)
		{
			topic_filters_.add(std::forward<Strings>(Strs)...);
			update_remain_length();
			return (*this);
		}

		inline unsubscribe& erase_topic_filter(std::string_view topic_filter)
		{
			topic_filters_.erase(topic_filter);
			update_remain_length();
			return (*this);
		}

		inline unsubscribe& update_remain_length()
		{
			remain_length_ = static_cast<std::int32_t>(0
				+ packet_id_    .required_size()
				+ topic_filters_.required_size()
				);

			return (*this);
		}
	protected:
		// The variable header contains a Packet Identifier. 
		two_byte_integer                packet_id_    {};

		// The payload for the UNSUBSCRIBE Packet contains the list of Topic Filters that the Client
		// wishes to unsubscribe from. The Topic Filters in an UNSUBSCRIBE packet MUST be UTF-8
		// encoded strings as defined in Section 1.5.3, packed contiguously [MQTT-3.10.3-1].
		// The Payload of an UNSUBSCRIBE packet MUST contain at least one Topic Filter.An UNSUBSCRIBE
		// packet with no payload is a protocol violation[MQTT - 3.10.3 - 2].See section 4.8 for
		// information about handling errors.
		utf8_string_set                 topic_filters_{};
	};

	/**
	 * UNSUBACK - Unsubscribe acknowledgement
	 * 
	 * The UNSUBACK packet is sent by the Server to the Client to confirm receipt of an UNSUBSCRIBE packet.
	 * 
	 * http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html#_Toc398718077
	 */
	class unsuback : public fixed_header<version_number>
	{
	public:
		unsuback() : fixed_header(control_packet_type::unsuback)
		{
			update_remain_length();
		}

		explicit unsuback(std::uint16_t packet_id)
			: fixed_header(control_packet_type::unsuback)
			, packet_id_  (packet_id)
		{
			update_remain_length();
		}

		inline std::size_t required_size() const
		{
			return (fixed_header::required_size() + fixed_header::remain_length());
		}

		/*
		 * The Container is usually a std::string, std::vector<char>, ...
		 */
		template<class Container>
		inline unsuback& serialize(Container& buffer)
		{
			fixed_header::serialize(buffer);

			packet_id_    .serialize(buffer);

			return (*this);
		}

		inline unsuback& deserialize(std::string_view& data)
		{
			fixed_header::deserialize(data);

			packet_id_    .deserialize(data);

			update_remain_length();

			return (*this);
		}

		inline two_byte_integer::value_type    packet_id    () const { return packet_id_  .value()   ; }

		inline unsuback       &  packet_id  (std::uint16_t v) { packet_id_   = v; return (*this); }

		inline unsuback& update_remain_length()
		{
			remain_length_ = static_cast<std::int32_t>(0
				+ packet_id_    .required_size()
				);

			return (*this);
		}
	protected:
		// The variable header contains the Packet Identifier of the UNSUBSCRIBE Packet that is being acknowledged.
		two_byte_integer                packet_id_   {};

		// The UNSUBACK Packet has no payload.
	};

	/**
	 * PINGREQ - PING request
	 * 
	 * The PINGREQ packet is sent from a Client to the Server.
	 * 
	 * http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html#_Toc398718081
	 */
	class pingreq : public fixed_header<version_number>
	{
	public:
		pingreq() : fixed_header(control_packet_type::pingreq)
		{
			update_remain_length();
		}

		inline std::size_t required_size() const
		{
			return (fixed_header::required_size() + fixed_header::remain_length());
		}

		/*
		 * The Container is usually a std::string, std::vector<char>, ...
		 */
		template<class Container>
		inline pingreq& serialize(Container& buffer)
		{
			fixed_header::serialize(buffer);

			return (*this);
		}

		inline pingreq& deserialize(std::string_view& data)
		{
			fixed_header::deserialize(data);

			update_remain_length();

			return (*this);
		}

		inline pingreq& update_remain_length()
		{
			remain_length_ = static_cast<std::int32_t>(0
				);

			return (*this);
		}
	protected:
		// The PINGREQ packet has no Variable Header.

		// The PINGREQ packet has no Payload.
	};

	/**
	 * PINGRESP - PING response
	 * 
	 * A PINGRESP Packet is sent by the Server to the Client in response to a PINGREQ packet.
	 * It indicates that the Server is alive.
	 * 
	 * http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html#_Toc398718086
	 */
	class pingresp : public fixed_header<version_number>
	{
	public:
		pingresp() : fixed_header(control_packet_type::pingresp)
		{
			update_remain_length();
		}

		inline std::size_t required_size() const
		{
			return (fixed_header::required_size() + fixed_header::remain_length());
		}

		/*
		 * The Container is usually a std::string, std::vector<char>, ...
		 */
		template<class Container>
		inline pingresp& serialize(Container& buffer)
		{
			fixed_header::serialize(buffer);

			return (*this);
		}

		inline pingresp& deserialize(std::string_view& data)
		{
			fixed_header::deserialize(data);

			update_remain_length();

			return (*this);
		}

		inline pingresp& update_remain_length()
		{
			remain_length_ = static_cast<std::int32_t>(0
				);

			return (*this);
		}
	protected:
		// The PINGRESP packet has no Variable Header.

		// The PINGRESP packet has no Payload.
	};

	/**
	 * DISCONNECT - Disconnect notification
	 * 
	 * The DISCONNECT Packet is the final Control Packet sent from the Client to the Server.
	 * It indicates that the Client is disconnecting cleanly.
	 * 
	 * http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html#_Toc398718090
	 */
	class disconnect : public fixed_header<version_number>
	{
	public:
		disconnect() : fixed_header(control_packet_type::disconnect)
		{
			update_remain_length();
		}

		inline std::size_t required_size() const
		{
			return (fixed_header::required_size() + fixed_header::remain_length());
		}

		/*
		 * The Container is usually a std::string, std::vector<char>, ...
		 */
		template<class Container>
		inline disconnect& serialize(Container& buffer)
		{
			fixed_header::serialize(buffer);

			return (*this);
		}

		inline disconnect& deserialize(std::string_view& data)
		{
			fixed_header::deserialize(data);

			update_remain_length();

			return (*this);
		}

		inline disconnect& update_remain_length()
		{
			remain_length_ = static_cast<std::int32_t>(0
				);

			return (*this);
		}
	protected:
		// The DISCONNECT Packet has no variable header.

		// The DISCONNECT Packet has no payload.
	};

}

namespace asio2::mqtt
{
	template<typename = void>
	inline constexpr std::string_view to_string(v4::connect_reason_code v)
	{
		using namespace std::string_view_literals;
		switch(v)
		{
		case v4::connect_reason_code::success						 : return "Connection accepted"sv;
		case v4::connect_reason_code::unacceptable_protocol_version	 : return "The Server does not support the level of the MQTT protocol requested by the Client"sv;
		case v4::connect_reason_code::identifier_rejected			 : return "The Client identifier is correct UTF-8 but not allowed by the Server"sv;
		case v4::connect_reason_code::server_unavailable			 : return "The Network Connection has been made but the MQTT service is unavailable"sv;
		case v4::connect_reason_code::bad_user_name_or_password		 : return "The data in the user name or password is malformed"sv;
		case v4::connect_reason_code::not_authorized				 : return "The Client is not authorized to connect"sv;
		default:
			ASIO2_ASSERT(false);
			break;
		}
		return "unknown"sv;
	}

	template<typename message_type>
	inline constexpr bool is_v4_message()
	{
		using type = asio2::detail::remove_cvref_t<message_type>;
		if constexpr (
			std::is_same_v<type, mqtt::v4::connect     > ||
			std::is_same_v<type, mqtt::v4::connack     > ||
			std::is_same_v<type, mqtt::v4::publish     > ||
			std::is_same_v<type, mqtt::v4::puback      > ||
			std::is_same_v<type, mqtt::v4::pubrec      > ||
			std::is_same_v<type, mqtt::v4::pubrel      > ||
			std::is_same_v<type, mqtt::v4::pubcomp     > ||
			std::is_same_v<type, mqtt::v4::subscribe   > ||
			std::is_same_v<type, mqtt::v4::suback      > ||
			std::is_same_v<type, mqtt::v4::unsubscribe > ||
			std::is_same_v<type, mqtt::v4::unsuback    > ||
			std::is_same_v<type, mqtt::v4::pingreq     > ||
			std::is_same_v<type, mqtt::v4::pingresp    > ||
			std::is_same_v<type, mqtt::v4::disconnect  > )
		{
			return true;
		}
		else
		{
			return false;
		}
	}
}

#endif // !__ASIO2_MQTT_PROTOCOL_V4_HPP__