v5_publish.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_PUBLISH_HPP)
#define ASYNC_MQTT_PACKET_V5_PUBLISH_HPP
 
#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/packet_id_type.hpp>
#include <async_mqtt/packet/pubopts.hpp>
#include <async_mqtt/packet/property_variant.hpp>
#include <async_mqtt/packet/detail/is_payload.hpp>
 
#include <async_mqtt/util/buffer.hpp>
#include <async_mqtt/util/variable_bytes.hpp>
#include <async_mqtt/util/static_vector.hpp>
 
#if defined(ASYNC_MQTT_PRINT_PAYLOAD)
#include <async_mqtt/util/json_like_out.hpp>
#endif // defined(ASYNC_MQTT_PRINT_PAYLOAD)
 
namespace async_mqtt::v5 {
 
namespace as = boost::asio;
 
template <std::size_t PacketIdBytes>
class basic_publish_packet {
public:
 
    template <
        typename StringViewLike,
        typename Payload,
        std::enable_if_t<
            std::is_convertible_v<std::decay_t<StringViewLike>, std::string_view> &&
            detail::is_payload<Payload>(),
            std::nullptr_t
        > = nullptr
    >
    explicit basic_publish_packet(
        typename basic_packet_id_type<PacketIdBytes>::type packet_id,
        StringViewLike&& topic_name,
        Payload&& payloads,
        pub::opts pubopts,
        properties props = {}
    );
 
    template <
        typename StringViewLike,
        typename Payload,
        std::enable_if_t<
            std::is_convertible_v<std::decay_t<StringViewLike>, std::string_view> &&
            detail::is_payload<Payload>(),
            std::nullptr_t
        > = nullptr
    >
    explicit basic_publish_packet(
        StringViewLike&& topic_name,
        Payload&& payloads,
        pub::opts pubopts,
        properties props = {}
    );
 
    static constexpr control_packet_type type() {
        return control_packet_type::publish;
    }
 
    std::vector<as::const_buffer> const_buffer_sequence() const;
 
    std::size_t size() const;
 
    std::size_t num_of_const_buffer_sequence() const;
 
    typename basic_packet_id_type<PacketIdBytes>::type packet_id() const;
 
    constexpr pub::opts opts() const {
        return pub::opts(fixed_header_);
    }
 
    std::string topic() const;
 
    buffer const& topic_as_buffer() const;
 
    std::string payload() const;
 
    auto payload_range() const;
 
    std::vector<buffer> const& payload_as_buffer() const;
 
    constexpr void set_dup(bool dup) {
        pub::set_dup(fixed_header_, dup);
    }
 
    properties const& props() const;
 
    void remove_topic_add_topic_alias(topic_alias_type val);
 
    void add_topic_alias(topic_alias_type val);
 
    void add_topic(std::string topic);
 
    void remove_topic_alias();
 
    void remove_topic_alias_add_topic(std::string topic);
 
    void update_message_expiry_interval(std::uint32_t val);
 
private:
    void update_remaining_length_buf();
 
    std::tuple<std::size_t, std::size_t> update_property_length_buf();
 
    std::size_t remove_topic_alias_impl();
 
    void add_topic_impl(std::string topic);
 
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_publish;
    friend struct ::ut_packet::v5_publish_qos0;
    friend struct ::ut_packet::v5_publish_invalid;
    friend struct ::ut_packet::v5_publish_pid4;
    friend struct ::ut_packet::v5_publish_topic_alias;
    friend struct ::ut_packet::v5_publish_error;
#endif // defined(ASYNC_MQTT_UNIT_TEST_FOR_PACKET)
 
    // private constructor for internal use
    explicit basic_publish_packet(buffer buf, error_code& ec);
 
    struct tag_internal{};
    explicit basic_publish_packet(
        tag_internal,
        typename basic_packet_id_type<PacketIdBytes>::type packet_id,
        buffer&& topic_name,
        std::vector<buffer>&& payloads,
        pub::opts pubopts,
        properties props
    );
 
private:
    std::uint8_t fixed_header_;
    buffer topic_name_;
    static_vector<char, 2> topic_name_length_buf_;
    static_vector<char, PacketIdBytes> packet_id_;
    std::size_t property_length_;
    static_vector<char, 4> property_length_buf_;
    properties props_;
    std::vector<buffer> payloads_;
    std::size_t remaining_length_;
    static_vector<char, 4> remaining_length_buf_;
};
 
template <std::size_t PacketIdBytes>
bool operator<(basic_publish_packet<PacketIdBytes> const& lhs, basic_publish_packet<PacketIdBytes> const& rhs);
 
template <std::size_t PacketIdBytes>
bool operator==(basic_publish_packet<PacketIdBytes> const& lhs, basic_publish_packet<PacketIdBytes> const& rhs);
 
template <std::size_t PacketIdBytes>
std::ostream& operator<<(std::ostream& o, basic_publish_packet<PacketIdBytes> const& v);
 
using publish_packet = basic_publish_packet<2>;
 
} // namespace async_mqtt::v5
 
#include <async_mqtt/packet/impl/v5_publish.hpp>
 
#if !defined(ASYNC_MQTT_SEPARATE_COMPILATION)
#include <async_mqtt/packet/impl/v5_publish.ipp>
#endif // !defined(ASYNC_MQTT_SEPARATE_COMPILATION)
 
#endif // ASYNC_MQTT_PACKET_V5_PUBLISH_HPP