feedc0de/boost_mqtt5
1
0
Fork 0
forked from boostorg/mqtt5
Code Pull Requests Activity

Remove using enum constructs

Browse Source 
Summary: related to T13242

Reviewers: ivica

Reviewed By: ivica

Subscribers: miljen, iljazovic

Differential Revision: https://repo.mireo.local/D26841
This commit is contained in:
Korina Šimičević
2023-12-06 08:25:12 +01:00
parent 35b190ef67
commit 3640a4fb2a
6 changed files with 112 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files

90
include/async_mqtt5/error.hpp
View File

@ -80,23 +80,21 @@ enum class error : int {
inline std::string client_error_to_string(error err) {
using enum error;
switch (err) {
case malformed_packet:
case error::malformed_packet:
return "Malformed packet has been detected";
case session_expired:
case error::session_expired:
return "The Client's session does not exist or it has expired. ";
case pid_overrun:
case error::pid_overrun:
return "There are no more available Packet Identifiers to use.";
case invalid_topic:
case error::invalid_topic:
return "The Topic is invalid and "
"does not conform to the specification.";
case qos_not_supported:
case error::qos_not_supported:
return "The Server does not support the specified QoS";
case retain_not_available:
case error::retain_not_available:
return "The Server does not support retained messages.";
case topic_alias_maximum_reached:
case error::topic_alias_maximum_reached:
return "The Client attempted to send a Topic Alias "
"that is greater than Topic Alias Maximum.";
default:
@ -216,10 +214,9 @@ public:
std::string message() const {
switch (_code) {
case 0x00:
using enum reason_codes::category;
if (_category == suback)
if (_category == reason_codes::category::suback)
return "The subscription is accepted with maximum QoS sent at 0";
if (_category == disconnect)
if (_category == reason_codes::category::disconnect)
return "Close the connection normally. Do not send the Will Message";
return "The operation completed successfully";
case 0x01:
@ -325,8 +322,6 @@ public:
namespace reason_codes {
using enum category;
/** No Reason Code. A \ref client::error occurred.*/
constexpr reason_code empty {};
@ -334,10 +329,10 @@ constexpr reason_code empty {};
constexpr reason_code success { 0x00 };
/** Close the connection normally. Do not send the Will Message. */
constexpr reason_code normal_disconnection { 0x00, disconnect };
constexpr reason_code normal_disconnection { 0x00, category::disconnect };
/** The subscription is accepted with maximum QoS sent at 0. */
constexpr reason_code granted_qos_0 { 0x00, suback };
constexpr reason_code granted_qos_0 { 0x00, category::suback };
/** The subscription is accepted with maximum QoS sent at 1. */
constexpr reason_code granted_qos_1 { 0x01 };
@ -475,11 +470,11 @@ constexpr reason_code wildcard_subscriptions_not_supported { 0xa2 };
namespace detail {
using enum category;
template <category cat>
std::pair<reason_code*, size_t> valid_codes()
requires (cat == connack) {
template <
category cat,
std::enable_if_t<cat == category::connack, bool> = true
>
std::pair<reason_code*, size_t> valid_codes() {
static reason_code valid_codes[] = {
success, unspecified_error, malformed_packet,
protocol_error, implementation_specific_error,
@ -496,9 +491,11 @@ requires (cat == connack) {
return std::make_pair(valid_codes, len);
}
template <category cat>
std::pair<reason_code*, size_t> valid_codes()
requires (cat == auth) {
template <
category cat,
std::enable_if_t<cat == category::auth, bool> = true
>
std::pair<reason_code*, size_t> valid_codes() {
static reason_code valid_codes[] = {
success, continue_authentication
};
@ -506,9 +503,13 @@ requires (cat == auth) {
return std::make_pair(valid_codes, len);
}
template <category cat>
std::pair<reason_code*, size_t> valid_codes()
requires (cat == puback || cat == pubrec) {
template <
category cat,
std::enable_if_t<
cat == category::puback || cat == category::pubrec, bool
> = true
>
std::pair<reason_code*, size_t> valid_codes() {
static reason_code valid_codes[] = {
success, no_matching_subscribers, unspecified_error,
implementation_specific_error, not_authorized,
@ -519,9 +520,13 @@ requires (cat == puback || cat == pubrec) {
return std::make_pair(valid_codes, len);
}
template <category cat>
std::pair<reason_code*, size_t> valid_codes()
requires (cat == pubrel || cat == pubcomp) {
template <
category cat,
std::enable_if_t<
cat == category::pubrel || cat == category::pubcomp, bool
> = true
>
std::pair<reason_code*, size_t> valid_codes() {
static reason_code valid_codes[] = {
success, packet_id_not_found
};
@ -529,9 +534,11 @@ requires (cat == pubrel || cat == pubcomp) {
return std::make_pair(valid_codes, len);
}
template <category cat>
std::pair<reason_code*, size_t> valid_codes()
requires (cat == suback) {
template <
category cat,
std::enable_if_t<cat == category::suback, bool> = true
>
std::pair<reason_code*, size_t> valid_codes() {
static reason_code valid_codes[] = {
granted_qos_0, granted_qos_1, granted_qos_2,
unspecified_error, implementation_specific_error,
@ -545,9 +552,11 @@ requires (cat == suback) {
return std::make_pair(valid_codes, len);
}
template <category cat>
std::pair<reason_code*, size_t> valid_codes()
requires (cat == unsuback) {
template <
category cat,
std::enable_if_t<cat == category::unsuback, bool> = true
>
std::pair<reason_code*, size_t> valid_codes() {
static reason_code valid_codes[] = {
success, no_subscription_existed,
unspecified_error, implementation_specific_error,
@ -558,9 +567,11 @@ requires (cat == unsuback) {
return std::make_pair(valid_codes, len);
}
template <category cat>
std::pair<reason_code*, size_t> valid_codes()
requires (cat == disconnect) {
template <
category cat,
std::enable_if_t<cat == category::disconnect, bool> = true
>
std::pair<reason_code*, size_t> valid_codes() {
static reason_code valid_codes[] = {
normal_disconnection, unspecified_error,
malformed_packet,protocol_error,
@ -606,4 +617,5 @@ struct is_error_code_enum <async_mqtt5::client::error> : std::true_type {};
} // end namespace boost::system
#endif // !ASYNC_MQTT5_ERROR_HPP

13
include/async_mqtt5/impl/assemble_op.hpp
View File

@ -171,15 +171,13 @@ public:
private:
static bool valid_header(uint8_t control_byte) {
using enum control_code_e;
auto code = control_code_e(control_byte & 0b11110000);
if (code == publish)
if (code == control_code_e::publish)
return true;
auto res = control_byte & 0b00001111;
if (code == pubrel)
if (code == control_code_e::pubrel)
return res == 0b00000010;
return res == 0b00000000;
}
@ -189,17 +187,18 @@ private:
uint8_t control_byte, byte_citer first, byte_citer last
) {
using namespace decoders;
using enum control_code_e;
if (!valid_header(control_byte))
return complete(client::error::malformed_packet, 0, {}, {});
auto code = control_code_e(control_byte & 0b11110000);
if (code == pingresp)
if (code == control_code_e::pingresp)
return perform(wait_for, asio::transfer_at_least(0));
bool is_reply = code != publish && code != auth && code != disconnect;
bool is_reply = code != control_code_e::publish &&
code != control_code_e::auth &&
code != control_code_e::disconnect;
if (is_reply) {
auto packet_id = decoders::decode_packet_id(first).value();
_svc._replies.dispatch(error_code {}, code, packet_id, first, last);

8
include/async_mqtt5/impl/read_message_op.hpp
View File

@ -83,11 +83,9 @@ private:
uint8_t control_byte,
byte_citer first, byte_citer last
) {
using enum control_code_e;
auto code = control_code_e(control_byte & 0b11110000);
switch (code) {
case publish: {
case control_code_e::publish: {
auto msg = decoders::decode_publish(
control_byte, std::distance(first, last), first
);
@ -99,12 +97,12 @@ private:
publish_rec_op { _svc_ptr }.perform(std::move(*msg));
}
break;
case disconnect: {
case control_code_e::disconnect: {
_svc_ptr->close_stream();
_svc_ptr->open_stream();
}
break;
case auth: {
case control_code_e::auth: {
auto rv = decoders::decode_auth(
std::distance(first, last), first
);

52
test/unit/include/test_common/packet_util.hpp
View File

@ -18,17 +18,16 @@ inline qos_e extract_qos(uint8_t flags) {
}
inline control_code_e extract_code(uint8_t control_byte) {
using enum control_code_e;
constexpr uint8_t mask = 0b11110000;
constexpr uint8_t publish_bits = 0b0011;
constexpr uint8_t special_mask = 0b00000010;
constexpr control_code_e codes_with_non_zero_end[] = {
pubrel, subscribe, unsubscribe
control_code_e::pubrel, control_code_e::subscribe,
control_code_e::unsubscribe
};
if ((control_byte >> 4) == publish_bits)
return publish;
return control_code_e::publish;
if ((control_byte & mask) == control_byte)
return control_code_e(control_byte & mask);
@ -36,29 +35,27 @@ inline control_code_e extract_code(uint8_t control_byte) {
if (control_byte == (uint8_t(special_code) | special_mask))
return special_code;
return no_packet;
return control_code_e::no_packet;
}
inline std::string_view code_to_str(control_code_e code) {
using enum control_code_e;
switch (code) {
case connect: return "CONNECT";
case connack: return "CONNACK";
case publish: return "PUBLISH";
case puback: return "PUBACK";
case pubrec: return "PUBREC";
case pubrel: return "PUBREL";
case pubcomp: return "PUBCOMP";
case subscribe: return "SUBSCRIBE";
case suback: return "SUBACK";
case unsubscribe: return "UNSUBSCRIBE";
case unsuback: return "UNSUBACK";
case auth: return "AUTH";
case disconnect: return "DISCONNECT";
case pingreq: return "PINGREQ";
case pingresp: return "PINGRESP";
case control_code_e::connect: return "CONNECT";
case control_code_e::connack: return "CONNACK";
case control_code_e::publish: return "PUBLISH";
case control_code_e::puback: return "PUBACK";
case control_code_e::pubrec: return "PUBREC";
case control_code_e::pubrel: return "PUBREL";
case control_code_e::pubcomp: return "PUBCOMP";
case control_code_e::subscribe: return "SUBSCRIBE";
case control_code_e::suback: return "SUBACK";
case control_code_e::unsubscribe: return "UNSUBSCRIBE";
case control_code_e::unsuback: return "UNSUBACK";
case control_code_e::auth: return "AUTH";
case control_code_e::disconnect: return "DISCONNECT";
case control_code_e::pingreq: return "PINGREQ";
case control_code_e::pingresp: return "PINGRESP";
}
return "UNKNOWN";
}
@ -66,12 +63,10 @@ inline std::string_view code_to_str(control_code_e code) {
inline std::string to_readable_packet(
std::string packet, error_code ec = {}, bool incoming = false
) {
using enum control_code_e;
auto control_byte = uint8_t(*packet.data());
auto code = extract_code(control_byte);
if (code == no_packet)
if (code == control_code_e::no_packet)
return {};
std::ostringstream stream;
@ -79,7 +74,10 @@ inline std::string to_readable_packet(
if (incoming)
stream << "-> ";
if (code == connect || code == connack || code == disconnect) {
if (
code == control_code_e::connect || code == control_code_e::connack ||
code == control_code_e::disconnect
) {
stream << code_to_str(code) << (ec ? " ec: " + ec.message() : "");
return stream.str();
}
@ -89,7 +87,7 @@ inline std::string to_readable_packet(
begin, packet.cend(), decoders::basic::varint_
);
if (code == publish) {
if (code == control_code_e::publish) {
auto publish = decoders::decode_publish(
control_byte, *varlen, begin
);

35
test/unit/test/cancellation.cpp
View File

@ -5,25 +5,24 @@
#include <boost/asio/detached.hpp>
#include <boost/asio/io_context.hpp>
#include <boost/asio/steady_timer.hpp>
#include <boost/asio/use_awaitable.hpp>
#include <async_mqtt5.hpp>
using namespace async_mqtt5;
constexpr auto use_nothrow_awaitable = asio::as_tuple(asio::use_awaitable);
namespace async_mqtt5::test {
enum cancellation_type {
enum cancel_type {
ioc_stop = 1,
client_cancel
};
} // end namespace async_mqtt5::test
template <test::cancellation_type type>
template <test::cancel_type type>
void cancel_async_receive() {
using enum test::cancellation_type;
using namespace test;
constexpr int num_handlers = 3;
constexpr int expected_handlers_called = type == ioc_stop ? 0 : num_handlers;
@ -59,9 +58,9 @@ void cancel_async_receive() {
BOOST_CHECK_EQUAL(handlers_called, expected_handlers_called);
}
template <test::cancellation_type type>
template <test::cancel_type type>
void cancel_async_publish() {
using enum test::cancellation_type;
using namespace test;
constexpr int expected_handlers_called = type == ioc_stop ? 0 : 3;
int handlers_called = 0;
@ -113,9 +112,9 @@ void cancel_async_publish() {
BOOST_CHECK_EQUAL(handlers_called, expected_handlers_called);
}
template <test::cancellation_type type>
template <test::cancel_type type>
void cancel_during_connecting() {
using enum test::cancellation_type;
using namespace test;
constexpr int expected_handlers_called = type == ioc_stop ? 0 : 1;
int handlers_called = 0;
@ -155,32 +154,36 @@ BOOST_AUTO_TEST_SUITE(cancellation/*, *boost::unit_test::disabled()*/)
BOOST_AUTO_TEST_CASE(ioc_stop_async_receive) {
cancel_async_receive<test::ioc_stop>();
cancel_async_receive<test::cancel_type::ioc_stop>();
}
BOOST_AUTO_TEST_CASE(client_cancel_async_receive) {
cancel_async_receive<test::client_cancel>();
cancel_async_receive<test::cancel_type::client_cancel>();
}
// passes on debian, hangs on windows in io_context destructor
BOOST_AUTO_TEST_CASE(ioc_stop_async_publish, *boost::unit_test::disabled() ) {
cancel_async_publish<test::ioc_stop>();
cancel_async_publish<test::cancel_type::ioc_stop>();
}
BOOST_AUTO_TEST_CASE(client_cancel_async_publish) {
cancel_async_publish<test::client_cancel>();
cancel_async_publish<test::cancel_type::client_cancel>();
}
// passes on debian, hangs on windows
BOOST_AUTO_TEST_CASE(ioc_stop_cancel_during_connecting, *boost::unit_test::disabled() ) {
cancel_during_connecting<test::ioc_stop>();
cancel_during_connecting<test::cancel_type::ioc_stop>();
}
BOOST_AUTO_TEST_CASE(client_cancel_during_connecting) {
cancel_during_connecting<test::client_cancel>();
cancel_during_connecting<test::cancel_type::client_cancel>();
}
#ifdef BOOST_ASIO_HAS_CO_AWAIT
constexpr auto use_nothrow_awaitable = asio::as_tuple(asio::use_awaitable);
BOOST_AUTO_TEST_CASE(rerunning_the_client) {
asio::io_context ioc;
@ -222,4 +225,6 @@ BOOST_AUTO_TEST_CASE(rerunning_the_client) {
ioc.run();
}
#endif
BOOST_AUTO_TEST_SUITE_END();

9
test/unit/test/coroutine.cpp
View File

@ -1,11 +1,13 @@
#include <boost/test/unit_test.hpp>
#include <boost/asio/use_awaitable.hpp>
#ifdef BOOST_ASIO_HAS_CO_AWAIT
#include <boost/asio/as_tuple.hpp>
#include <boost/asio/co_spawn.hpp>
#include <boost/asio/detached.hpp>
#include <boost/asio/io_context.hpp>
#include <boost/asio/steady_timer.hpp>
#include <boost/asio/use_awaitable.hpp>
#include <boost/beast/websocket.hpp>
@ -60,7 +62,7 @@ asio::awaitable<void> sanity_check(mqtt_client<StreamType, TlsContext>& c) {
auto [rec, topic, payload, publish_props] = co_await c.async_receive(use_nothrow_awaitable);
auto [unsub_ec, unsub_codes, unsub_props] = co_await c.async_unsubscribe(
std::vector<std::string>{"test/mqtt-test"}, unsubscribe_props{},
std::vector<std::string>{"test/mqtt-test"}, unsubscribe_props {},
use_nothrow_awaitable
);
BOOST_CHECK(!unsub_ec);
@ -145,3 +147,6 @@ BOOST_AUTO_TEST_CASE(websocket_tcp_client_check) {
}
BOOST_AUTO_TEST_SUITE_END()
#endif