Buffer.hpp

Go to the documentation of this file.

#pragma once
#include <etk/types.hpp>
#include <enet/WebSocket.hpp>
#include <zeus/ParamType.hpp>

namespace zeus {
    class WebServer;
    // define basic async call element ...
    using ActionAsyncClient = std::function<bool(WebServer* _interface, const uint32_t& _serviceId, uint64_t _transactionId, uint64_t _part)>;
}



namespace zeus {
    class BufferData;
    //U32 message lenght
    #pragma pack(push,1)
    /*
    struct headerBin {
        //uint16_t versionProtocol; // protocol Version (might be 1)
        uint32_t transactionID;
        uint32_t clientID; // same as sevice ID
        int16_t partID; // if < 0 the partId ifs the last (start at 0 if multiple or 0x8000 if single message)
        uint16_t typeMessage; //TypeMessgae (1:call, 2:Answer, 4:event)
        uint16_t numberOfParameter;
    };
    */
    struct headerBin {
        //uint16_t versionProtocol; // protocol Version (might be 1)
        uint32_t transactionID;
        uint32_t clientID; // same as sevice ID
        uint8_t flags; // List of flags & type message:
                       //    - 0-2: Type of the message
                       //    - 3-5: Reserved
                       //    - 6: message data is zipped
                       //    - 7: message finished
    };
    #pragma pack(pop)
    /*
     // not needed ==> can be deduced with parameter number ... U16 Offset String call Name (start of the buffer) end with \0
     ======================
     == call
     ======================
     U16 param count
     U16[param count] parameters offset (first offset is the "callName" and limit size of the number of parameter
     CALL Name (funtion name)
     [param 1]
     [param 2]
     [param 3]
     [param 4]
     ======================
     == Answer
     ======================
     U16 param count = 3
     U16[param count]
     [param 1] (return value)
     [param 2] (error value)
     [param 3] (error help)
     [error] (constituated with 2 strings (error type and comment)
     ======================
     == event
     ======================
     U16[param count] parameters offset (first offset is the "callName" and limit size of the number of parameter
     event Name
     [param 1]
     [param 2]
     [param 3]
     [param 4]
    ---------------------------
    parameter and return value is contituated like : 
    TYPE,DATAs....(in raw)
    Type is write in ascii in the list end with '\0':
        - void
        - bool
        - float
        - double
        - int64
        - int32
        - int16
        - int8
        - uint64
        - uint32
        - uint16
        - uint8
        - string
        - vector:bool
        - vector:float
        - vector:double
        - vector:int64
        - vector:int32
        - vector:int16
        - vector:int8
        - vector:uint64
        - vector:uint32
        - vector:uint16
        - vector:uint8
        - vector:string
        - obj:file
    */
    #define ZEUS_BUFFER_FLAG_FINISH (0x80)
    #define ZEUS_BUFFER_FLAG_TYPE_MESSAGE (0x07)

    class Buffer {
        friend std::ostream& operator<<(std::ostream&, zeus::Buffer*);
        protected:
            Buffer();
        public:
            virtual ~Buffer() = default;
            static ememory::SharedPtr<zeus::Buffer> create();
            static ememory::SharedPtr<zeus::Buffer> create(const std::vector<uint8_t>& _buffer);
        protected:
            headerBin m_header; 
            std::vector<zeus::ActionAsyncClient> m_multipleSend; 
        public:
            bool haveAsync() const {
                return m_multipleSend.size() != 0;
            }
            std::vector<zeus::ActionAsyncClient> moveAsync() {
                return std::move(m_multipleSend);
            }
            void appendBuffer(ememory::SharedPtr<zeus::Buffer> _obj);
            virtual void appendBufferData(ememory::SharedPtr<zeus::BufferData> _obj);
        protected:
            virtual void composeWith(const uint8_t* _buffer, uint32_t _lenght);
        public:
            void clear();
            uint32_t getTransactionId() const;
            void setTransactionId(uint32_t _value);
            uint32_t getClientId() const;// this is the same as serviceId
            void setClientId(uint32_t _value);
            uint32_t getServiceId() const {
                return getClientId();
            }
            void setServiceId(uint32_t _value) {
                setClientId(_value);
            }
            bool getPartFinish() const;
            void setPartFinish(bool _value);
            enum class typeMessage {
                unknow = 0x0000, 
                call = 0x0001, 
                answer = 0x0002, 
                data = 0x0003, 
                event = 0x0004, 
            };
            virtual enum typeMessage getType() const;
        public:
            virtual bool writeOn(enet::WebSocket& _interface);
            virtual void generateDisplay(std::ostream& _os) const ;
    };
    std::ostream& operator <<(std::ostream& _os, enum zeus::Buffer::typeMessage _value);
    std::ostream& operator <<(std::ostream& _os, ememory::SharedPtr<zeus::Buffer> _obj);
    
    // internal:
    void addType(std::vector<uint8_t>& _data, zeus::ParamType _type);
    void addTypeObject(std::vector<uint8_t>& _data, const std::string _type);
    void addTypeRaw(std::vector<uint8_t>& _data);
}