tcp_socket.h

Go to the documentation of this file.

#ifndef TCPSOCKET_H
#define TCPSOCKET_H
 
namespace argos {
   class CTCPSocket;
}
 
#include <argos3/core/utility/datatypes/byte_array.h>
#include <argos3/core/utility/datatypes/datatypes.h>
 
#include <unordered_set>
 
namespace argos {
 
   class CTCPSocket {
 
   public:
 
      enum class EEvent : UInt32 {
         InputReady,
         OutputReady,
         HangUp,
         ErrorCondition,
         InvalidRequest
      };
 
   public:
 
      CTCPSocket(int n_stream = -1);
 
      CTCPSocket(const CTCPSocket& c_other) = delete;
 
      CTCPSocket(CTCPSocket&& c_other);
 
      ~CTCPSocket();
 
      CTCPSocket& operator=(const CTCPSocket& c_other) = delete;
 
      CTCPSocket& operator=(CTCPSocket&& c_other);
 
      inline bool operator==(const CTCPSocket& c_other) const {
         return m_nStream == c_other.m_nStream;
      }
 
      inline bool IsConnected() const {
         return m_nStream != -1;
      }
 
      inline int GetStream() const {
         return m_nStream;
      }
 
      inline const std::string& GetAddress() const {
         return m_strAddress;
      }
 
      void Connect(const std::string& str_hostname,
                   SInt32 n_port);
 
      void Listen(SInt32 n_port,
                  SInt32 n_queue_length = 10);
 
      void Accept(CTCPSocket& c_socket);
 
      void Disconnect();
 
      std::unordered_set<EEvent> GetEvents();
 
      void SendBuffer(const UInt8* pun_buffer,
                      size_t un_size);
 
      bool ReceiveBuffer(UInt8* pun_buffer,
                         size_t un_size);
 
      void SendByteArray(const CByteArray& c_byte_array);
 
      bool ReceiveByteArray(CByteArray& c_byte_array);
 
      void SendMsg(const CByteArray& c_payload, bool b_more = false);
 
      void RecvMsg(CByteArray& c_payload);
 
   private:
 
      int m_nStream;
      std::string m_strAddress;
 
   };
 
}
 
namespace std {
   template<> struct hash<argos::CTCPSocket::EEvent> {
      size_t operator()(const argos::CTCPSocket::EEvent& e_event) const {
         return static_cast<size_t>(e_event);
      }
   };
}
 
#endif