error.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_ERROR_HPP)
#define ASYNC_MQTT_ERROR_HPP
 
#include <exception>
#include <sstream>
#include <string_view>
 
#include <boost/system/error_code.hpp>
#include <boost/system/system_error.hpp>
#include <boost/assert.hpp>
#include <boost/operators.hpp>
 
namespace async_mqtt {
 
namespace sys = boost::system;
 
namespace errc = sys::errc;
 
using error_code = sys::error_code;
 
using system_error = sys::system_error;
 
 
 
 
enum class mqtt_error {
    partial_error_detected                 = 0x0101, 
    all_error_detected                     = 0x0180, 
    packet_identifier_fully_used           = 0x0181, 
    packet_identifier_conflict             = 0x0182, 
    packet_not_allowed_to_send             = 0x0183, 
    packet_not_allowed_to_store            = 0x0185, 
    packet_not_regulated                   = 0x0186, 
};
 
error_code make_error_code(mqtt_error v);
 
constexpr char const* mqtt_error_to_string(mqtt_error v);
 
std::ostream& operator<<(std::ostream& o, mqtt_error v);
 
sys::error_category const& get_mqtt_error_category();
 
 
enum class connect_return_code : std::uint8_t {
    accepted                      = 0, 
    unacceptable_protocol_version = 1, 
    identifier_rejected           = 2, 
    server_unavailable            = 3, 
    bad_user_name_or_password     = 4, 
    not_authorized                = 5, 
};
 
error_code make_error_code(connect_return_code v);
 
constexpr char const* connect_return_code_to_string(connect_return_code v);
 
std::ostream& operator<<(std::ostream& o, connect_return_code v);
 
sys::error_category const& get_connect_return_code_category();
 
 
enum class suback_return_code : std::uint8_t {
    success_maximum_qos_0                  = 0x00, 
    success_maximum_qos_1                  = 0x01, 
    success_maximum_qos_2                  = 0x02, 
    failure                                = 0x80, 
};
 
error_code make_error_code(suback_return_code v);
 
constexpr char const* suback_return_code_to_string(suback_return_code v);
 
std::ostream& operator<<(std::ostream& o, suback_return_code v);
 
sys::error_category const& get_suback_return_code_category();
 
 
enum class connect_reason_code : std::uint8_t {
    success                       = 0x00, 
    unspecified_error             = 0x80, 
    malformed_packet              = 0x81, 
    protocol_error                = 0x82, 
    implementation_specific_error = 0x83, 
    unsupported_protocol_version  = 0x84, 
    client_identifier_not_valid   = 0x85, 
    bad_user_name_or_password     = 0x86, 
    not_authorized                = 0x87, 
    server_unavailable            = 0x88, 
    server_busy                   = 0x89, 
    banned                        = 0x8a, 
    bad_authentication_method     = 0x8c, 
    topic_name_invalid            = 0x90, 
    packet_too_large              = 0x95, 
    quota_exceeded                = 0x97, 
    payload_format_invalid        = 0x99, 
    retain_not_supported          = 0x9a, 
    qos_not_supported             = 0x9b, 
    use_another_server            = 0x9c, 
    server_moved                  = 0x9d, 
    connection_rate_exceeded      = 0x9f, 
};
 
error_code make_error_code(connect_reason_code v);
 
constexpr char const* connect_reason_code_to_string(connect_reason_code v);
 
std::ostream& operator<<(std::ostream& o, connect_reason_code v);
 
sys::error_category const& get_connect_reason_code_category();
 
 
enum class disconnect_reason_code : std::uint8_t {
    normal_disconnection                   = 0x00, 
    disconnect_with_will_message           = 0x04, 
    unspecified_error                      = 0x80, 
    malformed_packet                       = 0x81, 
    protocol_error                         = 0x82, 
    implementation_specific_error          = 0x83, 
    not_authorized                         = 0x87, 
    server_busy                            = 0x89, 
    server_shutting_down                   = 0x8b, 
    keep_alive_timeout                     = 0x8d, 
    session_taken_over                     = 0x8e, 
    topic_filter_invalid                   = 0x8f, 
    topic_name_invalid                     = 0x90, 
    receive_maximum_exceeded               = 0x93, 
    topic_alias_invalid                    = 0x94, 
    packet_too_large                       = 0x95, 
    message_rate_too_high                  = 0x96, 
    quota_exceeded                         = 0x97, 
    administrative_action                  = 0x98, 
    payload_format_invalid                 = 0x99, 
    retain_not_supported                   = 0x9a, 
    qos_not_supported                      = 0x9b, 
    use_another_server                     = 0x9c, 
    server_moved                           = 0x9d, 
    shared_subscriptions_not_supported     = 0x9e, 
    connection_rate_exceeded               = 0x9f, 
    maximum_connect_time                   = 0xa0, 
    subscription_identifiers_not_supported = 0xa1, 
    wildcard_subscriptions_not_supported   = 0xa2, 
};
 
error_code make_error_code(disconnect_reason_code v);
 
constexpr char const* disconnect_reason_code_to_string(disconnect_reason_code v);
 
std::ostream& operator<<(std::ostream& o, disconnect_reason_code v);
 
sys::error_category const& get_disconnect_reason_code_category();
 
 
enum class suback_reason_code : std::uint8_t {
    granted_qos_0                          = 0x00, 
    granted_qos_1                          = 0x01, 
    granted_qos_2                          = 0x02, 
    unspecified_error                      = 0x80, 
    implementation_specific_error          = 0x83, 
    not_authorized                         = 0x87, 
    topic_filter_invalid                   = 0x8f, 
    packet_identifier_in_use               = 0x91, 
    quota_exceeded                         = 0x97, 
    shared_subscriptions_not_supported     = 0x9e, 
    subscription_identifiers_not_supported = 0xa1, 
    wildcard_subscriptions_not_supported   = 0xa2, 
};
 
error_code make_error_code(suback_reason_code v);
 
constexpr char const* suback_reason_code_to_string(suback_reason_code v);
 
std::ostream& operator<<(std::ostream& o, suback_reason_code v);
 
sys::error_category const& get_suback_reason_code_category();
 
 
enum class unsuback_reason_code : std::uint8_t {
    success                       = 0x00, 
    no_subscription_existed       = 0x11, 
    unspecified_error             = 0x80, 
    implementation_specific_error = 0x83, 
    not_authorized                = 0x87, 
    topic_filter_invalid          = 0x8f, 
    packet_identifier_in_use      = 0x91, 
};
 
error_code make_error_code(unsuback_reason_code v);
 
constexpr char const* unsuback_reason_code_to_string(unsuback_reason_code v);
 
std::ostream& operator<<(std::ostream& o, unsuback_reason_code v);
 
sys::error_category const& get_unsuback_reason_code_category();
 
 
enum class puback_reason_code : std::uint8_t {
    success                       = 0x00, 
    no_matching_subscribers       = 0x10, 
    unspecified_error             = 0x80, 
    implementation_specific_error = 0x83, 
    not_authorized                = 0x87, 
    topic_name_invalid            = 0x90, 
    packet_identifier_in_use      = 0x91, 
    quota_exceeded                = 0x97, 
    payload_format_invalid        = 0x99, 
};
 
error_code make_error_code(puback_reason_code v);
 
constexpr char const* puback_reason_code_to_string(puback_reason_code v);
 
std::ostream& operator<<(std::ostream& o, puback_reason_code v);
 
sys::error_category const& get_puback_reason_code_category();
 
 
enum class pubrec_reason_code : std::uint8_t {
    success                       = 0x00, 
    no_matching_subscribers       = 0x10, 
    unspecified_error             = 0x80, 
    implementation_specific_error = 0x83, 
    not_authorized                = 0x87, 
    topic_name_invalid            = 0x90, 
    packet_identifier_in_use      = 0x91, 
    quota_exceeded                = 0x97, 
    payload_format_invalid        = 0x99, 
};
 
error_code make_error_code(pubrec_reason_code v);
 
constexpr char const* pubrec_reason_code_to_string(pubrec_reason_code v);
 
std::ostream& operator<<(std::ostream& o, pubrec_reason_code v);
 
sys::error_category const& get_pubrec_reason_code_category();
 
 
enum class pubrel_reason_code : std::uint8_t {
    success                     = 0x00, 
    packet_identifier_not_found = 0x92, 
};
 
error_code make_error_code(pubrel_reason_code v);
 
constexpr char const* pubrel_reason_code_to_string(pubrel_reason_code v);
 
std::ostream& operator<<(std::ostream& o, pubrel_reason_code v);
 
sys::error_category const& get_pubrel_reason_code_category();
 
 
enum class pubcomp_reason_code : std::uint8_t {
    success                     = 0x00, 
    packet_identifier_not_found = 0x92, 
};
 
error_code make_error_code(pubcomp_reason_code v);
 
constexpr char const* pubcomp_reason_code_to_string(pubcomp_reason_code v);
 
std::ostream& operator<<(std::ostream& o, pubcomp_reason_code v);
 
sys::error_category const& get_pubcomp_reason_code_category();
 
 
enum class auth_reason_code : std::uint8_t {
    success                 = 0x00, 
    continue_authentication = 0x18, 
    re_authenticate         = 0x19, 
};
 
error_code make_error_code(auth_reason_code v);
 
constexpr char const* auth_reason_code_to_string(auth_reason_code v);
 
std::ostream& operator<<(std::ostream& o, auth_reason_code v);
 
sys::error_category const& get_auth_reason_code_category();
 
} // namespace async_mqtt
 
 
namespace boost::system {
 
template <>
struct is_error_code_enum<async_mqtt::mqtt_error> : public std::true_type {};
template <>
struct is_error_code_enum<async_mqtt::connect_reason_code> : public std::true_type {};
template <>
struct is_error_code_enum<async_mqtt::connect_return_code> : public std::true_type {};
template <>
struct is_error_code_enum<async_mqtt::suback_return_code> : public std::true_type {};
template <>
struct is_error_code_enum<async_mqtt::disconnect_reason_code> : public std::true_type {};
template <>
struct is_error_code_enum<async_mqtt::suback_reason_code> : public std::true_type {};
template <>
struct is_error_code_enum<async_mqtt::unsuback_reason_code> : public std::true_type {};
template <>
struct is_error_code_enum<async_mqtt::puback_reason_code> : public std::true_type {};
template <>
struct is_error_code_enum<async_mqtt::pubrec_reason_code> : public std::true_type {};
template <>
struct is_error_code_enum<async_mqtt::pubrel_reason_code> : public std::true_type {};
template <>
struct is_error_code_enum<async_mqtt::pubcomp_reason_code> : public std::true_type {};
template <>
struct is_error_code_enum<async_mqtt::auth_reason_code> : public std::true_type {};
 
} // namespace boost::system
 
#include <async_mqtt/impl/error.hpp>
 
#endif // ASYNC_MQTT_ERROR_HPP