CDatagramSocket.hpp

Go to the documentation of this file.

#ifndef LIBS_COMM_CDATAGRAMSOCKET_HPP_
#define LIBS_COMM_CDATAGRAMSOCKET_HPP_
 
#include "comms/socket/CSocket.hpp"
#include "core/assert.hpp"
 
class CDatagramSocket : public CSocket
{
public:
    static constexpr int32_t COMM_TYPE = SOCK_DGRAM;
 
    CDatagramSocket()
    {
    }
 
    explicit CDatagramSocket(socket_t handle) : CSocket(handle)
    {
    }
 
    explicit CDatagramSocket(const CSocketAddress &address);
 
    CDatagramSocket(CDatagramSocket &&other) : CSocket(std::move(other))
    {
    }
 
    virtual ~CDatagramSocket()
    {
    }
 
    CDatagramSocket &operator=(CDatagramSocket &&rhs)
    {
        CSocket::operator=(std::move(rhs));
 
        return *this;
    }
 
    virtual bool connect(const CSocketAddress &address)
    {
        return checkRetBool(::connect(getHandle(), address.getSocketAddress(), address.size()));
    }
 
    ssize_t sendTo(const void *buf, size_t n, int32_t flags, const CSocketAddress &address)
    {
        IV_ASSERT_NULL_POINTER(buf);
        return checkRet(::sendto(getHandle(), buf, n, flags, address.getSocketAddress(), address.size()));
    }
 
    ssize_t sendTo(const void *buf, size_t n, const CSocketAddress &address)
    {
        return sendTo(buf, n, 0, address);
    }
 
    ssize_t sendTo(const std::string &s, int32_t flags, const CSocketAddress &address)
    {
        return sendTo(s.data(), s.length(), flags, address);
    }
 
    ssize_t sendTo(const std::string &s, const CSocketAddress &address)
    {
        return sendTo(s.data(), s.length(), 0, address);
    }
 
    ssize_t send(const void *buf, size_t n, int32_t flags = 0)
    {
        return checkRet(::send(getHandle(), buf, n, flags));
    }
 
    ssize_t send(const std::string &s, int32_t flags = 0)
    {
        return send(s.data(), s.length(), flags);
    }
 
    ssize_t recvFrom(void *buf, size_t n, int32_t flags, CSocketAddress *srcAddress = nullptr);
 
    ssize_t recvFrom(void *buf, size_t n, CSocketAddress *srcAddress = nullptr)
    {
        return recvFrom(buf, n, 0, srcAddress);
    }
 
    ssize_t recv(void *buf, size_t n, int32_t flags = 0)
    {
        return checkRet(::recv(getHandle(), buf, n, flags));
    }
 
protected:
    static socket_t createHandle(int32_t domain)
    {
        return socket_t(::socket(domain, COMM_TYPE, 0));
    }
 
private:
    CDatagramSocket(const CDatagramSocket &other) = delete;
    CDatagramSocket &operator=(const CDatagramSocket &other) = delete;
};
 
//---------------------------------------------------------------
 
template<typename ADDR>
class CDatagramSocketTmpl : public CDatagramSocket
{
public:
    static constexpr sa_family_t ADDRESS_FAMILY = ADDR::ADDRESS_FAMILY;
 
    using addr_t = ADDR;
 
    CDatagramSocketTmpl() : CDatagramSocket(createHandle(ADDRESS_FAMILY))
    {
    }
 
    explicit CDatagramSocketTmpl(socket_t handle) : CDatagramSocket(handle)
    {
    }
 
    explicit CDatagramSocketTmpl(const ADDR &address) : CDatagramSocket(address)
    {
    }
 
    CDatagramSocketTmpl(CDatagramSocketTmpl &&other) : CDatagramSocket(std::move(other))
    {
    }
 
    CDatagramSocketTmpl &operator=(CDatagramSocketTmpl &&rhs)
    {
        CDatagramSocket::operator=(std::move(rhs));
 
        return *this;
    }
 
    static std::tuple<CDatagramSocketTmpl, CDatagramSocketTmpl> pair(int32_t protocol = 0)
    {
        auto pr = CDatagramSocket::pair(addr_t::ADDRESS_FAMILY, COMM_TYPE, protocol);
 
        return std::make_tuple<CDatagramSocketTmpl, CDatagramSocketTmpl>(
                CDatagramSocketTmpl {std::get<0>(pr).release()}, CDatagramSocketTmpl {std::get<1>(pr).release()});
    }
 
    ssize_t sendTo(const void *buf, size_t n, int32_t flags, const ADDR &address)
    {
        return CDatagramSocket::sendTo(buf, n, flags, address);
    }
 
    ssize_t sendTo(const std::string &s, int32_t flags, const ADDR &address)
    {
        return CDatagramSocket::sendTo(s, flags, address);
    }
 
    ssize_t sendTo(const void *buf, size_t n, const ADDR &address)
    {
        return CDatagramSocket::sendTo(buf, n, 0, address);
    }
 
    ssize_t sendTo(const std::string &s, const ADDR &address)
    {
        return CDatagramSocket::sendTo(s, address);
    }
 
    ssize_t recvFrom(void *buf, size_t n, int32_t flags, ADDR *srcAddress)
    {
        return CDatagramSocket::recvFrom(buf, n, flags, srcAddress);
    }
 
    ssize_t recvFrom(void *buf, size_t n, ADDR *srcAddress = nullptr)
    {
        return CDatagramSocket::recvFrom(buf, n, srcAddress);
    }
};
 
#endif /* LIBS_COMM_CDATAGRAMSOCKET_HPP_ */