timur/ADC
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

...

Browse Source
This commit is contained in:
Timur A. Fatkhullin 2024-09-25 23:23:52 +03:00
parent fb86450f16
commit 78f2f1b8ed
3 changed files with 40 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
net/adc_net_concepts.h
View File

@ -75,13 +75,13 @@ using adc_common_duration_t = adc_duration_common_type_t<std::chrono::nanosecond
auto send(const R&, const std::chrono::duration<Rep, Period>&) auto send(const R&, const std::chrono::duration<Rep, Period>&)
template<adc::traits::adc_output_char_range R, typename Rep, typename Period> template<adc::traits::adc_output_char_range R, typename Rep, typename Period>
R received(const std::chrono::duration<Rep, Period>&) R receive(const std::chrono::duration<Rep, Period>&)
} }
*/ */
template <typename SRVT, template <typename SRVT,
typename SMSGT = std::string_view, // sending message type typename SMSGT = std::vector<char>, // sending message type
typename RMSGT = std::string, // receiving message type typename RMSGT = std::vector<char>, // receiving message type
typename DURT = adc_common_duration_t // time duration type typename DURT = adc_common_duration_t // time duration type
> >
concept adc_netservice_c = concept adc_netservice_c =

2
net/adc_netproto.h
View File

@ -108,7 +108,7 @@ struct AdcStopSeqSessionProto {
template <traits::adc_input_char_range R> template <traits::adc_input_char_range R>
auto fromProto(const R& r) auto fromProto(const R& r)
{ {
auto N = std::distance(r.begin(), r.end()); size_t N = std::distance(r.begin(), r.end());
if (N < STOP_SEQ_SIZE) { // one must ensure for input range size correctness if (N < STOP_SEQ_SIZE) { // one must ensure for input range size correctness
// return std::span<std::ranges::range_value_t<R>>(); // return std::span<std::ranges::range_value_t<R>>();

82
net/asio/adc_netservice_asio.h
View File

@ -31,6 +31,7 @@
#include "../../common/adc_traits.h" #include "../../common/adc_traits.h"
#include "../adc_net_concepts.h" #include "../adc_net_concepts.h"
#include "../adc_netproto.h"
namespace adc::impl namespace adc::impl
@ -72,33 +73,19 @@ concept adc_asio_special_comp_token =
adc_asio_is_future<T> || adc_asio_is_awaitable<T> || std::same_as<std::remove_cvref_t<T>, asio::deferred_t>; adc_asio_is_future<T> || adc_asio_is_awaitable<T> || std::same_as<std::remove_cvref_t<T>, asio::deferred_t>;
// template <typename T> // class adc_asio_async_call_ctx_t
// static constexpr bool adc_is_asio_special_comp_token = std::is_same_v<std::remove_cvref_t<T>, asio::use_future_t<>> // {
// || // };
// std::is_same_v<std::remove_cvref_t<T>, asio::deferred_t> ||
// std::is_same_v<std::remove_cvref_t<T>,
// asio::use_awaitable_t<>>;
struct adc_asio_async_call_ctx_t {
};
// template <typename T>
// concept adc_completion_token_c = traits::adc_is_callable<T> || std::same_as<T, adc_asio_async_call_ctx_t> ||
// std::same_as<T, asio::deferred_t> || adc_asio_is_future<T> ||
// asio::completion_token_for;
// template <typename T, typename SignatureT> // template <typename T, typename SignatureT = void>
// concept adc_completion_token_c = // concept adc_completion_token_c =
// std::same_as<T, adc_asio_async_call_ctx_t> || asio::completion_token_for<T, SignatureT>; // std::same_as<T, adc_asio_async_call_ctx_t> ||
// (traits::adc_is_callable<T> &&
// std::conditional_t<std::same_as<SignatureT, void>,
// std::true_type,
// std::bool_constant<asio::completion_token_for<T, SignatureT>>>::value);
template <typename T, typename SignatureT = void>
concept adc_completion_token_c =
std::same_as<T, adc_asio_async_call_ctx_t> ||
(traits::adc_is_callable<T> &&
std::conditional_t<std::same_as<SignatureT, void>,
std::true_type,
std::bool_constant<asio::completion_token_for<T, SignatureT>>>::value);
template <adc_asio_transport_proto_c TRANSPORT_PROTOT, template <adc_asio_transport_proto_c TRANSPORT_PROTOT,
@ -116,47 +103,46 @@ public:
std::nullptr_t, // there is no acceptor std::nullptr_t, // there is no acceptor
typename TRANSPORT_PROTOT::acceptor>; typename TRANSPORT_PROTOT::acceptor>;
struct asio_async_ctx_t { typedef std::function<void(std::error_code)> async_accept_callback_t;
bool use_future = false; typedef std::function<void(std::error_code)> async_connect_callback_t;
std::function<void(std::error_code)> accept_comp_token; typedef std::function<void(std::error_code)> async_send_callback_t;
std::function<void(std::error_code)> connect_comp_token; typedef std::function<void(std::error_code, RMSGT)> async_receive_callback_t;
std::function<void(std::error_code)> send_comp_token;
std::function<void(std::error_code, RMSGT)> receive_comp_token;
};
class contx_t
// to satisfy 'adc_netservice_c' concept
class async_call_ctx_t
{ {
std::function<void(std::error_code)> _errc_comp_token; std::function<void(std::error_code)> _errc_comp_token;
std::function<void(std::error_code, RMSGT)> _errc_msg_comp_token; std::function<void(std::error_code, RMSGT)> _errc_msg_comp_token;
public: public:
contx_t() = default; async_call_ctx_t() = default;
contx_t(contx_t&) = default; async_call_ctx_t(async_call_ctx_t&) = default;
contx_t(contx_t&&) = default; async_call_ctx_t(async_call_ctx_t&&) = default;
contx_t(const contx_t&) = default; async_call_ctx_t(const async_call_ctx_t&) = default;
template <asio::completion_token_for<void(std::error_code)> TokenT> template <asio::completion_token_for<void(std::error_code)> TokenT>
contx_t(TokenT&& token) async_call_ctx_t(TokenT&& token)
{ {
_errc_comp_token = std::forward<TokenT>(token); _errc_comp_token = std::forward<TokenT>(token);
} }
template <asio::completion_token_for<void(std::error_code, RMSGT)> TokenT> template <asio::completion_token_for<void(std::error_code, RMSGT)> TokenT>
contx_t(TokenT&& token) async_call_ctx_t(TokenT&& token)
{ {
_errc_msg_comp_token = std::forward<TokenT>(token); _errc_msg_comp_token = std::forward<TokenT>(token);
} }
template <asio::completion_token_for<void(std::error_code)> TokenT> template <asio::completion_token_for<void(std::error_code)> TokenT>
contx_t& operator=(TokenT&& token) async_call_ctx_t& operator=(TokenT&& token)
{ {
_errc_comp_token = std::forward<TokenT>(token); _errc_comp_token = std::forward<TokenT>(token);
return *this; return *this;
} }
template <asio::completion_token_for<void(std::error_code, RMSGT)> TokenT> template <asio::completion_token_for<void(std::error_code, RMSGT)> TokenT>
contx_t& operator=(TokenT&& token) async_call_ctx_t& operator=(TokenT&& token)
{ {
_errc_msg_comp_token = std::forward<TokenT>(token); _errc_msg_comp_token = std::forward<TokenT>(token);
return *this; return *this;
@ -185,8 +171,6 @@ public:
} }
}; };
// to satisfy 'adc_netservice_c' concept
using async_call_ctx_t = adc_asio_async_call_ctx_t;
static constexpr std::chrono::duration DEFAULT_ACCEPT_TIMEOUT = std::chrono::seconds::max(); static constexpr std::chrono::duration DEFAULT_ACCEPT_TIMEOUT = std::chrono::seconds::max();
static constexpr std::chrono::duration DEFAULT_CONNECT_TIMEOUT = std::chrono::seconds(10); static constexpr std::chrono::duration DEFAULT_CONNECT_TIMEOUT = std::chrono::seconds(10);
@ -303,7 +287,7 @@ public:
template <traits::adc_input_char_range MessageT, template <traits::adc_input_char_range MessageT,
adc_completion_token_c<void(std::error_code ec)> TokenT, asio::completion_token_for<void(std::error_code ec)> TokenT,
traits::adc_time_duration_c TimeoutT = decltype(DEFAULT_SEND_TIMEOUT)> traits::adc_time_duration_c TimeoutT = decltype(DEFAULT_SEND_TIMEOUT)>
auto asyncSend(const MessageT& msg, TokenT&& token, const TimeoutT& timeout = DEFAULT_SEND_TIMEOUT) auto asyncSend(const MessageT& msg, TokenT&& token, const TimeoutT& timeout = DEFAULT_SEND_TIMEOUT)
{ {
@ -346,13 +330,13 @@ public:
} }
template <adc_completion_token_c TokenT, traits::adc_time_duration_c TimeoutT = decltype(DEFAULT_RECEIVE_TIMEOUT)> template <typename TokenT, traits::adc_time_duration_c TimeoutT = decltype(DEFAULT_RECEIVE_TIMEOUT)>
auto asyncReceive(TokenT&& token, const TimeoutT& timeout = DEFAULT_RECEIVE_TIMEOUT) auto asyncReceive(TokenT&& token, const TimeoutT& timeout = DEFAULT_RECEIVE_TIMEOUT)
{ {
static_assert(!std::is_same_v<TokenT, async_call_ctx_t>, "'async_call_ctx_t'-TYPE MUST NOT BE USED!"); constexpr auto is_async_ctx_t = std::same_as<std::remove_cvref_t<TokenT>, async_call_ctx_t>;
// check completion token signature and deduce message type // check completion token signature and deduce message type
if constexpr (!adc_asio_special_comp_token<TokenT>) { if constexpr (!adc_asio_special_comp_token<TokenT> && !is_async_ctx_t) {
static_assert(traits::adc_func_traits<TokenT>::arity == 2, "INVALID COMPLETION TOKEN SIGNATURE!"); static_assert(traits::adc_func_traits<TokenT>::arity == 2, "INVALID COMPLETION TOKEN SIGNATURE!");
static_assert(std::is_same_v<std::remove_cvref_t<traits::adc_func_arg1_t<TokenT>>, std::error_code>, static_assert(std::is_same_v<std::remove_cvref_t<traits::adc_func_arg1_t<TokenT>>, std::error_code>,
"INVALID COMPLETION TOKEN SIGNATURE!"); "INVALID COMPLETION TOKEN SIGNATURE!");
@ -362,7 +346,7 @@ public:
} }
using msg_t = std::conditional_t< using msg_t = std::conditional_t<
adc_asio_special_comp_token<TokenT>, RMSGT, adc_asio_special_comp_token<TokenT> || is_async_ctx_t, RMSGT,
std::remove_cvref_t<std::tuple_element_t<1, typename traits::adc_func_traits<TokenT>::args_t>>>; std::remove_cvref_t<std::tuple_element_t<1, typename traits::adc_func_traits<TokenT>::args_t>>>;
// auto s_res = std::make_shared<std::invoke_result_t<decltype(this->template search<RMSGT>), RMSGT>>(); // auto s_res = std::make_shared<std::invoke_result_t<decltype(this->template search<RMSGT>), RMSGT>>();
@ -639,4 +623,10 @@ protected:
} }
}; };
// static_assert(adc::interfaces::adc_netservice_c<AdcNetServiceASIOBase<asio::ip::tcp, adc::AdcStopSeqSessionProto<>>>,
// "");
static_assert(adc::interfaces::adc_netsession_proto_c<adc::AdcStopSeqSessionProto<>>, "");
} // namespace adc::impl } // namespace adc::impl