socketdevice.h

#ifndef SOCKETDEVICE_H
#define SOCKETDEVICE_H
 
//#include <stdint.h>
 
#include <string>
#include <mutex>
#include <memory>
 
class SocketDevice
{
public:
    static std::string resolveHostname(const std::string &hostname);
 
    enum proto { tcpip,
                 udpip,
                 unset };
 
    uint64_t sentBytes() const { return _sent_bytes; }
 
    ~SocketDevice();
 
    SocketDevice(proto p,
                 const std::string& la,
                 int lp,
                 const std::string& ra,
                 int rp );
//    SocketDevice( int _existing_socket );
    SocketDevice(proto p, int _existing_socket );
 
    std::string getDeviceAddress() const;
    inline std::string getError() const { return _error_string; }
    inline bool hasIncomingData() const { return waitIncomingData(0); }
 
    bool isInitialized();
    bool initialize();
    void shutdown();
 
    inline bool canRead() const { return _canRead; }
    inline bool canWrite() const { return _canWrite; }
 
    bool setTimeout(int sec, int usec);
 
    int getProto();
 
    bool setRemoteIP( const std::string& ra );
    bool setRemotePort( int rp );
    inline std::string getLocalIP() const { return _localAddress; }
    inline std::string getRemoteIP() const { return _remoteAddress; }
    inline int getLocalPort() const { return _localPort; }
    inline int getRemotePort() const { return _remotePort; }
 
    std::unique_ptr<SocketDevice> accept();
    bool bind();
    bool listen();
    bool connect();
 
    void setTcpNodelay(bool s);
    bool setReuseAddr();
    
    bool setBroadcast();
 
    void setSoLinger(int timeout );
 
    template<typename T>
    bool readData( T& data )
    {
        return _readLoop( &data, sizeof(data) ) == sizeof(data);
    }
    bool readString( std::string& string );
 
    bool readData( void* data, int size )
    {
        return _readLoop( data, size ) == size;
    }
 
    template<typename T>
    bool writeData( const T& data )
    {
        return _writeLoop( &data, sizeof(data) ) == sizeof(data);
    }
    bool writeString( const std::string& string );
 
    bool writeData( const void* data, int size )
    {
        return _writeLoop( data, size ) == size;
    }
 
public:
    void joinMulticastGroup();
    bool setMulticastLoopback(bool loopback_enabled);
    bool setMulticastTTL(int multicast_ttl);
 
    int incomingDataSize() const;
    bool waitIncomingData( int64_t usecs ) const;
 
    void setDelayConnect( bool d );
    bool getDelayConnect() const;
 
    bool setSocketReceiveBufferSize(int desired_socket_size);
    bool setSocketTransmitBufferSize(int desired_socket_size);
 
    bool isLocalPortValid() const;
    bool isRemotePortValid() const;
 
    inline int getFd() const { return _socket; }
 
private:
    static std::string getErrnoString(const std::string &extra);
 
    int _readLoop(void* data, int length );
    int _writeLoop(const void *data, int length );
 
    void updateAddresses();
    void setErrorString( const std::string& err );
    void setCanRead( bool cr );
    void setCanWrite( bool cw );
 
    uint64_t _sent_bytes;
    bool _canRead;
    bool _canWrite;
    bool _isInitialized;
    std::string _error_string;
 
    int _localPort;
    int _remotePort;
    proto _proto;
    std::mutex _mtx;
 
    int _socket;
 
    std::string _localAddress;
    std::string _remoteAddress;
 
    bool _delay_connect;
    bool _set_reuseaddr;
 
};
 
#endif // SOCKETDEVICE_H