Http.hpp

Go to the documentation of this file.

#pragma once

#include <enet/Tcp.hpp>
#include <vector>
#include <map>
#include <thread>
#include <ethread/tools.hpp>

namespace enet {
    enum class HTTPAnswerCode {
        c000_unknow = 0,
        //1xx: Information
        c100_continue = 100, 
        c101_switchingProtocols, 
        c103_checkpoint, 
        //2xx: Successful
        c200_ok = 200, 
        c201_created, 
        c202_accepted, 
        c203_nonAuthoritativeInformation, 
        c204_noContent, 
        c205_resetContent, 
        c206_partialContent, 
        //3xx: Redirection
        c300_multipleChoices = 300, 
        c301_movedPermanently, 
        c302_found, 
        c303_seeOther, 
        c304_notModified, 
        c306_switchProxy, 
        c307_temporaryRedirect, 
        c308_resumeIncomplete, 
        //4xx: Client Error,
        c400_badRequest = 400, 
        c401_unauthorized, 
        c402_paymentRequired, 
        c403_forbidden, 
        c404_notFound, 
        c405_methodNotAllowed, 
        c406_notAcceptable, 
        c407_proxyAuthenticationRequired, 
        c408_requestTimeout, 
        c409_conflict, 
        c410_gone, 
        c411_lengthRequired, 
        c412_preconditionFailed, 
        c413_requestEntityTooLarge, 
        c414_requestURITooLong, 
        c415_unsupportedMediaType, 
        c416_requestedRangeNotSatisfiable, 
        c417_expectationFailed, 
        //5xx: Server Error
        c500_internalServerError = 500, 
        c501_notImplemented, 
        c502_badGateway, 
        c503_serviceUnavailable, 
        c504_gatewayTimeout, 
        c505_httpVersionNotSupported, 
        c511_networkAuthenticationRequired, 
    };
    std::ostream& operator <<(std::ostream& _os, enum enet::HTTPAnswerCode _obj);
    
    enum class HTTPProtocol {
        http_0_1,
        http_0_2,
        http_0_3,
        http_0_4,
        http_0_5,
        http_0_6,
        http_0_7,
        http_0_8,
        http_0_9,
        http_0_10,
        http_1_0,
        http_1_1,
        http_1_2,
        http_1_3,
        http_1_4,
        http_1_5,
        http_1_6,
        http_1_7,
        http_1_8,
        http_1_9,
        http_1_10,
        http_2_0,
        http_2_1,
        http_2_2,
        http_2_3,
        http_2_4,
        http_2_5,
        http_2_6,
        http_2_7,
        http_2_8,
        http_2_9,
        http_2_10,
        http_3_0,
        http_3_1,
        http_3_2,
        http_3_3,
        http_3_4,
        http_3_5,
        http_3_6,
        http_3_7,
        http_3_8,
        http_3_9,
        http_3_10,
    };
    std::ostream& operator <<(std::ostream& _os, enum enet::HTTPProtocol _obj);
    class HttpHeader {
        protected:
            // key, val
            std::map<std::string, std::string> m_map;
            enum HTTPProtocol m_protocol;
        public:
            void setKey(const std::string& _key, const std::string& _value);
            void rmKey(const std::string& _key);
            std::string getKey(const std::string& _key) const;
        protected:
            std::string generateKeys() const;
        public:
            enum HTTPProtocol getProtocol() const {
                return m_protocol;
            }
            void setProtocol(enum HTTPProtocol _protocol) {
                m_protocol = _protocol;
            }
            HttpHeader();
            virtual ~HttpHeader() = default;
            virtual std::string generate() const = 0;
    };
    
    class HttpAnswer : public HttpHeader {
        private:
            enet::HTTPAnswerCode m_what;
            std::string m_helpMessage;
        public:
            HttpAnswer(enum HTTPAnswerCode _code = enet::HTTPAnswerCode::c400_badRequest, const std::string& _help="");
            void display() const;
            std::string generate() const;
            void setErrorCode(enum HTTPAnswerCode _value) {
                m_what = _value;
            }
            enum HTTPAnswerCode getErrorCode() const {
                return m_what;
            }
            void setHelp(const std::string& _value) {
                m_helpMessage = _value;
            }
            const std::string& getHelp() const {
                return m_helpMessage;
            }
    };
    enum class HTTPReqType {
        HTTP_GET,
        HTTP_HEAD,
        HTTP_POST,
        HTTP_PUT,
        HTTP_DELETE,
    };
    std::ostream& operator <<(std::ostream& _os, enum enet::HTTPReqType _obj);
    class HttpRequest : public HttpHeader {
        private:
            // key, val
            enum HTTPReqType m_req;
            std::string m_uri;
        public:
            HttpRequest(enum enet::HTTPReqType _type=enet::HTTPReqType::HTTP_GET);
            void display() const;
            std::string generate() const;
            void setType(enum enet::HTTPReqType _value) {
                m_req = _value;
            }
            enum enet::HTTPReqType getType() const{
                return m_req;
            }
            void setUri(const std::string& _value) {
                m_uri = _value;
            }
            const std::string& getUri() const {
                return m_uri;
            }
    };
    class Http {
        public:
            Http(enet::Tcp _connection, bool _isServer=false);
            virtual ~Http();
        private:
            bool m_isServer;
        public:
            bool getServerState() {
                return m_isServer;
            }
            bool isServer() {
                return m_isServer;
            }
        protected:
            enet::HttpRequest m_requestHeader;
            void setRequestHeader(const enet::HttpRequest& _req);
        public:
            const enet::HttpRequest& getRequestHeader() {
                return m_requestHeader;
            }
        protected:
            enet::HttpAnswer m_answerHeader;
            void setAnswerHeader(const enet::HttpAnswer& _req);
        public:
            const enet::HttpAnswer& getAnswerHeader() {
                return m_answerHeader;
            }
        protected:
            enet::Tcp m_connection;
            bool m_headerIsSend;
            std::thread* m_thread;
            bool m_threadRunning;
            std::vector<uint8_t> m_temporaryBuffer;
        private:
            void threadCallback();
        private:
            void getHeader();
        public:
            void start();
            void stop(bool _inThread=false);
            bool isAlive() const {
                return m_connection.getConnectionStatus() == enet::Tcp::status::link;
            }
        public:
            using Observer = std::function<void(std::vector<uint8_t>&)>; 
            Observer m_observer;
            template<class CLASS_TYPE>
            void connect(CLASS_TYPE* _class, void (CLASS_TYPE::*_func)(std::vector<uint8_t>&)) {
                m_observer = [=](std::vector<uint8_t>& _value){
                    (*_class.*_func)(_value);
                };
            }
            void connect(Observer _func) {
                m_observer = _func;
            }
        public:
            using ObserverRaw = std::function<void(enet::Tcp&)>; 
            ObserverRaw m_observerRaw;
            template<class CLASS_TYPE>
            void connectRaw(CLASS_TYPE* _class, void (CLASS_TYPE::*_func)(enet::Tcp&)) {
                m_observerRaw = [=](enet::Tcp& _connection){
                    (*_class.*_func)(_connection);
                };
            }
            void connectRaw(ObserverRaw _func) {
                m_observerRaw = _func;
            }
        public:
            using ObserverRequest = std::function<void(const enet::HttpRequest&)>; 
        protected:
            ObserverRequest m_observerRequest;
        public:
            using ObserverAnswer = std::function<void(const enet::HttpAnswer&)>; 
        protected:
            ObserverAnswer m_observerAnswer;
        public:
            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);
            }
    };
    
    class HttpClient : public Http {
        public:
            HttpClient(enet::Tcp _connection);
        public:
            void setHeader(const enet::HttpRequest& _header) {
                setRequestHeader(_header);
            }
        public:
            //bool get(const std::string& _address);
            //bool post(const std::string& _address, const std::map<std::string, std::string>& _values);
            //bool post(const std::string& _address, const std::string& _contentType, const std::string& _data);
        public:
            template<class CLASS_TYPE>
            void connectHeader(CLASS_TYPE* _class, void (CLASS_TYPE::*_func)(const enet::HttpAnswer&)) {
                m_observerAnswer = [=](const enet::HttpAnswer& _value){
                    (*_class.*_func)(_value);
                };
            }
            void connectHeader(Http::ObserverAnswer _func) {
                m_observerAnswer = _func;
            }
    };
    
    class HttpServer : public Http {
        public:
            HttpServer(enet::Tcp _connection);
        public:
            void setHeader(const enet::HttpAnswer& _header) {
                setAnswerHeader(_header);
            }
        public:
            template<class CLASS_TYPE>
            void connectHeader(CLASS_TYPE* _class, void (CLASS_TYPE::*_func)(const enet::HttpRequest&)) {
                m_observerRequest = [=](const enet::HttpRequest& _value){
                    (*_class.*_func)(_value);
                };
            }
            void connectHeader(Http::ObserverRequest _func) {
                m_observerRequest = _func;
            }
    };
}