This commit is contained in:
Timur A. Fatkhullin
2026-10-07 23:23:01 +03:00
parent d40151c67d
commit 9f8647be8c
2 changed files with 98 additions and 83 deletions

View File

@@ -12,101 +12,68 @@
namespace snplib
{
// default implementation of the "net_repr_proto_result_c"
template <char_range_or_range_of_char_ranges_c OR>
struct net_repr_proto_result_t {
enum class result_flag_t : int { OK, NOT_ENOUGH_DATA, INVALID_DATA };
result_flag_t flag{result_flag_t::INVALID_DATA};
OR result{};
};
static_assert(net_repr_proto_result_c<net_repr_proto_result_t<std::span<const char>>>, "!!!");
static_assert(std::ranges::output_range<std::span<char>, char>);
/* TRIVIAL NO-OP PROTOCOL */
struct netproto_noop_t {
// copy
template <output_char_range_c OR, input_char_range_c IR>
OR toNetwork(IR&& message)
net_repr_proto_result_t<OR> toNetwork(IR&& message)
{
OR res;
std::ranges::copy(std::forward<IR>(message), std::back_inserter(res));
return res;
using ret_t = net_repr_proto_result_t<OR>;
return ret_t{.flag = ret_t::result_flag_t::OK, .result = transform_char_range<OR>(message)};
}
template <input_char_range_c IR>
auto toNetwork(IR&& message)
auto toNetwork(IR&& message) -> std::conditional_t<
std::ranges::contiguous_range<IR>,
net_repr_proto_result_t<std::span<const char>>,
net_repr_proto_result_t<std::ranges::subrange<std::ranges::iterator_t<IR>, std::ranges::sentinel_t<IR>>>>
{
if constexpr (std::ranges::contiguous_range<IR>) {
return std::span<const char>{message};
return toNetwork<std::span<const char>>(std::forward<IR>(message));
} else {
return std::ranges::subrange(message);
return toNetwork<std::ranges::subrange<std::ranges::iterator_t<IR>, std::ranges::sentinel_t<IR>>>(
std::forward<IR>(message));
}
}
};
template <std::ranges::range OR, input_char_range_c IR>
std::expected<OR, std::error_code> fromNetwork(IR&& bytes)
net_repr_proto_result_t<OR> 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!");
}
return toNetwork<OR>(std::forward<IR>(bytes));
}
// deduces a view-type from the input range-type
template <typename IR>
template <input_char_range_c 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));
return toNetwork(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);
}
// // to satisfy 'net_proto_c' concept
// template <typename CharT = char>
// requires(std::same_as<CharT, char> || std::same_as<CharT, const char>)
// net_repr_proto_result_t<std::span<CharT>> fromNetwork(std::span<CharT> bytes)
// {
// return fromNetwork<std::span<CharT>>(bytes);
// }
};
static_assert(net_repr_proto_c<netproto_noop_t>, "!!!");
/* SIMPLE STOP-SEQUENCE PROTOCOL */
@@ -120,6 +87,40 @@ struct netproto_noop_t {
static constexpr char SNPLIB_DEFAULT_NETPROTO_STOP_SEQ[] = "\n";
template <const char* STOP_SEQ = SNPLIB_DEFAULT_NETPROTO_STOP_SEQ>
requires(char_array_size(STOP_SEQ) > 0)
struct _netproto_stopseq_t {
static constexpr std::string_view NETPROTO_STOP_SEQ{STOP_SEQ};
// 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
net_repr_proto_result_t<OR> toNetwork(IR&& message)
{
using res_el_t = std::ranges::range_value_t<OR>;
net_repr_proto_result_t<OR> res{.flag = net_repr_proto_result_t<OR>::result_flag_t::OK};
std::back_inserter(res.result) = transform_char_range<res_el_t>(std::forward<IR>(message));
std::back_inserter(res.result) = transform_char_range<res_el_t>(NETPROTO_STOP_SEQ);
return res;
}
// returns a copy of the input message + tralling stop-sequence
template <output_char_range_c OR, input_char_range_c IR>
net_repr_proto_result_t<OR> toNetwork(IR&& message)
{
net_repr_proto_result_t<OR> res{.flag = net_repr_proto_result_t<OR>::result_flag_t::OK};
std::ranges::copy(std::forward<IR>(message), std::back_inserter(res.result));
std::ranges::copy(NETPROTO_STOP_SEQ, std::back_inserter(res.result));
return res;
}
};
template <const char* STOP_SEQ = SNPLIB_DEFAULT_NETPROTO_STOP_SEQ>
requires(char_array_size(STOP_SEQ) > 0)
struct netproto_stopseq_t {

View File

@@ -42,21 +42,20 @@ concept net_message_c = requires(const T t_const) {
});
};
template <typename T>
concept net_repr_proto_result_c = requires(T t) {
typename T::result_flag_t;
[]() {
[[maybe_unused]] static constexpr std::array arr{T::result_flag_t::OK,
[[maybe_unused]] static constexpr std::array arr{// OK!
T::result_flag_t::OK,
// needs more data
T::result_flag_t::NOT_ENOUGH_DATA,
// given byte sequence is invalid
T::result_flag_t::INVALID_DATA};
}();
// static_cast<bool>(T::NOT_ENOUGH_DATA) != false;
// static_cast<bool>(T::INVALID_DATA) != false;
std::same_as<typename T::result_flag_t, decltype(t.flag)>;
char_range_or_range_of_char_ranges_c<decltype(t.result)>;
@@ -90,20 +89,35 @@ concept net_repr_proto_c = requires(T t) {
// sequence to be sent over transport level (TCP, UDP etc...))
// The method may add some "markers" (e.g. "stop symbols") to the input byte sequence to encode
// sequence of messages
{ t.toNetwork(std::declval<CharRangeT>()) } -> char_range_or_range_of_char_ranges_c;
requires(
requires {
{ t.toNetwork(std::declval<std::span<const char>>()) } -> net_repr_proto_result_c;
} ||
requires {
{ t.toNetwork(std::declval<std::span<char>>()) } -> net_repr_proto_result_c;
});
{ t.toNetwork(std::declval<CharRangeT>()) } -> net_repr_proto_result_c;
// { t.toNetwork(std::declval<CharRangeT>()) } -> char_range_or_range_of_char_ranges_c;
// from "network"-ready 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())>>;
{ t.fromNetwork(std::declval<std::span<const char>>()) } -> net_repr_proto_result_c;
} ||
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())>>;
});
{ t.fromNetwork(std::declval<std::span<char>>()) } -> net_repr_proto_result_c;
}
// 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())>>;
// }
);
};