v5_connect.hpp

// Copyright Takatoshi Kondo 2022
//
// 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)
 
#if !defined(ASYNC_MQTT_PACKET_V5_CONNECT_HPP)
#define ASYNC_MQTT_PACKET_V5_CONNECT_HPP
 
#include <utility>
#include <numeric>
 
#include <async_mqtt/buffer_to_packet_variant.hpp>
#include <async_mqtt/error.hpp>
 
#include <async_mqtt/packet/control_packet_type.hpp>
#include <async_mqtt/packet/will.hpp>
#include <async_mqtt/packet/property_variant.hpp>
 
#include <async_mqtt/util/buffer.hpp>
#include <async_mqtt/util/variable_bytes.hpp>
#include <async_mqtt/util/static_vector.hpp>
 
namespace async_mqtt::v5 {
 
namespace as = boost::asio;
 
class connect_packet {
public:
    explicit connect_packet(
        bool clean_start,
        std::uint16_t keep_alive_sec,
        std::string client_id,
        std::optional<std::string> user_name = std::nullopt,
        std::optional<std::string> password = std::nullopt,
        properties props = {}
    );
 
    explicit connect_packet(
        bool clean_start,
        std::uint16_t keep_alive_sec,
        std::string client_id,
        std::optional<will> w,
        std::optional<std::string> user_name = std::nullopt,
        std::optional<std::string> password = std::nullopt,
        properties props = {}
    );
 
    static constexpr control_packet_type type() {
        return control_packet_type::connect;
    }
 
    std::vector<as::const_buffer> const_buffer_sequence() const;
 
    std::size_t size() const;
 
    std::size_t num_of_const_buffer_sequence() const;
 
    bool clean_start() const;
 
    std::uint16_t keep_alive() const;
 
    std::string client_id() const;
 
    std::optional<std::string> user_name() const;
 
    std::optional<std::string> password() const;
 
    std::optional<will> get_will() const;
 
    properties const& props() const;
 
private:
 
    template <std::size_t PacketIdBytesArg>
    friend basic_packet_variant<PacketIdBytesArg>
    async_mqtt::buffer_to_basic_packet_variant(buffer buf, protocol_version ver, error_code& ec);
 
#if defined(ASYNC_MQTT_UNIT_TEST_FOR_PACKET)
    friend struct ::ut_packet::v5_connect;
    friend struct ::ut_packet::v5_connect_error;
#endif // defined(ASYNC_MQTT_UNIT_TEST_FOR_PACKET)
 
    // private constructor for internal use
    explicit connect_packet(buffer buf, error_code& ec);
 
private:
    std::uint8_t fixed_header_;
    char connect_flags_;
 
    std::size_t remaining_length_;
    static_vector<char, 4> remaining_length_buf_;
 
    static_vector<char, 7> protocol_name_and_level_;
    buffer client_id_;
    static_vector<char, 2> client_id_length_buf_;
 
    buffer will_topic_;
    static_vector<char, 2> will_topic_length_buf_;
    buffer will_message_;
    static_vector<char, 2> will_message_length_buf_;
    std::size_t will_property_length_;
    static_vector<char, 4> will_property_length_buf_;
    properties will_props_;
 
    buffer user_name_;
    static_vector<char, 2> user_name_length_buf_;
    buffer password_;
    static_vector<char, 2> password_length_buf_;
 
    static_vector<char, 2> keep_alive_buf_;
 
    std::size_t property_length_;
    static_vector<char, 4> property_length_buf_;
    properties props_;
};
 
bool operator<(connect_packet const& lhs, connect_packet const& rhs);
 
bool operator==(connect_packet const& lhs, connect_packet const& rhs);
 
std::ostream& operator<<(std::ostream& o, connect_packet const& v);
 
} // namespace async_mqtt::v5
 
#if !defined(ASYNC_MQTT_SEPARATE_COMPILATION)
#include <async_mqtt/packet/impl/v5_connect.ipp>
#endif // !defined(ASYNC_MQTT_SEPARATE_COMPILATION)
 
#endif // ASYNC_MQTT_PACKET_V5_CONNECT_HPP