property.hpp

// Copyright Takatoshi Kondo 2018
//
// 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_HPP)
#define ASYNC_MQTT_PACKET_PROPERTY_HPP
 
#include <string>
#include <vector>
#include <memory>
#include <algorithm>
#include <numeric>
#include <iosfwd>
#include <iomanip>
 
#include <boost/asio/buffer.hpp>
#include <boost/numeric/conversion/cast.hpp>
#include <boost/container/static_vector.hpp>
#include <boost/operators.hpp>
 
#include <async_mqtt/util/json_like_out.hpp>
 
#include <async_mqtt/packet/qos.hpp>
#include <async_mqtt/packet/detail/base_property.hpp>
 
namespace async_mqtt {
 
namespace as = boost::asio;
 
// forward declarations
class property_variant;
enum class property_location;
property_variant make_property_variant(buffer& buf, property_location loc, error_code& ec);
 
enum class payload_format {
    binary, 
    string  
};
 
using session_expiry_interval_type = std::uint32_t;
 
using topic_alias_type = std::uint16_t;
 
using receive_maximum_type = std::uint16_t;
 
static constexpr session_expiry_interval_type session_never_expire = 0xffffffffUL;
 
static constexpr topic_alias_type topic_alias_max = 0xffff;
 
static constexpr receive_maximum_type receive_maximum_max = 0xffff;
 
static constexpr std::uint32_t packet_size_no_limit =
    1 + // fixed header
    4 + // remaining length
    128 * 128 * 128 * 128; // maximum value of remainin length
 
namespace property {
 
class payload_format_indicator : public detail::n_bytes_property<1> {
public:
    explicit payload_format_indicator(payload_format fmt = payload_format::binary);
 
    payload_format val() const;
 
    static constexpr detail::ostream_format const of_ = detail::ostream_format::binary_string;
 
private:
 
    friend property_variant async_mqtt::make_property_variant(buffer& buf, property_location loc, error_code& ec);
 
    // private constructor for internal use
    template <typename It, typename End>
    explicit payload_format_indicator(It b, End e, error_code& ec);
};
 
 
class message_expiry_interval : public detail::n_bytes_property<4> {
public:
    explicit message_expiry_interval(std::uint32_t val);
 
    std::uint32_t val() const;
 
private:
    friend property_variant async_mqtt::make_property_variant(buffer& buf, property_location loc, error_code& ec);
 
    // private constructor for internal use
    template <typename It, typename End>
    explicit message_expiry_interval(It b, End e);
};
 
class content_type : public detail::string_property {
public:
    explicit content_type(std::string val);
 
#if defined(GENERATING_DOCUMENTATION)
 
    std::vector<as::const_buffer> const_buffer_sequence() const;
 
    property::id id() const;
 
    std::size_t size() const;
 
    static constexpr std::size_t num_of_const_buffer_sequence();
 
    constexpr std::string val() const;
 
    constexpr buffer const& val_as_buffer() const;
 
    friend bool operator<(binary_property const& lhs, binary_property const& rhs);
 
    friend bool operator==(binary_property const& lhs, binary_property const& rhs);
 
#endif // defined(GENERATING_DOCUMENTATION)
 
private:
    friend property_variant async_mqtt::make_property_variant(buffer& buf, property_location loc, error_code& ec);
 
    // private constructor for internal use
    template <
        typename Buffer,
        std::enable_if_t<std::is_same_v<Buffer, buffer>, std::nullptr_t> = nullptr
    >
    explicit content_type(Buffer&& val, error_code& ec);
};
 
class response_topic : public detail::string_property {
public:
    explicit response_topic(std::string val);
 
#if defined(GENERATING_DOCUMENTATION)
 
    std::vector<as::const_buffer> const_buffer_sequence() const;
 
    property::id id() const;
 
    std::size_t size() const;
 
    static constexpr std::size_t num_of_const_buffer_sequence();
 
    constexpr std::string val() const;
 
    constexpr buffer const& val_as_buffer() const;
 
    friend bool operator<(binary_property const& lhs, binary_property const& rhs);
 
    friend bool operator==(binary_property const& lhs, binary_property const& rhs);
 
#endif // defined(GENERATING_DOCUMENTATION)
 
private:
    friend property_variant async_mqtt::make_property_variant(buffer& buf, property_location loc, error_code& ec);
 
    // private constructor for internal use
    template <
        typename Buffer,
        std::enable_if_t<std::is_same_v<Buffer, buffer>, std::nullptr_t> = nullptr
    >
    explicit response_topic(Buffer&& val, error_code& ec);
};
 
class correlation_data : public detail::binary_property {
public:
    explicit correlation_data(std::string val);
 
#if defined(GENERATING_DOCUMENTATION)
 
    std::vector<as::const_buffer> const_buffer_sequence() const;
 
    property::id id() const;
 
    std::size_t size() const;
 
    static constexpr std::size_t num_of_const_buffer_sequence();
 
    constexpr std::string val() const;
 
    constexpr buffer const& val_as_buffer() const;
 
    friend bool operator<(binary_property const& lhs, binary_property const& rhs);
 
    friend bool operator==(binary_property const& lhs, binary_property const& rhs);
 
#endif // defined(GENERATING_DOCUMENTATION)
 
private:
    friend property_variant async_mqtt::make_property_variant(buffer& buf, property_location loc, error_code& ec);
 
    // private constructor for internal use
    template <
        typename Buffer,
        std::enable_if_t<std::is_same_v<Buffer, buffer>, std::nullptr_t> = nullptr
    >
    explicit correlation_data(Buffer&& val, error_code& ec);
};
 
class subscription_identifier : public detail::variable_property {
public:
    explicit subscription_identifier(std::uint32_t val);
 
private:
    friend property_variant async_mqtt::make_property_variant(buffer& buf, property_location loc, error_code& ec);
 
    explicit subscription_identifier(std::uint32_t val, error_code& ec);
};
 
class session_expiry_interval : public detail::n_bytes_property<4> {
public:
    session_expiry_interval(std::uint32_t val);
 
    std::uint32_t val() const;
 
private:
    friend property_variant async_mqtt::make_property_variant(buffer& buf, property_location loc, error_code& ec);
 
    // private constructor for internal use
    template <typename It>
    explicit session_expiry_interval(It b, It e);
};
 
class assigned_client_identifier : public detail::string_property {
public:
    explicit assigned_client_identifier(std::string val);
 
#if defined(GENERATING_DOCUMENTATION)
 
    std::vector<as::const_buffer> const_buffer_sequence() const;
 
    property::id id() const;
 
    std::size_t size() const;
 
    static constexpr std::size_t num_of_const_buffer_sequence();
 
    constexpr std::string val() const;
 
    constexpr buffer const& val_as_buffer() const;
 
    friend bool operator<(binary_property const& lhs, binary_property const& rhs);
 
    friend bool operator==(binary_property const& lhs, binary_property const& rhs);
 
#endif // defined(GENERATING_DOCUMENTATION)
 
private:
    friend property_variant async_mqtt::make_property_variant(buffer& buf, property_location loc, error_code& ec);
 
    // private constructor for internal use
    template <
        typename Buffer,
        std::enable_if_t<std::is_same_v<Buffer, buffer>, std::nullptr_t> = nullptr
    >
    explicit assigned_client_identifier(Buffer&& val, error_code& ec);
};
 
class server_keep_alive : public detail::n_bytes_property<2> {
public:
    explicit server_keep_alive(std::uint16_t val);
 
    std::uint16_t val() const;
 
private:
    friend property_variant async_mqtt::make_property_variant(buffer& buf, property_location loc, error_code& ec);
 
    // private constructor for internal use
    template <typename It, typename End>
    explicit server_keep_alive(It b, End e);
};
 
class authentication_method : public detail::string_property {
public:
    explicit authentication_method(std::string val);
 
#if defined(GENERATING_DOCUMENTATION)
 
    std::vector<as::const_buffer> const_buffer_sequence() const;
 
    property::id id() const;
 
    std::size_t size() const;
 
    static constexpr std::size_t num_of_const_buffer_sequence();
 
    constexpr std::string val() const;
 
    constexpr buffer const& val_as_buffer() const;
 
    friend bool operator<(binary_property const& lhs, binary_property const& rhs);
 
    friend bool operator==(binary_property const& lhs, binary_property const& rhs);
 
#endif // defined(GENERATING_DOCUMENTATION)
 
private:
    friend property_variant async_mqtt::make_property_variant(buffer& buf, property_location loc, error_code& ec);
 
    // private constructor for internal use
    template <
        typename Buffer,
        std::enable_if_t<std::is_same_v<Buffer, buffer>, std::nullptr_t> = nullptr
    >
    explicit authentication_method(Buffer&& val, error_code& ec);
};
 
class authentication_data : public detail::binary_property {
public:
    explicit authentication_data(std::string val);
 
#if defined(GENERATING_DOCUMENTATION)
 
    std::vector<as::const_buffer> const_buffer_sequence() const;
 
    property::id id() const;
 
    std::size_t size() const;
 
    static constexpr std::size_t num_of_const_buffer_sequence();
 
    constexpr std::string val() const;
 
    constexpr buffer const& val_as_buffer() const;
 
    friend bool operator<(binary_property const& lhs, binary_property const& rhs);
 
    friend bool operator==(binary_property const& lhs, binary_property const& rhs);
 
#endif // defined(GENERATING_DOCUMENTATION)
 
private:
    friend property_variant async_mqtt::make_property_variant(buffer& buf, property_location loc, error_code& ec);
 
    // private constructor for internal use
    template <
        typename Buffer,
        std::enable_if_t<std::is_same_v<Buffer, buffer>, std::nullptr_t> = nullptr
    >
    explicit authentication_data(Buffer&& val, error_code& ec);
};
 
class request_problem_information : public detail::n_bytes_property<1> {
public:
    explicit request_problem_information(bool value);
 
    bool val() const;
 
private:
    friend property_variant async_mqtt::make_property_variant(buffer& buf, property_location loc, error_code& ec);
 
    // private constructor for internal use
    template <typename It, typename End>
    explicit request_problem_information(It b, End e);
};
 
class will_delay_interval : public detail::n_bytes_property<4> {
public:
    explicit will_delay_interval(std::uint32_t val);
 
    std::uint32_t val() const;
 
private:
    friend property_variant async_mqtt::make_property_variant(buffer& buf, property_location loc, error_code& ec);
 
    // private constructor for internal use
    template <typename It, typename End>
    explicit will_delay_interval(It b, End e);
};
 
class request_response_information : public detail::n_bytes_property<1> {
public:
    explicit request_response_information(bool value);
 
    bool val() const;
 
private:
    friend property_variant async_mqtt::make_property_variant(buffer& buf, property_location loc, error_code& ec);
 
    // private constructor for internal use
    template <typename It, typename End>
    explicit request_response_information(It b, End e);
};
 
class response_information : public detail::string_property {
public:
    explicit response_information(std::string val);
 
#if defined(GENERATING_DOCUMENTATION)
 
    std::vector<as::const_buffer> const_buffer_sequence() const;
 
    property::id id() const;
 
    std::size_t size() const;
 
    static constexpr std::size_t num_of_const_buffer_sequence();
 
    constexpr std::string val() const;
 
    constexpr buffer const& val_as_buffer() const;
 
    friend bool operator<(binary_property const& lhs, binary_property const& rhs);
 
    friend bool operator==(binary_property const& lhs, binary_property const& rhs);
 
#endif // defined(GENERATING_DOCUMENTATION)
 
private:
    friend property_variant async_mqtt::make_property_variant(buffer& buf, property_location loc, error_code& ec);
 
    // private constructor for internal use
    template <
        typename Buffer,
        std::enable_if_t<std::is_same_v<Buffer, buffer>, std::nullptr_t> = nullptr
    >
    explicit response_information(Buffer&& val, error_code& ec);
};
 
class server_reference : public detail::string_property {
public:
    explicit server_reference(std::string val);
 
#if defined(GENERATING_DOCUMENTATION)
 
    std::vector<as::const_buffer> const_buffer_sequence() const;
 
    property::id id() const;
 
    std::size_t size() const;
 
    static constexpr std::size_t num_of_const_buffer_sequence();
 
    constexpr std::string val() const;
 
    constexpr buffer const& val_as_buffer() const;
 
    friend bool operator<(binary_property const& lhs, binary_property const& rhs);
 
    friend bool operator==(binary_property const& lhs, binary_property const& rhs);
 
#endif // defined(GENERATING_DOCUMENTATION)
 
private:
    friend property_variant async_mqtt::make_property_variant(buffer& buf, property_location loc, error_code& ec);
 
    // private constructor for internal use
    template <
        typename Buffer,
        std::enable_if_t<std::is_same_v<Buffer, buffer>, std::nullptr_t> = nullptr
    >
    explicit server_reference(Buffer&& val, error_code& ec);
};
 
class reason_string : public detail::string_property {
public:
    explicit reason_string(std::string val);
 
#if defined(GENERATING_DOCUMENTATION)
 
    std::vector<as::const_buffer> const_buffer_sequence() const;
 
    property::id id() const;
 
    std::size_t size() const;
 
    static constexpr std::size_t num_of_const_buffer_sequence();
 
    constexpr std::string val() const;
 
    constexpr buffer const& val_as_buffer() const;
 
    friend bool operator<(binary_property const& lhs, binary_property const& rhs);
 
    friend bool operator==(binary_property const& lhs, binary_property const& rhs);
 
#endif // defined(GENERATING_DOCUMENTATION)
 
private:
    friend property_variant async_mqtt::make_property_variant(buffer& buf, property_location loc, error_code& ec);
 
    // private constructor for internal use
    template <
        typename Buffer,
        std::enable_if_t<std::is_same_v<Buffer, buffer>, std::nullptr_t> = nullptr
    >
    explicit reason_string(Buffer&& val, error_code& ec);
};
 
class receive_maximum : public detail::n_bytes_property<2> {
public:
    explicit receive_maximum(std::uint16_t val);
 
    std::uint16_t val() const;
 
private:
    friend property_variant async_mqtt::make_property_variant(buffer& buf, property_location loc, error_code& ec);
 
    // private constructor for internal use
    template <typename It, typename End>
    explicit receive_maximum(It b, End e, error_code& ec);
};
 
 
class topic_alias_maximum : public detail::n_bytes_property<2> {
public:
    explicit topic_alias_maximum(std::uint16_t val);
 
    std::uint16_t val() const;
 
private:
    friend property_variant async_mqtt::make_property_variant(buffer& buf, property_location loc, error_code& ec);
 
    // private constructor for internal use
    template <typename It, typename End>
    explicit topic_alias_maximum(It b, End e);
};
 
 
class topic_alias : public detail::n_bytes_property<2> {
public:
    explicit topic_alias(std::uint16_t val);
 
    std::uint16_t val() const;
 
private:
    friend property_variant async_mqtt::make_property_variant(buffer& buf, property_location loc, error_code& ec);
 
    // private constructor for internal use
    template <typename It, typename End>
    explicit topic_alias(It b, End e);
};
 
class maximum_qos : public detail::n_bytes_property<1> {
public:
    explicit maximum_qos(qos value);
 
    qos val() const;
 
    static constexpr const detail::ostream_format of_ = detail::ostream_format::int_cast;
 
private:
    friend property_variant async_mqtt::make_property_variant(buffer& buf, property_location loc, error_code& ec);
 
    // private constructor for internal use
    template <typename It, typename End>
    explicit maximum_qos(It b, End e, error_code& ec);
};
 
class retain_available : public detail::n_bytes_property<1> {
public:
    explicit retain_available(bool value);
 
    bool val() const;
 
private:
    friend property_variant async_mqtt::make_property_variant(buffer& buf, property_location loc, error_code& ec);
 
    // private constructor for internal use
    template <typename It, typename End>
    explicit retain_available(It b, End e);
};
 
 
class user_property : private boost::totally_ordered<user_property> {
public:
    explicit user_property(std::string key, std::string val);
 
    std::vector<as::const_buffer> const_buffer_sequence() const;
 
    property::id id() const;
 
    std::size_t size() const;
 
    static constexpr std::size_t num_of_const_buffer_sequence();
 
    std::string key() const;
 
    std::string val() const;
 
    constexpr buffer const& key_as_buffer() const;
 
    constexpr buffer const& val_as_buffer() const;
 
    friend bool operator<(user_property const& lhs, user_property const& rhs) {
        return std::tie(lhs.id_, lhs.key_.buf, lhs.val_.buf) < std::tie(rhs.id_, rhs.key_.buf, rhs.val_.buf);
    }
 
    friend bool operator==(user_property const& lhs, user_property const& rhs) {
        return std::tie(lhs.id_, lhs.key_.buf, lhs.val_.buf) == std::tie(rhs.id_, rhs.key_.buf, rhs.val_.buf);
    }
 
    static constexpr detail::ostream_format const of_ = detail::ostream_format::key_val;
 
private:
    friend property_variant async_mqtt::make_property_variant(buffer& buf, property_location loc, error_code& ec);
 
    // private constructor for internal use
    template <
        typename Buffer,
        std::enable_if_t<std::is_same_v<Buffer, buffer>, std::nullptr_t> = nullptr
    >
    explicit user_property(Buffer&& key, Buffer&& val, error_code& ec);
 
private:
    property::id id_ = id::user_property;
    detail::len_str key_;
    detail::len_str val_;
};
 
class maximum_packet_size : public detail::n_bytes_property<4> {
public:
    explicit maximum_packet_size(std::uint32_t val);
 
    std::uint32_t val() const;
 
private:
    friend property_variant async_mqtt::make_property_variant(buffer& buf, property_location loc, error_code& ec);
 
    // private constructor for internal use
    template <typename It, typename End>
    explicit maximum_packet_size(It b, End e, error_code& ec);
};
 
 
class wildcard_subscription_available : public detail::n_bytes_property<1> {
public:
    explicit wildcard_subscription_available(bool value);
 
    bool val() const;
 
private:
    friend property_variant async_mqtt::make_property_variant(buffer& buf, property_location loc, error_code& ec);
 
    // private constructor for internal use
    template <typename It, typename End>
    explicit wildcard_subscription_available(It b, End e);
};
 
 
class subscription_identifier_available : public detail::n_bytes_property<1> {
public:
    explicit subscription_identifier_available(bool value);
 
    bool val() const;
 
private:
    friend property_variant async_mqtt::make_property_variant(buffer& buf, property_location loc, error_code& ec);
 
    // private constructor for internal use
    template <typename It, typename End>
    explicit subscription_identifier_available(It b, End e);
};
 
 
class shared_subscription_available : public detail::n_bytes_property<1> {
public:
    explicit shared_subscription_available(bool value);
 
    bool val() const;
 
private:
    friend property_variant async_mqtt::make_property_variant(buffer& buf, property_location loc, error_code& ec);
 
    // private constructor for internal use
    template <typename It, typename End>
    explicit shared_subscription_available(It b, End e);
};
 
template <typename Property>
std::enable_if_t<
    Property::of_ == detail::ostream_format::direct,
    std::ostream&
>
operator<<(std::ostream& o, Property const& v);
 
template <typename Property>
std::enable_if_t<
    Property::of_ == detail::ostream_format::int_cast,
    std::ostream&
>
operator<<(std::ostream& o, Property const& v);
 
template <typename Property>
std::enable_if_t<
    Property::of_ == detail::ostream_format::key_val,
    std::ostream&
>
operator<<(std::ostream& o, Property const& v);
 
template <typename Property>
std::enable_if_t<
    Property::of_ == detail::ostream_format::binary_string,
    std::ostream&
>
operator<<(std::ostream& o, Property const& v);
 
template <typename Property>
std::enable_if_t<
    Property::of_ == detail::ostream_format::json_like,
    std::ostream&
>
operator<<(std::ostream& o, Property const& v);
 
} // namespace property
 
} // namespace async_mqtt
 
#include <async_mqtt/packet/impl/property.hpp>
 
#endif // ASYNC_MQTT_PACKET_PROPERTY_HPP