rewrite tranport-level protocol classes
This commit is contained in:
@@ -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;
|
||||
}
|
||||
@@ -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
|
||||
@@ -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>
|
||||
|
||||
Reference in New Issue
Block a user