From 84bde7fb9746ca5864e75f3d6024809df70a73c2 Mon Sep 17 00:00:00 2001 From: "Timur A. Fatkhullin" Date: Thu, 1 Oct 2026 17:41:05 +0300 Subject: [PATCH] ... --- include/snipplib/concepts/snplib_concepts.h | 20 ++- include/snipplib/network/snplib_netproto.h | 127 +++++++++++++++--- include/snipplib/network/snplib_network.h | 76 +++++++---- .../snipplib/network/snplib_network_asio.h | 23 +--- 4 files changed, 178 insertions(+), 68 deletions(-) diff --git a/include/snipplib/concepts/snplib_concepts.h b/include/snipplib/concepts/snplib_concepts.h index 43bbd09..55a5789 100644 --- a/include/snipplib/concepts/snplib_concepts.h +++ b/include/snipplib/concepts/snplib_concepts.h @@ -194,16 +194,28 @@ concept ret_expected_type_c = requires { }(std::type_identity>{}); }; +template +concept ret_expected_range_c = requires { + [](std::type_identity>) { + }(std::type_identity>{}); +}; + + +template +concept ret_expected_char_range_c = requires { + [](std::type_identity>) { + }(std::type_identity>{}); +}; + + // result of asynchronous callable template > -struct has_co_await_operator : std::false_type { -}; +struct has_co_await_operator : std::false_type {}; template -struct has_co_await_operator().operator co_await())>> : std::true_type { -}; +struct has_co_await_operator().operator co_await())>> : std::true_type {}; template constexpr bool has_co_await_operator_v = has_co_await_operator::value; diff --git a/include/snipplib/network/snplib_netproto.h b/include/snipplib/network/snplib_netproto.h index c86a5ba..7b9517d 100644 --- a/include/snipplib/network/snplib_netproto.h +++ b/include/snipplib/network/snplib_netproto.h @@ -12,6 +12,101 @@ namespace snplib { +/* TRIVIAL NO-OP PROTOCOL */ + +struct netproto_noop_t { + // copy + template + OR toNetwork(IR&& message) + { + OR res; + + std::ranges::copy(std::forward(message), std::back_inserter(res)); + + return res; + } + + template + auto toNetwork(IR&& message) + { + if constexpr (std::ranges::contiguous_range) { + return std::span{message}; + } else { + return std::ranges::subrange(message); + } + } + + + template + std::expected fromNetwork(IR&& bytes) + { + using inp_t = std::remove_cvref_t; + + // return a view + static constexpr bool ret_view = + std::ranges::view && std::ranges::viewable_range && + (std::constructible_from, std::ranges::iterator_t> || + std::constructible_from, std::ranges::sentinel_t>); + + + if constexpr (ret_view) { + return OR(bytes.begin(), bytes.end()); + } else if constexpr (output_char_range_c) { + if constexpr (!fixed_size_range_c) { + if constexpr (std::constructible_from, + std::ranges::iterator_t>) { + return OR(bytes.begin(), bytes.end()); + } else if constexpr (std::is_default_constructible_v) { + OR res; + std::ranges::copy( + std::forward(bytes) | std::views::take(std::distance(bytes.begin(), bytes.end())), + std::back_inserter(res)); + + return res; + } else { + static_assert(false, "Unsupported output byte sequence type!"); + } + } else { + auto Nelem = std::distance(bytes.begin(), bytes.end()); + if (Nelem > std::tuple_size_v) { + return std::unexpected(std::make_error_code(std::errc::invalid_seek)); + } + + OR res; + auto data_it = bytes.begin(); + for (auto it = res.begin(); it != res.end(); std::advance(it, 1)) { + *it = *data_it; + std::advance(data_it, 1); + } + + return res; + } + } else { + static_assert(false, "Unsupported output byte sequence type!"); + } + } + + // deduces a view-type from the input range-type + template + auto fromNetwork(IR&& bytes) + requires input_char_range_c> + { + using or_t = + std::conditional_t, std::span, + std::ranges::subrange, std::ranges::sentinel_t>>; + + return fromNetwork(std::forward(bytes)); + } + + // to satisfy 'net_proto_c' concept + template + requires(std::same_as || std::same_as) + std::expected, std::error_code> fromNetwork(std::span bytes) + { + return fromNetwork>(bytes); + } +}; + /* SIMPLE STOP-SEQUENCE PROTOCOL */ @@ -33,7 +128,7 @@ struct netproto_stopseq_t { // returns 2-element range of the input messsage and stop-sequence template requires char_range_c> // range of char ranges - OR toTransport(IR&& message) + OR toNetwork(IR&& message) { OR res; @@ -45,7 +140,7 @@ struct netproto_stopseq_t { // returns a copy of the input message + tralling stop-sequence template - OR toTransport(IR&& message) + OR toNetwork(IR&& message) { OR res; @@ -56,7 +151,7 @@ struct netproto_stopseq_t { } template - auto toTransport(IR&& message) + auto toNetwork(IR&& message) { if constexpr (std::ranges::contiguous_range) { return std::array{std::span{message}, std::span{NETPROTO_STOP_SEQ}}; @@ -67,7 +162,7 @@ struct netproto_stopseq_t { } template - std::expected fromTransport(IR&& bytes) + std::expected fromNetwork(IR&& bytes) { auto found = std::ranges::search(std::forward(bytes), NETPROTO_STOP_SEQ); if (found.empty()) { @@ -122,27 +217,27 @@ struct netproto_stopseq_t { // deduces a view-type from the input range-type template - auto fromTransport(IR&& bytes) + auto fromNetwork(IR&& bytes) requires input_char_range_c> { using or_t = std::conditional_t, std::span, std::ranges::subrange, std::ranges::sentinel_t>>; - return fromTransport(std::forward(bytes)); + return fromNetwork(std::forward(bytes)); } // to satisfy 'net_proto_c' concept template requires(std::same_as || std::same_as) - std::expected, std::error_code> fromTransport(std::span bytes) + std::expected, std::error_code> fromNetwork(std::span bytes) { - return fromTransport>(bytes); + return fromNetwork>(bytes); } }; -static_assert(net_proto_c>, "!!!"); +static_assert(net_connection_proto_c>, "!!!"); /* BINARY BLOB PROTOCOL */ @@ -164,7 +259,7 @@ struct netproto_binary_blob_t { static constexpr std::array BLOB_SIZE_FIELD_FORMAT{'{', ':', '0', '0' + BLOB_SIZE_FIELD, 'X', '}'}; template - auto toTransport(IR&& message) + auto toNetwork(IR&& message) { static thread_local std::string Nbytes{}; @@ -182,7 +277,7 @@ struct netproto_binary_blob_t { template - std::expected fromTransport(IR&& bytes) + std::expected fromNetwork(IR&& bytes) { using inp_t = std::remove_cvref_t; @@ -258,28 +353,28 @@ struct netproto_binary_blob_t { // deduces a view-type from the input range-type template - auto fromTransport(IR&& bytes) + auto fromNetwork(IR&& bytes) requires input_char_range_c> { using or_t = std::conditional_t, std::span, std::ranges::subrange, std::ranges::sentinel_t>>; - return fromTransport(std::forward(bytes)); + return fromNetwork(std::forward(bytes)); } // to satisfy 'net_proto_c' concept template requires(std::same_as || std::same_as) - std::expected, std::error_code> fromTransport(std::span bytes) + std::expected, std::error_code> fromNetwork(std::span bytes) { - return fromTransport>(bytes); + return fromNetwork>(bytes); } }; -static_assert(net_proto_c>, "!!!"); +static_assert(net_connection_proto_c>, "!!!"); diff --git a/include/snipplib/network/snplib_network.h b/include/snipplib/network/snplib_network.h index 50d3e1b..3fd21ef 100644 --- a/include/snipplib/network/snplib_network.h +++ b/include/snipplib/network/snplib_network.h @@ -24,32 +24,13 @@ concept net_endpoint_c = requires(T t, const T t_const) { }; -template > -concept net_proto_c = requires(T t) { - // from session-level representation to transport-level one - { t.toTransport(std::declval()) } -> char_range_or_range_of_char_ranges_c; - - // from transport-level representation to session-level one - requires( - requires { - { t.fromTransport(std::declval>()) } -> ret_expected_c; - requires char_range_c().fromTransport(std::declval>()).value())>>; - } || - requires { - { t.fromTransport(std::declval>()) } -> ret_expected_c; - requires char_range_c().fromTransport(std::declval>()).value())>>; - }); -}; - template concept net_message_c = requires(const T t_const) { - // { t.toBytes() } -> char_range_or_range_of_char_ranges_c; + // byte-sequence representation of the message payload { t_const.toBytes() } -> char_range_c; - // can be constructed from contiguous byte range + // the message payload can be constructed from contiguous byte range requires( requires { // { T::fromBytes(std::declval>()) } -> std::same_as; @@ -61,6 +42,49 @@ concept net_message_c = requires(const T t_const) { }); }; +// template +// concept net_connection_proto_c = requires(T t) { +// requires net_message_c; + +// // from application-level representation to session-level one +// // returns a byte sequence or range of byte sequences +// { t.toBytes(std::declval()) } -> char_range_or_range_of_char_ranges_c; + +// // from session-level representation to application-level one +// // constructs the object of "message_t" type from a byte sequence +// // (at least from the std::span or std::span) +// requires( +// requires { +// { t.fromBytes(std::declval>()) } -> ret_expected_type_c; +// } || +// requires { +// { t.fromBytes(std::declval>()) } -> ret_expected_type_c; +// }); +// }; + + +template > +concept net_connection_proto_c = requires(T t) { + // from byte sequence payload representation to "network"-ready (session) one (a byte sequence to be sent over + // transport level (TCP, UDP etc...)) + { t.toNetwork(std::declval()) } -> char_range_or_range_of_char_ranges_c; + + // from session level representation to byte sequence payload representation + requires( + requires { + { t.fromNetwork(std::declval>()) } -> ret_expected_c; + requires char_range_c().fromNetwork(std::declval>()).value())>>; + } || + requires { + { t.fromNetwork(std::declval>()) } -> ret_expected_c; + requires char_range_c< + std::remove_cvref_t().fromNetwork(std::declval>()).value())>>; + }); +}; + + + template concept net_connection_c = requires(T t) { // static constexpr member @@ -70,15 +94,11 @@ concept net_connection_c = requires(T t) { typename T::message_t; // minimal allowed unit of read/write operations typename T::error_t; - // { t.send(std::declval()) } -> async_retval_c; { t.send(std::declval()) } -> awaitable_ret_type_c; - // { t.recv() } -> async_retval_c; - { t.recv() } -> awaitable_ret_type_c; - // [] { - // typename T::message_t msg; - // co_await t.send(msg); - // }(); + { + t.recv() + } -> awaitable_ret_expected_type_c; // must return std::expected t.close(); }; diff --git a/include/snipplib/network/snplib_network_asio.h b/include/snipplib/network/snplib_network_asio.h index 6a5c466..dfd700d 100644 --- a/include/snipplib/network/snplib_network_asio.h +++ b/include/snipplib/network/snplib_network_asio.h @@ -12,7 +12,7 @@ namespace snplib::asio { -template +template class asio_net_connection_t { public: @@ -20,31 +20,14 @@ public: typedef NETPROTO_T netproto_t; typedef std::error_code error_t; - typedef std::expected result_t; + typedef std::expected recv_result_t; static constexpr std::string_view id{"ASIO-NETCONN"}; - // ::asio::awaitable send(asio_net_connection_t::message_t msg) - // { - // char data[1024]; - // size_t n = 1024; - // auto executor = co_await ::asio::this_coro::executor; - // ::asio::ip::tcp::acceptor acceptor(executor, {::asio::ip::tcp::v4(), 55555}); - - // ::asio::ip::tcp::socket socket = co_await acceptor.async_accept(::asio::use_awaitable); - - // co_await ::asio::async_write(socket, ::asio::buffer(data, n), ::asio::use_awaitable); - // } - - // ::asio::awaitable recv() {} - - // ::asio::awaitable close() {} - - // ::asio::experimental::coro send(asio_net_connection_t::message_t msg) {} ::asio::awaitable send(asio_net_connection_t::message_t msg) {} - ::asio::awaitable recv() {} + ::asio::awaitable recv() {} ::asio::awaitable close() {} };