ADC/net/asio/adc_netsession_asio.h

#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