This commit is contained in:
2026-10-01 17:41:05 +03:00
parent bc8c6b64ec
commit 84bde7fb97
4 changed files with 178 additions and 68 deletions

View File

@@ -194,16 +194,28 @@ concept ret_expected_type_c = requires {
}(std::type_identity<std::remove_cvref_t<T>>{});
};
template <typename T>
concept ret_expected_range_c = requires {
[]<std::ranges::range ValT, ret_error_c ErrT>(std::type_identity<std::expected<ValT, ErrT>>) {
}(std::type_identity<std::remove_cvref_t<T>>{});
};
template <typename T>
concept ret_expected_char_range_c = requires {
[]<char_range_c ValT, ret_error_c ErrT>(std::type_identity<std::expected<ValT, ErrT>>) {
}(std::type_identity<std::remove_cvref_t<T>>{});
};
// result of asynchronous callable
template <typename, typename = std::void_t<>>
struct has_co_await_operator : std::false_type {
};
struct has_co_await_operator : std::false_type {};
template <typename T>
struct has_co_await_operator<T, std::void_t<decltype(std::declval<T>().operator co_await())>> : std::true_type {
};
struct has_co_await_operator<T, std::void_t<decltype(std::declval<T>().operator co_await())>> : std::true_type {};
template <typename T>
constexpr bool has_co_await_operator_v = has_co_await_operator<T>::value;

View File

@@ -12,6 +12,101 @@
namespace snplib
{
/* TRIVIAL NO-OP PROTOCOL */
struct netproto_noop_t {
// copy
template <output_char_range_c OR, input_char_range_c IR>
OR toNetwork(IR&& message)
{
OR res;
std::ranges::copy(std::forward<IR>(message), std::back_inserter(res));
return res;
}
template <input_char_range_c IR>
auto toNetwork(IR&& message)
{
if constexpr (std::ranges::contiguous_range<IR>) {
return std::span<const char>{message};
} else {
return std::ranges::subrange(message);
}
}
template <std::ranges::range OR, input_char_range_c IR>
std::expected<OR, std::error_code> fromNetwork(IR&& bytes)
{
using inp_t = std::remove_cvref_t<IR>;
// return a view
static constexpr bool ret_view =
std::ranges::view<OR> && std::ranges::viewable_range<inp_t> &&
(std::constructible_from<OR, std::ranges::iterator_t<inp_t>, std::ranges::iterator_t<inp_t>> ||
std::constructible_from<OR, std::ranges::iterator_t<inp_t>, std::ranges::sentinel_t<inp_t>>);
if constexpr (ret_view) {
return OR(bytes.begin(), bytes.end());
} else if constexpr (output_char_range_c<OR>) {
if constexpr (!fixed_size_range_c<OR>) {
if constexpr (std::constructible_from<OR, std::ranges::iterator_t<inp_t>,
std::ranges::iterator_t<inp_t>>) {
return OR(bytes.begin(), bytes.end());
} else if constexpr (std::is_default_constructible_v<OR>) {
OR res;
std::ranges::copy(
std::forward<IR>(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<OR>) {
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 <typename IR>
auto fromNetwork(IR&& bytes)
requires input_char_range_c<std::remove_cvref_t<IR>>
{
using or_t =
std::conditional_t<std::ranges::contiguous_range<IR>, std::span<const char>,
std::ranges::subrange<std::ranges::iterator_t<IR>, std::ranges::sentinel_t<IR>>>;
return fromNetwork<or_t>(std::forward<IR>(bytes));
}
// to satisfy 'net_proto_c' concept
template <typename CharT = char>
requires(std::same_as<CharT, char> || std::same_as<CharT, const char>)
std::expected<std::span<CharT>, std::error_code> fromNetwork(std::span<CharT> bytes)
{
return fromNetwork<std::span<CharT>>(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 <std::ranges::range OR, input_char_range_c IR>
requires char_range_c<std::ranges::range_value_t<OR>> // 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 <output_char_range_c OR, input_char_range_c IR>
OR toTransport(IR&& message)
OR toNetwork(IR&& message)
{
OR res;
@@ -56,7 +151,7 @@ struct netproto_stopseq_t {
}
template <input_char_range_c IR>
auto toTransport(IR&& message)
auto toNetwork(IR&& message)
{
if constexpr (std::ranges::contiguous_range<IR>) {
return std::array{std::span<const char>{message}, std::span<const char>{NETPROTO_STOP_SEQ}};
@@ -67,7 +162,7 @@ struct netproto_stopseq_t {
}
template <std::ranges::range OR, input_char_range_c IR>
std::expected<OR, std::error_code> fromTransport(IR&& bytes)
std::expected<OR, std::error_code> fromNetwork(IR&& bytes)
{
auto found = std::ranges::search(std::forward<IR>(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 <typename IR>
auto fromTransport(IR&& bytes)
auto fromNetwork(IR&& bytes)
requires input_char_range_c<std::remove_cvref_t<IR>>
{
using or_t =
std::conditional_t<std::ranges::contiguous_range<IR>, std::span<const char>,
std::ranges::subrange<std::ranges::iterator_t<IR>, std::ranges::sentinel_t<IR>>>;
return fromTransport<or_t>(std::forward<IR>(bytes));
return fromNetwork<or_t>(std::forward<IR>(bytes));
}
// to satisfy 'net_proto_c' concept
template <typename CharT = char>
requires(std::same_as<CharT, char> || std::same_as<CharT, const char>)
std::expected<std::span<CharT>, std::error_code> fromTransport(std::span<CharT> bytes)
std::expected<std::span<CharT>, std::error_code> fromNetwork(std::span<CharT> bytes)
{
return fromTransport<std::span<CharT>>(bytes);
return fromNetwork<std::span<CharT>>(bytes);
}
};
static_assert(net_proto_c<netproto_stopseq_t<>>, "!!!");
static_assert(net_connection_proto_c<netproto_stopseq_t<>>, "!!!");
/* BINARY BLOB PROTOCOL */
@@ -164,7 +259,7 @@ struct netproto_binary_blob_t {
static constexpr std::array<char, 6> BLOB_SIZE_FIELD_FORMAT{'{', ':', '0', '0' + BLOB_SIZE_FIELD, 'X', '}'};
template <input_char_range_c IR>
auto toTransport(IR&& message)
auto toNetwork(IR&& message)
{
static thread_local std::string Nbytes{};
@@ -182,7 +277,7 @@ struct netproto_binary_blob_t {
template <char_range_c OR, input_char_range_c IR>
std::expected<OR, std::error_code> fromTransport(IR&& bytes)
std::expected<OR, std::error_code> fromNetwork(IR&& bytes)
{
using inp_t = std::remove_cvref_t<IR>;
@@ -258,28 +353,28 @@ struct netproto_binary_blob_t {
// deduces a view-type from the input range-type
template <typename IR>
auto fromTransport(IR&& bytes)
auto fromNetwork(IR&& bytes)
requires input_char_range_c<std::remove_cvref_t<IR>>
{
using or_t =
std::conditional_t<std::ranges::contiguous_range<IR>, std::span<const char>,
std::ranges::subrange<std::ranges::iterator_t<IR>, std::ranges::sentinel_t<IR>>>;
return fromTransport<or_t>(std::forward<IR>(bytes));
return fromNetwork<or_t>(std::forward<IR>(bytes));
}
// to satisfy 'net_proto_c' concept
template <typename CharT = char>
requires(std::same_as<CharT, char> || std::same_as<CharT, const char>)
std::expected<std::span<CharT>, std::error_code> fromTransport(std::span<CharT> bytes)
std::expected<std::span<CharT>, std::error_code> fromNetwork(std::span<CharT> bytes)
{
return fromTransport<std::span<CharT>>(bytes);
return fromNetwork<std::span<CharT>>(bytes);
}
};
static_assert(net_proto_c<netproto_binary_blob_t<>>, "!!!");
static_assert(net_connection_proto_c<netproto_binary_blob_t<>>, "!!!");

View File

@@ -24,32 +24,13 @@ concept net_endpoint_c = requires(T t, const T t_const) {
};
template <typename T, typename CharRangeT = std::vector<char>>
concept net_proto_c = requires(T t) {
// from session-level representation to transport-level one
{ t.toTransport(std::declval<CharRangeT>()) } -> char_range_or_range_of_char_ranges_c;
// from transport-level representation to session-level one
requires(
requires {
{ t.fromTransport(std::declval<std::span<const char>>()) } -> ret_expected_c;
requires char_range_c<std::remove_cvref_t<
decltype(std::declval<T>().fromTransport(std::declval<std::span<const char>>()).value())>>;
} ||
requires {
{ t.fromTransport(std::declval<std::span<char>>()) } -> ret_expected_c;
requires char_range_c<std::remove_cvref_t<
decltype(std::declval<T>().fromTransport(std::declval<std::span<char>>()).value())>>;
});
};
template <typename T>
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::span<const char>>()) } -> std::same_as<T>;
@@ -61,6 +42,49 @@ concept net_message_c = requires(const T t_const) {
});
};
// template <typename T>
// concept net_connection_proto_c = requires(T t) {
// requires net_message_c<typename T::message_t>;
// // from application-level representation to session-level one
// // returns a byte sequence or range of byte sequences
// { t.toBytes(std::declval<typename T::message_t>()) } -> 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<char> or std::span<const char>)
// requires(
// requires {
// { t.fromBytes(std::declval<std::span<const char>>()) } -> ret_expected_type_c<typename T::message_t>;
// } ||
// requires {
// { t.fromBytes(std::declval<std::span<char>>()) } -> ret_expected_type_c<typename T::message_t>;
// });
// };
template <typename T, typename CharRangeT = std::vector<char>>
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<CharRangeT>()) } -> char_range_or_range_of_char_ranges_c;
// from session level representation to byte sequence payload representation
requires(
requires {
{ t.fromNetwork(std::declval<std::span<const char>>()) } -> ret_expected_c;
requires char_range_c<std::remove_cvref_t<
decltype(std::declval<T>().fromNetwork(std::declval<std::span<const char>>()).value())>>;
} ||
requires {
{ t.fromNetwork(std::declval<std::span<char>>()) } -> ret_expected_c;
requires char_range_c<
std::remove_cvref_t<decltype(std::declval<T>().fromNetwork(std::declval<std::span<char>>()).value())>>;
});
};
template <typename T>
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<typename T::message_t>()) } -> async_retval_c<typename T::error_t>;
{ t.send(std::declval<typename T::message_t>()) } -> awaitable_ret_type_c<typename T::error_t>;
// { t.recv() } -> async_retval_c<typename T::message_t>;
{ t.recv() } -> awaitable_ret_type_c<typename T::message_t>;
// [] {
// typename T::message_t msg;
// co_await t.send(msg);
// }();
{
t.recv()
} -> awaitable_ret_expected_type_c<typename T::message_t>; // must return std::expected<message_t, error_t>
t.close();
};

View File

@@ -12,7 +12,7 @@
namespace snplib::asio
{
template <net_message_c NETMSG_T, net_proto_c NETPROTO_T>
template <net_message_c NETMSG_T, net_connection_proto_c NETPROTO_T>
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<message_t, error_t> result_t;
typedef std::expected<message_t, error_t> recv_result_t;
static constexpr std::string_view id{"ASIO-NETCONN"};
// ::asio::awaitable<void> 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<void> recv() {}
// ::asio::awaitable<void> close() {}
// ::asio::experimental::coro<error_t> send(asio_net_connection_t::message_t msg) {}
::asio::awaitable<error_t> send(asio_net_connection_t::message_t msg) {}
::asio::awaitable<message_t> recv() {}
::asio::awaitable<asio_net_connection_t::recv_result_t> recv() {}
::asio::awaitable<error_t> close() {}
};