CSocket.hpp

Go to the documentation of this file.

#ifndef LIBS_COMM_CSOCKET_HPP_
#define LIBS_COMM_CSOCKET_HPP_
 
#include <chrono>
#include <tuple>
 
#include "CSocketAddress.hpp"
#include "ENetPort.hpp"
 
class CSocket
{
public:
    CSocket();
 
    explicit CSocket(socket_t handle);
 
    CSocket(const CSocket &other) = delete;
 
    CSocket(CSocket &&other) noexcept;
 
    virtual ~CSocket();
 
    CSocket &operator=(const CSocket &other) = delete;
 
    CSocket &operator=(CSocket &&other) noexcept;
 
    bool operator!() const;
 
    explicit operator bool() const;
 
    virtual bool bind(const CSocketAddress &address);
    bool bind(const sockaddr *address, socklen_t len) const;
 
    bool isOpen() const;
 
    socket_t release();
 
    void reset(socket_t handle = INVALID_SOCKET);
 
    CSocket clone() const;
 
    bool close();
 
    static CSocket create(int32_t domain, int32_t type, int32_t protocol = 0);
    static bool close(socket_t h);
    static std::tuple<CSocket, CSocket> pair(int32_t domain, int32_t type, int32_t protocol = 0);
 
    virtual CSocketAddressAny getAddress() const;
    virtual CSocketAddressAny getPeerAddress() const;
 
    [[maybe_unused]] virtual sa_family_t getFamily() const;
 
    socket_t getHandle() const;
 
    void setLastError(int32_t err = INT32_MAX) const;
    std::string getLastErrorString() const;
    void clearLastError(int32_t value = 0) const;
 
    bool getOption(int32_t level, int32_t optName, void *optVal, socklen_t *optLength) const;
 
    template<typename T>
    bool getOption(const int32_t level, const int32_t optName, T *value) const
    {
        socklen_t len = sizeof(T);
        return getOption(level, optName, reinterpret_cast<void *>(value), &len);
    }
 
    bool setOption(int32_t level, int32_t optName, const void *optVal, socklen_t optLength) const;
 
    template<typename T>
    bool setOption(const int32_t level, const int32_t optName, const T &value)
    {
        return setOption(level, optName, reinterpret_cast<const void *>(&value), sizeof(T));
    }
 
    bool setNonBlocking(bool on = true) const;
 
protected:
    static int32_t getErrno();
 
    template<typename T>
    T checkRet(T ret) const
    {
        m_lastError = (ret == -1) ? getErrno() : 0;
 
        return ret;
    }
 
    template<typename T>
    bool checkRetBool(T ret) const
    {
        m_lastError = (ret == -1) ? getErrno() : 0;
 
        return ret >= 0;
    }
 
    socket_t checkSocket(socket_t ret) const
    {
        m_lastError = (ret == INVALID_SOCKET) ? getErrno() : 0;
 
        return ret;
    }
 
    bool checkSocketBool(socket_t ret) const
    {
        m_lastError = (ret == INVALID_SOCKET) ? getErrno() : 0;
 
        return ret != INVALID_SOCKET;
    }
 
    bool closeOnError()
    {
        close(release());
 
        return false;
    }
 
    socket_t m_handle;
 
private:
    mutable int32_t m_lastError;
};
 
timeval toTimeval(const std::chrono::microseconds &duration);
 
template<class Rep, class Period>
timeval toTimeval(const std::chrono::duration<Rep, Period> &duration)
{
    return toTimeval(std::chrono::duration_cast<std::chrono::microseconds>(duration));
}
 
#endif /* LIBS_COMM_CSOCKET_HPP_ */