client.h

Go to the documentation of this file.

 
#ifndef QB_IO_ASYNC_TCP_SESSION_H
#define QB_IO_ASYNC_TCP_SESSION_H
 
#include "../../../uuid.h"
#include "../io.h"
 
namespace qb::io::async::tcp {

template <typename _Derived, typename _Transport, typename _Server = void>
class client
    : public io<_Derived>
    , _Transport {
    using base_t = io<_Derived>;
    friend base_t;
 
public:
    using base_io_t = io<_Derived>; 
    using transport_io_type =
        typename _Transport::transport_io_type; 
    using _Transport::in;        
    using _Transport::out;       
    using _Transport::transport; 
    using base_t::publish;       
 
protected:
    const uuid _uuid;   
    _Server   &_server; 
 
public:
    using IOServer = _Server; 
    constexpr static const bool has_server =
        true; 

    client() = delete;

    explicit client(_Server &server)
        : _uuid(generate_random_uuid())
        , _server(server) {
        if constexpr (has_member_Protocol<_Derived>::value) {
            if constexpr (!std::is_void_v<typename _Derived::Protocol>) {
                this->template switch_protocol<typename _Derived::Protocol>(
                    static_cast<_Derived &>(*this));
            }
        }
    }

    ~client() = default;

    inline _Server &
    server() {
        return _server;
    }

    inline _Server &
    server() const {
        return _server;
    }

    inline uuid const &
    id() const noexcept {
        return _uuid;
    }

    inline auto
    shared() const {
        return server().session(id());
    }

    inline auto
    ip() const {
        return transport().peer_endpoint().ip();
    }

    inline auto
    port() const {
        return transport().peer_endpoint().port();
    }
};

template <typename _Derived, typename _Transport>
class client<_Derived, _Transport, void>
    : public io<_Derived>
    , _Transport {
    using base_t = io<_Derived>;
    friend base_t;
protected:
    const uuid _uuid;   
public:
    using base_io_t = io<_Derived>; 
    using transport_io_type =
        typename _Transport::transport_io_type; 
    using _Transport::in;        
    using _Transport::out;       
    using _Transport::transport; 
    using base_t::publish;       
 
public:
    client() noexcept {
        if constexpr (has_member_Protocol<_Derived>::value) {
            if constexpr (!std::is_void_v<typename _Derived::Protocol>) {
                this->template switch_protocol<typename _Derived::Protocol>(
                    static_cast<_Derived &>(*this));
            }
        }
    }

    ~client() = default;
};
 
} // namespace qb::io::async::tcp
 
#endif // QB_IO_ASYNC_TCP_SESSION_H