CStreamSocket.hpp

Go to the documentation of this file.

#ifndef LIBS_COMM_CSTREAMSOCKET_HPP_
#define LIBS_COMM_CSTREAMSOCKET_HPP_
 
#include "CSocket.hpp"
 
#include <vector>
 
class CStreamSocket : public CSocket
{
public:
    static constexpr int32_t COMM_TYPE = SOCK_STREAM;
 
    CStreamSocket() = default;
 
    explicit CStreamSocket(socket_t handle) : CSocket(handle)
    {
    }
 
    CStreamSocket(CStreamSocket &&sock) noexcept : CSocket(std::move(sock))
    {
    }
 
    static CStreamSocket create(int32_t domain, int32_t protocol = 0);
 
    CStreamSocket &operator=(CStreamSocket &&rhs) noexcept
    {
        CSocket::operator=(std::move(rhs));
 
        return *this;
    }
 
    ssize_t read(const std::vector<iovec> &ranges);
    virtual ssize_t read(void *buf, size_t n);
    virtual ssize_t read_n(void *buf, size_t n);
 
    virtual ssize_t write(const std::string &s)
    {
        return write_n(s.data(), s.size());
    }
 
    virtual ssize_t write(const std::vector<iovec> &ranges);
    virtual ssize_t write(const void *buf, size_t n);
    virtual ssize_t write_n(const void *buf, size_t n);
 
    virtual bool setReadTimeout(const std::chrono::microseconds &to);
 
    template<class Rep, class Period>
    bool setReadTimeout(const std::chrono::duration<Rep, Period> &to)
    {
        return setReadTimeout(std::chrono::duration_cast<std::chrono::microseconds>(to));
    }
 
    virtual bool setWriteTimeout(const std::chrono::microseconds &to);
 
    template<class Rep, class Period>
    bool write_timeout(const std::chrono::duration<Rep, Period> &to)
    {
        return setWriteTimeout(std::chrono::duration_cast<std::chrono::microseconds>(to));
    }
 
protected:
    friend class CAcceptorSocket;
 
    static socket_t createHandle(int32_t domain)
    {
        return (socket_t)::socket(domain, COMM_TYPE, 0);
    }
};
 
//---------------------------------------------------------------
 
template<typename ADDR>
class CStreamSocketTmpl : public CStreamSocket
{
public:
    static constexpr sa_family_t ADDRESS_FAMILY = ADDR::ADDRESS_FAMILY;
    using addr_t = ADDR;
 
    CStreamSocketTmpl() = default;
 
    explicit CStreamSocketTmpl(socket_t handle) : CStreamSocket(handle)
    {
    }
 
    explicit CStreamSocketTmpl(CStreamSocket &&sock) : CStreamSocket(std::move(sock))
    {
    }
 
    CStreamSocketTmpl(CStreamSocketTmpl &&sock) noexcept : CStreamSocket(std::move(sock))
    {
    }
 
    CStreamSocketTmpl &operator=(CStreamSocketTmpl &&rhs) noexcept
    {
        CStreamSocket::operator=(std::move(rhs));
 
        return *this;
    }
 
    CStreamSocketTmpl create(int32_t protocol = 0)
    {
        return CStreamSocketTmpl(std::move(CStreamSocket::create(ADDRESS_FAMILY, protocol)));
    }
 
    static std::tuple<CStreamSocketTmpl, CStreamSocketTmpl> pair(int32_t protocol = 0)
    {
        auto pr = CStreamSocket::pair(ADDRESS_FAMILY, COMM_TYPE, protocol);
 
        return std::make_tuple<CStreamSocketTmpl, CStreamSocketTmpl>(CStreamSocketTmpl {std::get<0>(pr).release()},
                                                                     CStreamSocketTmpl {std::get<1>(pr).release()});
    }
 
    addr_t getAddr() const
    {
        return addr_t(CSocket::getAddress());
    }
 
    addr_t getPeerAddr() const
    {
        return addr_t(CSocket::getPeerAddress());
    }
};
 
#endif /* LIBS_COMM_CSTREAMSOCKET_HPP_ */