client.hpp

// Copyright Takatoshi Kondo 2024
//
// 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_CLIENT_HPP)
#define ASYNC_MQTT_CLIENT_HPP
 
#include <async_mqtt/detail/client_impl.hpp>
 
namespace async_mqtt {
 
namespace as = boost::asio;
 
template <protocol_version Version, typename NextLayer>
class client {
    using this_type = client<Version, NextLayer>;
    using impl_type = detail::client_impl<Version, NextLayer>;
 
public:
    using endpoint_type = basic_endpoint<role::client, 2, NextLayer>;
 
    using next_layer_type = typename endpoint_type::next_layer_type;
 
    using lowest_layer_type = typename endpoint_type::lowest_layer_type;
 
    using executor_type = typename endpoint_type::executor_type;
 
    ASYNC_MQTT_PACKET_TYPE(Version, connect)
    ASYNC_MQTT_PACKET_TYPE(Version, connack)
    ASYNC_MQTT_PACKET_TYPE(Version, subscribe)
    ASYNC_MQTT_PACKET_TYPE(Version, suback)
    ASYNC_MQTT_PACKET_TYPE(Version, unsubscribe)
    ASYNC_MQTT_PACKET_TYPE(Version, unsuback)
    ASYNC_MQTT_PACKET_TYPE(Version, publish)
    ASYNC_MQTT_PACKET_TYPE(Version, puback)
    ASYNC_MQTT_PACKET_TYPE(Version, pubrec)
    ASYNC_MQTT_PACKET_TYPE(Version, pubrel)
    ASYNC_MQTT_PACKET_TYPE(Version, pubcomp)
    ASYNC_MQTT_PACKET_TYPE(Version, pingreq)
    ASYNC_MQTT_PACKET_TYPE(Version, pingresp)
    ASYNC_MQTT_PACKET_TYPE(Version, disconnect)
 
    
    struct pubres_type {
        std::optional<puback_packet> puback_opt;
        std::optional<pubrec_packet> pubrec_opt;
        std::optional<pubcomp_packet> pubcomp_opt;
    };
 
    template <typename... Args>
    explicit
    client(
        Args&&... args
    );
 
    client(this_type const&) = delete;
 
    client(this_type&&) = default;
 
    ~client() = default;
 
    this_type& operator=(this_type const&) = delete;
 
    this_type& operator=(this_type&&) = default;
 
    template <typename... Args>
    auto async_start(Args&&... args);
 
    template <typename... Args>
    auto async_subscribe(Args&&... args);
 
    template <typename... Args>
    auto async_unsubscribe(Args&&... args);
 
    template <typename... Args>
    auto async_publish(Args&&... args);
 
    template <typename... Args>
    auto async_disconnect(Args&&... args);
 
    template <typename... Args>
    auto async_auth(Args&&... args);
 
    template <
        typename CompletionToken = as::default_completion_token_t<executor_type>
    >
#if !defined(GENERATING_DOCUMENTATION)
    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(
        CompletionToken,
        void()
    )
#endif // !defined(GENERATING_DOCUMENTATION)
    async_close(
        CompletionToken&& token = as::default_completion_token_t<executor_type>{}
    );
 
    template <
        typename CompletionToken = as::default_completion_token_t<executor_type>
    >
#if !defined(GENERATING_DOCUMENTATION)
    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(
        CompletionToken,
        void(error_code, packet_variant)
    )
#endif // !defined(GENERATING_DOCUMENTATION)
    async_recv(
        CompletionToken&& token = as::default_completion_token_t<executor_type>{}
    );
 
    as::any_io_executor get_executor();
 
    next_layer_type const& next_layer() const;
 
    next_layer_type& next_layer();
 
    lowest_layer_type const& lowest_layer() const;
 
    lowest_layer_type& lowest_layer();
 
    endpoint_type const& get_endpoint() const;
 
    endpoint_type& get_endpoint();
 
    void set_auto_map_topic_alias_send(bool val);
 
    void set_auto_replace_topic_alias_send(bool val);
 
    void set_pingresp_recv_timeout(std::chrono::milliseconds duration);
 
    void set_bulk_write(bool val);
 
    void set_bulk_read_buffer_size(std::size_t val);
 
    template <
        typename CompletionToken = as::default_completion_token_t<executor_type>
    >
#if !defined(GENERATING_DOCUMENTATION)
    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(
        CompletionToken,
        void(error_code, packet_id_type)
    )
#endif // !defined(GENERATING_DOCUMENTATION)
    async_acquire_unique_packet_id(
        CompletionToken&& token = as::default_completion_token_t<executor_type>{}
    );
 
    template <
        typename CompletionToken = as::default_completion_token_t<executor_type>
    >
#if !defined(GENERATING_DOCUMENTATION)
    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(
        CompletionToken,
        void(error_code, packet_id_type)
    )
#endif // !defined(GENERATING_DOCUMENTATION)
    async_acquire_unique_packet_id_wait_until(
        CompletionToken&& token = as::default_completion_token_t<executor_type>{}
    );
 
    template <
        typename CompletionToken = as::default_completion_token_t<executor_type>
    >
#if !defined(GENERATING_DOCUMENTATION)
    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(
        CompletionToken,
        void(error_code)
    )
#endif // !defined(GENERATING_DOCUMENTATION)
    async_register_packet_id(
        packet_id_type packet_id,
        CompletionToken&& token = as::default_completion_token_t<executor_type>{}
    );
 
    template <
        typename CompletionToken = as::default_completion_token_t<executor_type>
    >
#if !defined(GENERATING_DOCUMENTATION)
    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(
        CompletionToken,
        void()
    )
#endif // !defined(GENERATING_DOCUMENTATION)
    async_release_packet_id(
        packet_id_type packet_id,
        CompletionToken&& token = as::default_completion_token_t<executor_type>{}
    );
 
    std::optional<packet_id_type> acquire_unique_packet_id();
 
    bool register_packet_id(packet_id_type packet_id);
 
    void release_packet_id(packet_id_type packet_id);
 
    template <typename Executor1>
    struct rebind_executor {
        using other = client<
            Version,
            typename NextLayer::template rebind_executor<Executor1>::other
        >;
    };
 
private:
    template <typename Other>
    explicit
    client(
        client<Version, Other>&& other
    );
 
    template <
        typename CompletionToken = as::default_completion_token_t<executor_type>
    >
#if !defined(GENERATING_DOCUMENTATION)
    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(
        CompletionToken,
        void(error_code, std::optional<connack_packet>)
    )
#endif // !defined(GENERATING_DOCUMENTATION)
    async_start_impl(
        error_code ec,
        std::optional<connect_packet> packet,
        CompletionToken&& token = as::default_completion_token_t<executor_type>{}
    );
 
    template <
        typename CompletionToken = as::default_completion_token_t<executor_type>
    >
#if !defined(GENERATING_DOCUMENTATION)
    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(
        CompletionToken,
        void(error_code, std::optional<suback_packet>)
    )
#endif // !defined(GENERATING_DOCUMENTATION)
    async_subscribe_impl(
        error_code ec,
        std::optional<subscribe_packet> packet,
        CompletionToken&& token = as::default_completion_token_t<executor_type>{}
    );
 
    template <
        typename CompletionToken = as::default_completion_token_t<executor_type>
    >
#if !defined(GENERATING_DOCUMENTATION)
    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(
        CompletionToken,
        void(error_code, std::optional<suback_packet>)
    )
#endif // !defined(GENERATING_DOCUMENTATION)
    async_unsubscribe_impl(
        error_code ec,
        std::optional<unsubscribe_packet> packet,
        CompletionToken&& token = as::default_completion_token_t<executor_type>{}
    );
 
    template <
        typename CompletionToken = as::default_completion_token_t<executor_type>
    >
#if !defined(GENERATING_DOCUMENTATION)
    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(
        CompletionToken,
        void(error_code, pubres_type)
    )
#endif // !defined(GENERATING_DOCUMENTATION)
    async_publish_impl(
        error_code ec,
        std::optional<publish_packet> packet,
        CompletionToken&& token = as::default_completion_token_t<executor_type>{}
    );
 
    template <
        typename CompletionToken = as::default_completion_token_t<executor_type>
    >
#if !defined(GENERATING_DOCUMENTATION)
    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(
        CompletionToken,
        void(error_code)
    )
#endif // !defined(GENERATING_DOCUMENTATION)
    async_disconnect_impl(
        error_code ec,
        std::optional<disconnect_packet> packet,
        CompletionToken&& token = as::default_completion_token_t<executor_type>{}
    );
 
    template <
        typename CompletionToken = as::default_completion_token_t<executor_type>
    >
#if !defined(GENERATING_DOCUMENTATION)
    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(
        CompletionToken,
        void(error_code)
    )
#endif // !defined(GENERATING_DOCUMENTATION)
    async_auth_impl(
        error_code ec,
        std::optional<v5::auth_packet> packet,
        CompletionToken&& token = as::default_completion_token_t<executor_type>{}
    );
 
    void recv_loop();
 
private:
    std::shared_ptr<impl_type> impl_;
};
 
} // namespace async_mqtt
 
#include <async_mqtt/impl/client_impl.hpp>
#include <async_mqtt/impl/client_start.hpp>
#include <async_mqtt/impl/client_subscribe.hpp>
#include <async_mqtt/impl/client_unsubscribe.hpp>
#include <async_mqtt/impl/client_publish.hpp>
#include <async_mqtt/impl/client_disconnect.hpp>
#include <async_mqtt/impl/client_auth.hpp>
#include <async_mqtt/impl/client_close.hpp>
#include <async_mqtt/impl/client_recv.hpp>
#include <async_mqtt/impl/client_acquire_unique_packet_id.hpp>
#include <async_mqtt/impl/client_acquire_unique_packet_id_wait_until.hpp>
#include <async_mqtt/impl/client_register_packet_id.hpp>
#include <async_mqtt/impl/client_release_packet_id.hpp>
 
#endif // ASYNC_MQTT_CLIENT_HPP