CAcceptorSocket.hpp

Go to the documentation of this file.

#ifndef LIBS_COMM_CACCEPTORSOCKET_HPP_
#define LIBS_COMM_CACCEPTORSOCKET_HPP_
 
#include "comms/socket/CStreamSocket.hpp"
 
class CAcceptorSocket : public CSocket
{
public:
    CAcceptorSocket() = default;
 
    explicit CAcceptorSocket(socket_t handle) : CSocket(handle)
    {
    }
 
    explicit CAcceptorSocket(const CSocketAddress &address, int32_t queueSize = DFLT_QUEUE_SIZE)
    {
        open(address, queueSize);
    }
 
    CAcceptorSocket(CAcceptorSocket &&acc) noexcept : CSocket(std::move(acc))
    {
    }
 
    CAcceptorSocket(const CAcceptorSocket &) = delete;
    CAcceptorSocket &operator=(const CAcceptorSocket &) = delete;
 
    static CAcceptorSocket create(int32_t domain);
 
    CAcceptorSocket &operator=(CAcceptorSocket &&rhs) noexcept
    {
        CSocket::operator=(std::move(rhs));
 
        return *this;
    }
 
    bool listen(int32_t queueSize = DFLT_QUEUE_SIZE)
    {
        return checkRetBool(::listen(getHandle(), queueSize));
    }
 
    bool open(const CSocketAddress &address, int32_t queueSize = DFLT_QUEUE_SIZE);
    CStreamSocket accept(CSocketAddress *clientAddress = nullptr);
    CStreamSocket acceptWithTimeout(CSocketAddress *clientAddress, uint64_t timeout);
 
protected:
    static const int32_t DFLT_QUEUE_SIZE = 4;
 
    static socket_t createHandle(int32_t domain)
    {
        return CStreamSocket::createHandle(domain);
    }
};
 
template<typename STREAM_SOCK, typename ADDR = typename STREAM_SOCK::addr_t>
class CAcceptorSocketTmpl : public CAcceptorSocket
{
public:
    using stream_sock_t = STREAM_SOCK;
    using addr_t = ADDR;
 
    CAcceptorSocketTmpl() = default;
 
    explicit CAcceptorSocketTmpl(const addr_t &address, int32_t queueSize = DFLT_QUEUE_SIZE)
    {
        open(address, queueSize);
    }
 
    explicit CAcceptorSocketTmpl(in_port_t port, int32_t queueSize = DFLT_QUEUE_SIZE)
    {
        open(port, queueSize);
    }
 
    CAcceptorSocketTmpl(CAcceptorSocketTmpl &&acc) noexcept : CAcceptorSocket(std::move(acc))
    {
    }
 
    CAcceptorSocketTmpl(const CAcceptorSocketTmpl &) = delete;
    CAcceptorSocketTmpl &operator=(const CAcceptorSocketTmpl &) = delete;
 
    static CAcceptorSocketTmpl create()
    {
        return CAcceptorSocket::create(addr_t::ADDRESS_FAMILY);
    }
 
    CAcceptorSocketTmpl &operator=(CAcceptorSocketTmpl &&rhs) noexcept
    {
        CAcceptorSocket::operator=(std::move(rhs));
 
        return *this;
    }
 
    stream_sock_t accept(addr_t *clientAddress = nullptr)
    {
        return stream_sock_t(CAcceptorSocket::accept(clientAddress));
    }
 
    stream_sock_t acceptWithTimeout(addr_t *clientAddress, uint64_t timeout)
    {
        return stream_sock_t(CAcceptorSocket::acceptWithTimeout(clientAddress, timeout));
    }
 
    bool bind(const addr_t &address)
    {
        return CAcceptorSocket::bind(address);
    }
 
    bool open(const addr_t &address, int32_t queueSize = DFLT_QUEUE_SIZE)
    {
        return CAcceptorSocket::open(address, queueSize);
    }
 
    bool open(in_port_t port, int32_t queueSize = DFLT_QUEUE_SIZE)
    {
        return open(addr_t(port), queueSize);
    }
 
    addr_t getAddr() const
    {
        return addr_t(CAcceptorSocket::getAddress());
    }
};
 
#endif /* LIBS_COMM_CACCEPTORSOCKET_HPP_ */