PosixSocket.hpp

#pragma once
 
#include <EasySockets/Api/SocketTypes.hpp>
#include <EasySockets/Api/Addresses.hpp>
#include <EasySockets/Api/Documentation.hpp>
#include <netdb.h>
 
namespace es
{
    ES_API_DOC(socket)
    class PosixSocket
    {
    public:
        ES_API_DOC(socket_default_constructor)
        PosixSocket();
 
        ES_API_DOC(socket_constructor)
        PosixSocket(IpVersion ip_version, Protocol protocol);
 
        ~PosixSocket();
 
        PosixSocket(const PosixSocket&) = delete;
 
        PosixSocket& operator=(const PosixSocket&) = delete;
 
        PosixSocket(PosixSocket&& other) noexcept;
 
        PosixSocket& operator=(PosixSocket&& other) noexcept;
 
        ES_API_DOC(socket_bind_to)
        void bind_to(const EndPoint& end_point);
 
        ES_API_DOC(socket_connect_to)
        void connect_to(const EndPoint& end_point);
 
        ES_API_DOC(socket_listen_for_connections)
        void listen_for_connections(int backlog);
 
        ES_API_DOC(socket_accept_connection)
        PosixSocket accept_connection();
 
        ES_API_DOC(socket_receive_data)
        int64_t receive_data(char* buffer, int buffer_size);
 
        ES_API_DOC(socket_receive_data_from)
        int64_t receive_data_from(char* buffer, int buffer_size, EndPoint& sender_end_point);
 
        ES_API_DOC(socket_send_data)
        int64_t send_data(const char* buffer, int buffer_size);
 
        ES_API_DOC(socket_send_data_to)
        int64_t send_data_to(const char* buffer, int buffer_size, const EndPoint& end_point);
 
        ES_API_DOC(socket_close)
        void close();
 
        ES_API_DOC(make_connected_tcp)
        static PosixSocket make_connected_tcp(const EndPoint& end_point);
 
        ES_API_DOC(make_connected_udp)
        static PosixSocket make_connected_udp(const EndPoint& end_point);
 
        ES_API_DOC(make_bound_tcp)
        static PosixSocket make_bound_tcp(Port port, IpVersion ip_version = IpVersion::DUAL_STACK);
 
        ES_API_DOC(make_bound_udp)
        static PosixSocket make_bound_udp(Port port, IpVersion ip_version = IpVersion::DUAL_STACK);
 
    private:
        struct SocketData
        {
            int af;
            int type;
            int protocol;
        };
 
        static addrinfo* resolve_address(const SocketData& socket_data, const EndPoint& end_point); // must call freeaddrinfo afterward
 
        int m_socket;
        SocketData m_socket_data;
    };
}