Tcp.hpp

Go to the documentation of this file.

#pragma once

#include <etk/types.hpp>
#include <mutex>
#ifdef __TARGET_OS__Windows
    #include <winsock2.h>
    #include <ws2tcpip.h>
#endif

namespace enet {
    class Tcp {
        private:
            #ifdef __TARGET_OS__Windows
                SOCKET m_socketId; 
            #else
                int32_t m_socketId; 
            #endif
            std::mutex m_mutex;
        public:
            Tcp();
            #ifdef __TARGET_OS__Windows
                Tcp(SOCKET _idSocket, const std::string& _name);
            #else
                Tcp(int32_t _idSocket, const std::string& _name);
            #endif
            // move constructor
            Tcp(Tcp&& _obj);
            // Move operator;
            Tcp& operator= (Tcp&& _obj);
            // Remove copy operator ... ==> not valid ...
            Tcp& operator= (Tcp& _obj) = delete;
            virtual ~Tcp();
        private:
            std::string m_name; 
        public:
            const std::string& getName() {
                return m_name;
            }
        public:
            enum class status {
                unlink,
                link,
                linkRemoteClose,
                error
            };
        private:
            enum status m_status; 
        public:
            enum status getConnectionStatus() const {
                return m_status;
            }
        public:
            bool unlink();
            int32_t read(void* _data, int32_t _maxLen);
            int32_t write(const void* _data, int32_t _len);
            int32_t write(const std::string& _data, bool _writeBackSlashZero = true) {
                if (_data.size() == 0) {
                    return 0;
                }
                if (_writeBackSlashZero == true) {
                    return write(_data.c_str(), _data.size()+1);
                }
                return write(_data.c_str(), _data.size());
            }
            template <class T>
            int32_t write(const std::vector<T>& _data) {
                if (_data.size() == 0) {
                    return 0;
                }
                size_t ret = write(&_data[0], _data.size()*sizeof(T));
                if (ret <=0) {
                    return ret;
                }
                return ret/sizeof(T);
            }
            
            bool setTCPNoDelay(bool _enabled);
    };
}