callable_overlay.hpp

Go to the documentation of this file.

// Copyright Takatoshi Kondo 2015
//
// 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(MQTT_CALLABLE_OVERLAY_HPP)
#define MQTT_CALLABLE_OVERLAY_HPP
 
#include <mqtt/variant.hpp> // should be top to configure variant limit
 
#include <mqtt/namespace.hpp>
#include <mqtt/attributes.hpp>
#include <mqtt/endpoint.hpp>
#include <mqtt/move.hpp>
 
namespace MQTT_NS {
template<typename Impl>
struct callable_overlay final : public Impl
{
    using base = Impl;
    using packet_id_t = typename base::packet_id_t;
 
    template<typename ... Args>
    callable_overlay(Args && ... args)
     : base(std::forward<Args>(args)...)
    { }
    ~callable_overlay() = default;
    callable_overlay(callable_overlay&&) = default;
    callable_overlay(callable_overlay const&) = default;
    callable_overlay& operator=(callable_overlay&&) = default;
    callable_overlay& operator=(callable_overlay const&) = default;
 
    // MQTT Common handlers
 
    MQTT_ALWAYS_INLINE bool on_pingreq() noexcept override final {
        return ! h_pingreq_ || h_pingreq_();
    }
 
    MQTT_ALWAYS_INLINE bool on_pingresp() noexcept override final {
        return ! h_pingresp_ || h_pingresp_();
    }
 
    // MQTT v3_1_1 handlers
 
    MQTT_ALWAYS_INLINE bool on_connect(buffer client_id,
                                       optional<buffer> user_name,
                                       optional<buffer> password,
                                       optional<will> will,
                                       bool clean_session,
                                       std::uint16_t keep_alive) noexcept override final {
        return    ! h_connect_
               || h_connect_(force_move(client_id),
                             force_move(user_name),
                             force_move(password),
                             force_move(will),
                             clean_session,
                             keep_alive);
    }
 
    MQTT_ALWAYS_INLINE bool on_connack(bool session_present, connect_return_code return_code) noexcept override final {
        return    ! h_connack_
               || h_connack_(session_present, return_code);
    }
 
    MQTT_ALWAYS_INLINE bool on_publish(optional<packet_id_t> packet_id,
                                       publish_options pubopts,
                                       buffer topic_name,
                                       buffer contents) noexcept override final {
        return    ! h_publish_
               || h_publish_(packet_id,
                             pubopts,
                             force_move(topic_name),
                             force_move(contents));
    }
 
    MQTT_ALWAYS_INLINE bool on_puback(packet_id_t packet_id) noexcept override final {
        return    ! h_puback_
               || h_puback_(packet_id);
    }
 
    MQTT_ALWAYS_INLINE bool on_pubrec(packet_id_t packet_id) noexcept override final {
        return    ! h_pubrec_
               || h_pubrec_(packet_id);
    }
 
    MQTT_ALWAYS_INLINE bool on_pubrel(packet_id_t packet_id) noexcept override final {
        return    ! h_pubrel_
               || h_pubrel_(packet_id);
    }
 
    MQTT_ALWAYS_INLINE bool on_pubcomp(packet_id_t packet_id) noexcept override final {
        return    ! h_pubcomp_
               || h_pubcomp_(packet_id);
    }
 
    MQTT_ALWAYS_INLINE bool on_subscribe(packet_id_t packet_id,
                                         std::vector<subscribe_entry> entries) noexcept override final {
        return    ! h_subscribe_
               || h_subscribe_(packet_id, force_move(entries));
    }
 
    MQTT_ALWAYS_INLINE bool on_suback(packet_id_t packet_id,
                                      std::vector<suback_return_code> reasons) noexcept override final {
        return    ! h_suback_
               || h_suback_(packet_id, force_move(reasons));
    }
 
    MQTT_ALWAYS_INLINE bool on_unsubscribe(packet_id_t packet_id,
                                           std::vector<unsubscribe_entry> entries) noexcept override final {
        return    ! h_unsubscribe_
               || h_unsubscribe_(packet_id, force_move(entries));
    }
 
    MQTT_ALWAYS_INLINE bool on_unsuback(packet_id_t packet_id) noexcept override final {
        return    ! h_unsuback_
               || h_unsuback_(packet_id);
    }
 
    MQTT_ALWAYS_INLINE void on_disconnect() noexcept override final {
        if(h_disconnect_) h_disconnect_();
    }
 
    // MQTT v5 handlers
 
    MQTT_ALWAYS_INLINE bool on_v5_connect(buffer client_id,
                                          optional<buffer> user_name,
                                          optional<buffer> password,
                                          optional<will> will,
                                          bool clean_start,
                                          std::uint16_t keep_alive,
                                          v5::properties props) noexcept override final {
        return    ! h_v5_connect_
               || h_v5_connect_(force_move(client_id),
                                force_move(user_name),
                                force_move(password),
                                force_move(will),
                                clean_start,
                                keep_alive,
                                force_move(props));
    }
 
    MQTT_ALWAYS_INLINE bool on_v5_connack(bool session_present,
                                          v5::connect_reason_code reason_code,
                                          v5::properties props) noexcept override final {
        return    ! h_v5_connack_
               || h_v5_connack_(session_present, reason_code, force_move(props));
    }
 
    MQTT_ALWAYS_INLINE bool on_v5_publish(optional<packet_id_t> packet_id,
                                          publish_options pubopts,
                                          buffer topic_name,
                                          buffer contents,
                                          v5::properties props) noexcept override final {
        return    ! h_v5_publish_
               || h_v5_publish_(packet_id,
                                pubopts,
                                force_move(topic_name),
                                force_move(contents),
                                force_move(props));
    }
 
    MQTT_ALWAYS_INLINE bool on_v5_puback(packet_id_t packet_id,
                                         v5::puback_reason_code reason_code,
                                         v5::properties props) noexcept override final {
        return    ! h_v5_puback_
               || h_v5_puback_(packet_id, reason_code, force_move(props));
    }
 
    MQTT_ALWAYS_INLINE bool on_v5_pubrec(packet_id_t packet_id,
                                         v5::pubrec_reason_code reason_code,
                                         v5::properties props) noexcept override final {
        return    ! h_v5_pubrec_
               || h_v5_pubrec_(packet_id, reason_code, force_move(props));
    }
 
    MQTT_ALWAYS_INLINE bool on_v5_pubrel(packet_id_t packet_id,
                                         v5::pubrel_reason_code reason_code,
                                         v5::properties props) noexcept override final {
        return    ! h_v5_pubrel_
               || h_v5_pubrel_(packet_id, reason_code, force_move(props));
    }
 
    MQTT_ALWAYS_INLINE bool on_v5_pubcomp(packet_id_t packet_id,
                                          v5::pubcomp_reason_code reason_code,
                                          v5::properties props) noexcept override final {
        return    ! h_v5_pubcomp_
               || h_v5_pubcomp_(packet_id, reason_code, force_move(props));
    }
 
    MQTT_ALWAYS_INLINE bool on_v5_subscribe(packet_id_t packet_id,
                                            std::vector<subscribe_entry> entries,
                                            v5::properties props) noexcept override final {
        return    ! h_v5_subscribe_
               || h_v5_subscribe_(packet_id, force_move(entries), force_move(props));
    }
 
    MQTT_ALWAYS_INLINE bool on_v5_suback(packet_id_t packet_id,
                                         std::vector<v5::suback_reason_code> reasons,
                                         v5::properties props) noexcept override final {
        return    ! h_v5_suback_
               || h_v5_suback_(packet_id, force_move(reasons), force_move(props));
    }
 
    MQTT_ALWAYS_INLINE bool on_v5_unsubscribe(packet_id_t packet_id,
                                              std::vector<unsubscribe_entry> entries,
                                              v5::properties props) noexcept override final {
        return    ! h_v5_unsubscribe_
               || h_v5_unsubscribe_(packet_id, force_move(entries), force_move(props));
    }
 
    MQTT_ALWAYS_INLINE bool on_v5_unsuback(packet_id_t packet_id,
                                           std::vector<v5::unsuback_reason_code> reasons,
                                           v5::properties props) noexcept override final {
        return    ! h_v5_unsuback_
               || h_v5_unsuback_(packet_id, force_move(reasons), force_move(props));
    }
 
    MQTT_ALWAYS_INLINE void on_v5_disconnect(v5::disconnect_reason_code reason_code,
                                             v5::properties props) noexcept override final {
        if (h_v5_disconnect_) h_v5_disconnect_(reason_code, force_move(props));
    }
 
    MQTT_ALWAYS_INLINE bool on_v5_auth(v5::auth_reason_code reason_code,
                                       v5::properties props) noexcept override final {
        return    ! h_v5_auth_
               || h_v5_auth_(reason_code, force_move(props));
 
    }
 
    // Original handlers
 
    MQTT_ALWAYS_INLINE void on_close() noexcept override final {
        base::on_close();
        if (h_close_) h_close_();
    }
 
    MQTT_ALWAYS_INLINE void on_error(error_code ec) noexcept override final {
        base::on_error(ec);
        if (h_error_) h_error_(ec);
    }
 
    MQTT_ALWAYS_INLINE void on_pub_res_sent(packet_id_t packet_id) noexcept override final {
        if (h_pub_res_sent_) h_pub_res_sent_(packet_id);
    }
 
    MQTT_ALWAYS_INLINE void on_serialize_publish_message(basic_publish_message<sizeof(packet_id_t)> msg) noexcept override final {
        if (h_serialize_publish_) h_serialize_publish_(msg);
    }
 
    MQTT_ALWAYS_INLINE void on_serialize_v5_publish_message(v5::basic_publish_message<sizeof(packet_id_t)> msg) noexcept override final {
        if (h_serialize_v5_publish_) h_serialize_v5_publish_(msg);
    }
 
    MQTT_ALWAYS_INLINE void on_serialize_pubrel_message(basic_pubrel_message<sizeof(packet_id_t)> msg) noexcept override final {
        if (h_serialize_pubrel_) h_serialize_pubrel_(msg);
    }
 
    MQTT_ALWAYS_INLINE void on_serialize_v5_pubrel_message(v5::basic_pubrel_message<sizeof(packet_id_t)> msg) noexcept override final {
        if (h_serialize_v5_pubrel_) h_serialize_v5_pubrel_(msg);
    }
 
    MQTT_ALWAYS_INLINE void on_serialize_remove(packet_id_t packet_id) noexcept override final {
        if (h_serialize_remove_) h_serialize_remove_(packet_id);
    }
 
    MQTT_ALWAYS_INLINE void on_pre_send() noexcept override final {
        base::on_pre_send();
        if (h_pre_send_) h_pre_send_();
    }
 
    MQTT_ALWAYS_INLINE bool check_is_valid_length(control_packet_type packet_type, std::size_t remaining_length) noexcept override final {
        return    ! h_is_valid_length_
               || h_is_valid_length_(packet_type, remaining_length);
    }
 
    MQTT_ALWAYS_INLINE void on_mqtt_message_processed(any session_life_keeper) noexcept override final {
        if(h_mqtt_message_processed_) {
            h_mqtt_message_processed_(force_move(session_life_keeper));
        }
        else {
            base::on_mqtt_message_processed(force_move(session_life_keeper));
        }
    }
 
    using pingreq_handler = std::function<bool()>;
 
    using pingresp_handler = std::function<bool()>;
 
 
    // MQTT v3_1_1 handlers
 
    using connect_handler = std::function<
        bool(buffer client_id,
             optional<buffer> user_name,
             optional<buffer> password,
             optional<will> will,
             bool clean_session,
             std::uint16_t keep_alive)>;
 
    using connack_handler = std::function<bool(bool session_present, connect_return_code return_code)>;
 
    using publish_handler = std::function<bool(optional<packet_id_t> packet_id,
                                               publish_options pubopts,
                                               buffer topic_name,
                                               buffer contents)>;
 
    using puback_handler = std::function<bool(packet_id_t packet_id)>;
 
    using pubrec_handler = std::function<bool(packet_id_t packet_id)>;
 
    using pubrel_handler = std::function<bool(packet_id_t packet_id)>;
 
    using pubcomp_handler = std::function<bool(packet_id_t packet_id)>;
 
    using subscribe_handler = std::function<bool(packet_id_t packet_id,
                                                 std::vector<subscribe_entry> entries)>;
 
    using suback_handler = std::function<bool(packet_id_t packet_id,
                                              std::vector<suback_return_code> qoss)>;
 
    using unsubscribe_handler = std::function<bool(packet_id_t packet_id,
                                                   std::vector<unsubscribe_entry> entries)>;
 
    using unsuback_handler = std::function<bool(packet_id_t)>;
 
    using disconnect_handler = std::function<void()>;
 
    // MQTT v5 handlers
 
    using v5_connect_handler = std::function<
        bool(buffer client_id,
             optional<buffer> user_name,
             optional<buffer> password,
             optional<will> will,
             bool clean_start,
             std::uint16_t keep_alive,
             v5::properties props)
    >;
 
    using v5_connack_handler = std::function<
        bool(bool session_present,
             v5::connect_reason_code reason_code,
             v5::properties props)
    >;
 
    using v5_publish_handler = std::function<
        bool(optional<packet_id_t> packet_id,
             publish_options pubopts,
             buffer topic_name,
             buffer contents,
             v5::properties props)
    >;
 
    using v5_puback_handler = std::function<
        bool(packet_id_t packet_id,
             v5::puback_reason_code reason_code,
             v5::properties props)
    >;
 
    using v5_pubrec_handler = std::function<
        bool(packet_id_t packet_id,
             v5::pubrec_reason_code reason_code,
             v5::properties props)
    >;
 
    using v5_pubrel_handler = std::function<
        bool(packet_id_t packet_id,
             v5::pubrel_reason_code reason_code,
             v5::properties props)
    >;
 
    using v5_pubcomp_handler = std::function<
        bool(packet_id_t packet_id,
             v5::pubcomp_reason_code reason_code,
             v5::properties props)
    >;
 
    using v5_subscribe_handler = std::function<
        bool(packet_id_t packet_id,
             std::vector<subscribe_entry> entries,
             v5::properties props)
    >;
 
    using v5_suback_handler = std::function<
        bool(packet_id_t packet_id,
             std::vector<v5::suback_reason_code> reasons,
             v5::properties props)
    >;
 
    using v5_unsubscribe_handler = std::function<
        bool(packet_id_t packet_id,
             std::vector<unsubscribe_entry> entries,
             v5::properties props)
    >;
 
    using v5_unsuback_handler = std::function<
        bool(packet_id_t,
             std::vector<v5::unsuback_reason_code> reasons,
             v5::properties props)
    >;
 
    using v5_disconnect_handler = std::function<
        void(v5::disconnect_reason_code reason_code,
             v5::properties props)
    >;
 
    using v5_auth_handler = std::function<
        bool(v5::auth_reason_code reason_code,
             v5::properties props)
    >;
 
 
    // Original handlers
 
    using close_handler = std::function<void()>;
 
    using error_handler = std::function<void(error_code ec)>;
 
    using pub_res_sent_handler = std::function<void(packet_id_t packet_id)>;
 
    using serialize_publish_message_handler = std::function<void(basic_publish_message<sizeof(packet_id_t)> msg)>;
 
    using serialize_v5_publish_message_handler = std::function<void(v5::basic_publish_message<sizeof(packet_id_t)> msg)>;
 
    using serialize_publish_handler = std::function<void(packet_id_t packet_id, char const* data, std::size_t size)>;
 
    using serialize_pubrel_message_handler = std::function<void(basic_pubrel_message<sizeof(packet_id_t)> msg)>;
 
    using serialize_v5_pubrel_message_handler = std::function<void(v5::basic_pubrel_message<sizeof(packet_id_t)> msg)>;
 
    using serialize_pubrel_handler = std::function<void(packet_id_t packet_id, char const* data, std::size_t size)>;
 
    using serialize_remove_handler = std::function<void(packet_id_t packet_id)>;
 
    using pre_send_handler = std::function<void()>;
 
    using is_valid_length_handler =
        std::function<bool(control_packet_type packet_type, std::size_t remaining_length)>;
 
    using mqtt_message_processed_handler =
        std::function<void(any session_life_keeper)>;
 
 
 
    // MQTT Common handlers
 
    void set_pingreq_handler(pingreq_handler h = pingreq_handler()) {
        h_pingreq_ = force_move(h);
    }
 
    void set_pingresp_handler(pingresp_handler h = pingresp_handler()) {
        h_pingresp_ = force_move(h);
    }
 
 
    pingreq_handler const& get_pingreq_handler() const {
        return h_pingreq_;
    }
 
    pingresp_handler const& get_pingresp_handler() const {
        return h_pingresp_;
    }
 
 
    // MQTT v3_1_1 handlers
 
    void set_connect_handler(connect_handler h = connect_handler()) {
        h_connect_ = force_move(h);
    }
 
    void set_connack_handler(connack_handler h = connack_handler()) {
        h_connack_ = force_move(h);
    }
 
    void set_publish_handler(publish_handler h = publish_handler()) {
        h_publish_ = force_move(h);
    }
 
    void set_puback_handler(puback_handler h = puback_handler()) {
        h_puback_ = force_move(h);
    }
 
    void set_pubrec_handler(pubrec_handler h = pubrec_handler()) {
        h_pubrec_ = force_move(h);
    }
 
    void set_pubrel_handler(pubrel_handler h = pubrel_handler()) {
        h_pubrel_ = force_move(h);
    }
 
    void set_pubcomp_handler(pubcomp_handler h = pubcomp_handler()) {
        h_pubcomp_ = force_move(h);
    }
 
    void set_subscribe_handler(subscribe_handler h = subscribe_handler()) {
        h_subscribe_ = force_move(h);
    }
 
    void set_suback_handler(suback_handler h = suback_handler()) {
        h_suback_ = force_move(h);
    }
 
    void set_unsubscribe_handler(unsubscribe_handler h = unsubscribe_handler()) {
        h_unsubscribe_ = force_move(h);
    }
 
    void set_unsuback_handler(unsuback_handler h = unsuback_handler()) {
        h_unsuback_ = force_move(h);
    }
 
    void set_disconnect_handler(disconnect_handler h = disconnect_handler()) {
        h_disconnect_ = force_move(h);
    }
 
    connect_handler const& get_connect_handler() const {
        return h_connect_;
    }
 
    connack_handler const& get_connack_handler() const {
        return h_connack_;
    }
 
    publish_handler const& get_publish_handler() const {
        return h_publish_;
    }
 
    puback_handler const& get_puback_handler() const {
        return h_puback_;
    }
 
    pubrec_handler const& get_pubrec_handler() const {
        return h_pubrec_;
    }
 
    pubrel_handler const& get_pubrel_handler() const {
        return h_pubrel_;
    }
 
    pubcomp_handler const& get_pubcomp_handler() const {
        return h_pubcomp_;
    }
 
    subscribe_handler const& get_subscribe_handler() const {
        return h_subscribe_;
    }
 
    suback_handler const& get_suback_handler() const {
        return h_suback_;
    }
 
    unsubscribe_handler const& get_unsubscribe_handler() const {
        return h_unsubscribe_;
    }
 
    unsuback_handler const& get_unsuback_handler() const {
        return h_unsuback_;
    }
 
    disconnect_handler const& get_disconnect_handler() const {
        return h_disconnect_;
    }
 
    // MQTT v5 handlers
 
    void set_v5_connect_handler(v5_connect_handler h = v5_connect_handler()) {
        h_v5_connect_ = force_move(h);
    }
 
    void set_v5_connack_handler(v5_connack_handler h = v5_connack_handler()) {
        h_v5_connack_ = force_move(h);
    }
 
    void set_v5_publish_handler(v5_publish_handler h = v5_publish_handler()) {
        h_v5_publish_ = force_move(h);
    }
 
    void set_v5_puback_handler(v5_puback_handler h = v5_puback_handler()) {
        h_v5_puback_ = force_move(h);
    }
 
    void set_v5_pubrec_handler(v5_pubrec_handler h = v5_pubrec_handler()) {
        h_v5_pubrec_ = force_move(h);
    }
 
    void set_v5_pubrel_handler(v5_pubrel_handler h = v5_pubrel_handler()) {
        h_v5_pubrel_ = force_move(h);
    }
 
    void set_v5_pubcomp_handler(v5_pubcomp_handler h = v5_pubcomp_handler()) {
        h_v5_pubcomp_ = force_move(h);
    }
 
    void set_v5_subscribe_handler(v5_subscribe_handler h = v5_subscribe_handler()) {
        h_v5_subscribe_ = force_move(h);
    }
 
    void set_v5_suback_handler(v5_suback_handler h = v5_suback_handler()) {
        h_v5_suback_ = force_move(h);
    }
 
    void set_v5_unsubscribe_handler(v5_unsubscribe_handler h = v5_unsubscribe_handler()) {
        h_v5_unsubscribe_ = force_move(h);
    }
 
    void set_v5_unsuback_handler(v5_unsuback_handler h = v5_unsuback_handler()) {
        h_v5_unsuback_ = force_move(h);
    }
 
    void set_v5_disconnect_handler(v5_disconnect_handler h = v5_disconnect_handler()) {
        h_v5_disconnect_ = force_move(h);
    }
 
    void set_v5_auth_handler(v5_auth_handler h = v5_auth_handler()) {
        h_v5_auth_ = force_move(h);
    }
 
    v5_connect_handler const& get_v5_connect_handler() const {
        return h_v5_connect_;
    }
 
    v5_connack_handler const& get_v5_connack_handler() const {
        return h_v5_connack_;
    }
 
    v5_publish_handler const& get_v5_publish_handler() const {
        return h_v5_publish_;
    }
 
    v5_puback_handler const& get_v5_puback_handler() const {
        return h_v5_puback_;
    }
 
    v5_pubrec_handler const& get_v5__handler() const {
        return h_v5_pubrec_;
    }
 
    v5_pubrel_handler const& get_v5_pubrel_handler() const {
        return h_v5_pubrel_;
    }
 
    v5_pubcomp_handler const& get_v5_pubcomp_handler() const {
        return h_v5_pubcomp_;
    }
 
    v5_subscribe_handler const& get_v5_subscribe_handler() const {
        return h_v5_subscribe_;
    }
 
    v5_suback_handler const& get_v5_suback_handler() const {
        return h_v5_suback_;
    }
 
    v5_unsubscribe_handler const& get_v5_unsubscribe_handler() const {
        return h_v5_unsubscribe_;
    }
 
    v5_unsuback_handler const& get_v5_unsuback_handler() const {
        return h_v5_unsuback_;
    }
 
    v5_disconnect_handler const& get_v5_disconnect_handler() const {
        return h_v5_disconnect_;
    }
 
    v5_auth_handler const& get_v5_auth_handler() const {
        return h_v5_auth_;
    }
 
 
    // Original handlers
 
    void set_pub_res_sent_handler(pub_res_sent_handler h = pub_res_sent_handler()) {
        h_pub_res_sent_ = force_move(h);
    }
 
    void set_serialize_handlers(
        serialize_publish_message_handler h_publish,
        serialize_pubrel_message_handler h_pubrel,
        serialize_remove_handler h_remove) {
        h_serialize_publish_ = force_move(h_publish);
        h_serialize_pubrel_ = force_move(h_pubrel);
        h_serialize_remove_ = force_move(h_remove);
    }
 
    void set_v5_serialize_handlers(
        serialize_v5_publish_message_handler h_publish,
        serialize_v5_pubrel_message_handler h_pubrel,
        serialize_remove_handler h_remove) {
        h_serialize_v5_publish_ = force_move(h_publish);
        h_serialize_v5_pubrel_ = force_move(h_pubrel);
        h_serialize_remove_ = force_move(h_remove);
    }
 
    void set_serialize_handlers(
        serialize_publish_handler h_publish,
        serialize_pubrel_handler h_pubrel,
        serialize_remove_handler h_remove) {
        h_serialize_publish_ =
            [h_publish = force_move(h_publish)]
            (basic_publish_message<sizeof(packet_id_t)> msg) {
                if (h_publish) {
                    auto buf = msg.continuous_buffer();
                    h_publish(msg.packet_id(), buf.data(), buf.size());
                }
            };
        h_serialize_pubrel_ =
            [h_pubrel = force_move(h_pubrel)]
            (basic_pubrel_message<sizeof(packet_id_t)> msg) {
                if (h_pubrel) {
                    auto buf = msg.continuous_buffer();
                    h_pubrel(msg.packet_id(), buf.data(), buf.size());
                }
            };
        h_serialize_remove_ = force_move(h_remove);
    }
 
    void set_v5_serialize_handlers(
        serialize_publish_handler h_publish,
        serialize_pubrel_handler h_pubrel,
        serialize_remove_handler h_remove) {
        h_serialize_v5_publish_ =
            [h_publish = force_move(h_publish)]
            (v5::basic_publish_message<sizeof(packet_id_t)> msg) {
                if (h_publish) {
                    auto buf = msg.continuous_buffer();
                    h_publish(msg.packet_id(), buf.data(), buf.size());
                }
            };
        h_serialize_v5_pubrel_ =
            [h_pubrel = force_move(h_pubrel)]
            (v5::basic_pubrel_message<sizeof(packet_id_t)> msg) {
                if (h_pubrel) {
                    auto buf = msg.continuous_buffer();
                    h_pubrel(msg.packet_id(), buf.data(), buf.size());
                }
            };
        h_serialize_remove_ = force_move(h_remove);
    }
 
    void set_serialize_handlers() {
        h_serialize_publish_ = serialize_publish_message_handler();
        h_serialize_pubrel_ = serialize_pubrel_message_handler();
        h_serialize_v5_publish_ = serialize_v5_publish_message_handler();
        h_serialize_v5_pubrel_ = serialize_v5_pubrel_message_handler();
        h_serialize_remove_ = serialize_remove_handler();
    }
 
    void set_pre_send_handler(pre_send_handler h = pre_send_handler()) {
        h_pre_send_ = force_move(h);
    }
 
    void set_is_valid_length_handler(is_valid_length_handler h = is_valid_length_handler()) {
        h_is_valid_length_ = force_move(h);
    }
 
    pub_res_sent_handler const& get_pub_res_sent_handler() const {
        return h_pub_res_sent_;
    }
 
    serialize_publish_message_handler const& get_serialize_publish_message_handler() const {
        return h_serialize_publish_;
    }
 
    serialize_pubrel_message_handler const& get_serialize_pubrel_message_handler() const {
        return h_serialize_pubrel_;
    }
 
    serialize_v5_publish_message_handler const& get_serialize_v5_publish_message_handler() const {
        return h_serialize_v5_publish_;
    }
 
    serialize_v5_pubrel_message_handler const& get_serialize_v5_pubrel_message_handler() const {
        return h_serialize_v5_pubrel_;
    }
 
    serialize_remove_handler const& get_serialize_remove_handler() const {
        return h_serialize_remove_;
    }
 
    pre_send_handler const& get_pre_send_handler() const {
        return h_pre_send_;
    }
 
    is_valid_length_handler const& get_is_valid_length_handler() const {
        return h_is_valid_length_;
    }
 
    void set_mqtt_message_processed_handler(
        mqtt_message_processed_handler h = mqtt_message_processed_handler()) {
        if (h) {
            h_mqtt_message_processed_ = force_move(h);
        }
        else {
            h_mqtt_message_processed_ = {};
        }
    }
 
    mqtt_message_processed_handler get_mqtt_message_processed_handler() const {
        return h_mqtt_message_processed_;
    }
 
    void set_close_handler(close_handler h = close_handler()) {
        h_close_ = force_move(h);
    }
 
    void set_error_handler(error_handler h = error_handler()) {
        h_error_ = force_move(h);
    }
 
    close_handler get_close_handler() const {
        return h_close_;
    }
 
    error_handler get_error_handler() const {
        return h_error_;
    }
 
private:
    // MQTT common handlers
    pingreq_handler h_pingreq_;
    pingresp_handler h_pingresp_;
 
    // MQTT v3_1_1 handlers
    connect_handler h_connect_;
    connack_handler h_connack_;
    publish_handler h_publish_;
    puback_handler h_puback_;
    pubrec_handler h_pubrec_;
    pubrel_handler h_pubrel_;
    pubcomp_handler h_pubcomp_;
    subscribe_handler h_subscribe_;
    suback_handler h_suback_;
    unsubscribe_handler h_unsubscribe_;
    unsuback_handler h_unsuback_;
    disconnect_handler h_disconnect_;
 
    // MQTT v5 handlers
    v5_connect_handler h_v5_connect_;
    v5_connack_handler h_v5_connack_;
    v5_publish_handler h_v5_publish_;
    v5_puback_handler h_v5_puback_;
    v5_pubrec_handler h_v5_pubrec_;
    v5_pubrel_handler h_v5_pubrel_;
    v5_pubcomp_handler h_v5_pubcomp_;
    v5_subscribe_handler h_v5_subscribe_;
    v5_suback_handler h_v5_suback_;
    v5_unsubscribe_handler h_v5_unsubscribe_;
    v5_unsuback_handler h_v5_unsuback_;
    v5_disconnect_handler h_v5_disconnect_;
    v5_auth_handler h_v5_auth_;
 
    // original handlers
    close_handler h_close_;
    error_handler h_error_;
    pub_res_sent_handler h_pub_res_sent_;
    serialize_publish_message_handler h_serialize_publish_;
    serialize_v5_publish_message_handler h_serialize_v5_publish_;
    serialize_pubrel_message_handler h_serialize_pubrel_;
    serialize_v5_pubrel_message_handler h_serialize_v5_pubrel_;
    serialize_remove_handler h_serialize_remove_;
    pre_send_handler h_pre_send_;
    is_valid_length_handler h_is_valid_length_;
    mqtt_message_processed_handler h_mqtt_message_processed_;
}; // callable_overlay
 
} // namespace MQTT_NS
 
#endif // MQTT_CALLABLE_OVERLAY_HPP