property_variant.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_PROPERTY_VARIANT_HPP)
#define ASYNC_MQTT_PACKET_PROPERTY_VARIANT_HPP
 
#include <variant>
 
#include <async_mqtt/util/overload.hpp>
#include <async_mqtt/packet/property.hpp>
 
namespace async_mqtt {
 
bool operator==(property_variant const& lhs, property_variant const& rhs);
 
bool operator<(property_variant const& lhs, property_variant const& rhs);
 
/*
 * @brief output to the stream
 * @param os output stream
 * @param v  target
 * @return output stream
 *
 * #### Requirements
 * - Header: async_mqtt/packet/property_variant.hpp
 * - Convenience header: async_mqtt/all.hpp
 *
 */
std::ostream& operator<<(std::ostream& o, property_variant const& v);
 
 
class property_variant {
public:
 
    template <
        typename Property,
        std::enable_if_t<
            !std::is_same_v<std::decay_t<Property>, property_variant>,
            std::nullptr_t
        >* = nullptr
    >
    property_variant(Property&& property);
 
    explicit property_variant() = default;
 
    template <typename Func>
    auto visit(Func&& func) const&;
 
    template <typename Func>
    auto visit(Func&& func) &;
 
    template <typename Func>
    auto visit(Func&& func) &&;
 
    property::id id() const;
 
    std::size_t num_of_const_buffer_sequence() const;
 
    std::vector<as::const_buffer> const_buffer_sequence() const;
 
    std::size_t size() const;
 
    template <typename T>
    decltype(auto) get();
 
    template <typename T>
    decltype(auto) get() const;
 
    template <typename T>
    decltype(auto) get_if();
 
    template <typename T>
    decltype(auto) get_if() const;
 
    operator bool();
 
    friend bool operator==(property_variant const& lhs, property_variant const& rhs);
    friend bool operator<(property_variant const& lhs, property_variant const& rhs);
    friend std::ostream& operator<<(std::ostream& o, property_variant const& v);
 
private:
    using variant_t = std::variant<
        std::monostate,
        property::payload_format_indicator,
        property::message_expiry_interval,
        property::content_type,
        property::response_topic,
        property::correlation_data,
        property::subscription_identifier,
        property::session_expiry_interval,
        property::assigned_client_identifier,
        property::server_keep_alive,
        property::authentication_method,
        property::authentication_data,
        property::request_problem_information,
        property::will_delay_interval,
        property::request_response_information,
        property::response_information,
        property::server_reference,
        property::reason_string,
        property::receive_maximum,
        property::topic_alias_maximum,
        property::topic_alias,
        property::maximum_qos,
        property::retain_available,
        property::user_property,
        property::maximum_packet_size,
        property::wildcard_subscription_available,
        property::subscription_identifier_available,
        property::shared_subscription_available
    >;
 
    variant_t var_;
};
 
using properties = std::vector<property_variant>;
 
/*
 * @ingroup property
 * @brief output to the stream
 * @param os output stream
 * @param v  target
 * @return output stream
 *
 * #### Requirements
 * - Header: async_mqtt/packet/property_variant.hpp
 * - Convenience header: async_mqtt/all.hpp
 *
 */
std::ostream& operator<<(std::ostream& o, properties const& props);
 
bool operator<(property_variant const& lhs, property_variant const& rhs);
 
bool operator==(property_variant const& lhs, property_variant const& rhs);
 
std::ostream& operator<<(std::ostream& o, property_variant const& v);
 
} // namespace async_mqtt
 
#include <async_mqtt/packet/impl/property_variant.hpp>
 
#endif // ASYNC_MQTT_PACKET_PROPERTY_VARIANT_HPP