WebServer.hpp

Go to the documentation of this file.

#pragma once
#include <zeus/Buffer.hpp>
#include <zeus/BufferAnswer.hpp>
#include <enet/WebSocket.hpp>
#include <thread>
#include <ememory/memory.hpp>
#include <zeus/AbstractFunction.hpp>
#include <zeus/FutureBase.hpp>

namespace zeus {
    ememory::SharedPtr<zeus::BufferCall> createBaseCall(uint64_t _transactionId, const std::string& _functionName, const uint32_t& _serviceId=0);
    void createParam(int32_t _paramId,
                     ememory::SharedPtr<zeus::BufferCall> _obj);
    
    template<class ZEUS_TYPE, class... _ARGS>
    void createParam(int32_t _paramId,
                     ememory::SharedPtr<zeus::BufferCall> _obj,
                     const ZEUS_TYPE& _param,
                     _ARGS&&... _args) {
        _obj->addParameter<ZEUS_TYPE>(_param);
        _paramId++;
        createParam(_paramId, _obj, std::forward<_ARGS>(_args)...);
    }
    // convert const char in std::string ...
    template<class... _ARGS>
    void createParam(int32_t _paramId,
                     ememory::SharedPtr<zeus::BufferCall> _obj,
                     const char* _param,
                     _ARGS&&... _args) {
        createParam(_paramId, _obj, std::string(_param), std::forward<_ARGS>(_args)...);
    }
    
    template<class... _ARGS>
    ememory::SharedPtr<zeus::BufferCall> createCall(uint64_t _transactionId, const std::string& _functionName, _ARGS&&... _args) {
        ememory::SharedPtr<zeus::BufferCall> callElem = createBaseCall(_transactionId, _functionName);
        if (callElem == nullptr) {
            return nullptr;
        }
        createParam(0, callElem, std::forward<_ARGS>(_args)...);
        return callElem;
    }
    template<class... _ARGS>
    ememory::SharedPtr<zeus::BufferCall> createCallService(uint64_t _transactionId, const uint32_t& _serviceName, const std::string& _functionName, _ARGS&&... _args) {
        ememory::SharedPtr<zeus::BufferCall> callElem = createBaseCall(_transactionId, _functionName, _serviceName);
        if (callElem == nullptr) {
            return nullptr;
        }
        createParam(0, callElem, std::forward<_ARGS>(_args)...);
        return callElem;
    }
    
    class WebServer {
        private:
            enet::WebSocket m_connection;
            uint16_t m_transmissionId;
            uint16_t getId() {
                return m_transmissionId++;
            }
            std::mutex m_pendingCallMutex;
            std::vector<std::pair<uint64_t, zeus::FutureBase>> m_pendingCall;
        public:
            using Observer = std::function<void(ememory::SharedPtr<zeus::Buffer>)>; 
            Observer m_observerElement;
            template<class CLASS_TYPE>
            void connect(CLASS_TYPE* _class, void (CLASS_TYPE::*_func)(ememory::SharedPtr<zeus::Buffer>)) {
                m_observerElement = [=](ememory::SharedPtr<zeus::Buffer> _value){
                    (*_class.*_func)(_value);
                };
            }
        public:
            WebServer();
            WebServer(enet::Tcp _connection, bool _isServer);
            virtual ~WebServer();
            void setInterface(enet::Tcp _connection, bool _isServer);
            void connect(bool _async = false);
            void disconnect(bool _inThreadStop = false);
            bool isActive() const;
            void setInterfaceName(const std::string& _name);
            int32_t writeBinary(ememory::SharedPtr<zeus::Buffer> _data);
            void ping();
            bool onReceiveUri(const std::string& _uri, const std::vector<std::string>& _protocols);
            void onReceiveData(std::vector<uint8_t>& _frame, bool _isBinary);
            void newBuffer(ememory::SharedPtr<zeus::Buffer> _buffer);
        public:
            const std::chrono::steady_clock::time_point& getLastTimeReceive() {
                return m_connection.getLastTimeReceive();
            }
            const std::chrono::steady_clock::time_point& getLastTimeSend() {
                return m_connection.getLastTimeSend();
            }
        private:
            using ActionAsync = std::function<bool(WebServer* _interface)>;
            std::mutex m_threadAsyncMutex;
            std::thread* m_threadAsync;
            bool m_threadAsyncRunning;
            std::vector<ActionAsync> m_threadAsyncList;
            std::vector<ActionAsync> m_threadAsyncList2;
        private:
            void threadAsyncCallback();
        public:
            void addAsync(ActionAsync _elem);
        private:
            zeus::FutureBase callBinary(uint64_t _transactionId,
                                        ememory::SharedPtr<zeus::Buffer> _obj,
                                        zeus::FutureData::ObserverFinish _callback=nullptr,
                                        const uint32_t& _service=0);
        public: // section call direct
            template<class... _ARGS>
            zeus::FutureBase call(const std::string& _functionName, _ARGS&&... _args) {
                uint16_t id = getId();
                ememory::SharedPtr<zeus::BufferCall> callElem = zeus::createCall(id, _functionName, std::forward<_ARGS>(_args)...);
                return callBinary(id, callElem);
            }
            template<class... _ARGS>
            zeus::FutureBase callAction(const std::string& _functionName, _ARGS&&... _args, zeus::FutureData::ObserverFinish _callback) {
                uint16_t id = getId();
                ememory::SharedPtr<zeus::BufferCall> callElem = zeus::createCall(id, _functionName, std::forward<_ARGS>(_args)...);
                return callBinary(id, callElem, _callback);
            }
        public: // section call with service ID / Client ID
            
            template<class... _ARGS>
            zeus::FutureBase callService(uint32_t _serviceId, const std::string& _functionName, _ARGS&&... _args) {
                uint16_t id = getId();
                ememory::SharedPtr<zeus::BufferCall> callElem = zeus::createCallService(id, _serviceId, _functionName, std::forward<_ARGS>(_args)...);
                return callBinary(id, callElem);
            }
            template<class... _ARGS>
            zeus::FutureBase callServiceAction(uint32_t _serviceId, const std::string& _functionName, _ARGS&&... _args, zeus::FutureData::ObserverFinish _callback) {
                uint16_t id = getId();
                ememory::SharedPtr<zeus::BufferCall> callElem = zeus::createCallService(id, _serviceId, _functionName, std::forward<_ARGS>(_args)...);
                return callBinary(id, callElem, _callback);
            }
            template<class... _ARGS>
            zeus::FutureBase callClient(uint32_t _clientId,
                                        const std::string& _functionName,
                                        _ARGS&&... _args) {
                return callService(_clientId, _functionName, _args...);
            }
            template<class... _ARGS>
            zeus::FutureBase callClientAction(uint32_t _clientId,
                                              const std::string& _functionName,
                                              _ARGS&&... _args,
                                              zeus::FutureData::ObserverFinish _callback) {
                return callServiceAction(_clientId, _functionName, _args..., _callback);
            }
            zeus::FutureBase callForward(uint32_t _clientId,
                                         ememory::SharedPtr<zeus::Buffer> _Buffer,
                                         uint64_t _singleReferenceId,
                                         zeus::FutureData::ObserverFinish _callback);
            void callForwardMultiple(uint32_t _clientId,
                                     ememory::SharedPtr<zeus::Buffer> _Buffer,
                                     uint64_t _singleReferenceId);
        public: // answers ...
            void answerProtocolError(uint32_t _transactionId, const std::string& _errorHelp);
            template<class ZEUS_ARG>
            void answerValue(uint64_t _clientTransactionId, ZEUS_ARG _value, uint32_t _clientId=0) {
                ememory::SharedPtr<zeus::BufferAnswer> answer = zeus::BufferAnswer::create();
                answer->setTransactionId(_clientTransactionId);
                answer->setClientId(_clientId);
                answer->addAnswer(_value);
                writeBinary(answer);
            }
            void answerVoid(uint64_t _clientTransactionId, uint32_t _clientId=0);
            void answerError(uint64_t _clientTransactionId, const std::string& _errorValue, const std::string& _errorComment="", uint32_t _clientId=0);
    };
}