diff --git a/include/snipplib/network/snplib_netproto.h b/include/snipplib/network/snplib_netproto.h index 5fa38cb..51bd654 100644 --- a/include/snipplib/network/snplib_netproto.h +++ b/include/snipplib/network/snplib_netproto.h @@ -12,101 +12,68 @@ namespace snplib { + +// default implementation of the "net_repr_proto_result_c" +template +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>>, "!!!"); +static_assert(std::ranges::output_range, char>); + /* TRIVIAL NO-OP PROTOCOL */ struct netproto_noop_t { - // copy template - OR toNetwork(IR&& message) + net_repr_proto_result_t toNetwork(IR&& message) { - OR res; - - std::ranges::copy(std::forward(message), std::back_inserter(res)); - - return res; + using ret_t = net_repr_proto_result_t; + return ret_t{.flag = ret_t::result_flag_t::OK, .result = transform_char_range(message)}; } template - auto toNetwork(IR&& message) + auto toNetwork(IR&& message) -> std::conditional_t< + std::ranges::contiguous_range, + net_repr_proto_result_t>, + net_repr_proto_result_t, std::ranges::sentinel_t>>> { if constexpr (std::ranges::contiguous_range) { - return std::span{message}; + return toNetwork>(std::forward(message)); } else { - return std::ranges::subrange(message); + return toNetwork, std::ranges::sentinel_t>>( + std::forward(message)); } - } + }; template - std::expected fromNetwork(IR&& bytes) + 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>); - - - if constexpr (ret_view) { - return OR(bytes.begin(), bytes.end()); - } else if constexpr (output_char_range_c) { - if constexpr (!fixed_size_range_c) { - if constexpr (std::constructible_from, - std::ranges::iterator_t>) { - return OR(bytes.begin(), bytes.end()); - } else if constexpr (std::is_default_constructible_v) { - OR res; - std::ranges::copy( - std::forward(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) { - 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(std::forward(bytes)); } - // deduces a view-type from the input range-type - template + template auto fromNetwork(IR&& bytes) - requires input_char_range_c> { - using or_t = - std::conditional_t, std::span, - std::ranges::subrange, std::ranges::sentinel_t>>; - - return fromNetwork(std::forward(bytes)); + return toNetwork(std::forward(bytes)); } - // to satisfy 'net_proto_c' concept - template - requires(std::same_as || std::same_as) - std::expected, std::error_code> fromNetwork(std::span bytes) - { - return fromNetwork>(bytes); - } + // // to satisfy 'net_proto_c' concept + // template + // requires(std::same_as || std::same_as) + // net_repr_proto_result_t> fromNetwork(std::span bytes) + // { + // return fromNetwork>(bytes); + // } }; +static_assert(net_repr_proto_c, "!!!"); + /* SIMPLE STOP-SEQUENCE PROTOCOL */ @@ -120,6 +87,40 @@ struct netproto_noop_t { static constexpr char SNPLIB_DEFAULT_NETPROTO_STOP_SEQ[] = "\n"; + +template + 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 + requires char_range_c> // range of char ranges + net_repr_proto_result_t toNetwork(IR&& message) + { + 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); + + return res; + } + + // returns a copy of the input message + tralling stop-sequence + template + net_repr_proto_result_t toNetwork(IR&& message) + { + net_repr_proto_result_t res{.flag = net_repr_proto_result_t::result_flag_t::OK}; + + std::ranges::copy(std::forward(message), std::back_inserter(res.result)); + std::ranges::copy(NETPROTO_STOP_SEQ, std::back_inserter(res.result)); + + return res; + } +}; + + template requires(char_array_size(STOP_SEQ) > 0) struct netproto_stopseq_t { diff --git a/include/snipplib/network/snplib_network.h b/include/snipplib/network/snplib_network.h index 306dd69..3285d99 100644 --- a/include/snipplib/network/snplib_network.h +++ b/include/snipplib/network/snplib_network.h @@ -42,21 +42,20 @@ concept net_message_c = requires(const T t_const) { }); }; + template 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(T::NOT_ENOUGH_DATA) != false; - // static_cast(T::INVALID_DATA) != false; - std::same_as; char_range_or_range_of_char_ranges_c; @@ -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()) } -> char_range_or_range_of_char_ranges_c; + requires( + requires { + { t.toNetwork(std::declval>()) } -> net_repr_proto_result_c; + } || + requires { + { t.toNetwork(std::declval>()) } -> net_repr_proto_result_c; + }); + { t.toNetwork(std::declval()) } -> net_repr_proto_result_c; + // { t.toNetwork(std::declval()) } -> char_range_or_range_of_char_ranges_c; // from "network"-ready level representation to byte sequence payload representation requires( requires { - { t.fromNetwork(std::declval>()) } -> ret_expected_c; - requires char_range_c().fromNetwork(std::declval>()).value())>>; + { t.fromNetwork(std::declval>()) } -> net_repr_proto_result_c; } || requires { - { t.fromNetwork(std::declval>()) } -> ret_expected_c; - requires char_range_c< - std::remove_cvref_t().fromNetwork(std::declval>()).value())>>; - }); + { t.fromNetwork(std::declval>()) } -> net_repr_proto_result_c; + } + // requires { + // { t.fromNetwork(std::declval>()) } -> ret_expected_c; + // requires char_range_c().fromNetwork(std::declval>()).value())>>; + // } || + // requires { + // { t.fromNetwork(std::declval>()) } -> ret_expected_c; + // requires char_range_c< + // std::remove_cvref_t().fromNetwork(std::declval>()).value())>>; + // } + ); };