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