abstractsocket.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_NETWORK
#include <promeki/iodevice.h>
#include <promeki/error.h>
#include <promeki/socketaddress.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class AbstractSocket : public IODevice {
                PROMEKI_OBJECT(AbstractSocket, IODevice)
        public:
                static constexpr unsigned int DefaultReceiveTimeoutMs = 5000;
 
                static constexpr unsigned int DefaultSendTimeoutMs = 5000;
 
                enum SocketType {
                        TcpSocketType, 
                        UdpSocketType, 
                        RawSocketType  
                };
 
                enum SocketState {
                        Unconnected, 
                        Connecting,  
                        Connected,   
                        Bound,       
                        Closing,     
                        Listening    
                };
 
                AbstractSocket(SocketType type, ObjectBase *parent = nullptr);
 
                virtual ~AbstractSocket();
 
                SocketType socketType() const { return _type; }
 
                SocketState state() const { return _state; }
 
                Error bind(const SocketAddress &address);
 
                Error connectToHost(const SocketAddress &address);
 
                void disconnectFromHost();
 
                SocketAddress localAddress() const { return _localAddress; }
 
                SocketAddress peerAddress() const { return _peerAddress; }
 
                Error waitForConnected(unsigned int timeoutMs = 0);
 
                int socketDescriptor() const { return _fd; }
 
                void setSocketDescriptor(int fd);
 
                Error setReceiveTimeout(unsigned int timeoutMs);
 
                Error setSendTimeout(unsigned int timeoutMs);
 
                Error setSocketOption(int level, int option, int value);
 
                Result<int> socketOption(int level, int option) const;
 
                bool isSequential() const override { return true; }
 
                bool waitForReadyRead(unsigned int timeoutMs = 0) override;
 
                PROMEKI_SIGNAL(connected);
 
                PROMEKI_SIGNAL(disconnected);
 
                PROMEKI_SIGNAL(stateChanged, SocketState);
 
                Error setNonBlocking(bool enable);
 
        protected:
                Error createSocket(int domain, int type, int protocol = 0);
 
                void closeSocket();
 
                void updateLocalAddress();
 
                void setState(SocketState state);
 
                int           _fd = -1;             
                SocketState   _state = Unconnected; 
                SocketType    _type;                
                SocketAddress _localAddress;        
                SocketAddress _peerAddress;         
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_NETWORK