SimpleSocket.h

#ifndef NET_SimpleSocket_h__
#define NET_SimpleSocket_h__
 
#include <sys/socket.h>
#include <string>
#include <exception>
 
namespace NET
{
    class SocketException : public std::exception
    {
    public:
        SocketException( std::string_view message, bool inclSysMsg = true);
 
        SocketException( const SocketException&) = default;

        ~SocketException() noexcept {};

        const char* what() const noexcept { return m_message.c_str(); }

        int errorCode() const noexcept { return m_errorcode; }
 
    private:
        std::string m_message;
        int m_errorcode;
    };
 
    enum AddressFamily
    {
        IPv4,
        IPv6
    };

    typedef void raw_type;


    class SimpleSocket
    {
    public:
        enum ShutdownDirection
        {
            STOP_SEND = SHUT_WR,     
            STOP_RECEIVE = SHUT_RD,  
            STOP_BOTH = SHUT_RDWR    
        };
 
        SimpleSocket( const SimpleSocket&) = delete;
        SimpleSocket& operator=( const SimpleSocket&) = delete;

        int nativeHandle() noexcept { return m_socket; }


        int send( const void* buffer, size_t len);


        int receive( void* buffer, size_t len);


        int timedReceive( void* buffer, size_t len, int timeout);


        void disconnect();


        void shutdown( ShutdownDirection type);


        bool peerDisconnected() const noexcept;
 
    protected:

        void listen( int backlog = 5);


        int sendAll( const void* buffer, size_t len);


        int receiveAll( void* buffer, size_t len);

        explicit SimpleSocket( int sockfd);

        SimpleSocket( int domain, int type, int protocol);
 
        // protected to avoid delete via base class
        ~SimpleSocket();

        int accept() const;

        int timedAccept( int timeout) const;
 
        // socket descriptor
        int m_socket;
        bool m_peerDisconnected;
        bool m_connectionOriented;
    };
 
} // namespace NET
 
#endif // NET_SimpleSocket_h__