rewrite tranport-level protocol classes

This commit is contained in:
Timur A. Fatkhullin
2026-10-09 23:33:42 +03:00
parent 1aacc4bca5
commit 07b3d69311
3 changed files with 128 additions and 323 deletions

View File

@@ -17,27 +17,27 @@ int main()
std::println("BYTES VEC: {}", bytes_vec);
auto msg = proto.fromTransport(bytes_vec);
auto msg = proto.fromNetwork(bytes_vec);
if (msg) {
std::println("MSG (from std::vector): {}", msg.value());
if (msg.flag == snplib::net_repr_proto_result_flag_e::OK) {
std::println("MSG (from std::vector): {}", msg.result);
} else {
std::println("MSG ERR: {}", msg.error().message());
std::println("MSG ERR: {}", std::to_underlying(msg.flag));
}
auto msg_l = proto.fromTransport(bytes_lst);
auto msg_l = proto.fromNetwork(bytes_lst);
if (msg_l) {
std::println("MSG (from std::list): {}", msg_l.value());
if (msg_l.flag == snplib::net_repr_proto_result_flag_e::OK) {
std::println("MSG (from std::list): {}", msg_l.result);
} else {
std::println("MSG ERR: {}", msg_l.error().message());
std::println("MSG ERR: {}", std::to_underlying(msg_l.flag));
}
auto vmsg = proto.fromTransport<std::vector<char>>(bytes_lst);
if (vmsg) {
std::println("VMSG (from std::list): {}", vmsg.value());
auto vmsg = proto.fromNetwork<std::vector<char>>(bytes_lst);
if (vmsg.flag == snplib::net_repr_proto_result_flag_e::OK) {
std::println("VMSG (from std::list): {}", vmsg.result);
} else {
std::println("VMSG ERR: {}", vmsg.error().message());
std::println("VMSG ERR: {}", std::to_underlying(vmsg.flag));
}
@@ -49,14 +49,14 @@ int main()
std::println("MSG: {}", bytes_vec);
auto bs = proto.toTransport(bytes_vec);
std::println("BYTES (from std::vector): {}", bs);
auto bs = proto.toNetwork(bytes_vec);
std::println("BYTES (from std::vector): {}", bs.result);
auto bs1 = proto.toTransport(bytes_lst);
std::println("BYTES (from std::list): {}", bs1);
// auto bs1 = proto.toNetwork(bytes_lst);
// std::println("BYTES (from std::list): {}", bs1.result);
bytes_vec = proto.toTransport<decltype(bytes_vec)>(bytes_lst);
std::println("BYTES: {}", bytes_vec);
auto bs11 = proto.toNetwork<decltype(bytes_vec)>(bytes_lst);
std::println("BYTES: {}", bs11.result);
std::println("\n\n{:*^80}\n", " BINARY-BLOB PROTOCOL ");
@@ -71,24 +71,28 @@ int main()
std::println("BLOB: {}", bytes);
bs = bb_proto.toTransport(bytes_vec);
std::println("BYTES (from std::vector): {}", bs);
auto bs21 = bb_proto.toNetwork(bytes_vec);
std::println("BYTES (from std::vector): {}", bs21.result);
auto bs2 = bb_proto.toTransport(bytes_lst);
std::println("BYTES (from std::list): {}", bs2);
auto bs2 = bb_proto.toNetwork(bytes_lst);
std::println("BYTES (from std::list): {}", bs2.result);
auto blob = std::vector(std::from_range, bs | std::views::join);
// auto blob = std::vector(std::from_range, bs.result | std::views::join);
// auto blob = std::ranges::views::concat(std::get<0>(bs2.result), std::get<1>(bs2.result));
std::vector<char> blob;
std::ranges::copy(std::get<0>(bs2.result), std::back_inserter(blob));
std::ranges::copy(std::get<1>(bs2.result), std::back_inserter(blob));
std::println("\nBYTES: {}", blob);
vmsg = bb_proto.fromTransport<std::vector<char>>(blob);
if (vmsg) {
std::println("BLOB (from std::vector): {}", vmsg.value());
vmsg = bb_proto.fromNetwork<std::vector<char>>(blob);
if (vmsg.flag == snplib::net_repr_proto_result_flag_e::OK) {
std::println("BLOB (from std::vector): {}", vmsg.result);
} else {
std::println("VMSG ERR: {}", vmsg.error().message());
std::println("VMSG ERR: {}", std::to_underlying(vmsg.flag));
}
// std::array<char, 30> arr = bb_proto.toTransport<decltype(arr)>(bytes_lst);
// std::array<char, 30> arr = bb_proto.toNetwork<decltype(arr)>(bytes_lst);
return 0;
}

View File

@@ -100,7 +100,7 @@ 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 {
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
@@ -114,7 +114,7 @@ struct _netproto_stopseq_t {
if constexpr (fixed_size_range_c<OR>) {
static_assert(std::tuple_size_v<OR> > 1, "Invalid range size!!!");
auto it = std::forward<IR>(message).begin();
auto it = res.result.begin();
*it = transform_char_range<res_el_t>(std::forward<IR>(message));
std::ranges::advance(it, 1);
*it = transform_char_range<res_el_t>(NETPROTO_STOP_SEQ);
@@ -139,18 +139,33 @@ struct _netproto_stopseq_t {
return res;
}
// template <input_char_range_c IR>
// auto toNetwork(IR&& message) -> std::conditional_t<
// std::ranges::contiguous_range<IR>,
// net_repr_proto_result_t<std::array<std::span<std::ranges::range_value_t<IR>>, 2>>,
// 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 toNetwork<std::span<const char>>(std::forward<IR>(message));
// } else {
// return toNetwork<std::ranges::subrange<std::ranges::iterator_t<IR>, std::ranges::sentinel_t<IR>>>(
// std::forward<IR>(message));
// }
// }
template <input_char_range_c IR>
auto toNetwork(IR&& message) -> std::conditional_t<
std::ranges::contiguous_range<IR>,
net_repr_proto_result_t<std::array<std::span<std::ranges::range_value_t<IR>>, 2>>,
net_repr_proto_result_t<std::ranges::subrange<std::ranges::iterator_t<IR>, std::ranges::sentinel_t<IR>>>>
auto toNetwork(IR&& message) -> net_repr_proto_result_t<
std::array<std::conditional_t<std::ranges::contiguous_range<IR>,
std::string_view,
std::ranges::subrange<std::ranges::iterator_t<IR>, std::ranges::sentinel_t<IR>>>,
2>>
{
if constexpr (std::ranges::contiguous_range<IR>) {
return toNetwork<std::span<const char>>(std::forward<IR>(message));
} else {
return toNetwork<std::ranges::subrange<std::ranges::iterator_t<IR>, std::ranges::sentinel_t<IR>>>(
std::forward<IR>(message));
}
using or_t = std::array<
std::conditional_t<std::ranges::contiguous_range<IR>, std::string_view,
std::ranges::subrange<std::ranges::iterator_t<IR>, std::ranges::sentinel_t<IR>>>,
2>;
return toNetwork<or_t>(std::forward<IR>(message));
}
template <char_range_c OR, char_range_c IR>
@@ -168,11 +183,13 @@ struct _netproto_stopseq_t {
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>>);
static constexpr bool ret_view = std::ranges::view<OR> && std::ranges::viewable_range<inp_t>;
// 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>>);
// static_assert(std::ranges::view<std::span<const char>> && std::ranges::viewable_range<std::list<char>>);
if constexpr (ret_view) {
res.result = OR(bytes.begin(), found.begin()); // return without stop-sequence!!!
@@ -212,137 +229,25 @@ struct _netproto_stopseq_t {
// return a view of the input bytes except trailing stop-sequence
template <input_char_range_c IR>
auto fromNetwork(IR&& bytes) -> std::conditional_t<
std::ranges::contiguous_range<IR>,
net_repr_proto_result_t<std::span<std::ranges::range_value_t<IR>>>,
net_repr_proto_result_t<std::ranges::subrange<std::ranges::iterator_t<IR>, std::ranges::sentinel_t<IR>>>>
{
return fromNetwork<std::span<std::ranges::range_value_t<IR>>>(std::forward<IR>(bytes));
}
};
static_assert(net_repr_proto_c<_netproto_stopseq_t<>>, "!!!");
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
OR toNetwork(IR&& message)
{
OR res;
std::back_inserter(res) = std::forward<IR>(message);
std::back_inserter(res) = std::remove_cvref_t<IR>{NETPROTO_STOP_SEQ.begin(), NETPROTO_STOP_SEQ.end()};
return res;
}
// returns a copy of the input message + tralling stop-sequence
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));
std::ranges::copy(NETPROTO_STOP_SEQ, std::back_inserter(res));
return res;
}
template <input_char_range_c IR>
auto toNetwork(IR&& message)
auto fromNetwork(IR&& bytes)
// -> std::conditional_t<
// std::ranges::contiguous_range<IR>,
// net_repr_proto_result_t<std::span<std::ranges::range_value_t<IR>>>,
// 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::array{std::span<const char>{message}, std::span<const char>{NETPROTO_STOP_SEQ}};
// return fromNetwork<std::span<std::ranges::range_value_t<IR>>>(std::forward<IR>(bytes));
return fromNetwork<std::string_view>(std::forward<IR>(bytes));
} else {
// return std::array{std::ranges::subrange(message), std::ranges::subrange(NETPROTO_STOP_SEQ)};
return std::make_tuple(std::ranges::subrange(message), std::ranges::subrange(NETPROTO_STOP_SEQ));
return fromNetwork<std::ranges::subrange<std::ranges::iterator_t<IR>, std::ranges::sentinel_t<IR>>>(
std::forward<IR>(bytes));
}
}
template <std::ranges::range OR, input_char_range_c IR>
std::expected<OR, std::error_code> fromNetwork(IR&& bytes)
{
auto found = std::ranges::search(std::forward<IR>(bytes), NETPROTO_STOP_SEQ);
if (found.empty()) {
return std::unexpected(std::make_error_code(std::errc::invalid_argument));
}
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(), found.begin()); // return without stop-sequence!!!
} 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(), found.begin()); // return without stop-sequence!!!
} 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(), found.begin())),
std::back_inserter(res));
return res;
} else {
static_assert(false, "Unsupported output byte sequence type!");
}
} else {
auto Nelem = std::distance(bytes.begin(), found.begin());
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);
}
};
// static_assert(net_repr_proto_c<netproto_stopseq_t<>>, "!!!");
static_assert(net_repr_proto_c<netproto_stopseq_t<>>, "!!!");
/* BINARY BLOB PROTOCOL */
@@ -358,11 +263,12 @@ struct netproto_stopseq_t {
template <size_t SZ_FIELD_WIDTH = 8>
requires(SZ_FIELD_WIDTH > 0 &&
SZ_FIELD_WIDTH <= 16) // not greater than allowed for 64-bit unsigned integer representation
struct _netproto_binary_blob_t {
struct netproto_binary_blob_t {
static constexpr size_t BLOB_SIZE_FIELD{SZ_FIELD_WIDTH};
static constexpr std::array<char, 6> BLOB_SIZE_FIELD_FORMAT{'{', ':', '0', '0' + BLOB_SIZE_FIELD, 'X', '}'};
// blob size filed and copy of the input message
template <output_char_range_c OR, input_char_range_c IR>
requires(!char_view_c<OR>)
net_repr_proto_result_t<OR> toNetwork(IR&& message)
@@ -376,29 +282,39 @@ struct _netproto_binary_blob_t {
return res;
}
// template <input_char_range_c IR>
// requires std::ranges::contiguous_range<IR>
// auto toNetwork(IR&& message)
// {
// using ret_t = net_repr_proto_result_t<std::tuple<std::string, std::string_view>>;
// return ret_t{.flag = net_repr_proto_result_flag_e::OK,
// .result = std::make_tuple(std::format(std::string_view(BLOB_SIZE_FIELD_FORMAT),
// std::ranges::size(std::forward<IR>(message))),
// std::string_view(message))};
// }
template <input_char_range_c IR>
requires std::ranges::contiguous_range<IR>
auto toNetwork(IR&& message)
{
using char_t = std::ranges::range_value_t<IR>;
// using ret_t = net_repr_proto_result_t<std::array<std::span<char_t>, 2>>;
// using ret_t = net_repr_proto_result_t<std::array<std::string_view, 2>>;
using ret_t = net_repr_proto_result_t<std::tuple<std::string, std::string_view>>;
// using ret_t = net_repr_proto_result_t<std::tuple<std::string, std::string_view>>;
// _nbytes.emplace_back("");
using ret_t = net_repr_proto_result_t<std::tuple<
std::string,
std::conditional_t<std::ranges::contiguous_range<IR>, std::string_view,
std::ranges::subrange<std::ranges::iterator_t<IR>, std::ranges::sentinel_t<IR>>>>>;
// std::format_to(std::back_inserter(_nbytes.back()), std::string_view(BLOB_SIZE_FIELD_FORMAT),
// std::ranges::size(std::forward<IR>(message)));
// return ret_t{.flag = net_repr_proto_result_flag_e::OK,
// .result = std::array{std::span<char_t>{_nbytes.back()}, std::span<char_t>(message)}};
// return ret_t{.flag = net_repr_proto_result_flag_e::OK,
// .result = std::array{std::string_view{_nbytes.back()}, std::string_view(message)}};
return ret_t{.flag = net_repr_proto_result_flag_e::OK,
.result = std::make_tuple(std::format(std::string_view(BLOB_SIZE_FIELD_FORMAT),
std::ranges::size(std::forward<IR>(message))),
std::string_view(message))};
if constexpr (std::ranges::contiguous_range<IR>) {
return ret_t{.flag = net_repr_proto_result_flag_e::OK,
.result = std::make_tuple(std::format(std::string_view(BLOB_SIZE_FIELD_FORMAT),
std::ranges::size(std::forward<IR>(message))),
std::string_view(message))};
} else {
return ret_t{.flag = net_repr_proto_result_flag_e::OK,
.result = std::make_tuple(std::format(std::string_view(BLOB_SIZE_FIELD_FORMAT),
std::ranges::size(std::forward<IR>(message))),
std::ranges::subrange(std::forward<IR>(message)))};
}
}
template <char_range_c OR, input_char_range_c IR>
@@ -481,148 +397,33 @@ struct _netproto_binary_blob_t {
}
// return a view of the input bytes except starting blob-size field
template <input_char_range_c IR>
auto fromNetwork(IR&& bytes) -> std::conditional_t<
std::ranges::contiguous_range<IR>,
net_repr_proto_result_t<std::span<std::ranges::range_value_t<IR>>>,
net_repr_proto_result_t<std::ranges::subrange<std::ranges::iterator_t<IR>, std::ranges::sentinel_t<IR>>>>
{
return fromNetwork<std::span<std::ranges::range_value_t<IR>>>(std::forward<IR>(bytes));
}
// protected:
// std::vector<std::string> _nbytes{};
};
static_assert(net_repr_proto_c<_netproto_binary_blob_t<>>, "!!!");
template <size_t SZ_FIELD_WIDTH = 8>
requires(SZ_FIELD_WIDTH > 0 &&
SZ_FIELD_WIDTH <= 16) // not greater than allowed for 64-bit unsigned integer representation
struct netproto_binary_blob_t {
static constexpr size_t BLOB_SIZE_FIELD{SZ_FIELD_WIDTH};
static constexpr std::array<char, 6> BLOB_SIZE_FIELD_FORMAT{'{', ':', '0', '0' + BLOB_SIZE_FIELD, 'X', '}'};
// template <input_char_range_c IR>
// auto fromNetwork(IR&& bytes) -> std::conditional_t<
// std::ranges::contiguous_range<IR>,
// net_repr_proto_result_t<std::span<std::ranges::range_value_t<IR>>>,
// net_repr_proto_result_t<std::ranges::subrange<std::ranges::iterator_t<IR>, std::ranges::sentinel_t<IR>>>>
// {
// return fromNetwork<std::span<std::ranges::range_value_t<IR>>>(std::forward<IR>(bytes));
// }
template <input_char_range_c IR>
auto toNetwork(IR&& message)
{
static thread_local std::string Nbytes{};
Nbytes.clear();
// std::format_to(std::back_inserter(Nbytes), "{:08X}", std::ranges::size(std::forward<IR>(message)));
std::format_to(std::back_inserter(Nbytes), std::string_view(BLOB_SIZE_FIELD_FORMAT),
std::ranges::size(std::forward<IR>(message)));
if constexpr (std::ranges::contiguous_range<IR>) {
return std::array{std::span<const char>{Nbytes}, std::span<const char>{message}};
} else {
return std::make_tuple(std::ranges::subrange(Nbytes), std::ranges::subrange(message));
}
}
template <char_range_c 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>>);
auto bytes_sz = std::ranges::size(std::forward<IR>(bytes));
if (bytes_sz < BLOB_SIZE_FIELD) { // not enough data
return std::unexpected(std::make_error_code(std::errc::invalid_seek));
}
std::optional<size_t> blob_sz;
if constexpr (std::ranges::contiguous_range<IR>) {
blob_sz = char_range_to_number<size_t>(std::span(bytes.begin(), BLOB_SIZE_FIELD), 16);
} else {
blob_sz = char_range_to_number<size_t>(bytes | std::views::take(BLOB_SIZE_FIELD), 16);
}
if (!blob_sz) {
return std::unexpected(std::make_error_code(std::errc::invalid_argument));
}
bytes_sz -= BLOB_SIZE_FIELD;
if (bytes_sz < blob_sz.value()) {
return std::unexpected(std::make_error_code(std::errc::invalid_seek));
}
auto it_start = std::forward<IR>(bytes).begin();
std::advance(it_start, BLOB_SIZE_FIELD);
auto it_end = std::forward<IR>(bytes).begin();
std::advance(it_end, BLOB_SIZE_FIELD + blob_sz.value());
if constexpr (ret_view) {
return OR(it_start, it_end); // return without blob size field
} 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(it_start, it_end); // return without blob size field!!!
} else if constexpr (std::is_default_constructible_v<OR>) {
OR res;
std::ranges::copy(
std::forward<IR>(bytes) | std::views::drop(BLOB_SIZE_FIELD) | std::views::take(blob_sz.value()),
std::back_inserter(res));
return res;
} else {
static_assert(false, "Unsupported output byte sequence type!");
}
} else {
if (blob_sz.value() > std::tuple_size_v<OR>) {
return std::unexpected(std::make_error_code(std::errc::invalid_seek));
}
OR res;
for (auto it = res.begin(); it != res.end(); std::advance(it, 1)) {
*it = *it_start;
std::advance(it_start, 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>>
// -> std::conditional_t<
// std::ranges::contiguous_range<IR>,
// net_repr_proto_result_t<std::span<std::ranges::range_value_t<IR>>>,
// net_repr_proto_result_t<std::ranges::subrange<std::ranges::iterator_t<IR>, std::ranges::sentinel_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);
if constexpr (std::ranges::contiguous_range<IR>) {
// return fromNetwork<std::span<std::ranges::range_value_t<IR>>>(std::forward<IR>(bytes));
return fromNetwork<std::string_view>(std::forward<IR>(bytes));
} else {
return fromNetwork<std::ranges::subrange<std::ranges::iterator_t<IR>, std::ranges::sentinel_t<IR>>>(
std::forward<IR>(bytes));
}
}
};
static_assert(net_repr_proto_c<netproto_binary_blob_t<>>, "!!!");
} // namespace snplib

View File

@@ -56,13 +56,13 @@ concept net_repr_proto_result_c = requires(T t) {
T::result_flag_t::INVALID_DATA};
}();
std::same_as<typename T::result_flag_t, decltype(t.flag)>;
requires std::same_as<typename T::result_flag_t, decltype(t.flag)>;
// char_range_or_range_of_char_ranges_c<decltype(t.result)>;
requires(
requires { char_range_or_range_of_char_ranges_c<decltype(t.result)>; } ||
requires { char_range_or_tuple_of_char_ranges_c<decltype(t.result)>; });
requires { requires char_range_or_range_of_char_ranges_c<decltype(t.result)>; } ||
requires { requires char_range_or_tuple_of_char_ranges_c<decltype(t.result)>; });
};
// template <typename T>