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>&)
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,
typename SMSGT = std::string_view, // sending message type
typename RMSGT = std::string, // receiving message type
typename SMSGT = std::vector<char>, // sending message type
typename RMSGT = std::vector<char>, // receiving message type
typename DURT = adc_common_duration_t // time duration type
>
concept adc_netservice_c =

2
net/adc_netproto.h
View File

@ -108,7 +108,7 @@ struct AdcStopSeqSessionProto {
template <traits::adc_input_char_range 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
// 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 "../adc_net_concepts.h"
#include "../adc_netproto.h"
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>;
// template <typename 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;
// class adc_asio_async_call_ctx_t
// {
// };
// template <typename T, typename SignatureT>
// template <typename T, typename SignatureT = void>
// 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,
@ -116,47 +103,46 @@ public:
std::nullptr_t, // there is no acceptor
typename TRANSPORT_PROTOT::acceptor>;
struct asio_async_ctx_t {
bool use_future = false;
std::function<void(std::error_code)> accept_comp_token;
std::function<void(std::error_code)> connect_comp_token;
std::function<void(std::error_code)> send_comp_token;
std::function<void(std::error_code, RMSGT)> receive_comp_token;
};
typedef std::function<void(std::error_code)> async_accept_callback_t;
typedef std::function<void(std::error_code)> async_connect_callback_t;
typedef std::function<void(std::error_code)> async_send_callback_t;
typedef std::function<void(std::error_code, RMSGT)> async_receive_callback_t;
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, RMSGT)> _errc_msg_comp_token;
public:
contx_t() = default;
async_call_ctx_t() = default;
contx_t(contx_t&) = default;
contx_t(contx_t&&) = default;
contx_t(const contx_t&) = default;
async_call_ctx_t(async_call_ctx_t&) = default;
async_call_ctx_t(async_call_ctx_t&&) = default;
async_call_ctx_t(const async_call_ctx_t&) = default;
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);
}
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);
}
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);
return *this;
}
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);
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_CONNECT_TIMEOUT = std::chrono::seconds(10);
@ -303,7 +287,7 @@ public:
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)>
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)
{
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
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(std::is_same_v<std::remove_cvref_t<traits::adc_func_arg1_t<TokenT>>, std::error_code>,
"INVALID COMPLETION TOKEN SIGNATURE!");
@ -362,7 +346,7 @@ public:
}
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>>>;
// 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