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

Compare commits

base: timur:51c6fb4bbaab58bef64690b5e099aaf2323d35e1
Branches Tags
timur:master
..
compare: timur:49d1b71565d84d2714251dd008e360ec0e254d19
Branches Tags
timur:master

No commits in common. "51c6fb4bbaab58bef64690b5e099aaf2323d35e1" and "49d1b71565d84d2714251dd008e360ec0e254d19" have entirely different histories.
51c6fb4bba ... 49d1b71565

6 changed files with 287 additions and 143 deletions
Show Stats Expand all files Collapse all files

1
CMakeLists.txt
View File

@ -68,6 +68,7 @@ if (ASIO_LIBRARY)
set(ADC_NETWORK_HEADERS ${ADC_NETWORK_HEADERS}
net/asio/adc_netservice_asio.h
net/asio/adc_netsession_asio.h
net/asio/adc_device_netserver_asio.h
)

14
common/adc_spdlog.h
View File

@ -84,37 +84,37 @@ public:
}
template <traits::formattable... ArgTs>
void logCritical(spdlog::format_string_t<ArgTs...> fmt, ArgTs&&... args)
void logCritical(std::format_string<ArgTs...> fmt, ArgTs&&... args)
{
_loggerSPtr->log(spdlog::level::critical, fmt, std::forward<ArgTs>(args)...);
}
template <typename... ArgTs>
void logError(spdlog::format_string_t<ArgTs...> fmt, ArgTs&&... args)
template <traits::formattable... ArgTs>
void logError(std::format_string<ArgTs...> fmt, ArgTs&&... args)
{
_loggerSPtr->log(spdlog::level::err, fmt, std::forward<ArgTs>(args)...);
}
template <traits::formattable... ArgTs>
void logWarn(spdlog::format_string_t<ArgTs...> fmt, ArgTs&&... args)
void logWarn(std::format_string<ArgTs...> fmt, ArgTs&&... args)
{
_loggerSPtr->log(spdlog::level::warn, fmt, std::forward<ArgTs>(args)...);
}
template <traits::formattable... ArgTs>
void logInfo(spdlog::format_string_t<ArgTs...> fmt, ArgTs&&... args)
void logInfo(std::format_string<ArgTs...> fmt, ArgTs&&... args)
{
_loggerSPtr->log(spdlog::level::info, fmt, std::forward<ArgTs>(args)...);
}
template <traits::formattable... ArgTs>
void logDebug(spdlog::format_string_t<ArgTs...> fmt, ArgTs&&... args)
void logDebug(std::format_string<ArgTs...> fmt, ArgTs&&... args)
{
_loggerSPtr->log(spdlog::level::debug, fmt, std::forward<ArgTs>(args)...);
}
template <traits::formattable... ArgTs>
void logTrace(spdlog::format_string_t<ArgTs...> fmt, ArgTs&&... args)
void logTrace(std::format_string<ArgTs...> fmt, ArgTs&&... args)
{
_loggerSPtr->log(spdlog::level::trace, fmt, std::forward<ArgTs>(args)...);
}

2
device/adc_device.h
View File

@ -157,7 +157,7 @@ public:
template <typename... CtorArgTs>
AdcGenericDevice& addAttribute(CtorArgTs&&... ctor_args)
{
return addAttribute(AttributeT(std::forward<CtorArgTs>(ctor_args)...));
return addAttribute({std::forward<CtorArgTs>(ctor_args)...});
}

196
net/adc_device_netclient.h
View File

@ -112,6 +112,7 @@ public:
typedef std::vector<char> message_t;
// Session(const netsession_ident_t& id, netservice_t srv, AdcDeviceNetServer* srv_ptr)
Session(const netsession_ident_t& id, netservice_t srv, netsession_ctx_t ctx)
: _ident(id),
_netService(std::move(srv)),
@ -150,77 +151,8 @@ public:
}
// general-purpose server communication methods
// blocking
template <traits::adc_range_of_output_char_range R, typename... ArgTs>
R serverCall(ServerResponseType& rtype, std::string_view key, ArgTs&&... args)
{
typename netservice_t::send_msg_t bytes;
AdcDeviceProtoMessage msg(bytes);
msg.setKeyValue(key, std::forward<ArgTs>(args)...);
return getFromServer<R>(key, bytes, rtype);
}
template <typename... ArgTs>
default_server_resp_t serverCall(ServerResponseType& rtype, std::string_view key, ArgTs&&... args)
{
return serverCall<default_server_resp_t>(rtype, key, std::forward<ArgTs>(args)...);
}
// asynchronous
template <std::convertible_to<async_callback_func_t> CallbackT, typename... ArgTs>
auto asyncServerCall(std::string_view key, CallbackT&& callback_func, ArgTs&&... args)
{
auto bytes = std::shared_ptr<typename netservice_t::send_msg_t>();
AdcDeviceProtoMessage msg(*bytes);
msg.setKeyValue(key, std::forward<ArgTs>(args)...);
asyncSendRecv(*bytes, [bytes, key, wrapper = traits::adc_pf_wrapper(std::forward<CallbackT>(callback_func)),
this](auto err, auto rmsg) mutable {
if (err) {
_clientPtr->logError("An error occured while receiving server respond: {}",
netservice_t::formattableError(err));
} else {
try {
ServerResponseType type;
auto attrs = checkServerCall<default_server_resp_t>(key, rmsg, type);
std::forward<CallbackT>(std::get<0>(wrapper))(type, attrs);
} catch (const std::system_error& err) {
_clientPtr->logError("An error occured while getting server respond: {}", err.what());
}
}
});
}
// ADC device helper methods (blocking)
// send client HELLO-message
template <traits::adc_range_of_output_char_range R,
traits::adc_input_char_range SenderNameT,
typename... ParamTs>
R clientHello(ServerResponseType& rtype, SenderNameT&& name, ParamTs&&... params)
{
// expected respond: ACK HELLO ...
// return HELLO ... (or error description 'code category what')
return serverCall<R>(rtype, constants::ADC_DEVICE_NETPROTO_KEY_HELLO, std::forward<SenderNameT>(name),
std::forward<ParamTs>(params)...);
}
template <traits::adc_input_char_range SenderNameT, typename... ParamTs>
default_server_resp_t clientHello(ServerResponseType& rtype, SenderNameT&& name, ParamTs&&... params)
{
return clientHello<default_server_resp_t>(rtype, std::forward<SenderNameT>(name),
std::forward<ParamTs>(params)...);
}
// get names of devices
template <traits::adc_range_of_output_char_range R>
@ -228,7 +160,7 @@ public:
{
// expected respond: ACK NAMES DEV1 DEV2 ...
// return DEV1 DEV2 ... (or error description 'code category what')
return serverCall<R>(rtype, constants::ADC_DEVICE_NETPROTO_KEY_NAMES);
return deviceFuncHelper<R>(constants::ADC_DEVICE_NETPROTO_KEY_NAMES, rtype);
}
default_server_resp_t deviceNames(ServerResponseType& rtype)
@ -238,49 +170,51 @@ public:
// bind device to the client
template <traits::adc_range_of_output_char_range R, traits::adc_input_char_range DevNameT>
R bindDevice(ServerResponseType& rtype, DevNameT&& dev_name)
R bindDevice(DevNameT&& dev_name, ServerResponseType& rtype)
{
// expected respond: ACK DEVICE DEV_NAME
// return DEV_NAME (or error description 'code category what')
return serverCall<R>(rtype, constants::ADC_DEVICE_NETPROTO_KEY_DEVICE, std::forward<DevNameT>(dev_name));
return deviceFuncHelper<R>(constants::ADC_DEVICE_NETPROTO_KEY_DEVICE, rtype,
std::forward<DevNameT>(dev_name));
}
template <traits::adc_input_char_range DevNameT>
default_server_resp_t bindDevice(ServerResponseType& rtype, DevNameT&& dev_name)
default_server_resp_t bindDevice(DevNameT&& dev_name, ServerResponseType& rtype)
{
return bindDevice<default_server_resp_t>(rtype, std::forward<DevNameT>(dev_name));
return bindDevice<default_server_resp_t>(std::forward<DevNameT>(dev_name), rtype);
}
// execute a command
template <traits::adc_range_of_output_char_range R, traits::adc_input_char_range CmdNameT>
R exec(ServerResponseType& rtype, CmdNameT&& cmd_name)
R exec(CmdNameT&& cmd_name, ServerResponseType& rtype)
{
// expected respond: ACK CMD CMD_NAME
// return CMD_NAME ... (or error description 'code category what')
return serverCall<R>(rtype, constants::ADC_DEVICE_NETPROTO_KEY_CMD, std::forward<CmdNameT>(cmd_name));
return deviceFuncHelper<R>(constants::ADC_DEVICE_NETPROTO_KEY_CMD, rtype, std::forward<CmdNameT>(cmd_name));
}
template <traits::adc_input_char_range CmdNameT>
default_server_resp_t exec(ServerResponseType& rtype, CmdNameT&& cmd_name)
default_server_resp_t exec(CmdNameT&& cmd_name, ServerResponseType& rtype)
{
return exec<default_server_resp_t>(rtype, std::forward<CmdNameT>(cmd_name));
return exec<default_server_resp_t>(std::forward<CmdNameT>(cmd_name), rtype);
}
// get an attribute value
template <traits::adc_range_of_output_char_range R, traits::adc_input_char_range AttrNameT>
R getAttr(ServerResponseType& rtype, AttrNameT&& attr_name)
R getAttr(AttrNameT&& attr_name, ServerResponseType& rtype)
{
// expected respond: ACK GET ATTR_NAME ATTR_VALUE
// return ATTR_NAME ATTR_VALUE (or error description 'code category what')
return serverCall<R>(rtype, constants::ADC_DEVICE_NETPROTO_KEY_GET, std::forward<AttrNameT>(attr_name));
return deviceFuncHelper<R>(constants::ADC_DEVICE_NETPROTO_KEY_GET, rtype,
std::forward<AttrNameT>(attr_name));
}
template <traits::adc_input_char_range AttrNameT>
default_server_resp_t getAttr(ServerResponseType& rtype, AttrNameT&& attr_name)
default_server_resp_t getAttr(AttrNameT&& attr_name, ServerResponseType& rtype)
{
return getAttr<default_server_resp_t>(rtype, std::forward<AttrNameT>(attr_name));
return getAttr<default_server_resp_t>(std::forward<AttrNameT>(attr_name), rtype);
}
@ -293,8 +227,8 @@ public:
{
// expected respond: ACK SET ATTR_NAME ATTR_VALUE
// return ATTR_NAME ATTR_VALUE (or error description 'code category what')
return serverCall<R>(constants::ADC_DEVICE_NETPROTO_KEY_SET, rtype, std::forward<AttrNameT>(attr_name),
std::forward<ValueT>(value), std::forward<ValueTs>(values)...);
return deviceFuncHelper<R>(constants::ADC_DEVICE_NETPROTO_KEY_SET, rtype, std::forward<ValueT>(value),
std::forward<ValueTs>(values)...);
}
template <traits::adc_input_char_range AttrNameT, typename ValueT, typename... ValueTs>
@ -309,40 +243,32 @@ public:
// ADC device helper methods (asynchronous)
template <std::convertible_to<async_callback_func_t> CallbackT,
traits::adc_input_char_range SenderNameT,
typename... ParamTs>
auto asyncClientHello(CallbackT&& callback_func, SenderNameT&& name, ParamTs&&... params)
{
return asyncServerCall(constants::ADC_DEVICE_NETPROTO_KEY_HELLO, std::forward<CallbackT>(callback_func),
std::forward<SenderNameT>(name), std::forward<ParamTs>(params)...);
}
template <std::convertible_to<async_callback_func_t> CallbackT>
auto asyncDeviceNames(CallbackT&& callback_func)
{
return asyncServerCall(constants::ADC_DEVICE_NETPROTO_KEY_NAMES, std::forward<CallbackT>(callback_func));
return asyncDeviceFuncHelper(constants::ADC_DEVICE_NETPROTO_KEY_NAMES,
std::forward<CallbackT>(callback_func));
}
template <std::convertible_to<async_callback_func_t> CallbackT, traits::adc_input_char_range DevNameT>
auto asyncBindDevice(CallbackT&& callback_func, DevNameT&& dev_name)
{
return asyncServerCall(constants::ADC_DEVICE_NETPROTO_KEY_DEVICE, std::forward<CallbackT>(callback_func),
std::forward<DevNameT>(dev_name));
return asyncDeviceFuncHelper(constants::ADC_DEVICE_NETPROTO_KEY_DEVICE,
std::forward<CallbackT>(callback_func), std::forward<DevNameT>(dev_name));
}
template <std::convertible_to<async_callback_func_t> CallbackT, traits::adc_input_char_range CmdNameT>
auto asyncExec(CallbackT&& callback_func, CmdNameT&& cmd_name)
{
return asyncServerCall(constants::ADC_DEVICE_NETPROTO_KEY_CMD, std::forward<CallbackT>(callback_func),
std::forward<CmdNameT>(cmd_name));
return asyncDeviceFuncHelper(constants::ADC_DEVICE_NETPROTO_KEY_CMD, std::forward<CallbackT>(callback_func),
std::forward<CmdNameT>(cmd_name));
}
template <std::convertible_to<async_callback_func_t> CallbackT, traits::adc_input_char_range AttrNameT>
auto asyncGetAttr(CallbackT&& callback_func, AttrNameT&& attr_name)
{
return asyncServerCall(constants::ADC_DEVICE_NETPROTO_KEY_GET, std::forward<CallbackT>(callback_func),
std::forward<AttrNameT>(attr_name));
return asyncDeviceFuncHelper(constants::ADC_DEVICE_NETPROTO_KEY_GET, std::forward<CallbackT>(callback_func),
std::forward<AttrNameT>(attr_name));
}
template <std::convertible_to<async_callback_func_t> CallbackT,
@ -351,9 +277,9 @@ public:
typename... ValueTs>
auto asyncSetAttr(CallbackT&& callback_func, AttrNameT&& attr_name, ValueT&& value, ValueTs&&... values)
{
return asyncServerCall(constants::ADC_DEVICE_NETPROTO_KEY_SET, std::forward<CallbackT>(callback_func),
std::forward<AttrNameT>(attr_name), std::forward<ValueT>(value),
std::forward<ValueTs>(values)...);
return asyncDeviceFuncHelper(constants::ADC_DEVICE_NETPROTO_KEY_SET, std::forward<CallbackT>(callback_func),
std::forward<AttrNameT>(attr_name), std::forward<ValueT>(value),
std::forward<ValueTs>(values)...);
}
protected:
@ -371,7 +297,7 @@ public:
// helper methods
template <traits::adc_range_of_output_char_range R>
R checkServerCall(std::string_view key, const auto& bytes, ServerResponseType& type) const
R checkServerRespond(std::string_view key, const auto& bytes, ServerResponseType& type) const
{
AdcDeviceProtoMessage dev_msg(bytes);
@ -395,9 +321,47 @@ public:
{
auto rbytes = sendRecv(bytes);
return checkServerCall<R>(key, rbytes, type);
return checkServerRespond<R>(key, rbytes, type);
}
template <traits::adc_range_of_output_char_range R, typename... ArgTs>
R deviceFuncHelper(std::string_view key, ServerResponseType& rtype, ArgTs&&... args)
{
typename netservice_t::send_msg_t bytes;
AdcDeviceProtoMessage msg(bytes);
msg.setKeyValue(key, std::forward<ArgTs>(args)...);
return getFromServer<R>(key, bytes, rtype);
}
template <std::convertible_to<async_callback_func_t> CallbackT, typename... ArgTs>
auto asyncDeviceFuncHelper(std::string_view key, CallbackT&& callback_func, ArgTs&&... args)
{
auto bytes = std::shared_ptr<typename netservice_t::send_msg_t>();
AdcDeviceProtoMessage msg(*bytes);
msg.setKeyValue(key, std::forward<ArgTs>(args)...);
asyncSendRecv(*bytes, [bytes, key, wrapper = traits::adc_pf_wrapper(std::forward<CallbackT>(callback_func)),
this](auto err, auto rmsg) mutable {
if (err) {
_clientPtr->logError("An error occured while receiving server respond: {}",
netservice_t::formattableError(err));
} else {
try {
ServerResponseType type;
auto attrs = checkServerRespond<default_server_resp_t>(key, rmsg, type);
std::forward<CallbackT>(std::get<0>(wrapper))(type, attrs);
} catch (const std::system_error& err) {
_clientPtr->logError("An error occured while getting server respond: {}", err.what());
}
}
});
}
template <traits::adc_input_char_range SendMsgT>
auto sendRecv(const SendMsgT& send_msg)
@ -430,8 +394,6 @@ public:
};
/* A HELPER CLASS TO IMPLEMENT AN SIMPLE QUEUE FOR DEVICE ATTRIBUTE GET/SET OPERATIONS AND COMMAND EXECUTION */
template <traits::adc_range_of_input_char_range ArgRangeT = std::vector<std::string>>
class AdcNetClientSendQueue
{
@ -453,13 +415,13 @@ public:
return *this;
}
template <traits::adc_input_char_range... ArgTs>
AdcNetClientSendQueue& addToQueue(std::string key, ArgTs&&... elems)
template <traits::adc_input_char_range... ElemTs>
AdcNetClientSendQueue& addToQueue(std::string key, ElemTs&&... elems)
{
if constexpr (sizeof...(ArgTs)) {
if constexpr (sizeof...(ElemTs)) {
_queue.push({key, ArgRangeT()});
addToQueueHelper(std::get<1>(_queue.back()), std::forward<ArgTs>(elems)...);
addToQueueHelper(std::get<1>(_queue.back()), std::forward<ElemTs>(elems)...);
}
return *this;
@ -501,17 +463,17 @@ public:
protected:
std::queue<queue_elem_t> _queue;
template <traits::adc_input_char_range ArgT, traits::adc_input_char_range... ArgTs>
void addToQueueHelper(ArgRangeT& args, ArgT&& elem, ArgTs&&... elems)
template <traits::adc_input_char_range ElemT, traits::adc_input_char_range... ElemTs>
void addToQueueHelper(ArgRangeT& args, ElemT&& elem, ElemTs&&... elems)
{
using el_t = std::ranges::range_value_t<ArgRangeT>;
if constexpr (std::same_as<el_t, std::remove_cvref_t<ArgT>>) {
if constexpr (std::same_as<el_t, std::remove_cvref_t<ElemT>>) {
std::ranges::copy(std::ranges::single_view(elem), std::back_inserter(args));
} else {
std::span<const char> sp;
if constexpr (std::is_array_v<std::remove_cvref_t<ArgT>>) {
if constexpr (std::is_array_v<std::remove_cvref_t<ElemT>>) {
sp = std::string_view(elem);
} else {
sp = std::span<const char>(elem);
@ -526,8 +488,8 @@ protected:
std::back_inserter(args));
}
if constexpr (sizeof...(ArgTs)) {
addToQueue(args, std::forward<ArgTs>(elems)...);
if constexpr (sizeof...(ElemTs)) {
addToQueue(args, std::forward<ElemTs>(elems)...);
}
}
};

19
net/asio/adc_netservice_asio.h
View File

@ -6,7 +6,6 @@
#include <asio/basic_stream_socket.hpp>
#include <asio/bind_executor.hpp>
#include <asio/compose.hpp>
#include <asio/connect.hpp>
#include <asio/deferred.hpp>
#include <asio/ip/tcp.hpp>
#include <asio/ip/udp.hpp>
@ -125,10 +124,6 @@ public:
static constexpr bool isTLS = false;
#endif
typedef TRANSPORT_PROTOT transport_proto_t;
typedef SESSION_PROTOT session_proto_t;
typedef RMSGT receive_msg_t;
// typedefs to satisfy 'adc_netservice_c' concept
typedef std::string_view netservice_ident_t;
@ -798,17 +793,6 @@ public:
return s;
}
template <std::derived_from<AdcBaseNetServiceASIO> ST,
typename EptRangeT,
asio::completion_token_for<std::error_code, endpoint_t> CallbackT>
friend auto async_connect(ST& service, const EptRangeT& ept_range, CallbackT&& token)
requires std::ranges::range<EptRangeT> &&
std::same_as<std::ranges::range_value_t<EptRangeT>, AdcBaseNetServiceASIO::endpoint_t>
{
return asio::async_connect(service._socket, ept_range, token);
};
protected:
static constexpr netservice_ident_t _ident =
std::derived_from<socket_t, asio::basic_stream_socket<typename socket_t::protocol_type>>
@ -947,8 +931,7 @@ protected:
/* PARTIAL AdcBaseNetServiceASIO-CLASS SPECIALIZATIONS */
/* */
template <
adc_asio_transport_proto_c TRANSPORT_PROTOT, // transport-level proto (e.g. asio::ip::tcp)
interfaces::adc_netsession_proto_c<std::string_view> SESSION_PROTOT, // session-level proto (see ../adc_netproto.h)

198
net/asio/adc_netsession_asio.h Normal file
View File

@ -0,0 +1,198 @@
#pragma once
#include "adc_netservice_asio.h"
namespace adc::impl
{
template <typename SessionContextT,
adc_asio_transport_proto_c TRANSPORT_PROTOT,
interfaces::adc_netsession_proto_c<std::string_view> SESSION_PROTOT,
traits::adc_output_char_range RMSGT = std::vector<char>>
class AdcGenericNetSessionASIO : public std::enable_shared_from_this<
AdcGenericNetSessionASIO<SessionContextT, TRANSPORT_PROTOT, SESSION_PROTOT, RMSGT>>
{
public:
typedef std::string netsession_ident_t;
typedef SessionContextT netsession_ctx_t;
typedef AdcNetServiceASIOBase<TRANSPORT_PROTOT, SESSION_PROTOT, RMSGT> netservice_t;
typedef std::shared_ptr<netservice_t> netservice_sptr_t;
template <traits::adc_input_char_range R>
AdcGenericNetSessionASIO(const R& id, netservice_sptr_t netservice, netsession_ctx_t&& context)
: _ident(), _netservice(std::move(netservice)), _sessionContext(std::forward<netsession_ctx_t>(context))
{
if constexpr (std::is_array_v<R>) {
_ident = id;
} else {
_ident = std::string(id.begin(), id.end());
}
}
AdcGenericNetSessionASIO(netservice_sptr_t netservice, netsession_ctx_t&& context)
: AdcGenericNetSessionASIO(
std::derived_from<TRANSPORT_PROTOT, asio::ip::tcp> ? "ASIO TCP SESSION"
: std::derived_from<TRANSPORT_PROTOT, asio::ip::udp> ? "ASIO UDP SESSION"
: std::derived_from<TRANSPORT_PROTOT, asio::local::seq_packet_protocol> ? "ASIO UNIX SEQPACKET SESSION"
: std::derived_from<TRANSPORT_PROTOT, asio::local::stream_protocol> ? "ASIO UNIX STREAM SESSION"
: std::derived_from<TRANSPORT_PROTOT, asio::local::datagram_protocol> ? "ASIO UNIX DATAGRAM SESSION"
: "ASIO UNKNOWN",
std::move(netservice),
std::forward<netsession_ctx_t>(context))
{
}
virtual ~AdcGenericNetSessionASIO()
{
stop();
}
netsession_ident_t ident() const
{
return _ident;
}
virtual void start() = 0;
virtual void stop()
{
_netservice->close();
}
template <traits::adc_time_duration_c TimeoutT>
AdcGenericNetSessionASIO& setDefaultTimeouts(const TimeoutT& send_timeout, const TimeoutT& recv_timeout)
{
_sendTimeout = send_timeout;
_recvTimeout = recv_timeout;
return *this;
}
protected:
netsession_ident_t _ident;
netservice_sptr_t _netservice;
netsession_ctx_t _sessionContext;
std::chrono::duration<std::chrono::seconds::rep, std::chrono::seconds::period> _recvTimeout =
std::chrono::seconds::max();
std::chrono::duration<std::chrono::seconds::rep, std::chrono::seconds::period> _sendTimeout =
std::chrono::seconds(5);
};
/*
class AdcGenericNetSessionASIO
{
public:
typedef std::string netsession_ident_t;
template <traits::adc_input_char_range R,
adc_asio_transport_proto_c TRANSPORT_PROTOT,
interfaces::adc_netsession_proto_c<std::string_view> SESSION_PROTOT,
traits::adc_output_char_range RMSGT = std::vector<char>,
traits::adc_is_callable RECV_MSG_TOKENT>
AdcGenericNetSessionASIO(const R& id,
std::shared_ptr<AdcNetServiceASIOBase<TRANSPORT_PROTOT, SESSION_PROTOT, RMSGT>> netservice,
RECV_MSG_TOKENT&& recv_msg_token)
: _ident(id.begin(), id.end())
{
// check receive message completion token signature and deduce message type
if constexpr (!adc_asio_special_comp_token_c<RECV_MSG_TOKENT>) {
static_assert(traits::adc_func_traits<RECV_MSG_TOKENT>::arity == 2, "INVALID COMPLETION TOKEN SIGNATURE!");
static_assert(
std::is_same_v<std::remove_cvref_t<traits::adc_func_arg1_t<RECV_MSG_TOKENT>>, std::error_code>,
"INVALID COMPLETION TOKEN SIGNATURE!");
static_assert(traits::adc_output_char_range<
std::tuple_element_t<1, typename traits::adc_func_traits<RECV_MSG_TOKENT>::args_t>>,
"INVALID COMPLETION TOKEN SIGNATURE!");
}
using msg_t = std::conditional_t<
adc_asio_special_comp_token_c<RECV_MSG_TOKENT>, RMSGT,
std::remove_cvref_t<std::tuple_element_t<1, typename traits::adc_func_traits<RECV_MSG_TOKENT>::args_t>>>;
_startFunc = [netservice, wrapper = traits::adc_pf_wrapper(std::forward<RECV_MSG_TOKENT>(recv_msg_token)),
this]() {
//
netservice->asyncReceive(std::get<0>(wrapper), _recvTimeout);
};
_stopFunc = [netservice]() {
// stop
netservice->close();
};
}
template <adc_asio_transport_proto_c TRANSPORT_PROTOT,
interfaces::adc_netsession_proto_c<std::string_view> SESSION_PROTOT,
traits::adc_output_char_range RMSGT = std::vector<char>,
traits::adc_is_callable RECV_MSG_TOKENT>
AdcGenericNetSessionASIO(std::shared_ptr<AdcNetServiceASIOBase<TRANSPORT_PROTOT, SESSION_PROTOT, RMSGT>> netservice,
RECV_MSG_TOKENT&& recv_msg_token)
: AdcGenericNetSessionASIO(std::derived_from<TRANSPORT_PROTOT, asio::ip::tcp> ? "TCP SESSION"
: std::derived_from<TRANSPORT_PROTOT, asio::ip::udp> ? "UDP SESSION"
: std::derived_from<TRANSPORT_PROTOT, asio::local::seq_packet_protocol>
? "UNIX SEQPACKET SESSION"
: std::derived_from<TRANSPORT_PROTOT, asio::local::stream_protocol> ? "UNIX STREAM
SESSION" : "UNKNOWN", std::move(netservice), std::forward<RECV_MSG_TOKENT>(recv_msg_token))
{
}
virtual ~AdcGenericNetSessionASIO()
{
stop();
}
netsession_ident_t ident() const
{
return _ident;
}
void start()
{
_startFunc();
}
void stop()
{
_stopFunc();
}
template <traits::adc_time_duration_c TimeoutT>
AdcGenericNetSessionASIO& setDefaultTimeouts(const TimeoutT& send_timeout, const TimeoutT& recv_timeout)
{
_sendTimeout = send_timeout;
_recvTimeout = recv_timeout;
return *this;
}
protected:
netsession_ident_t _ident;
std::function<void()> _startFunc;
std::function<void()> _stopFunc;
std::chrono::duration<std::chrono::seconds::rep, std::chrono::seconds::period> _recvTimeout =
std::chrono::seconds::max();
std::chrono::duration<std::chrono::seconds::rep, std::chrono::seconds::period> _sendTimeout =
std::chrono::seconds(5);
};
*/
} // namespace adc::impl