endpoint.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_ENDPOINT_HPP)
#define ASYNC_MQTT_ENDPOINT_HPP
 
#include <async_mqtt/detail/endpoint_impl.hpp>
 
namespace async_mqtt {
 
enum class filter {
    match,  
    except  
};
 
template <role Role, std::size_t PacketIdBytes, typename NextLayer>
class basic_endpoint {
    using this_type = basic_endpoint<Role, PacketIdBytes, NextLayer>;
    using impl_type = detail::basic_endpoint_impl<Role, PacketIdBytes, NextLayer>;
    using stream_type =
        stream<
            NextLayer
        >;
public:
    using next_layer_type = typename stream_type::next_layer_type;
 
    using lowest_layer_type = typename stream_type::lowest_layer_type;
 
    using executor_type = typename next_layer_type::executor_type;
 
    using packet_variant_type = basic_packet_variant<PacketIdBytes>;
 
    template <typename... Args>
    explicit
    basic_endpoint(
        protocol_version ver,
        Args&&... args
    );
 
    ~basic_endpoint();
 
    basic_endpoint(this_type const&) = delete;
 
    basic_endpoint(this_type&&) = default;
 
    this_type& operator=(this_type const&) = delete;
 
    this_type& operator=(this_type&&) = default;
 
    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();
 
    void set_auto_pub_response(bool val);
 
    void set_auto_ping_response(bool val);
 
    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);
 
 
    // async functions
 
    template <
        typename CompletionToken = as::default_completion_token_t<executor_type>
    >
#if !defined(GENERATING_DOCUMENTATION)
    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(
        CompletionToken,
        void(error_code, typename basic_packet_id_type<PacketIdBytes>::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, typename basic_packet_id_type<PacketIdBytes>::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(
        typename basic_packet_id_type<PacketIdBytes>::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(
        typename basic_packet_id_type<PacketIdBytes>::type packet_id,
        CompletionToken&& token = as::default_completion_token_t<executor_type>{}
    );
 
    template <
        typename Packet,
        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_send(
        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, packet_variant_type)
    )
#endif // !defined(GENERATING_DOCUMENTATION)
    async_recv(
        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_type)
    )
#endif // !defined(GENERATING_DOCUMENTATION)
    async_recv(
        std::set<control_packet_type> types,
        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_type)
    )
#endif // !defined(GENERATING_DOCUMENTATION)
    async_recv(
        filter fil,
        std::set<control_packet_type> types,
        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_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()
    )
#endif // !defined(GENERATING_DOCUMENTATION)
    async_restore_packets(
        std::vector<basic_store_packet_variant<PacketIdBytes>> pvs,
        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::vector<basic_store_packet_variant<PacketIdBytes>>)
    )
#endif // !defined(GENERATING_DOCUMENTATION)
    async_get_stored_packets(
        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, v5::basic_publish_packet<PacketIdBytes>)
    )
#endif // !defined(GENERATING_DOCUMENTATION)
    async_regulate_for_store(
        v5::basic_publish_packet<PacketIdBytes> packet,
        CompletionToken&& token = as::default_completion_token_t<executor_type>{}
    );
 
    // sync APIs
 
    std::optional<typename basic_packet_id_type<PacketIdBytes>::type> acquire_unique_packet_id();
 
    bool register_packet_id(typename basic_packet_id_type<PacketIdBytes>::type packet_id);
 
    void release_packet_id(typename basic_packet_id_type<PacketIdBytes>::type packet_id);
 
    std::set<typename basic_packet_id_type<PacketIdBytes>::type> get_qos2_publish_handled_pids() const;
 
    void restore_qos2_publish_handled_pids(std::set<typename basic_packet_id_type<PacketIdBytes>::type> pids);
 
    void restore_packets(
        std::vector<basic_store_packet_variant<PacketIdBytes>> pvs
    );
 
    std::vector<basic_store_packet_variant<PacketIdBytes>> get_stored_packets() const;
 
    protocol_version get_protocol_version() const;
 
    bool is_publish_processing(typename basic_packet_id_type<PacketIdBytes>::type pid) const;
 
    void regulate_for_store(
        v5::basic_publish_packet<PacketIdBytes>& packet,
        error_code& ec
    ) const;
 
    void set_pingreq_send_interval(std::chrono::milliseconds duration);
 
    template <typename Executor1>
    struct rebind_executor {
        using other = basic_endpoint<
            Role,
            PacketIdBytes,
            typename NextLayer::template rebind_executor<Executor1>::other
        >;
    };
 
private: // compose operation impl
    template <typename Other>
    explicit
    basic_endpoint(
        basic_endpoint<Role, PacketIdBytes, Other>&& other
    );
 
private:
    std::shared_ptr<impl_type> impl_;
};
 
} // namespace async_mqtt
 
#include <async_mqtt/impl/endpoint_impl.hpp>
#include <async_mqtt/impl/endpoint_acquire_unique_packet_id.hpp>
#include <async_mqtt/impl/endpoint_acquire_unique_packet_id_wait_until.hpp>
#include <async_mqtt/impl/endpoint_register_packet_id.hpp>
#include <async_mqtt/impl/endpoint_release_packet_id.hpp>
#include <async_mqtt/impl/endpoint_send.hpp>
#include <async_mqtt/impl/endpoint_recv.hpp>
#include <async_mqtt/impl/endpoint_close.hpp>
#include <async_mqtt/impl/endpoint_restore_packets.hpp>
#include <async_mqtt/impl/endpoint_get_stored_packets.hpp>
#include <async_mqtt/impl/endpoint_regulate_for_store.hpp>
#include <async_mqtt/impl/endpoint_add_retry.hpp>
 
#endif // ASYNC_MQTT_ENDPOINT_HPP