diff --git a/include/snipplib/network/snplib_netproto.h b/include/snipplib/network/snplib_netproto.h index 51bd654..bb1cfb1 100644 --- a/include/snipplib/network/snplib_netproto.h +++ b/include/snipplib/network/snplib_netproto.h @@ -13,10 +13,15 @@ namespace snplib { + // default implementation of the "net_repr_proto_result_c" + +enum class net_repr_proto_result_flag_e : int { OK, NOT_ENOUGH_DATA, INVALID_DATA }; + template struct net_repr_proto_result_t { - enum class result_flag_t : int { OK, NOT_ENOUGH_DATA, INVALID_DATA }; + // enum class result_flag_t : int { OK, NOT_ENOUGH_DATA, INVALID_DATA }; + typedef net_repr_proto_result_flag_e result_flag_t; result_flag_t flag{result_flag_t::INVALID_DATA}; @@ -26,6 +31,8 @@ struct net_repr_proto_result_t { static_assert(net_repr_proto_result_c>>, "!!!"); static_assert(std::ranges::output_range, char>); + + /* TRIVIAL NO-OP PROTOCOL */ struct netproto_noop_t { @@ -39,7 +46,9 @@ struct netproto_noop_t { template auto toNetwork(IR&& message) -> std::conditional_t< std::ranges::contiguous_range, - net_repr_proto_result_t>, + net_repr_proto_result_t>, + std::span, + std::span>>, net_repr_proto_result_t, std::ranges::sentinel_t>>> { if constexpr (std::ranges::contiguous_range) { @@ -101,14 +110,24 @@ struct _netproto_stopseq_t { using res_el_t = std::ranges::range_value_t; net_repr_proto_result_t res{.flag = net_repr_proto_result_t::result_flag_t::OK}; - std::back_inserter(res.result) = transform_char_range(std::forward(message)); - std::back_inserter(res.result) = transform_char_range(NETPROTO_STOP_SEQ); + if constexpr (fixed_size_range_c) { + static_assert(std::tuple_size_v > 1, "Invalid range size!!!"); + + auto it = std::forward(message).begin(); + *it = transform_char_range(std::forward(message)); + std::ranges::advance(it, 1); + *it = transform_char_range(NETPROTO_STOP_SEQ); + } else { + std::back_inserter(res.result) = transform_char_range(std::forward(message)); + std::back_inserter(res.result) = transform_char_range(NETPROTO_STOP_SEQ); + } return res; } // returns a copy of the input message + tralling stop-sequence template + requires(!char_view_c) net_repr_proto_result_t toNetwork(IR&& message) { net_repr_proto_result_t res{.flag = net_repr_proto_result_t::result_flag_t::OK}; @@ -118,9 +137,93 @@ struct _netproto_stopseq_t { return res; } + + template + auto toNetwork(IR&& message) -> std::conditional_t< + std::ranges::contiguous_range, + net_repr_proto_result_t>, 2>>, + net_repr_proto_result_t, std::ranges::sentinel_t>>> + { + if constexpr (std::ranges::contiguous_range) { + return toNetwork>(std::forward(message)); + } else { + return toNetwork, std::ranges::sentinel_t>>( + std::forward(message)); + } + } + + template + net_repr_proto_result_t fromNetwork(IR&& bytes) + { + net_repr_proto_result_t res{.flag = net_repr_proto_result_flag_e::NOT_ENOUGH_DATA}; + + auto found = std::ranges::search(std::forward(bytes), NETPROTO_STOP_SEQ); + if (found.empty()) { + return res; + } + + res.flag = net_repr_proto_result_flag_e::OK; + + using inp_t = std::remove_cvref_t; + + // return a view + static constexpr bool ret_view = + std::ranges::view && std::ranges::viewable_range && + (std::constructible_from, std::ranges::iterator_t> || + std::constructible_from, std::ranges::sentinel_t>); + + + if constexpr (ret_view) { + res.result = OR(bytes.begin(), found.begin()); // return without stop-sequence!!! + } else if constexpr (output_char_range_c) { + if constexpr (!fixed_size_range_c) { + if constexpr (std::constructible_from, + std::ranges::iterator_t>) { + res.result = OR(bytes.begin(), found.begin()); // return without stop-sequence!!! + } else if constexpr (std::is_default_constructible_v) { + std::ranges::copy( + std::forward(bytes) | std::views::take(std::distance(bytes.begin(), found.begin())), + std::back_inserter(res.result)); + } else { + static_assert(false, "Unsupported output byte sequence type!"); + } + } else { + auto Nelem = std::distance(bytes.begin(), found.begin()); + if (Nelem > std::tuple_size_v) { + // let's assume a byte sequence was expected here; the length must be strictly adhered to. + // so, if the sequence length exceeds the capacity of the input array, the error + // "invalid data" should be returned + res.flag = net_repr_proto_result_flag_e::INVALID_DATA; + } else { + auto data_it = bytes.begin(); + for (auto it = res.result.begin(); it != res.result.end(); std::advance(it, 1)) { + *it = *data_it; + std::advance(data_it, 1); + } + } + } + } else { + static_assert(false, "Unsupported output byte sequence type!"); + } + + return res; + } + + // return a view of the input bytes except trailing stop-sequence + template + auto fromNetwork(IR&& bytes) -> std::conditional_t< + std::ranges::contiguous_range, + net_repr_proto_result_t>>, + net_repr_proto_result_t, std::ranges::sentinel_t>>> + { + return fromNetwork>>(std::forward(bytes)); + } }; +static_assert(net_repr_proto_c<_netproto_stopseq_t<>>, "!!!"); + + template requires(char_array_size(STOP_SEQ) > 0) struct netproto_stopseq_t { @@ -238,7 +341,7 @@ struct netproto_stopseq_t { }; -static_assert(net_repr_proto_c>, "!!!"); +// static_assert(net_repr_proto_c>, "!!!"); /* BINARY BLOB PROTOCOL */ @@ -251,6 +354,142 @@ static_assert(net_repr_proto_c>, "!!!"); (e.g. "000000FA", MUST BE IN UPPER-CASE!!!) */ +template + 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 BLOB_SIZE_FIELD_FORMAT{'{', ':', '0', '0' + BLOB_SIZE_FIELD, 'X', '}'}; + + template + requires(!char_view_c) + net_repr_proto_result_t toNetwork(IR&& message) + { + net_repr_proto_result_t res{.flag = net_repr_proto_result_flag_e::OK}; + + std::format_to(std::back_inserter(res.result), std::string_view(BLOB_SIZE_FIELD_FORMAT), + std::ranges::size(std::forward(message))); + std::format_to(std::back_inserter(res.result), "{}", std::forward(message)); + + return res; + } + + template + requires std::ranges::contiguous_range + auto toNetwork(IR&& message) + { + using char_t = std::ranges::range_value_t; + // using ret_t = net_repr_proto_result_t, 2>>; + using ret_t = net_repr_proto_result_t>; + + _nbytes.emplace_back(""); + + std::format_to(std::back_inserter(_nbytes.back()), std::string_view(BLOB_SIZE_FIELD_FORMAT), + std::ranges::size(std::forward(message))); + + // return ret_t{.flag = net_repr_proto_result_flag_e::OK, + // .result = std::array{std::span{_nbytes.back()}, std::span(message)}}; + return ret_t{.flag = net_repr_proto_result_flag_e::OK, + .result = std::array{std::string_view{_nbytes.back()}, std::string_view(message)}}; + } + + template + net_repr_proto_result_t fromNetwork(IR&& bytes) + { + using inp_t = std::remove_cvref_t; + + // return a view + static constexpr bool ret_view = + std::ranges::view && std::ranges::viewable_range && + (std::constructible_from, std::ranges::iterator_t> || + std::constructible_from, std::ranges::sentinel_t>); + + + net_repr_proto_result_t res{.flag = net_repr_proto_result_flag_e::NOT_ENOUGH_DATA}; + + auto bytes_sz = std::ranges::size(std::forward(bytes)); + + if (bytes_sz < BLOB_SIZE_FIELD) { // not enough data + return res; + } + + std::optional blob_sz; + if constexpr (std::ranges::contiguous_range) { + blob_sz = char_range_to_number(std::span(bytes.begin(), BLOB_SIZE_FIELD), 16); + } else { + blob_sz = char_range_to_number(bytes | std::views::take(BLOB_SIZE_FIELD), 16); + } + + if (!blob_sz) { // zero-size blob is not an error?!! + res.flag = net_repr_proto_result_flag_e::OK; + return res; + } + + bytes_sz -= BLOB_SIZE_FIELD; + + if (bytes_sz < blob_sz.value()) { // not enough data + return res; + } + + auto it_start = std::forward(bytes).begin(); + std::advance(it_start, BLOB_SIZE_FIELD); + auto it_end = std::forward(bytes).begin(); + std::advance(it_end, BLOB_SIZE_FIELD + blob_sz.value()); + + if constexpr (ret_view) { + res.result = OR(it_start, it_end); // return without blob size field + } else if constexpr (output_char_range_c) { + if constexpr (!fixed_size_range_c) { + if constexpr (std::constructible_from, + std::ranges::iterator_t>) { + res.result = OR(it_start, it_end); // return without blob size field!!! + } else if constexpr (std::is_default_constructible_v) { + std::ranges::copy( + std::forward(bytes) | std::views::drop(BLOB_SIZE_FIELD) | std::views::take(blob_sz.value()), + std::back_inserter(res.result)); + } else { + static_assert(false, "Unsupported output byte sequence type!"); + } + res.flag = net_repr_proto_result_flag_e::OK; + } else { + if (blob_sz.value() > std::tuple_size_v) { + // let's assume a byte sequence was expected here; the length must be strictly adhered to. + // so, if the sequence length exceeds the capacity of the input array, the error + // "invalid data" should be returned + res.flag = net_repr_proto_result_flag_e::INVALID_DATA; + } else { + for (auto it = res.result.begin(); it != res.result.end(); std::advance(it, 1)) { + *it = *it_start; + std::advance(it_start, 1); + } + res.flag = net_repr_proto_result_flag_e::OK; + } + } + } else { + static_assert(false, "Unsupported output byte sequence type!"); + } + + return res; + } + + // return a view of the input bytes except starting blob-size field + template + auto fromNetwork(IR&& bytes) -> std::conditional_t< + std::ranges::contiguous_range, + net_repr_proto_result_t>>, + net_repr_proto_result_t, std::ranges::sentinel_t>>> + { + return fromNetwork>>(std::forward(bytes)); + } + +protected: + std::vector _nbytes{}; +}; + +static_assert(net_repr_proto_c<_netproto_binary_blob_t<>>, "!!!"); + + template requires(SZ_FIELD_WIDTH > 0 && SZ_FIELD_WIDTH <= 16) // not greater than allowed for 64-bit unsigned integer representation