...
This commit is contained in:
@@ -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;
|
||||
|
||||
@@ -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<>>, "!!!");
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -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();
|
||||
};
|
||||
|
||||
@@ -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() {}
|
||||
};
|
||||
|
||||
Reference in New Issue
Block a user