diff --git a/lutin_zeus.py b/lutin_zeus.py index 1aada03..d0946a4 100644 --- a/lutin_zeus.py +++ b/lutin_zeus.py @@ -39,6 +39,8 @@ def create(target, module_name): 'zeus/Future.cpp', 'zeus/File.cpp', 'zeus/Buffer.cpp', + 'zeus/Buffer_addParameter.cpp', + 'zeus/Buffer_getParameter.cpp', 'zeus/ParamType.cpp', 'zeus/Client.cpp', 'zeus/GateWay.cpp', diff --git a/test/client/appl/main.cpp b/test/client/appl/main.cpp index bdade3f..3c98a13 100644 --- a/test/client/appl/main.cpp +++ b/test/client/appl/main.cpp @@ -87,7 +87,7 @@ int main(int _argc, const char *_argv[]) { } */ - if (true) { + if (false) { APPL_INFO(" ----------------------------------"); APPL_INFO(" -- Get service system-user"); APPL_INFO(" ----------------------------------"); @@ -140,10 +140,9 @@ int main(int _argc, const char *_argv[]) { APPL_INFO(" ----------------------------------"); APPL_INFO(" -- Get service picture"); APPL_INFO(" ----------------------------------"); - if (false) { + if (true) { zeus::ServiceRemote remoteServicePicture = client1.getService("picture"); if (remoteServicePicture.exist() == true) { - /* zeus::Future> retCall = remoteServicePicture.call("getAlbums").wait(); APPL_INFO(" album list: "); for (auto &it : retCall.get()) { @@ -182,16 +181,15 @@ int main(int _argc, const char *_argv[]) { } } } - */ - #if 0 - std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now(); - zeus::File tmp("./photo_2016_33913.bmp");//"image/jpg", {0,5,2,6,7,5,8,4,5,2,1,5,65,5,2,6,85,4,6,6,54,65,88,64,14,6,4,64,51,3,16,4}); - int32_t size = tmp.getData().size(); - zeus::FutureBase retSendImage = remoteServicePicture.call("addFile", tmp).wait(); - std::chrono::steady_clock::time_point stop = std::chrono::steady_clock::now(); - APPL_WARNING(" IO*=" << int64_t((stop-start).count()/1000)/1000.0 << " ms"); - double megaParSec = double(size)/(double((stop-start).count())/1000000000.0); - APPL_WARNING(" speed=" << int64_t(megaParSec/1024.0)/1024.0 << " Mo/s"); + #if 1 + std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now(); + zeus::File tmp("./testzz.png"); + int32_t size = tmp.getData().size(); + zeus::FutureBase retSendImage = remoteServicePicture.call("addFile", tmp).wait(); + std::chrono::steady_clock::time_point stop = std::chrono::steady_clock::now(); + APPL_WARNING(" IO*=" << int64_t((stop-start).count()/1000)/1000.0 << " ms"); + double megaParSec = double(size)/(double((stop-start).count())/1000000000.0); + APPL_WARNING(" speed=" << int64_t(megaParSec/1024.0)/1024.0 << " Mo/s"); #endif } } diff --git a/tools/picture/appl/main.cpp b/tools/picture/appl/main.cpp index e0952c8..7027d66 100644 --- a/tools/picture/appl/main.cpp +++ b/tools/picture/appl/main.cpp @@ -89,17 +89,21 @@ namespace appl { std::vector out; ejson::Array globalGroups = m_database["group-global"].toArray(); if (globalGroups.exist() == false) { + APPL_DEBUG("'group-global' ==> does not exist ==> No album"); return out; } ejson::Object groups = m_database["groups"].toObject(); if (groups.exist() == false) { + APPL_DEBUG("'group' ==> does not exist ==> No album"); return out; } + APPL_DEBUG("for element in 'group-global'"); for (auto it: globalGroups) { std::string tmpString = it.toString().get(); if (tmpString == "") { continue; } + APPL_DEBUG(" find emlement:" << tmpString); out.push_back(tmpString); } return out; diff --git a/zeus/AbstractFunction.cpp b/zeus/AbstractFunction.cpp index 0532238..1e99c65 100644 --- a/zeus/AbstractFunction.cpp +++ b/zeus/AbstractFunction.cpp @@ -7,21 +7,18 @@ #include #include -zeus::Buffer zeus::createBinaryCall(uint64_t _transactionId, const std::string& _functionName, const zeus::Buffer& _params) { - zeus::Buffer callElem = createBinaryBaseCall(_transactionId, _functionName); - //callElem.add("param", _params); - return callElem; -} - -zeus::Buffer zeus::createBinaryBaseCall(uint64_t _transactionId, const std::string& _functionName, const uint32_t& _serviceId) { - zeus::Buffer obj; - obj.setServiceId(_serviceId); - obj.setCall(_functionName); - obj.setTransactionId(_transactionId); +ememory::SharedPtr zeus::createBinaryBaseCall(uint64_t _transactionId, const std::string& _functionName, const uint32_t& _serviceId) { + ememory::SharedPtr obj = zeus::Buffer::create(); + if (obj == nullptr) { + return nullptr; + } + obj->setServiceId(_serviceId); + obj->setCall(_functionName); + obj->setTransactionId(_transactionId); return obj; } -void zeus::createBinaryParam(std::vector& _asyncAction, int32_t _paramId, zeus::Buffer& _obj) { +void zeus::createBinaryParam(int32_t _paramId, const ememory::SharedPtr& _obj) { // Finish recursive parse ... } diff --git a/zeus/AbstractFunction.h b/zeus/AbstractFunction.h index 53e67b7..6d8cbfe 100644 --- a/zeus/AbstractFunction.h +++ b/zeus/AbstractFunction.h @@ -11,14 +11,6 @@ #include #include -namespace zeus { - class TcpString; - // define basic async call element ... - using ActionAsyncClient = std::function; -} - - - namespace zeus { class AbstractFunction { @@ -64,48 +56,53 @@ namespace zeus { virtual std::string getPrototype() const = 0; virtual std::string getPrototypeReturn() const = 0; virtual std::vector getPrototypeParam() const = 0; - virtual void execute(const ememory::SharedPtr& _interfaceClient, uint64_t _transactionId, uint64_t _clientId, zeus::Buffer& _params, void* _class=nullptr) = 0; + virtual void execute(const ememory::SharedPtr& _interfaceClient, + uint64_t _transactionId, + uint64_t _clientId, + const ememory::SharedPtr& _params, + void* _class=nullptr) = 0; }; - zeus::Buffer createBinaryBaseCall(uint64_t _transactionId, const std::string& _functionName, const uint32_t& _serviceId=0); - void createBinaryParam(std::vector& _asyncAction, - int32_t _paramId, - zeus::Buffer& _obj); + ememory::SharedPtr createBinaryBaseCall(uint64_t _transactionId, const std::string& _functionName, const uint32_t& _serviceId=0); + void createBinaryParam(int32_t _paramId, + const ememory::SharedPtr& _obj); template - void createBinaryParam(std::vector& _asyncAction, - int32_t _paramId, - zeus::Buffer& _obj, + void createBinaryParam(int32_t _paramId, + const ememory::SharedPtr& _obj, const ZEUS_TYPE& _param, _ARGS&&... _args) { - _obj.addParameter(/*_asyncAction, _paramId,*/ _param); + _obj->addParameter(_param); _paramId++; - createBinaryParam(_asyncAction, _paramId, _obj, std::forward<_ARGS>(_args)...); + createBinaryParam(_paramId, _obj, std::forward<_ARGS>(_args)...); } // convert const char in std::string ... template - void createBinaryParam(std::vector& _asyncAction, - int32_t _paramId, - zeus::Buffer& _obj, + void createBinaryParam(int32_t _paramId, + const ememory::SharedPtr& _obj, const char* _param, _ARGS&&... _args) { - createBinaryParam(_asyncAction, _paramId, _obj, std::string(_param), std::forward<_ARGS>(_args)...); + createBinaryParam(_paramId, _obj, std::string(_param), std::forward<_ARGS>(_args)...); } template - zeus::Buffer createBinaryCall(std::vector& _asyncAction, uint64_t _transactionId, const std::string& _functionName, _ARGS&&... _args) { - zeus::Buffer callElem = createBinaryBaseCall(_transactionId, _functionName); - createBinaryParam(_asyncAction, 0, callElem, std::forward<_ARGS>(_args)...); + ememory::SharedPtr createBinaryCall(uint64_t _transactionId, const std::string& _functionName, _ARGS&&... _args) { + ememory::SharedPtr callElem = createBinaryBaseCall(_transactionId, _functionName); + if (callElem == nullptr) { + return nullptr; + } + createBinaryParam(0, callElem, std::forward<_ARGS>(_args)...); return callElem; } template - zeus::Buffer createBinaryCallService(std::vector& _asyncAction, uint64_t _transactionId, const uint32_t& _serviceName, const std::string& _functionName, _ARGS&&... _args) { - zeus::Buffer callElem = createBinaryBaseCall(_transactionId, _functionName, _serviceName); - createBinaryParam(_asyncAction, 0, callElem, std::forward<_ARGS>(_args)...); + ememory::SharedPtr createBinaryCallService(uint64_t _transactionId, const uint32_t& _serviceName, const std::string& _functionName, _ARGS&&... _args) { + ememory::SharedPtr callElem = createBinaryBaseCall(_transactionId, _functionName, _serviceName); + if (callElem == nullptr) { + return nullptr; + } + createBinaryParam(0, callElem, std::forward<_ARGS>(_args)...); return callElem; } - zeus::Buffer createBinaryCall(uint64_t _transactionId, const std::string& _functionName, const zeus::Buffer& _params); - } #include diff --git a/zeus/AbstractFunctionTypeClass.h b/zeus/AbstractFunctionTypeClass.h index d8a93c4..2865a16 100644 --- a/zeus/AbstractFunctionTypeClass.h +++ b/zeus/AbstractFunctionTypeClass.h @@ -10,7 +10,6 @@ #include #include #include -#include namespace zeus { @@ -20,129 +19,46 @@ namespace zeus { uint64_t _clientId, ZEUS_CLASS_TYPE* _pointer, ZEUS_RETURN (ZEUS_CLASS_TYPE::*_func)(ZEUS_TYPES...), - zeus::Buffer& _obj) { - std::vector asyncAction; + const ememory::SharedPtr& _obj) { + if (_obj == nullptr) { + return; + } #if defined(__clang__) // clang generate a basic warning: // warning: multiple unsequenced modifications to 'idParam' [-Wunsequenced] int32_t idParam = 0; - ZEUS_RETURN ret = (*_pointer.*_func)(_obj.getParameter(idParam++)...); + ZEUS_RETURN ret = (*_pointer.*_func)(_obj->getParameter(idParam++)...); #elif defined(__GNUC__) || defined(__GNUG__) || defined(_MSC_VER) int32_t idParam = int32_t(sizeof...(ZEUS_TYPES))-1; - ZEUS_RETURN ret = (*_pointer.*_func)(_obj.getParameter(idParam--)...); + ZEUS_RETURN ret = (*_pointer.*_func)(_obj->getParameter(idParam--)...); #else #error Must be implemented ... ZEUS_RETURN ret; return; #endif - if (asyncAction.size() != 0) { - ZEUS_ERROR("Missing send async messages"); - } _interfaceClient->addAsync([=](TcpString* _interface) { _interface->answerValue(_transactionId, ret, _clientId); return true; }); } - class SendFile { - private: - zeus::FileServer m_data; - uint64_t m_transactionId; - uint64_t m_clientId; - uint32_t m_partId; - etk::FSNode m_node; - uint64_t m_size; - public: - SendFile(zeus::FileServer _data, - uint64_t _transactionId, - uint64_t _clientId) : - m_data(_data), - m_transactionId(_transactionId), - m_clientId(_clientId), - m_partId(0), - m_node(_data.getFileName()), - m_size(0) { - - } - ~SendFile() { - //m_node.fileClose(); - } - bool operator() (TcpString* _interface) { - zeus::Buffer answer; - answer.setTransactionId(m_transactionId); - answer.setClientId(m_clientId); - answer.setPartId(m_partId); - answer.setPartFinish(false); - if (m_partId == 0) { - answer.setType(zeus::Buffer::typeMessage::answer); - m_node.fileOpenRead(); - std::string extention = std::string(m_data.getFileName().begin()+m_data.getFileName().size() -3, m_data.getFileName().end()); - ZEUS_WARNING("send file: '" << m_data.getFileName() << "' with extention: '" << extention << "'"); - m_size = m_node.fileSize(); - zeus::File tmpFile(zeus::getMineType(extention), std::vector(), m_size); - answer.addAnswer(tmpFile); - _interface->writeBinary(answer); - m_partId++; - return false; - } - answer.setType(zeus::Buffer::typeMessage::data); - int32_t tmpSize = 1024; - if (m_size < 1024) { - tmpSize = m_size; - } - uint8_t tmpData[1024]; - m_node.fileRead(tmpData, 1, tmpSize); - answer.addData(tmpData, tmpSize); - m_size -= tmpSize; - if (m_size <= 0) { - answer.setPartFinish(true); - m_node.fileClose(); - } - _interface->writeBinary(answer);; - m_partId++; - if (m_size <= 0) { - return true; - } - return false; - } - }; - template - void executeClassCall(const ememory::SharedPtr& _interfaceClient, - uint64_t _transactionId, - uint64_t _clientId, - ZEUS_CLASS_TYPE* _pointer, - zeus::FileServer (ZEUS_CLASS_TYPE::*_func)(ZEUS_TYPES...), - zeus::Buffer& _obj) { - #if defined(__clang__) - // clang generate a basic warning: - // warning: multiple unsequenced modifications to 'idParam' [-Wunsequenced] - int32_t idParam = 0; - zeus::FileServer tmpElem = (*_pointer.*_func)(_obj.getParameter(idParam++)...); - #elif defined(__GNUC__) || defined(__GNUG__) || defined(_MSC_VER) - int32_t idParam = int32_t(sizeof...(ZEUS_TYPES))-1; - zeus::FileServer tmpElem = (*_pointer.*_func)(_obj.getParameter(idParam--)...); - #else - #error Must be implemented ... - zeus::FileServer tmpElem; - return; - #endif - _interfaceClient->addAsync(SendFile(tmpElem, _transactionId, _clientId)); - } - template void executeClassCall(const ememory::SharedPtr& _interfaceClient, uint64_t _transactionId, uint64_t _clientId, ZEUS_CLASS_TYPE* _pointer, void (ZEUS_CLASS_TYPE::*_func)(ZEUS_TYPES...), - zeus::Buffer& _obj) { + const ememory::SharedPtr& _obj) { + if (_obj == nullptr) { + return; + } #if defined(__clang__) // clang generate a basic warning: // warning: multiple unsequenced modifications to 'idParam' [-Wunsequenced] int32_t idParam = 0; - (*_pointer.*_func)(_obj.getParameter(idParam++)...); + (*_pointer.*_func)(_obj->getParameter(idParam++)...); #elif defined(__GNUC__) || defined(__GNUG__) || defined(_MSC_VER) int32_t idParam = int32_t(sizeof...(ZEUS_TYPES))-1; - (*_pointer.*_func)(_obj.getParameter(idParam--)...); + (*_pointer.*_func)(_obj->getParameter(idParam--)...); #else #error Must be implemented ... return; @@ -193,18 +109,21 @@ namespace zeus { void execute(const ememory::SharedPtr& _interfaceClient, uint64_t _transactionId, uint64_t _clientId, - zeus::Buffer& _obj, + const ememory::SharedPtr& _obj, void* _class) override { + if (_obj == nullptr) { + return; + } ZEUS_CLASS_TYPE* tmpClass = nullptr; if (_class != nullptr) { tmpClass = (ZEUS_CLASS_TYPE*)_class; } // check parameter number - if (_obj.getNumberParameter() != sizeof...(ZEUS_TYPES)) { + if (_obj->getNumberParameter() != sizeof...(ZEUS_TYPES)) { ZEUS_ERROR("Wrong number of Parameters ..."); std::string help = "request "; - help += etk::to_string(_obj.getNumberParameter()); + help += etk::to_string(_obj->getNumberParameter()); help += " parameters and need "; help += etk::to_string(sizeof...(ZEUS_TYPES)); help += " parameters. prototype function:"; @@ -217,7 +136,7 @@ namespace zeus { } // check parameter compatibility for (size_t iii=0; iiigetParameterType(iii)) == false) { _interfaceClient->answerError(_transactionId, "WRONG-PARAMETER-TYPE", std::string("Parameter id ") + etk::to_string(iii) + " not compatible with type: '" + m_paramType[iii].getName() + "'", diff --git a/zeus/AbstractFunctionTypeDirect.h b/zeus/AbstractFunctionTypeDirect.h index 21e7184..5d94fff 100644 --- a/zeus/AbstractFunctionTypeDirect.h +++ b/zeus/AbstractFunctionTypeDirect.h @@ -15,15 +15,18 @@ namespace zeus { uint64_t _transactionId, uint64_t _clientId, ZEUS_RETURN (*_func)(ZEUS_TYPES...), - zeus::Buffer& _obj) { + const ememory::SharedPtr& _obj) { + if (_obj == nullptr) { + return; + } #if defined(__clang__) // clang generate a basic warning: // warning: multiple unsequenced modifications to 'idParam' [-Wunsequenced] int32_t idParam = 0; - ZEUS_RETURN ret = _func(_obj.getParameter(idParam++)...); + ZEUS_RETURN ret = _func(_obj->getParameter(idParam++)...); #elif defined(__GNUC__) || defined(__GNUG__) || defined(_MSC_VER) int32_t idParam = int32_t(sizeof...(ZEUS_TYPES))-1; - ZEUS_RETURN ret = _func(_obj.getParameter(idParam--)...); + ZEUS_RETURN ret = _func(_obj->getParameter(idParam--)...); #else #error Must be implemented ... #endif @@ -38,15 +41,18 @@ namespace zeus { uint64_t _transactionId, uint64_t _clientId, void (*_func)(ZEUS_TYPES...), - zeus::Buffer& _obj) { + const ememory::SharedPtr& _obj) { + if (_obj == nullptr) { + return; + } #if defined(__clang__) // clang generate a basic warning: // warning: multiple unsequenced modifications to 'idParam' [-Wunsequenced] int32_t idParam = 0; - _func(_obj.getParameter(idParam++)...); + _func(_obj->getParameter(idParam++)...); #elif defined(__GNUC__) || defined(__GNUG__) || defined(_MSC_VER) int32_t idParam = int32_t(sizeof...(ZEUS_TYPES))-1; - _func(_obj.getParameter(idParam--)...); + _func(_obj->getParameter(idParam--)...); #else #error Must be implemented ... #endif @@ -96,12 +102,15 @@ namespace zeus { void execute(const ememory::SharedPtr& _interfaceClient, uint64_t _transactionId, uint64_t _clientId, - zeus::Buffer& _obj, + const ememory::SharedPtr& _obj, void* _class) override { + if (_obj == nullptr) { + return; + } // check parameter number - if (_obj.getNumberParameter() != sizeof...(ZEUS_TYPES)) { + if (_obj->getNumberParameter() != sizeof...(ZEUS_TYPES)) { std::string help = "request "; - help += etk::to_string(_obj.getNumberParameter()); + help += etk::to_string(_obj->getNumberParameter()); help += " parameters and need "; help += etk::to_string(sizeof...(ZEUS_TYPES)); help += " parameters. prototype function:"; @@ -114,7 +123,7 @@ namespace zeus { } // check parameter compatibility for (size_t iii=0; iiigetParameterType(iii)) == false) { _interfaceClient->answerError(_transactionId, "WRONG-PARAMETER-TYPE", std::string("Parameter id ") + etk::to_string(iii) + " not compatible with type: '" + m_paramType[iii].getName() + "'", diff --git a/zeus/Buffer.cpp b/zeus/Buffer.cpp index 1a95a3b..b40ed50 100644 --- a/zeus/Buffer.cpp +++ b/zeus/Buffer.cpp @@ -14,6 +14,8 @@ namespace etk { template<> std::string to_string(const enum zeus::Buffer::typeMessage& _value) { switch (_value) { + case zeus::Buffer::typeMessage::unknow: + return "unknow"; case zeus::Buffer::typeMessage::call: return "call"; case zeus::Buffer::typeMessage::answer: @@ -21,7 +23,7 @@ namespace etk { case zeus::Buffer::typeMessage::event: return "event"; case zeus::Buffer::typeMessage::data: - return "event"; + return "data"; } return "???"; } @@ -33,6 +35,8 @@ std::ostream& zeus::operator <<(std::ostream& _os, enum zeus::Buffer::typeMessag static enum zeus::Buffer::typeMessage getTypeType(uint16_t _value) { switch (_value) { + case 0: + return zeus::Buffer::typeMessage::unknow; case 1: return zeus::Buffer::typeMessage::call; case 2: @@ -42,13 +46,58 @@ static enum zeus::Buffer::typeMessage getTypeType(uint16_t _value) { case 4: return zeus::Buffer::typeMessage::event; } - return zeus::Buffer::typeMessage::call; + return zeus::Buffer::typeMessage::unknow; } zeus::Buffer::Buffer() { clear(); } +ememory::SharedPtr zeus::Buffer::create() { + return ememory::SharedPtr(new zeus::Buffer); +} + +void zeus::Buffer::appendBufferData(const ememory::SharedPtr& _obj) { + if (_obj == nullptr) { + return; + } + if (_obj->getType() != zeus::Buffer::typeMessage::data) { + ZEUS_ERROR("try to add data with a wrong buffer: " << _obj->getType()); + return; + } + if (_obj->m_parameter.size() <= 1) { + // normal end frame with no data ==> no problem ... + return; + } + // At this point we just add data at the parameter value: + //It contain 2 things : + // - param 0 : parameter ID (int16_t) + // - param 1 : Raw data (local direct acces ...) + uint16_t parameterID = _obj->internalGetParameter(0); + + zeus::ParamType type = _obj->internalGetParameterType(1); + const uint8_t* pointer = _obj->internalGetParameterPointer(1); + uint32_t dataSize = _obj->internalGetParameterSize(1); + if ( type.getId() != zeus::paramTypeRaw + || pointer == nullptr) { + ZEUS_ERROR("Can not get parameter Raw ==> stop add"); + return; + } + if (dataSize == 0) { + // no data (normal case) + return; + } + // now, we will add datas: + if (parameterID >= m_parameter.size()) { + ZEUS_ERROR("Try to add data on an unexisting parameter..."); + return; + } + int32_t offset = m_parameter[parameterID].second.size(); + m_parameter[parameterID].second.resize(offset + dataSize); + memcpy(&m_parameter[parameterID].second[offset], pointer, dataSize); +} + + void zeus::Buffer::internalComposeWith(const uint8_t* _buffer, uint32_t _lenght) { clear(); if (_lenght < sizeof(headerBin)) { @@ -65,9 +114,9 @@ void zeus::Buffer::internalComposeWith(const uint8_t* _buffer, uint32_t _lenght) while ( nbParameters < m_header.numberOfParameter && offset < _lenght) { // parameters is contituated with size + data assiciated - uint16_t sizeParam; - memcpy(&sizeParam, &_buffer[offset], sizeof(uint16_t)); - offset += sizeof(uint16_t); + uint32_t sizeParam; + memcpy(&sizeParam, &_buffer[offset], sizeof(uint32_t)); + offset += sizeof(uint32_t); if (offset+sizeParam > _lenght) { ZEUS_ERROR("Wrong parameter size : " << sizeParam << " / availlable=" << _lenght-offset); return; @@ -85,7 +134,7 @@ bool zeus::Buffer::writeOn(enet::WebSocket& _interface) { m_header.numberOfParameter = m_parameter.size(); uint64_t size = sizeof(headerBin); for (auto &it : m_parameter) { - size += sizeof(uint16_t); // parameter size + size += sizeof(uint32_t); // parameter size size += it.second.size(); } ZEUS_DEBUG("Send BINARY " << size << " bytes '" << generateHumanString() << "'"); @@ -98,8 +147,8 @@ bool zeus::Buffer::writeOn(enet::WebSocket& _interface) { m_header.numberOfParameter = m_parameter.size(); size = _interface.writeData((uint8_t*)&m_header, sizeof(headerBin)); for (auto &it : m_parameter) { - uint16_t paramSize = it.second.size(); - size = _interface.writeData((uint8_t*)¶mSize, sizeof(uint16_t)); + uint32_t paramSize = it.second.size(); + size = _interface.writeData((uint8_t*)¶mSize, sizeof(uint32_t)); size = _interface.writeData(&it.second[0], it.second.size() * sizeof(uint8_t)); } return true; @@ -123,8 +172,8 @@ std::string zeus::Buffer::generateHumanString() { //out += " v=" + etk::to_string(m_header.versionProtocol); // se it in the websocket out += " id=" + etk::to_string(m_header.transactionID); out += " cId=" + etk::to_string(m_header.clientID); - if ( getPartId() != 0 - || getPartFinish() == false) { + if ( getPartFinish() == false + || getPartId() != 0) { out += " part=" + etk::to_string(getPartId()); if (getPartFinish() == true) { out += "/finish"; @@ -132,6 +181,9 @@ std::string zeus::Buffer::generateHumanString() { } enum zeus::Buffer::typeMessage type = getTypeType(m_header.typeMessage); switch (type) { + case zeus::Buffer::typeMessage::unknow: + out += " -UNKNOW-"; + break; case zeus::Buffer::typeMessage::call: out += " nbParam=" + etk::to_string(getNumberParameter()); out += " -CALL-:'" + getCall() + "'"; @@ -161,6 +213,10 @@ std::string zeus::Buffer::generateHumanString() { } if (getNumberParameter() != 0) { out += " paramType("; + if (getNumberParameter() >256) { + out += " !!!!!!!"; + return out; + } for (int32_t iii=0; iii< getNumberParameter(); ++iii) { if (iii != 0) { out += ","; @@ -218,6 +274,9 @@ void zeus::Buffer::setType(enum typeMessage _value) { } uint16_t zeus::Buffer::getNumberParameter() const { + if (m_parameter.size() <= 1) { + return 0; + } return m_parameter.size()-1; } zeus::ParamType zeus::Buffer::internalGetParameterType(int32_t _id) const { @@ -257,6 +316,10 @@ zeus::ParamType zeus::Buffer::internalGetParameterType(int32_t _id) const { if (typeId == createType>().getId()) { m_parameter[_id].first = 2; return createType>(); } if (typeId == createType>().getId()) { m_parameter[_id].first = 2; return createType>(); } if (typeId == createType().getId()) { m_parameter[_id].first = 2; return createType(); } + if (typeId == paramTypeRaw) { + m_parameter[_id].first = sizeof(uint16_t); + return zeus::ParamType("raw", paramTypeRaw); + } if (typeId == paramTypeObject) { std::string type = reinterpret_cast(&m_parameter[_id].second[2]); m_parameter[_id].first = type.size() + sizeof(uint16_t); @@ -299,1744 +362,22 @@ uint32_t zeus::Buffer::internalGetParameterSize(int32_t _id) const { return m_parameter[_id].second.size() - m_parameter[_id].first; } -void zeus::Buffer::addData(void* _data, uint32_t _size) { +void zeus::Buffer::addData(uint16_t _parameterId, void* _data, uint32_t _size) { m_parameter.clear(); - setType(zeus::Buffer::typeMessage::data); - //m_data.resize(_size); - //memcpy(&m_data[0], _data, _size); - ZEUS_TODO("Must implement the add data ..."); + addParameter(_parameterId); + std::vector data; + // set parameter type in case of wrong interpretation + zeus::addTypeRaw(data); + int32_t offset = data.size(); + data.resize(offset + _size); + memcpy(&data[offset], _data, _size); + m_parameter.push_back(std::make_pair(2,data)); } uint32_t zeus::Buffer::getParameterSize(int32_t _id) const { return internalGetParameterSize(_id + 1); } -static void addType(std::vector& _data, zeus::ParamType _type) { - _data.push_back(uint8_t(_type.getId()>>8)); - _data.push_back(uint8_t(_type.getId())); -} - -static void addTypeObject(std::vector& _data, const std::string _type) { - _data.push_back(uint8_t(zeus::paramTypeObject>>8)); - _data.push_back(uint8_t(zeus::paramTypeObject)); - for (auto &it : _type) { - _data.push_back(uint8_t(it)); - } - _data.push_back(0); -} - -void zeus::Buffer::addParameter() { - std::vector data; - addType(data, createType()); - m_parameter.push_back(std::make_pair(2,data)); -} -void zeus::Buffer::addParameterEmptyVector() { - // special case of json change mode - std::vector data; - addType(data, createType>()); - m_parameter.push_back(std::make_pair(2,data)); -} -template<> -void zeus::Buffer::addParameter(const std::string& _value) { - std::vector data; - addType(data, createType()); - int32_t currentOffset = data.size(); - data.resize(data.size()+_value.size()); - memcpy(&data[currentOffset], &_value[0], _value.size()); - m_parameter.push_back(std::make_pair(2,data)); -} -template<> -void zeus::Buffer::addParameter>(const std::vector& _value) { - std::vector data; - addType(data, createType>()); - // count all datas: - uint32_t size = 0; - for (auto &it : _value) { - size+=it.size()+1; - } - uint16_t nb = _value.size(); - int32_t currentOffset = data.size(); - data.resize(data.size()+size+2); - memcpy(&data[currentOffset], &nb, sizeof(uint16_t)); - currentOffset += sizeof(uint16_t); - for (auto &it : _value) { - memcpy(&data[currentOffset], &it[0], it.size()); - currentOffset += it.size(); - data[currentOffset] = '\0'; - currentOffset++; - } - m_parameter.push_back(std::make_pair(2,data)); -} - -template<> -void zeus::Buffer::addParameter>(const std::vector& _value) { - std::vector data; - addType(data, createType>()); - // add size: - uint16_t nb = _value.size(); - int32_t currentOffset = data.size(); - data.resize(data.size()+_value.size()); - for (const auto &it : _value) { - if (it == true) { - data[currentOffset] = 'T'; - } else { - data[currentOffset] = 'F'; - } - currentOffset++; - } - m_parameter.push_back(std::make_pair(2,data)); -} - -template<> -void zeus::Buffer::addParameter>(const std::vector& _value) { - std::vector data; - addType(data, createType>()); - // add size: - int32_t currentOffset = data.size(); - data.resize(data.size()+_value.size()); - memcpy(&data[currentOffset], &_value[0], sizeof(int8_t)*_value.size()); - m_parameter.push_back(std::make_pair(2,data)); -} -template<> -void zeus::Buffer::addParameter>(const std::vector& _value) { - std::vector data; - addType(data, createType>()); - // add size: - int32_t currentOffset = data.size(); - data.resize(data.size()+_value.size()); - memcpy(&data[currentOffset], &_value[0], sizeof(int16_t)*_value.size()); - m_parameter.push_back(std::make_pair(2,data)); -} -template<> -void zeus::Buffer::addParameter>(const std::vector& _value) { - std::vector data; - addType(data, createType>()); - // add size: - int32_t currentOffset = data.size(); - data.resize(data.size()+_value.size()); - memcpy(&data[currentOffset], &_value[0], sizeof(int32_t)*_value.size()); - m_parameter.push_back(std::make_pair(2,data)); -} -template<> -void zeus::Buffer::addParameter>(const std::vector& _value) { - std::vector data; - addType(data, createType>()); - // add size: - int32_t currentOffset = data.size(); - data.resize(data.size()+_value.size()); - memcpy(&data[currentOffset], &_value[0], sizeof(int64_t)*_value.size()); - m_parameter.push_back(std::make_pair(2,data)); -} -template<> -void zeus::Buffer::addParameter>(const std::vector& _value) { - std::vector data; - addType(data, createType>()); - // add size: - int32_t currentOffset = data.size(); - data.resize(data.size()+_value.size()); - memcpy(&data[currentOffset], &_value[0], sizeof(uint8_t)*_value.size()); - m_parameter.push_back(std::make_pair(2,data)); -} -template<> -void zeus::Buffer::addParameter>(const std::vector& _value) { - std::vector data; - addType(data, createType>()); - // add size: - int32_t currentOffset = data.size(); - data.resize(data.size()+_value.size()); - memcpy(&data[currentOffset], &_value[0], sizeof(uint16_t)*_value.size()); - m_parameter.push_back(std::make_pair(2,data)); -} -template<> -void zeus::Buffer::addParameter>(const std::vector& _value) { - std::vector data; - addType(data, createType>()); - // add size: - int32_t currentOffset = data.size(); - data.resize(data.size()+_value.size()); - memcpy(&data[currentOffset], &_value[0], sizeof(uint32_t)*_value.size()); - m_parameter.push_back(std::make_pair(2,data)); -} -template<> -void zeus::Buffer::addParameter>(const std::vector& _value) { - std::vector data; - addType(data, createType>()); - // add size: - int32_t currentOffset = data.size(); - data.resize(data.size()+_value.size()); - memcpy(&data[currentOffset], &_value[0], sizeof(uint64_t)*_value.size()); - m_parameter.push_back(std::make_pair(2,data)); -} - -template<> -void zeus::Buffer::addParameter>(const std::vector& _value) { - std::vector data; - addType(data, createType>()); - // add size: - int32_t currentOffset = data.size(); - data.resize(data.size()+_value.size()); - memcpy(&data[currentOffset], &_value[0], sizeof(float)*_value.size()); - m_parameter.push_back(std::make_pair(2,data)); -} - -template<> -void zeus::Buffer::addParameter>(const std::vector& _value) { - std::vector data; - addType(data, createType>()); - // add size: - int32_t currentOffset = data.size(); - data.resize(data.size()+_value.size()); - memcpy(&data[currentOffset], &_value[0], sizeof(double)*_value.size()); - m_parameter.push_back(std::make_pair(2,data)); -} - -template<> -void zeus::Buffer::addParameter(const int8_t& _value) { - std::vector data; - addType(data, createType()); - data.push_back(uint8_t(_value)); - m_parameter.push_back(std::make_pair(2,data)); -} -template<> -void zeus::Buffer::addParameter(const uint8_t& _value) { - std::vector data; - addType(data, createType()); - data.push_back(_value); - m_parameter.push_back(std::make_pair(2,data)); -} -template<> -void zeus::Buffer::addParameter(const int16_t& _value) { - std::vector data; - addType(data, createType()); - int32_t currentOffset = data.size(); - data.resize(data.size()+2); - memcpy(&data[currentOffset], &_value, 2); - m_parameter.push_back(std::make_pair(2,data)); -} -template<> -void zeus::Buffer::addParameter(const uint16_t& _value) { - std::vector data; - addType(data, createType()); - int32_t currentOffset = data.size(); - data.resize(data.size()+2); - memcpy(&data[currentOffset], &_value, 2); - m_parameter.push_back(std::make_pair(2,data)); -} -template<> -void zeus::Buffer::addParameter(const int32_t& _value) { - std::vector data; - addType(data, createType()); - int32_t currentOffset = data.size(); - data.resize(data.size()+4); - memcpy(&data[currentOffset], &_value, 4); - m_parameter.push_back(std::make_pair(2,data)); -} -template<> -void zeus::Buffer::addParameter(const uint32_t& _value) { - std::vector data; - addType(data, createType()); - int32_t currentOffset = data.size(); - data.resize(data.size()+4); - memcpy(&data[currentOffset], &_value, 4); - m_parameter.push_back(std::make_pair(2,data)); -} -template<> -void zeus::Buffer::addParameter(const int64_t& _value) { - std::vector data; - addType(data, createType()); - int32_t currentOffset = data.size(); - data.resize(data.size()+8); - memcpy(&data[currentOffset], &_value, 8); - m_parameter.push_back(std::make_pair(2,data)); -} -template<> -void zeus::Buffer::addParameter(const uint64_t& _value) { - std::vector data; - addType(data, createType()); - int32_t currentOffset = data.size(); - data.resize(data.size()+8); - memcpy(&data[currentOffset], &_value, 8); - m_parameter.push_back(std::make_pair(2,data)); -} -template<> -void zeus::Buffer::addParameter(const float& _value) { - std::vector data; - addType(data, createType()); - int32_t currentOffset = data.size(); - data.resize(data.size()+4); - memcpy(&data[currentOffset], &_value, 4); - m_parameter.push_back(std::make_pair(2,data)); -} -template<> -void zeus::Buffer::addParameter(const double& _value) { - std::vector data; - addType(data, createType()); - int32_t currentOffset = data.size(); - data.resize(data.size()+8); - memcpy(&data[currentOffset], &_value, 8); - m_parameter.push_back(std::make_pair(2,data)); -} -template<> -void zeus::Buffer::addParameter(const bool& _value) { - std::vector data; - addType(data, createType()); - if (_value == true) { - data.push_back('T'); - } else { - data.push_back('F'); - } - m_parameter.push_back(std::make_pair(2,data)); -} - -template<> -void zeus::Buffer::addParameter(const zeus::File& _value) { - std::vector data; - addType(data, createType()); - ZEUS_TODO("Send file in output ..."); - m_parameter.push_back(std::make_pair(2,data)); -} - -template<> -bool zeus::Buffer::internalGetParameter(int32_t _id) const { - zeus::ParamType type = internalGetParameterType(_id); - const uint8_t* pointer = internalGetParameterPointer(_id); - uint32_t dataSize = internalGetParameterSize(_id); - if (createType() != type) { - return 0; - } - const char* pointer2 = reinterpret_cast(pointer); - if ( *pointer2 == 'T' - || *pointer2 == '1' - || *pointer2 == 1) { - return true; - } - return false; -} - -template<> -std::string zeus::Buffer::internalGetParameter(int32_t _id) const { - std::string out; - zeus::ParamType type = internalGetParameterType(_id); - const uint8_t* pointer = internalGetParameterPointer(_id); - uint32_t dataSize = internalGetParameterSize(_id); - out.resize(dataSize, 0); - memcpy(&out[0], pointer, out.size()); - return out; -} - - -template<> -uint8_t zeus::Buffer::internalGetParameter(int32_t _id) const { - zeus::ParamType type = internalGetParameterType(_id); - const uint8_t* pointer = internalGetParameterPointer(_id); - uint32_t dataSize = internalGetParameterSize(_id); - // TODO : Check size ... - if (createType() == type) { - const uint8_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const uint16_t* tmp = reinterpret_cast(pointer); - return std::min(*tmp, uint16_t(UCHAR_MAX)); - } else if (createType() == type) { - const uint32_t* tmp = reinterpret_cast(pointer); - return std::min(*tmp, uint32_t(UCHAR_MAX)); - } else if (createType() == type) { - const uint64_t* tmp = reinterpret_cast(pointer); - return std::min(*tmp, uint64_t(UCHAR_MAX)); - } else if (createType() == type) { - const int8_t* tmp = reinterpret_cast(pointer); - return std::max(int8_t(0), *tmp); - } else if (createType() == type) { - const int16_t* tmp = reinterpret_cast(pointer); - return etk::avg(int16_t(0), *tmp, int16_t(UCHAR_MAX)); - } else if (createType() == type) { - const int32_t* tmp = reinterpret_cast(pointer); - return etk::avg(int32_t(0), *tmp, int32_t(UCHAR_MAX)); - } else if (createType() == type) { - const int64_t* tmp = reinterpret_cast(pointer); - return etk::avg(int64_t(0), *tmp, int64_t(UCHAR_MAX)); - } else if (createType() == type) { - const float* tmp = reinterpret_cast(pointer); - return uint8_t(etk::avg(float(0), *tmp, float(UCHAR_MAX))); - } else if (createType() == type) { - const double* tmp = reinterpret_cast(pointer); - return uint8_t(etk::avg(double(0), *tmp, double(UCHAR_MAX))); - } - ZEUS_ERROR("Can not get type from '" << type << "'"); - return 0; -} -template<> -uint16_t zeus::Buffer::internalGetParameter(int32_t _id) const { - zeus::ParamType type = internalGetParameterType(_id); - const uint8_t* pointer = internalGetParameterPointer(_id); - uint32_t dataSize = internalGetParameterSize(_id); - // TODO : Check size ... - if (createType() == type) { - const uint8_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const uint16_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const uint32_t* tmp = reinterpret_cast(pointer); - return std::min(*tmp, uint32_t(USHRT_MAX)); - } else if (createType() == type) { - const uint64_t* tmp = reinterpret_cast(pointer); - return std::min(*tmp, uint64_t(USHRT_MAX)); - } else if (createType() == type) { - const int8_t* tmp = reinterpret_cast(pointer); - return std::max(int8_t(0), *tmp); - } else if (createType() == type) { - const int16_t* tmp = reinterpret_cast(pointer); - return std::max(int16_t(0), *tmp); - } else if (createType() == type) { - const int32_t* tmp = reinterpret_cast(pointer); - return etk::avg(int32_t(0), *tmp, int32_t(USHRT_MAX)); - } else if (createType() == type) { - const int64_t* tmp = reinterpret_cast(pointer); - return etk::avg(int64_t(0), *tmp, int64_t(USHRT_MAX)); - } else if (createType() == type) { - const float* tmp = reinterpret_cast(pointer); - return uint16_t(etk::avg(float(0), *tmp, float(USHRT_MAX))); - } else if (createType() == type) { - const double* tmp = reinterpret_cast(pointer); - return uint16_t(etk::avg(double(0), *tmp, double(USHRT_MAX))); - } - ZEUS_ERROR("Can not get type from '" << type << "'"); - return 0; -} - -template<> -uint32_t zeus::Buffer::internalGetParameter(int32_t _id) const { - zeus::ParamType type = internalGetParameterType(_id); - const uint8_t* pointer = internalGetParameterPointer(_id); - uint32_t dataSize = internalGetParameterSize(_id); - // TODO : Check size ... - if (createType() == type) { - const uint8_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const uint16_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const uint32_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const uint64_t* tmp = reinterpret_cast(pointer); - return std::min(*tmp, uint64_t(ULONG_MAX)); - } else if (createType() == type) { - const int8_t* tmp = reinterpret_cast(pointer); - return std::max(int8_t(0), *tmp); - } else if (createType() == type) { - const int16_t* tmp = reinterpret_cast(pointer); - return std::max(int16_t(0), *tmp); - } else if (createType() == type) { - const int32_t* tmp = reinterpret_cast(pointer); - return std::max(int32_t(0), *tmp); - } else if (createType() == type) { - const int64_t* tmp = reinterpret_cast(pointer); - return etk::avg(int64_t(0), *tmp, int64_t(ULONG_MAX)); - } else if (createType() == type) { - const float* tmp = reinterpret_cast(pointer); - return uint32_t(etk::avg(float(0), *tmp, float(ULONG_MAX))); - } else if (createType() == type) { - const double* tmp = reinterpret_cast(pointer); - return uint32_t(etk::avg(double(0), *tmp, double(ULONG_MAX))); - } - ZEUS_ERROR("Can not get type from '" << type << "'"); - return 0; -} - -template<> -uint64_t zeus::Buffer::internalGetParameter(int32_t _id) const { - zeus::ParamType type = internalGetParameterType(_id); - const uint8_t* pointer = internalGetParameterPointer(_id); - uint32_t dataSize = internalGetParameterSize(_id); - // TODO : Check size ... - if (createType() == type) { - const uint8_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const uint16_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const uint32_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const uint64_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const int8_t* tmp = reinterpret_cast(pointer); - return std::max(int8_t(0), *tmp); - } else if (createType() == type) { - const int16_t* tmp = reinterpret_cast(pointer); - return std::max(int16_t(0), *tmp); - } else if (createType() == type) { - const int32_t* tmp = reinterpret_cast(pointer); - return std::max(int32_t(0), *tmp); - } else if (createType() == type) { - const int64_t* tmp = reinterpret_cast(pointer); - return std::max(int64_t(0), *tmp); - } else if (createType() == type) { - const float* tmp = reinterpret_cast(pointer); - return uint64_t(etk::avg(float(0), *tmp, float(ULONG_MAX))); - } else if (createType() == type) { - const double* tmp = reinterpret_cast(pointer); - return uint64_t(etk::avg(double(0), *tmp, double(ULONG_MAX))); - } - ZEUS_ERROR("Can not get type from '" << type << "'"); - return 0; -} - -template<> -int8_t zeus::Buffer::internalGetParameter(int32_t _id) const { - zeus::ParamType type = internalGetParameterType(_id); - const uint8_t* pointer = internalGetParameterPointer(_id); - uint32_t dataSize = internalGetParameterSize(_id); - // TODO : Check size ... - if (createType() == type) { - const uint8_t* tmp = reinterpret_cast(pointer); - return std::min(*tmp, uint8_t(SCHAR_MAX)); - } else if (createType() == type) { - const uint16_t* tmp = reinterpret_cast(pointer); - return std::min(*tmp, uint16_t(SCHAR_MAX)); - } else if (createType() == type) { - const uint32_t* tmp = reinterpret_cast(pointer); - return std::min(*tmp, uint32_t(SCHAR_MAX)); - } else if (createType() == type) { - const uint64_t* tmp = reinterpret_cast(pointer); - return std::min(*tmp, uint64_t(SCHAR_MAX)); - } else if (createType() == type) { - const int8_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const int16_t* tmp = reinterpret_cast(pointer); - return etk::avg(int16_t(SCHAR_MIN), *tmp, int16_t(SCHAR_MAX)); - } else if (createType() == type) { - const int32_t* tmp = reinterpret_cast(pointer); - return etk::avg(int32_t(SCHAR_MIN), *tmp, int32_t(SCHAR_MAX)); - } else if (createType() == type) { - const int64_t* tmp = reinterpret_cast(pointer); - return etk::avg(int64_t(SCHAR_MIN), *tmp, int64_t(SCHAR_MAX)); - } else if (createType() == type) { - const float* tmp = reinterpret_cast(pointer); - return int8_t(etk::avg(float(SCHAR_MIN), *tmp, float(SCHAR_MAX))); - } else if (createType() == type) { - const double* tmp = reinterpret_cast(pointer); - return int8_t(etk::avg(double(SCHAR_MIN), *tmp, double(SCHAR_MAX))); - } - ZEUS_ERROR("Can not get type from '" << type << "'"); - return 0; -} - -template<> -int16_t zeus::Buffer::internalGetParameter(int32_t _id) const { - zeus::ParamType type = internalGetParameterType(_id); - const uint8_t* pointer = internalGetParameterPointer(_id); - uint32_t dataSize = internalGetParameterSize(_id); - // TODO : Check size ... - if (createType() == type) { - const uint8_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const uint16_t* tmp = reinterpret_cast(pointer); - return std::min(*tmp, uint16_t(SHRT_MAX)); - } else if (createType() == type) { - const uint32_t* tmp = reinterpret_cast(pointer); - return std::min(*tmp, uint32_t(SHRT_MAX)); - } else if (createType() == type) { - const uint64_t* tmp = reinterpret_cast(pointer); - return std::min(*tmp, uint64_t(SHRT_MAX)); - } else if (createType() == type) { - const int8_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const int16_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const int32_t* tmp = reinterpret_cast(pointer); - return etk::avg(int32_t(SHRT_MIN), *tmp, int32_t(SHRT_MAX)); - } else if (createType() == type) { - const int64_t* tmp = reinterpret_cast(pointer); - return etk::avg(int64_t(SHRT_MIN), *tmp, int64_t(SHRT_MAX)); - } else if (createType() == type) { - const float* tmp = reinterpret_cast(pointer); - return int16_t(etk::avg(float(SHRT_MIN), *tmp, float(SHRT_MAX))); - } else if (createType() == type) { - const double* tmp = reinterpret_cast(pointer); - return int16_t(etk::avg(double(SHRT_MIN), *tmp, double(SHRT_MAX))); - } - ZEUS_ERROR("Can not get type from '" << type << "'"); - return 0; -} - -template<> -int32_t zeus::Buffer::internalGetParameter(int32_t _id) const { - zeus::ParamType type = internalGetParameterType(_id); - const uint8_t* pointer = internalGetParameterPointer(_id); - uint32_t dataSize = internalGetParameterSize(_id); - // TODO : Check size ... - if (createType() == type) { - const uint8_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const uint16_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const uint32_t* tmp = reinterpret_cast(pointer); - return std::min(*tmp, uint32_t(LONG_MAX)); - } else if (createType() == type) { - const uint64_t* tmp = reinterpret_cast(pointer); - return std::min(*tmp, uint64_t(LONG_MAX)); - } else if (createType() == type) { - const int8_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const int16_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const int32_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const int64_t* tmp = reinterpret_cast(pointer); - return etk::avg(int64_t(LONG_MIN), *tmp, int64_t(LONG_MAX)); - } else if (createType() == type) { - const float* tmp = reinterpret_cast(pointer); - return int32_t(etk::avg(float(LONG_MIN), *tmp, float(LONG_MAX))); - } else if (createType() == type) { - const double* tmp = reinterpret_cast(pointer); - return int32_t(etk::avg(double(LONG_MIN), *tmp, double(LONG_MAX))); - } - ZEUS_ERROR("Can not get type from '" << type << "'"); - return 0; -} - -template<> -int64_t zeus::Buffer::internalGetParameter(int32_t _id) const { - zeus::ParamType type = internalGetParameterType(_id); - const uint8_t* pointer = internalGetParameterPointer(_id); - uint32_t dataSize = internalGetParameterSize(_id); - // TODO : Check size ... - if (createType() == type) { - const uint8_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const uint16_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const uint32_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const uint64_t* tmp = reinterpret_cast(pointer); - return std::min(*tmp, uint64_t(LLONG_MAX)); - } else if (createType() == type) { - const int8_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const int16_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const int32_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const int64_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const float* tmp = reinterpret_cast(pointer); - return int64_t(etk::avg(float(LLONG_MIN), *tmp, float(LLONG_MAX))); - } else if (createType() == type) { - const double* tmp = reinterpret_cast(pointer); - return int64_t(etk::avg(double(LLONG_MIN), *tmp, double(LLONG_MAX))); - } - ZEUS_ERROR("Can not get type from '" << type << "'"); - return 0; -} - -template<> -float zeus::Buffer::internalGetParameter(int32_t _id) const { - zeus::ParamType type = internalGetParameterType(_id); - const uint8_t* pointer = internalGetParameterPointer(_id); - uint32_t dataSize = internalGetParameterSize(_id); - // TODO : Check size ... - if (createType() == type) { - const uint8_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const uint16_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const uint32_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const uint64_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const int8_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const int16_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const int32_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const int64_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const float* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const double* tmp = reinterpret_cast(pointer); - return *tmp; - } - ZEUS_ERROR("Can not get type from '" << type << "'"); - return 0.0f; -} -template<> -double zeus::Buffer::internalGetParameter(int32_t _id) const { - zeus::ParamType type = internalGetParameterType(_id); - const uint8_t* pointer = internalGetParameterPointer(_id); - uint32_t dataSize = internalGetParameterSize(_id); - // TODO : Check size ... - if (createType() == type) { - const uint8_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const uint16_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const uint32_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const uint64_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const int8_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const int16_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const int32_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const int64_t* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const float* tmp = reinterpret_cast(pointer); - return *tmp; - } else if (createType() == type) { - const double* tmp = reinterpret_cast(pointer); - return *tmp; - } - ZEUS_ERROR("Can not get type from '" << type << "'"); - return 0.0; -} - - - - - - - - - - - - - - - - - - - - - - - - -template<> -std::vector zeus::Buffer::internalGetParameter>(int32_t _id) const { - std::vector out; - zeus::ParamType type = internalGetParameterType(_id); - const uint8_t* pointer = internalGetParameterPointer(_id); - uint32_t dataSize = internalGetParameterSize(_id); - // TODO : Check size ... - if (type == createType>()) { - return out; - } else if (createType>() == type) { - int32_t nbElement = dataSize / sizeof(uint8_t); - out.resize(nbElement); - memcpy(&out, pointer, nbElement * sizeof(uint8_t)); - return out; - } else if (createType>() == type) { - const uint16_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint16_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const uint32_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint32_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const uint64_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint64_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const int8_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int8_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const int16_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int16_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const int32_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int32_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const int64_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int64_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const float* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(float); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const double* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(double); - out.resize(nbElement); - for (size_t iii=0; iii -std::vector zeus::Buffer::internalGetParameter>(int32_t _id) const { - std::vector out; - zeus::ParamType type = internalGetParameterType(_id); - const uint8_t* pointer = internalGetParameterPointer(_id); - uint32_t dataSize = internalGetParameterSize(_id); - // TODO : Check size ... - if (type == createType>()) { - return out; - } else if (createType>() == type) { - const uint8_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint8_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - int32_t nbElement = dataSize / sizeof(uint16_t); - out.resize(nbElement); - memcpy(&out, pointer, nbElement * sizeof(uint16_t)); - return out; - } else if (createType>() == type) { - const uint32_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint32_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const uint64_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint64_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const int8_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int8_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const int16_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int16_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const int32_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int32_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const int64_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int64_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const float* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(float); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const double* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(double); - out.resize(nbElement); - for (size_t iii=0; iii -std::vector zeus::Buffer::internalGetParameter>(int32_t _id) const { - std::vector out; - zeus::ParamType type = internalGetParameterType(_id); - const uint8_t* pointer = internalGetParameterPointer(_id); - uint32_t dataSize = internalGetParameterSize(_id); - // TODO : Check size ... - if (type == createType>()) { - return out; - } else if (createType>() == type) { - const uint8_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint8_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const uint16_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint16_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - int32_t nbElement = dataSize / sizeof(uint32_t); - out.resize(nbElement); - memcpy(&out, pointer, nbElement * sizeof(uint32_t)); - return out; - } else if (createType>() == type) { - const uint64_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint64_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const int8_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int8_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const int16_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int16_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const int32_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int32_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const int64_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int64_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const float* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(float); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const double* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(double); - out.resize(nbElement); - for (size_t iii=0; iii -std::vector zeus::Buffer::internalGetParameter>(int32_t _id) const { - std::vector out; - zeus::ParamType type = internalGetParameterType(_id); - const uint8_t* pointer = internalGetParameterPointer(_id); - uint32_t dataSize = internalGetParameterSize(_id); - // TODO : Check size ... - if (type == createType>()) { - return out; - } else if (createType>() == type) { - const uint8_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint8_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const uint16_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint16_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const uint32_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint32_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - int32_t nbElement = dataSize / sizeof(uint64_t); - out.resize(nbElement); - memcpy(&out, pointer, nbElement * sizeof(uint64_t)); - return out; - } else if (createType>() == type) { - const int8_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int8_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const int16_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int16_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const int32_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int32_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const int64_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int64_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const float* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(float); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const double* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(double); - out.resize(nbElement); - for (size_t iii=0; iii -std::vector zeus::Buffer::internalGetParameter>(int32_t _id) const { - std::vector out; - zeus::ParamType type = internalGetParameterType(_id); - const uint8_t* pointer = internalGetParameterPointer(_id); - uint32_t dataSize = internalGetParameterSize(_id); - // TODO : Check size ... - if (type == createType>()) { - return out; - } else if (createType>() == type) { - const uint8_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint8_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const uint16_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint16_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const uint32_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint32_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const uint64_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint64_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - int32_t nbElement = dataSize / sizeof(int8_t); - out.resize(nbElement); - memcpy(&out, pointer, nbElement * sizeof(int8_t)); - return out; - } else if (createType>() == type) { - const int16_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int16_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const int32_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int32_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const int64_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int64_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const float* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(float); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const double* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(double); - out.resize(nbElement); - for (size_t iii=0; iii -std::vector zeus::Buffer::internalGetParameter>(int32_t _id) const { - std::vector out; - zeus::ParamType type = internalGetParameterType(_id); - const uint8_t* pointer = internalGetParameterPointer(_id); - uint32_t dataSize = internalGetParameterSize(_id); - // TODO : Check size ... - if (type == createType>()) { - return out; - } else if (createType>() == type) { - const uint8_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint8_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const uint16_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint16_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const uint32_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint32_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const uint64_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint64_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const int8_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int8_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - int32_t nbElement = dataSize / sizeof(int16_t); - out.resize(nbElement); - memcpy(&out, pointer, nbElement * sizeof(int16_t)); - return out; - } else if (createType>() == type) { - const int32_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int32_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const int64_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int64_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const float* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(float); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const double* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(double); - out.resize(nbElement); - for (size_t iii=0; iii -std::vector zeus::Buffer::internalGetParameter>(int32_t _id) const { - std::vector out; - zeus::ParamType type = internalGetParameterType(_id); - const uint8_t* pointer = internalGetParameterPointer(_id); - uint32_t dataSize = internalGetParameterSize(_id); - // TODO : Check size ... - if (type == createType>()) { - return out; - } else if (createType>() == type) { - const uint8_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint8_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const uint16_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint16_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const uint32_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint32_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const uint64_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint64_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const int8_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int8_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const int16_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int16_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - int32_t nbElement = dataSize / sizeof(int32_t); - out.resize(nbElement); - memcpy(&out, pointer, nbElement * sizeof(int32_t)); - return out; - } else if (createType>() == type) { - const int64_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int64_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const float* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(float); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const double* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(double); - out.resize(nbElement); - for (size_t iii=0; iii -std::vector zeus::Buffer::internalGetParameter>(int32_t _id) const { - std::vector out; - zeus::ParamType type = internalGetParameterType(_id); - const uint8_t* pointer = internalGetParameterPointer(_id); - uint32_t dataSize = internalGetParameterSize(_id); - // TODO : Check size ... - if (type == createType>()) { - return out; - } else if (createType>() == type) { - const uint8_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint8_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const uint16_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint16_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const uint32_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint32_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const uint64_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint64_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const int8_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int8_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const int16_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int16_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const int32_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int32_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - int32_t nbElement = dataSize / sizeof(int64_t); - out.resize(nbElement); - memcpy(&out, pointer, nbElement * sizeof(int64_t)); - return out; - } else if (createType>() == type) { - const float* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(float); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const double* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(double); - out.resize(nbElement); - for (size_t iii=0; iii -std::vector zeus::Buffer::internalGetParameter>(int32_t _id) const { - std::vector out; - zeus::ParamType type = internalGetParameterType(_id); - const uint8_t* pointer = internalGetParameterPointer(_id); - uint32_t dataSize = internalGetParameterSize(_id); - // TODO : Check size ... - if (type == createType>()) { - return out; - } else if (createType>() == type) { - const uint8_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint8_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const uint16_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint16_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const uint32_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint32_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const uint64_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint64_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const int8_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int8_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const int16_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int16_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const int32_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int32_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const int64_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int64_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - int32_t nbElement = dataSize / sizeof(float); - out.resize(nbElement); - memcpy(&out, pointer, nbElement * sizeof(float)); - return out; - } else if (createType>() == type) { - const double* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(double); - out.resize(nbElement); - for (size_t iii=0; iii -std::vector zeus::Buffer::internalGetParameter>(int32_t _id) const { - std::vector out; - zeus::ParamType type = internalGetParameterType(_id); - const uint8_t* pointer = internalGetParameterPointer(_id); - uint32_t dataSize = internalGetParameterSize(_id); - // TODO : Check size ... - if (type == createType>()) { - return out; - } else if (createType>() == type) { - const uint8_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint8_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const uint16_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint16_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const uint32_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint32_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const uint64_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint64_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const int8_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int8_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const int16_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int16_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const int32_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int32_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const int64_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(int64_t); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - const float* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(float); - out.resize(nbElement); - for (size_t iii=0; iii>() == type) { - int32_t nbElement = dataSize / sizeof(double); - out.resize(nbElement); - memcpy(&out, pointer, nbElement * sizeof(double)); - return out; - } - ZEUS_ERROR("Can not get type from '" << type << "'"); - return out; -} - -template<> -std::vector zeus::Buffer::internalGetParameter>(int32_t _id) const { - std::vector out; - zeus::ParamType type = internalGetParameterType(_id); - const uint8_t* pointer = internalGetParameterPointer(_id); - uint32_t dataSize = internalGetParameterSize(_id); - // TODO : Check size ... - if (type == createType>()) { - return out; - } else if (createType>() == type) { - const uint8_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint8_t); - out.resize(nbElement); - for (size_t iii=0; iii -std::vector zeus::Buffer::internalGetParameter>(int32_t _id) const { - std::vector out; - zeus::ParamType type = internalGetParameterType(_id); - const uint8_t* pointer = internalGetParameterPointer(_id); - uint32_t dataSize = internalGetParameterSize(_id); - if (type == createType>()) { - return out; - } else if (createType>() == type) { - // first element is the number of elements: - const uint16_t* tmp = reinterpret_cast(pointer); - out.resize(*tmp); - pointer += sizeof(uint16_t); - ZEUS_DEBUG("Parse list of string: Find " << out.size() << " elements"); - //each string is separated with a \0: - for (int32_t iii=0; iii(pointer); - out[iii] = tmp2; - pointer += out[iii].size() + 1; - ZEUS_DEBUG(" value: '" << out[iii] << "'"); - } - return out; - } - ZEUS_ERROR("Can not get type from '" << type << "'"); - return out; -} - -template<> -zeus::File zeus::Buffer::internalGetParameter(int32_t _id) const { - zeus::File out; - zeus::ParamType type = internalGetParameterType(_id); - const uint8_t* pointer = internalGetParameterPointer(_id); - uint32_t dataSize = internalGetParameterSize(_id); - // TODO : Check size ... - if (createType() == type) { - /* - const uint8_t* tmp = reinterpret_cast(pointer); - int32_t nbElement = dataSize / sizeof(uint8_t); - out.resize(nbElement); - for (size_t iii=0; iii(_id)); } if (paramType == createType()) { - return internalGetParameter(_id); + return "{" + internalGetParameter(_id) + "}"; + } + if (paramType == createType>()) { + return "[" + etk::to_string(internalGetParameter>(_id)) + "]"; } return paramType.getName(); } diff --git a/zeus/Buffer.h b/zeus/Buffer.h index 342edab..c9ed261 100644 --- a/zeus/Buffer.h +++ b/zeus/Buffer.h @@ -8,6 +8,14 @@ #include #include +namespace zeus { + class TcpString; + // define basic async call element ... + using ActionAsyncClient = std::function; +} + + + namespace zeus { //U32 message lenght #pragma pack(push,1) @@ -82,13 +90,25 @@ namespace zeus { - obj:file */ class Buffer { - private: + protected: + Buffer(); + public: + static ememory::SharedPtr create(); + protected: headerBin m_header; mutable std::vector>> m_parameter; - private: + std::vector m_multipleSend; + public: + bool haveAsync() const { + return m_multipleSend.size() != 0; + } + std::vector moveAsync() { + return std::move(m_multipleSend); + } + void appendBufferData(const ememory::SharedPtr& _obj); + protected: void internalComposeWith(const uint8_t* _buffer, uint32_t _lenght); public: - Buffer(); void composeWith(const std::vector& _buffer); void composeWith(const std::string& _buffer); std::string generateHumanString(); @@ -109,6 +129,7 @@ namespace zeus { bool getPartFinish() const; void setPartFinish(bool _value); enum class typeMessage { + unknow = 0x0000, // Init value call = 0x0001, // Remote call on a service ID answer = 0x0002, // Answer from a previous call data = 0x0003, // data message happend when partId > 0 it compleate the data of a parameter or an answer or an event @@ -120,7 +141,7 @@ namespace zeus { // =============================================== // == Section call // =============================================== - private: + protected: template ZEUS_TYPE_DATA internalGetParameter(int32_t _id) const; zeus::ParamType internalGetParameterType(int32_t _id) const; @@ -135,9 +156,14 @@ namespace zeus { const uint8_t* getParameterPointer(int32_t _id) const; uint32_t getParameterSize(int32_t _id) const; + protected: + template + void internalAddParameter(uint16_t _paramId, const ZEUS_TYPE_DATA& _value); public: template - void addParameter(const ZEUS_TYPE_DATA& _value); + void addParameter(const ZEUS_TYPE_DATA& _value) { + internalAddParameter(m_parameter.size(), _value); + } void addParameterEmptyVector(); void addParameter(); @@ -167,10 +193,14 @@ namespace zeus { public: //multiple section of data (part ...) - void addData(void* _data, uint32_t _size); + void addData(uint16_t _parameterId, void* _data, uint32_t _size); bool writeOn(enet::WebSocket& _interface); }; std::ostream& operator <<(std::ostream& _os, enum zeus::Buffer::typeMessage _value); + + void addType(std::vector& _data, zeus::ParamType _type); + void addTypeObject(std::vector& _data, const std::string _type); + void addTypeRaw(std::vector& _data); } diff --git a/zeus/Buffer_addParameter.cpp b/zeus/Buffer_addParameter.cpp new file mode 100644 index 0000000..8e0f67b --- /dev/null +++ b/zeus/Buffer_addParameter.cpp @@ -0,0 +1,449 @@ +/** @file + * @author Edouard DUPIN + * @copyright 2016, Edouard DUPIN, all right reserved + * @license APACHE v2.0 (see license file) + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +void zeus::addType(std::vector& _data, zeus::ParamType _type) { + _data.push_back(uint8_t(_type.getId()>>8)); + _data.push_back(uint8_t(_type.getId())); +} + +void zeus::addTypeObject(std::vector& _data, const std::string _type) { + _data.push_back(uint8_t(zeus::paramTypeObject>>8)); + _data.push_back(uint8_t(zeus::paramTypeObject)); + for (auto &it : _type) { + _data.push_back(uint8_t(it)); + } + _data.push_back(0); +} + +void zeus::addTypeRaw(std::vector& _data) { + _data.push_back(uint8_t(zeus::paramTypeRaw>>8)); + _data.push_back(uint8_t(zeus::paramTypeRaw)); +} + + +void zeus::Buffer::addParameter() { + std::vector data; + addType(data, createType()); + m_parameter.push_back(std::make_pair(2,data)); +} +void zeus::Buffer::addParameterEmptyVector() { + // special case of json change mode + std::vector data; + addType(data, createType>()); + m_parameter.push_back(std::make_pair(2,data)); +} +template<> +void zeus::Buffer::internalAddParameter(uint16_t _paramId, const std::string& _value) { + std::vector data; + addType(data, createType()); + int32_t currentOffset = data.size(); + data.resize(data.size()+_value.size()); + memcpy(&data[currentOffset], &_value[0], _value.size()); + m_parameter.push_back(std::make_pair(2,data)); +} +template<> +void zeus::Buffer::internalAddParameter>(uint16_t _paramId, const std::vector& _value) { + std::vector data; + addType(data, createType>()); + // count all datas: + uint32_t size = 0; + for (auto &it : _value) { + size+=it.size()+1; + } + uint16_t nb = _value.size(); + int32_t currentOffset = data.size(); + data.resize(data.size()+size+2); + memcpy(&data[currentOffset], &nb, sizeof(uint16_t)); + currentOffset += sizeof(uint16_t); + for (auto &it : _value) { + memcpy(&data[currentOffset], &it[0], it.size()); + currentOffset += it.size(); + data[currentOffset] = '\0'; + currentOffset++; + } + m_parameter.push_back(std::make_pair(2,data)); +} + +template<> +void zeus::Buffer::internalAddParameter>(uint16_t _paramId, const std::vector& _value) { + std::vector data; + addType(data, createType>()); + // add size: + uint16_t nb = _value.size(); + int32_t currentOffset = data.size(); + data.resize(data.size()+_value.size()); + for (const auto &it : _value) { + if (it == true) { + data[currentOffset] = 'T'; + } else { + data[currentOffset] = 'F'; + } + currentOffset++; + } + m_parameter.push_back(std::make_pair(2,data)); +} + +template<> +void zeus::Buffer::internalAddParameter>(uint16_t _paramId, const std::vector& _value) { + std::vector data; + addType(data, createType>()); + // add size: + int32_t currentOffset = data.size(); + data.resize(data.size()+_value.size()); + memcpy(&data[currentOffset], &_value[0], sizeof(int8_t)*_value.size()); + m_parameter.push_back(std::make_pair(2,data)); +} +template<> +void zeus::Buffer::internalAddParameter>(uint16_t _paramId, const std::vector& _value) { + std::vector data; + addType(data, createType>()); + // add size: + int32_t currentOffset = data.size(); + data.resize(data.size()+_value.size()); + memcpy(&data[currentOffset], &_value[0], sizeof(int16_t)*_value.size()); + m_parameter.push_back(std::make_pair(2,data)); +} +template<> +void zeus::Buffer::internalAddParameter>(uint16_t _paramId, const std::vector& _value) { + std::vector data; + addType(data, createType>()); + // add size: + int32_t currentOffset = data.size(); + data.resize(data.size()+_value.size()); + memcpy(&data[currentOffset], &_value[0], sizeof(int32_t)*_value.size()); + m_parameter.push_back(std::make_pair(2,data)); +} +template<> +void zeus::Buffer::internalAddParameter>(uint16_t _paramId, const std::vector& _value) { + std::vector data; + addType(data, createType>()); + // add size: + int32_t currentOffset = data.size(); + data.resize(data.size()+_value.size()); + memcpy(&data[currentOffset], &_value[0], sizeof(int64_t)*_value.size()); + m_parameter.push_back(std::make_pair(2,data)); +} +template<> +void zeus::Buffer::internalAddParameter>(uint16_t _paramId, const std::vector& _value) { + std::vector data; + addType(data, createType>()); + // add size: + int32_t currentOffset = data.size(); + data.resize(data.size()+_value.size()); + memcpy(&data[currentOffset], &_value[0], sizeof(uint8_t)*_value.size()); + m_parameter.push_back(std::make_pair(2,data)); +} +template<> +void zeus::Buffer::internalAddParameter>(uint16_t _paramId, const std::vector& _value) { + std::vector data; + addType(data, createType>()); + // add size: + int32_t currentOffset = data.size(); + data.resize(data.size()+_value.size()); + memcpy(&data[currentOffset], &_value[0], sizeof(uint16_t)*_value.size()); + m_parameter.push_back(std::make_pair(2,data)); +} +template<> +void zeus::Buffer::internalAddParameter>(uint16_t _paramId, const std::vector& _value) { + std::vector data; + addType(data, createType>()); + // add size: + int32_t currentOffset = data.size(); + data.resize(data.size()+_value.size()); + memcpy(&data[currentOffset], &_value[0], sizeof(uint32_t)*_value.size()); + m_parameter.push_back(std::make_pair(2,data)); +} +template<> +void zeus::Buffer::internalAddParameter>(uint16_t _paramId, const std::vector& _value) { + std::vector data; + addType(data, createType>()); + // add size: + int32_t currentOffset = data.size(); + data.resize(data.size()+_value.size()); + memcpy(&data[currentOffset], &_value[0], sizeof(uint64_t)*_value.size()); + m_parameter.push_back(std::make_pair(2,data)); +} + +template<> +void zeus::Buffer::internalAddParameter>(uint16_t _paramId, const std::vector& _value) { + std::vector data; + addType(data, createType>()); + // add size: + int32_t currentOffset = data.size(); + data.resize(data.size()+_value.size()); + memcpy(&data[currentOffset], &_value[0], sizeof(float)*_value.size()); + m_parameter.push_back(std::make_pair(2,data)); +} + +template<> +void zeus::Buffer::internalAddParameter>(uint16_t _paramId, const std::vector& _value) { + std::vector data; + addType(data, createType>()); + // add size: + int32_t currentOffset = data.size(); + data.resize(data.size()+_value.size()); + memcpy(&data[currentOffset], &_value[0], sizeof(double)*_value.size()); + m_parameter.push_back(std::make_pair(2,data)); +} + +template<> +void zeus::Buffer::internalAddParameter(uint16_t _paramId, const int8_t& _value) { + std::vector data; + addType(data, createType()); + data.push_back(uint8_t(_value)); + m_parameter.push_back(std::make_pair(2,data)); +} +template<> +void zeus::Buffer::internalAddParameter(uint16_t _paramId, const uint8_t& _value) { + std::vector data; + addType(data, createType()); + data.push_back(_value); + m_parameter.push_back(std::make_pair(2,data)); +} +template<> +void zeus::Buffer::internalAddParameter(uint16_t _paramId, const int16_t& _value) { + std::vector data; + addType(data, createType()); + int32_t currentOffset = data.size(); + data.resize(data.size()+2); + memcpy(&data[currentOffset], &_value, 2); + m_parameter.push_back(std::make_pair(2,data)); +} +template<> +void zeus::Buffer::internalAddParameter(uint16_t _paramId, const uint16_t& _value) { + std::vector data; + addType(data, createType()); + int32_t currentOffset = data.size(); + data.resize(data.size()+2); + memcpy(&data[currentOffset], &_value, 2); + m_parameter.push_back(std::make_pair(2,data)); +} +template<> +void zeus::Buffer::internalAddParameter(uint16_t _paramId, const int32_t& _value) { + std::vector data; + addType(data, createType()); + int32_t currentOffset = data.size(); + data.resize(data.size()+4); + memcpy(&data[currentOffset], &_value, 4); + m_parameter.push_back(std::make_pair(2,data)); +} +template<> +void zeus::Buffer::internalAddParameter(uint16_t _paramId, const uint32_t& _value) { + std::vector data; + addType(data, createType()); + int32_t currentOffset = data.size(); + data.resize(data.size()+4); + memcpy(&data[currentOffset], &_value, 4); + m_parameter.push_back(std::make_pair(2,data)); +} +template<> +void zeus::Buffer::internalAddParameter(uint16_t _paramId, const int64_t& _value) { + std::vector data; + addType(data, createType()); + int32_t currentOffset = data.size(); + data.resize(data.size()+8); + memcpy(&data[currentOffset], &_value, 8); + m_parameter.push_back(std::make_pair(2,data)); +} +template<> +void zeus::Buffer::internalAddParameter(uint16_t _paramId, const uint64_t& _value) { + std::vector data; + addType(data, createType()); + int32_t currentOffset = data.size(); + data.resize(data.size()+8); + memcpy(&data[currentOffset], &_value, 8); + m_parameter.push_back(std::make_pair(2,data)); +} +template<> +void zeus::Buffer::internalAddParameter(uint16_t _paramId, const float& _value) { + std::vector data; + addType(data, createType()); + int32_t currentOffset = data.size(); + data.resize(data.size()+4); + memcpy(&data[currentOffset], &_value, 4); + m_parameter.push_back(std::make_pair(2,data)); +} +template<> +void zeus::Buffer::internalAddParameter(uint16_t _paramId, const double& _value) { + std::vector data; + addType(data, createType()); + int32_t currentOffset = data.size(); + data.resize(data.size()+8); + memcpy(&data[currentOffset], &_value, 8); + m_parameter.push_back(std::make_pair(2,data)); +} +template<> +void zeus::Buffer::internalAddParameter(uint16_t _paramId, const bool& _value) { + std::vector data; + addType(data, createType()); + if (_value == true) { + data.push_back('T'); + } else { + data.push_back('F'); + } + m_parameter.push_back(std::make_pair(2,data)); +} +#define ZEUS_MINIMUM_SIZE_MULTIPLE (1024*40) + +namespace zeus { + class SendData { + private: + std::vector m_data; + uint16_t m_parameterId; + int64_t m_size; + uint64_t m_offset; + public: + SendData(const std::vector& _data, uint16_t _parameterId) : + m_data(_data), + m_parameterId(_parameterId), + m_size(_data.size()-1), + m_offset(0) { + + } + ~SendData() { + + } + bool operator() (zeus::TcpString* _interface, + uint32_t _clientId, + uint32_t _transactionId, + uint32_t _partId) { + ememory::SharedPtr answer = zeus::Buffer::create(); + answer->setTransactionId(_transactionId); + answer->setClientId(_clientId); + answer->setPartId(_partId); + answer->setPartFinish(false); + answer->setType(zeus::Buffer::typeMessage::data); + int32_t tmpSize = ZEUS_MINIMUM_SIZE_MULTIPLE; + if (m_size < ZEUS_MINIMUM_SIZE_MULTIPLE) { + tmpSize = m_size; + } + answer->addData(m_parameterId, &m_data[m_offset], tmpSize); + m_size -= tmpSize; + m_offset += tmpSize; + _interface->writeBinary(answer);; + if (m_size <= 0) { + return true; + } + return false; + } + }; +} +template<> +void zeus::Buffer::internalAddParameter(uint16_t _paramId, const zeus::File& _value) { + std::vector data; + addType(data, createType()); + // set mine type in string: + std::string name = _value.getMineType(); + int32_t currentOffset = data.size(); + data.resize(data.size()+name.size()+1); + memcpy(&data[currentOffset], &name[0], name.size()); + // finish with '\0' + currentOffset = data.size()-1; + data[currentOffset] = 0; + // set size if the file in int32_t + int32_t size = _value.getTheoricFileSize(); + currentOffset = data.size(); + data.resize(data.size()+sizeof(int32_t)); + memcpy(&data[currentOffset], &size, sizeof(int32_t)); + // and now the data (can be none ...): + const std::vector& dataFile = _value.getData(); + if (dataFile.size() != 0) { + currentOffset = data.size(); + ZEUS_ERROR("set buffer with size: " << dataFile.size()); + if (dataFile.size() < ZEUS_MINIMUM_SIZE_MULTIPLE) { + data.resize(data.size()+dataFile.size()); + memcpy(&data[currentOffset], &dataFile[0], dataFile.size()); + } else { + ZEUS_WARNING("multiple send the data file: " << _value.getMineType()); + // multiple send ... (no data in the first frame ... + // TODO : m_multipleSend.push_back(SendFile(std::move(node), _paramId, size)); + m_multipleSend.push_back(zeus::SendData(dataFile, _paramId)); + } + } + m_parameter.push_back(std::make_pair(2,data)); +} +namespace zeus { + class SendFile { + private: + etk::FSNode m_node; + uint16_t m_parameterId; + int64_t m_size; + public: + SendFile(const std::string& _data, uint16_t _parameterId, uint32_t _size) : + m_node(_data), + m_parameterId(_parameterId), + m_size(_size) { + + } + ~SendFile() { + + } + bool operator() (zeus::TcpString* _interface, + uint32_t _clientId, + uint32_t _transactionId, + uint32_t _partId) { + if (m_node.fileIsOpen() == false) { + m_node.fileOpenRead(); + } + ememory::SharedPtr answer = zeus::Buffer::create(); + answer->setTransactionId(_transactionId); + answer->setClientId(_clientId); + answer->setPartId(_partId); + answer->setPartFinish(false); + answer->setType(zeus::Buffer::typeMessage::data); + int32_t tmpSize = ZEUS_MINIMUM_SIZE_MULTIPLE; + if (m_size < ZEUS_MINIMUM_SIZE_MULTIPLE) { + tmpSize = m_size; + } + uint8_t tmpData[ZEUS_MINIMUM_SIZE_MULTIPLE]; + m_node.fileRead(tmpData, 1, tmpSize); + answer->addData(m_parameterId, tmpData, tmpSize); + m_size -= tmpSize; + _interface->writeBinary(answer);; + if (m_size <= 0) { + m_node.fileClose(); + return true; + } + return false; + } + }; +} + +template<> +void zeus::Buffer::internalAddParameter(uint16_t _paramId, const zeus::FileServer& _value) { + etk::FSNode node(_value.getFileName()); + node.fileOpenRead(); + std::string extention = std::string(_value.getFileName().begin()+_value.getFileName().size() -3, _value.getFileName().end()); + ZEUS_WARNING("send file: '" << _value.getFileName() << "' with extention: '" << extention << "'"); + uint64_t size = node.fileSize(); + std::vector fileData; + if (size < ZEUS_MINIMUM_SIZE_MULTIPLE) { + // if the file is small ==> send directly ... + fileData.resize(size); + node.fileRead(&fileData[0], 1, size); + } + zeus::File tmpFile(zeus::getMineType(extention), fileData, size); + internalAddParameter(_paramId, tmpFile); + node.fileClose(); + if (size < ZEUS_MINIMUM_SIZE_MULTIPLE) { + //node.fileClose(); + } else { + ZEUS_WARNING("multiple send the file: " << _value.getFileName() << " with size " << size); + // multiple send ... (no data in the first frame ... + // TODO : m_multipleSend.push_back(SendFile(std::move(node), _paramId, size)); + m_multipleSend.push_back(zeus::SendFile(_value.getFileName(), _paramId, size)); + } +} diff --git a/zeus/Buffer_getParameter.cpp b/zeus/Buffer_getParameter.cpp new file mode 100644 index 0000000..3377a58 --- /dev/null +++ b/zeus/Buffer_getParameter.cpp @@ -0,0 +1,1466 @@ +/** @file + * @author Edouard DUPIN + * @copyright 2016, Edouard DUPIN, all right reserved + * @license APACHE v2.0 (see license file) + */ +#include +#include +#include +#include +#include +#include +#include + +template<> +bool zeus::Buffer::internalGetParameter(int32_t _id) const { + zeus::ParamType type = internalGetParameterType(_id); + const uint8_t* pointer = internalGetParameterPointer(_id); + uint32_t dataSize = internalGetParameterSize(_id); + if (createType() != type) { + return 0; + } + const char* pointer2 = reinterpret_cast(pointer); + if ( *pointer2 == 'T' + || *pointer2 == '1' + || *pointer2 == 1) { + return true; + } + return false; +} + +template<> +std::string zeus::Buffer::internalGetParameter(int32_t _id) const { + std::string out; + zeus::ParamType type = internalGetParameterType(_id); + const uint8_t* pointer = internalGetParameterPointer(_id); + uint32_t dataSize = internalGetParameterSize(_id); + out.resize(dataSize, 0); + memcpy(&out[0], pointer, out.size()); + return out; +} + + +template<> +uint8_t zeus::Buffer::internalGetParameter(int32_t _id) const { + zeus::ParamType type = internalGetParameterType(_id); + const uint8_t* pointer = internalGetParameterPointer(_id); + uint32_t dataSize = internalGetParameterSize(_id); + // TODO : Check size ... + if (createType() == type) { + const uint8_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const uint16_t* tmp = reinterpret_cast(pointer); + return std::min(*tmp, uint16_t(UCHAR_MAX)); + } else if (createType() == type) { + const uint32_t* tmp = reinterpret_cast(pointer); + return std::min(*tmp, uint32_t(UCHAR_MAX)); + } else if (createType() == type) { + const uint64_t* tmp = reinterpret_cast(pointer); + return std::min(*tmp, uint64_t(UCHAR_MAX)); + } else if (createType() == type) { + const int8_t* tmp = reinterpret_cast(pointer); + return std::max(int8_t(0), *tmp); + } else if (createType() == type) { + const int16_t* tmp = reinterpret_cast(pointer); + return etk::avg(int16_t(0), *tmp, int16_t(UCHAR_MAX)); + } else if (createType() == type) { + const int32_t* tmp = reinterpret_cast(pointer); + return etk::avg(int32_t(0), *tmp, int32_t(UCHAR_MAX)); + } else if (createType() == type) { + const int64_t* tmp = reinterpret_cast(pointer); + return etk::avg(int64_t(0), *tmp, int64_t(UCHAR_MAX)); + } else if (createType() == type) { + const float* tmp = reinterpret_cast(pointer); + return uint8_t(etk::avg(float(0), *tmp, float(UCHAR_MAX))); + } else if (createType() == type) { + const double* tmp = reinterpret_cast(pointer); + return uint8_t(etk::avg(double(0), *tmp, double(UCHAR_MAX))); + } + ZEUS_ERROR("Can not get type from '" << type << "'"); + return 0; +} +template<> +uint16_t zeus::Buffer::internalGetParameter(int32_t _id) const { + zeus::ParamType type = internalGetParameterType(_id); + const uint8_t* pointer = internalGetParameterPointer(_id); + uint32_t dataSize = internalGetParameterSize(_id); + // TODO : Check size ... + if (createType() == type) { + const uint8_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const uint16_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const uint32_t* tmp = reinterpret_cast(pointer); + return std::min(*tmp, uint32_t(USHRT_MAX)); + } else if (createType() == type) { + const uint64_t* tmp = reinterpret_cast(pointer); + return std::min(*tmp, uint64_t(USHRT_MAX)); + } else if (createType() == type) { + const int8_t* tmp = reinterpret_cast(pointer); + return std::max(int8_t(0), *tmp); + } else if (createType() == type) { + const int16_t* tmp = reinterpret_cast(pointer); + return std::max(int16_t(0), *tmp); + } else if (createType() == type) { + const int32_t* tmp = reinterpret_cast(pointer); + return etk::avg(int32_t(0), *tmp, int32_t(USHRT_MAX)); + } else if (createType() == type) { + const int64_t* tmp = reinterpret_cast(pointer); + return etk::avg(int64_t(0), *tmp, int64_t(USHRT_MAX)); + } else if (createType() == type) { + const float* tmp = reinterpret_cast(pointer); + return uint16_t(etk::avg(float(0), *tmp, float(USHRT_MAX))); + } else if (createType() == type) { + const double* tmp = reinterpret_cast(pointer); + return uint16_t(etk::avg(double(0), *tmp, double(USHRT_MAX))); + } + ZEUS_ERROR("Can not get type from '" << type << "'"); + return 0; +} + +template<> +uint32_t zeus::Buffer::internalGetParameter(int32_t _id) const { + zeus::ParamType type = internalGetParameterType(_id); + const uint8_t* pointer = internalGetParameterPointer(_id); + uint32_t dataSize = internalGetParameterSize(_id); + // TODO : Check size ... + if (createType() == type) { + const uint8_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const uint16_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const uint32_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const uint64_t* tmp = reinterpret_cast(pointer); + return std::min(*tmp, uint64_t(ULONG_MAX)); + } else if (createType() == type) { + const int8_t* tmp = reinterpret_cast(pointer); + return std::max(int8_t(0), *tmp); + } else if (createType() == type) { + const int16_t* tmp = reinterpret_cast(pointer); + return std::max(int16_t(0), *tmp); + } else if (createType() == type) { + const int32_t* tmp = reinterpret_cast(pointer); + return std::max(int32_t(0), *tmp); + } else if (createType() == type) { + const int64_t* tmp = reinterpret_cast(pointer); + return etk::avg(int64_t(0), *tmp, int64_t(ULONG_MAX)); + } else if (createType() == type) { + const float* tmp = reinterpret_cast(pointer); + return uint32_t(etk::avg(float(0), *tmp, float(ULONG_MAX))); + } else if (createType() == type) { + const double* tmp = reinterpret_cast(pointer); + return uint32_t(etk::avg(double(0), *tmp, double(ULONG_MAX))); + } + ZEUS_ERROR("Can not get type from '" << type << "'"); + return 0; +} + +template<> +uint64_t zeus::Buffer::internalGetParameter(int32_t _id) const { + zeus::ParamType type = internalGetParameterType(_id); + const uint8_t* pointer = internalGetParameterPointer(_id); + uint32_t dataSize = internalGetParameterSize(_id); + // TODO : Check size ... + if (createType() == type) { + const uint8_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const uint16_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const uint32_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const uint64_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const int8_t* tmp = reinterpret_cast(pointer); + return std::max(int8_t(0), *tmp); + } else if (createType() == type) { + const int16_t* tmp = reinterpret_cast(pointer); + return std::max(int16_t(0), *tmp); + } else if (createType() == type) { + const int32_t* tmp = reinterpret_cast(pointer); + return std::max(int32_t(0), *tmp); + } else if (createType() == type) { + const int64_t* tmp = reinterpret_cast(pointer); + return std::max(int64_t(0), *tmp); + } else if (createType() == type) { + const float* tmp = reinterpret_cast(pointer); + return uint64_t(etk::avg(float(0), *tmp, float(ULONG_MAX))); + } else if (createType() == type) { + const double* tmp = reinterpret_cast(pointer); + return uint64_t(etk::avg(double(0), *tmp, double(ULONG_MAX))); + } + ZEUS_ERROR("Can not get type from '" << type << "'"); + return 0; +} + +template<> +int8_t zeus::Buffer::internalGetParameter(int32_t _id) const { + zeus::ParamType type = internalGetParameterType(_id); + const uint8_t* pointer = internalGetParameterPointer(_id); + uint32_t dataSize = internalGetParameterSize(_id); + // TODO : Check size ... + if (createType() == type) { + const uint8_t* tmp = reinterpret_cast(pointer); + return std::min(*tmp, uint8_t(SCHAR_MAX)); + } else if (createType() == type) { + const uint16_t* tmp = reinterpret_cast(pointer); + return std::min(*tmp, uint16_t(SCHAR_MAX)); + } else if (createType() == type) { + const uint32_t* tmp = reinterpret_cast(pointer); + return std::min(*tmp, uint32_t(SCHAR_MAX)); + } else if (createType() == type) { + const uint64_t* tmp = reinterpret_cast(pointer); + return std::min(*tmp, uint64_t(SCHAR_MAX)); + } else if (createType() == type) { + const int8_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const int16_t* tmp = reinterpret_cast(pointer); + return etk::avg(int16_t(SCHAR_MIN), *tmp, int16_t(SCHAR_MAX)); + } else if (createType() == type) { + const int32_t* tmp = reinterpret_cast(pointer); + return etk::avg(int32_t(SCHAR_MIN), *tmp, int32_t(SCHAR_MAX)); + } else if (createType() == type) { + const int64_t* tmp = reinterpret_cast(pointer); + return etk::avg(int64_t(SCHAR_MIN), *tmp, int64_t(SCHAR_MAX)); + } else if (createType() == type) { + const float* tmp = reinterpret_cast(pointer); + return int8_t(etk::avg(float(SCHAR_MIN), *tmp, float(SCHAR_MAX))); + } else if (createType() == type) { + const double* tmp = reinterpret_cast(pointer); + return int8_t(etk::avg(double(SCHAR_MIN), *tmp, double(SCHAR_MAX))); + } + ZEUS_ERROR("Can not get type from '" << type << "'"); + return 0; +} + +template<> +int16_t zeus::Buffer::internalGetParameter(int32_t _id) const { + zeus::ParamType type = internalGetParameterType(_id); + const uint8_t* pointer = internalGetParameterPointer(_id); + uint32_t dataSize = internalGetParameterSize(_id); + // TODO : Check size ... + if (createType() == type) { + const uint8_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const uint16_t* tmp = reinterpret_cast(pointer); + return std::min(*tmp, uint16_t(SHRT_MAX)); + } else if (createType() == type) { + const uint32_t* tmp = reinterpret_cast(pointer); + return std::min(*tmp, uint32_t(SHRT_MAX)); + } else if (createType() == type) { + const uint64_t* tmp = reinterpret_cast(pointer); + return std::min(*tmp, uint64_t(SHRT_MAX)); + } else if (createType() == type) { + const int8_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const int16_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const int32_t* tmp = reinterpret_cast(pointer); + return etk::avg(int32_t(SHRT_MIN), *tmp, int32_t(SHRT_MAX)); + } else if (createType() == type) { + const int64_t* tmp = reinterpret_cast(pointer); + return etk::avg(int64_t(SHRT_MIN), *tmp, int64_t(SHRT_MAX)); + } else if (createType() == type) { + const float* tmp = reinterpret_cast(pointer); + return int16_t(etk::avg(float(SHRT_MIN), *tmp, float(SHRT_MAX))); + } else if (createType() == type) { + const double* tmp = reinterpret_cast(pointer); + return int16_t(etk::avg(double(SHRT_MIN), *tmp, double(SHRT_MAX))); + } + ZEUS_ERROR("Can not get type from '" << type << "'"); + return 0; +} + +template<> +int32_t zeus::Buffer::internalGetParameter(int32_t _id) const { + zeus::ParamType type = internalGetParameterType(_id); + const uint8_t* pointer = internalGetParameterPointer(_id); + uint32_t dataSize = internalGetParameterSize(_id); + // TODO : Check size ... + if (createType() == type) { + const uint8_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const uint16_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const uint32_t* tmp = reinterpret_cast(pointer); + return std::min(*tmp, uint32_t(LONG_MAX)); + } else if (createType() == type) { + const uint64_t* tmp = reinterpret_cast(pointer); + return std::min(*tmp, uint64_t(LONG_MAX)); + } else if (createType() == type) { + const int8_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const int16_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const int32_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const int64_t* tmp = reinterpret_cast(pointer); + return etk::avg(int64_t(LONG_MIN), *tmp, int64_t(LONG_MAX)); + } else if (createType() == type) { + const float* tmp = reinterpret_cast(pointer); + return int32_t(etk::avg(float(LONG_MIN), *tmp, float(LONG_MAX))); + } else if (createType() == type) { + const double* tmp = reinterpret_cast(pointer); + return int32_t(etk::avg(double(LONG_MIN), *tmp, double(LONG_MAX))); + } + ZEUS_ERROR("Can not get type from '" << type << "'"); + return 0; +} + +template<> +int64_t zeus::Buffer::internalGetParameter(int32_t _id) const { + zeus::ParamType type = internalGetParameterType(_id); + const uint8_t* pointer = internalGetParameterPointer(_id); + uint32_t dataSize = internalGetParameterSize(_id); + // TODO : Check size ... + if (createType() == type) { + const uint8_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const uint16_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const uint32_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const uint64_t* tmp = reinterpret_cast(pointer); + return std::min(*tmp, uint64_t(LLONG_MAX)); + } else if (createType() == type) { + const int8_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const int16_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const int32_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const int64_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const float* tmp = reinterpret_cast(pointer); + return int64_t(etk::avg(float(LLONG_MIN), *tmp, float(LLONG_MAX))); + } else if (createType() == type) { + const double* tmp = reinterpret_cast(pointer); + return int64_t(etk::avg(double(LLONG_MIN), *tmp, double(LLONG_MAX))); + } + ZEUS_ERROR("Can not get type from '" << type << "'"); + return 0; +} + +template<> +float zeus::Buffer::internalGetParameter(int32_t _id) const { + zeus::ParamType type = internalGetParameterType(_id); + const uint8_t* pointer = internalGetParameterPointer(_id); + uint32_t dataSize = internalGetParameterSize(_id); + // TODO : Check size ... + if (createType() == type) { + const uint8_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const uint16_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const uint32_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const uint64_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const int8_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const int16_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const int32_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const int64_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const float* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const double* tmp = reinterpret_cast(pointer); + return *tmp; + } + ZEUS_ERROR("Can not get type from '" << type << "'"); + return 0.0f; +} +template<> +double zeus::Buffer::internalGetParameter(int32_t _id) const { + zeus::ParamType type = internalGetParameterType(_id); + const uint8_t* pointer = internalGetParameterPointer(_id); + uint32_t dataSize = internalGetParameterSize(_id); + // TODO : Check size ... + if (createType() == type) { + const uint8_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const uint16_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const uint32_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const uint64_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const int8_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const int16_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const int32_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const int64_t* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const float* tmp = reinterpret_cast(pointer); + return *tmp; + } else if (createType() == type) { + const double* tmp = reinterpret_cast(pointer); + return *tmp; + } + ZEUS_ERROR("Can not get type from '" << type << "'"); + return 0.0; +} + + + + + + + + + + + + + + + + + + + + + + + + +template<> +std::vector zeus::Buffer::internalGetParameter>(int32_t _id) const { + std::vector out; + zeus::ParamType type = internalGetParameterType(_id); + const uint8_t* pointer = internalGetParameterPointer(_id); + uint32_t dataSize = internalGetParameterSize(_id); + // TODO : Check size ... + if (type == createType>()) { + return out; + } else if (createType>() == type) { + int32_t nbElement = dataSize / sizeof(uint8_t); + out.resize(nbElement); + memcpy(&out, pointer, nbElement * sizeof(uint8_t)); + return out; + } else if (createType>() == type) { + const uint16_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint16_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const uint32_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint32_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const uint64_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint64_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const int8_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int8_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const int16_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int16_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const int32_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int32_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const int64_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int64_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const float* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(float); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const double* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(double); + out.resize(nbElement); + for (size_t iii=0; iii +std::vector zeus::Buffer::internalGetParameter>(int32_t _id) const { + std::vector out; + zeus::ParamType type = internalGetParameterType(_id); + const uint8_t* pointer = internalGetParameterPointer(_id); + uint32_t dataSize = internalGetParameterSize(_id); + // TODO : Check size ... + if (type == createType>()) { + return out; + } else if (createType>() == type) { + const uint8_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint8_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + int32_t nbElement = dataSize / sizeof(uint16_t); + out.resize(nbElement); + memcpy(&out, pointer, nbElement * sizeof(uint16_t)); + return out; + } else if (createType>() == type) { + const uint32_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint32_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const uint64_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint64_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const int8_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int8_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const int16_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int16_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const int32_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int32_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const int64_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int64_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const float* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(float); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const double* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(double); + out.resize(nbElement); + for (size_t iii=0; iii +std::vector zeus::Buffer::internalGetParameter>(int32_t _id) const { + std::vector out; + zeus::ParamType type = internalGetParameterType(_id); + const uint8_t* pointer = internalGetParameterPointer(_id); + uint32_t dataSize = internalGetParameterSize(_id); + // TODO : Check size ... + if (type == createType>()) { + return out; + } else if (createType>() == type) { + const uint8_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint8_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const uint16_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint16_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + int32_t nbElement = dataSize / sizeof(uint32_t); + out.resize(nbElement); + memcpy(&out, pointer, nbElement * sizeof(uint32_t)); + return out; + } else if (createType>() == type) { + const uint64_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint64_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const int8_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int8_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const int16_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int16_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const int32_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int32_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const int64_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int64_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const float* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(float); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const double* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(double); + out.resize(nbElement); + for (size_t iii=0; iii +std::vector zeus::Buffer::internalGetParameter>(int32_t _id) const { + std::vector out; + zeus::ParamType type = internalGetParameterType(_id); + const uint8_t* pointer = internalGetParameterPointer(_id); + uint32_t dataSize = internalGetParameterSize(_id); + // TODO : Check size ... + if (type == createType>()) { + return out; + } else if (createType>() == type) { + const uint8_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint8_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const uint16_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint16_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const uint32_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint32_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + int32_t nbElement = dataSize / sizeof(uint64_t); + out.resize(nbElement); + memcpy(&out, pointer, nbElement * sizeof(uint64_t)); + return out; + } else if (createType>() == type) { + const int8_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int8_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const int16_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int16_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const int32_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int32_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const int64_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int64_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const float* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(float); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const double* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(double); + out.resize(nbElement); + for (size_t iii=0; iii +std::vector zeus::Buffer::internalGetParameter>(int32_t _id) const { + std::vector out; + zeus::ParamType type = internalGetParameterType(_id); + const uint8_t* pointer = internalGetParameterPointer(_id); + uint32_t dataSize = internalGetParameterSize(_id); + // TODO : Check size ... + if (type == createType>()) { + return out; + } else if (createType>() == type) { + const uint8_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint8_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const uint16_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint16_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const uint32_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint32_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const uint64_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint64_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + int32_t nbElement = dataSize / sizeof(int8_t); + out.resize(nbElement); + memcpy(&out, pointer, nbElement * sizeof(int8_t)); + return out; + } else if (createType>() == type) { + const int16_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int16_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const int32_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int32_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const int64_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int64_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const float* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(float); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const double* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(double); + out.resize(nbElement); + for (size_t iii=0; iii +std::vector zeus::Buffer::internalGetParameter>(int32_t _id) const { + std::vector out; + zeus::ParamType type = internalGetParameterType(_id); + const uint8_t* pointer = internalGetParameterPointer(_id); + uint32_t dataSize = internalGetParameterSize(_id); + // TODO : Check size ... + if (type == createType>()) { + return out; + } else if (createType>() == type) { + const uint8_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint8_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const uint16_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint16_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const uint32_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint32_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const uint64_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint64_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const int8_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int8_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + int32_t nbElement = dataSize / sizeof(int16_t); + out.resize(nbElement); + memcpy(&out, pointer, nbElement * sizeof(int16_t)); + return out; + } else if (createType>() == type) { + const int32_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int32_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const int64_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int64_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const float* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(float); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const double* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(double); + out.resize(nbElement); + for (size_t iii=0; iii +std::vector zeus::Buffer::internalGetParameter>(int32_t _id) const { + std::vector out; + zeus::ParamType type = internalGetParameterType(_id); + const uint8_t* pointer = internalGetParameterPointer(_id); + uint32_t dataSize = internalGetParameterSize(_id); + // TODO : Check size ... + if (type == createType>()) { + return out; + } else if (createType>() == type) { + const uint8_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint8_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const uint16_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint16_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const uint32_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint32_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const uint64_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint64_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const int8_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int8_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const int16_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int16_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + int32_t nbElement = dataSize / sizeof(int32_t); + out.resize(nbElement); + memcpy(&out, pointer, nbElement * sizeof(int32_t)); + return out; + } else if (createType>() == type) { + const int64_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int64_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const float* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(float); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const double* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(double); + out.resize(nbElement); + for (size_t iii=0; iii +std::vector zeus::Buffer::internalGetParameter>(int32_t _id) const { + std::vector out; + zeus::ParamType type = internalGetParameterType(_id); + const uint8_t* pointer = internalGetParameterPointer(_id); + uint32_t dataSize = internalGetParameterSize(_id); + // TODO : Check size ... + if (type == createType>()) { + return out; + } else if (createType>() == type) { + const uint8_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint8_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const uint16_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint16_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const uint32_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint32_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const uint64_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint64_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const int8_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int8_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const int16_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int16_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const int32_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int32_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + int32_t nbElement = dataSize / sizeof(int64_t); + out.resize(nbElement); + memcpy(&out, pointer, nbElement * sizeof(int64_t)); + return out; + } else if (createType>() == type) { + const float* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(float); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const double* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(double); + out.resize(nbElement); + for (size_t iii=0; iii +std::vector zeus::Buffer::internalGetParameter>(int32_t _id) const { + std::vector out; + zeus::ParamType type = internalGetParameterType(_id); + const uint8_t* pointer = internalGetParameterPointer(_id); + uint32_t dataSize = internalGetParameterSize(_id); + // TODO : Check size ... + if (type == createType>()) { + return out; + } else if (createType>() == type) { + const uint8_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint8_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const uint16_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint16_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const uint32_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint32_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const uint64_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint64_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const int8_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int8_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const int16_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int16_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const int32_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int32_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const int64_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int64_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + int32_t nbElement = dataSize / sizeof(float); + out.resize(nbElement); + memcpy(&out, pointer, nbElement * sizeof(float)); + return out; + } else if (createType>() == type) { + const double* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(double); + out.resize(nbElement); + for (size_t iii=0; iii +std::vector zeus::Buffer::internalGetParameter>(int32_t _id) const { + std::vector out; + zeus::ParamType type = internalGetParameterType(_id); + const uint8_t* pointer = internalGetParameterPointer(_id); + uint32_t dataSize = internalGetParameterSize(_id); + // TODO : Check size ... + if (type == createType>()) { + return out; + } else if (createType>() == type) { + const uint8_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint8_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const uint16_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint16_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const uint32_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint32_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const uint64_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint64_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const int8_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int8_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const int16_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int16_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const int32_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int32_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const int64_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(int64_t); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + const float* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(float); + out.resize(nbElement); + for (size_t iii=0; iii>() == type) { + int32_t nbElement = dataSize / sizeof(double); + out.resize(nbElement); + memcpy(&out, pointer, nbElement * sizeof(double)); + return out; + } + ZEUS_ERROR("Can not get type from '" << type << "'"); + return out; +} + +template<> +std::vector zeus::Buffer::internalGetParameter>(int32_t _id) const { + std::vector out; + zeus::ParamType type = internalGetParameterType(_id); + const uint8_t* pointer = internalGetParameterPointer(_id); + uint32_t dataSize = internalGetParameterSize(_id); + // TODO : Check size ... + if (type == createType>()) { + return out; + } else if (createType>() == type) { + const uint8_t* tmp = reinterpret_cast(pointer); + int32_t nbElement = dataSize / sizeof(uint8_t); + out.resize(nbElement); + for (size_t iii=0; iii +std::vector zeus::Buffer::internalGetParameter>(int32_t _id) const { + std::vector out; + zeus::ParamType type = internalGetParameterType(_id); + const uint8_t* pointer = internalGetParameterPointer(_id); + uint32_t dataSize = internalGetParameterSize(_id); + if (type == createType>()) { + return out; + } else if (createType>() == type) { + // first element is the number of elements: + const uint16_t* tmp = reinterpret_cast(pointer); + out.resize(*tmp); + pointer += sizeof(uint16_t); + //each string is separated with a \0: + for (int32_t iii=0; iii(pointer); + out[iii] = tmp2; + pointer += out[iii].size() + 1; + } + return out; + } + ZEUS_ERROR("Can not get type from '" << type << "'"); + return out; +} + +template<> +zeus::File zeus::Buffer::internalGetParameter(int32_t _id) const { + zeus::File out; + zeus::ParamType type = internalGetParameterType(_id); + const uint8_t* pointer = internalGetParameterPointer(_id); + uint32_t dataSize = internalGetParameterSize(_id); + // TODO : Check size ... + if (createType() == type) { + // get mine type in string: + std::string mineType; + int32_t currentOffset = 0; + while ( char(pointer[currentOffset]) != '\0' + && currentOffset= dataSize) { + ZEUS_ERROR("Parameter size is wrong ..."); + return out; + } + // get size if the file in int32_t + int32_t size = 0; + memcpy(&size, &pointer[currentOffset], sizeof(int32_t)); + currentOffset += sizeof(int32_t); + out.preSetDataSize(dataSize); + // Get the datas: + out.setData(0, &pointer[currentOffset], dataSize); + return out; + } + ZEUS_ERROR("Can not get type from '" << type << "'"); + return out; +} + + diff --git a/zeus/Client.cpp b/zeus/Client.cpp index bb275a9..bf09b53 100644 --- a/zeus/Client.cpp +++ b/zeus/Client.cpp @@ -20,8 +20,11 @@ zeus::Client::~Client() { } -void zeus::Client::onClientData(zeus::Buffer& _value) { - ZEUS_ERROR("Get Data On the Communication interface that is not understand ... : " << _value.generateHumanString()); +void zeus::Client::onClientData(const ememory::SharedPtr& _value) { + if (_value == nullptr) { + return; + } + ZEUS_ERROR("Get Data On the Communication interface that is not understand ... : " << _value->generateHumanString()); } zeus::ServiceRemote zeus::Client::getService(const std::string& _name) { diff --git a/zeus/Client.h b/zeus/Client.h index e874dd2..13defd4 100644 --- a/zeus/Client.h +++ b/zeus/Client.h @@ -53,13 +53,13 @@ namespace zeus { // Connect to ourself: //client1.authentificate("coucou"); private: - void onClientData(zeus::Buffer& _value); + void onClientData(const ememory::SharedPtr& _value); public: template zeus::FutureBase call(const std::string& _functionName, _ARGS&&... _args) { if (m_interfaceClient == nullptr) { - zeus::Buffer ret; - ret.addError("NULLPTR", "call " + _functionName + " with no interface open"); + ememory::SharedPtr ret = zeus::Buffer::create(); + ret->addError("NULLPTR", "call " + _functionName + " with no interface open"); return zeus::FutureBase(0, true, ret); } return m_interfaceClient->call(_functionName, _args...); @@ -67,8 +67,8 @@ namespace zeus { template zeus::FutureBase callAction(const std::string& _functionName, _ARGS&&... _args, zeus::FutureData::ObserverFinish _callback) { if (m_interfaceClient == nullptr) { - zeus::Buffer ret; - ret.addError("NULLPTR", "call " + _functionName + " with no interface open"); + ememory::SharedPtr ret = zeus::Buffer::create(); + ret->addError("NULLPTR", "call " + _functionName + " with no interface open"); return zeus::FutureBase(0, true, ret, _callback); } return m_interfaceClient->callAction(_functionName, _args..., _callback); diff --git a/zeus/File.cpp b/zeus/File.cpp index 454d2e2..f17e521 100644 --- a/zeus/File.cpp +++ b/zeus/File.cpp @@ -9,6 +9,7 @@ #include #include #include +#include @@ -38,14 +39,22 @@ zeus::File::File(const std::string& _mineType, std::vector _data, int32 } void zeus::File::setData(uint64_t _offset, const std::vector& _data) { - // TODO : Check size/offset before set - memcpy(&m_data[_offset], &_data[0], _data.size()); + setData(_offset, &_data[0], _data.size()); +} + +void zeus::File::setData(uint64_t _offset, const uint8_t* _data, uint32_t _size) { + if (_size+_offset >= m_data.size()) { + ZEUS_ERROR("Need Resize file buffer ..."); + m_data.resize(_size+_offset); + } + memcpy(&m_data[_offset], _data, _size); } zeus::FileServer::FileServer() { } + zeus::FileServer::FileServer(const std::string& _filename) : m_name(_filename) { diff --git a/zeus/File.h b/zeus/File.h index 979ace8..a99937f 100644 --- a/zeus/File.h +++ b/zeus/File.h @@ -16,6 +16,9 @@ namespace zeus { File(); File(const std::string& _filename); File(const std::string& _mineType, std::vector _data, int32_t _fileSize = -1); + int32_t getTheoricFileSize() const { + return m_fileSize; + } void storeIn(const std::string& _filename) const; const std::string& getMineType() const { return m_mineType; @@ -30,6 +33,7 @@ namespace zeus { return m_data; } void setData(uint64_t _offset, const std::vector& _data); + void setData(uint64_t _offset, const uint8_t* _data, uint32_t _size); }; class FileServer { private: @@ -37,7 +41,7 @@ namespace zeus { public: FileServer(); FileServer(const std::string& _filename); - const std::string& getFileName() { + const std::string& getFileName() const { return m_name; } }; diff --git a/zeus/Future.cpp b/zeus/Future.cpp index 5787bf4..8555279 100644 --- a/zeus/Future.cpp +++ b/zeus/Future.cpp @@ -11,326 +11,328 @@ namespace zeus { template<> bool zeus::Future::get() { - if (m_data == nullptr) { + if ( m_data == nullptr + || m_data->m_returnData == nullptr) { return false; } - if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) { + if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) { ZEUS_WARNING("No Return value ..."); return false; } - return m_data->m_returnData.getAnswer(); + return m_data->m_returnData->getAnswer(); } template<> int64_t zeus::Future::get() { - if (m_data == nullptr) { + if ( m_data == nullptr + || m_data->m_returnData == nullptr) { return 0; } - if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) { + if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) { ZEUS_WARNING("No Return value ..."); return 0; } - return m_data->m_returnData.getAnswer(); + return m_data->m_returnData->getAnswer(); } template<> int32_t zeus::Future::get() { - if (m_data == nullptr) { + if ( m_data == nullptr + || m_data->m_returnData == nullptr) { return 0; } - if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) { + if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) { ZEUS_WARNING("No Return value ..."); return 0; } - return m_data->m_returnData.getAnswer(); + return m_data->m_returnData->getAnswer(); } template<> int16_t zeus::Future::get() { - if (m_data == nullptr) { + if ( m_data == nullptr + || m_data->m_returnData == nullptr) { return 0; } - if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) { + if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) { ZEUS_WARNING("No Return value ..."); return 0; } - return m_data->m_returnData.getAnswer(); + return m_data->m_returnData->getAnswer(); } template<> int8_t zeus::Future::get() { - if (m_data == nullptr) { + if ( m_data == nullptr + || m_data->m_returnData == nullptr) { return 0; } - if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) { + if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) { ZEUS_WARNING("No Return value ..."); return 0; } - return m_data->m_returnData.getAnswer(); + return m_data->m_returnData->getAnswer(); } template<> uint64_t zeus::Future::get() { - if (m_data == nullptr) { + if ( m_data == nullptr + || m_data->m_returnData == nullptr) { return 0; } - if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) { + if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) { ZEUS_WARNING("No Return value ..."); return 0; } - return m_data->m_returnData.getAnswer(); + return m_data->m_returnData->getAnswer(); } template<> uint32_t zeus::Future::get() { - if (m_data == nullptr) { + if ( m_data == nullptr + || m_data->m_returnData == nullptr) { return 0; } - if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) { + if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) { ZEUS_WARNING("No Return value ..."); return 0; } - return m_data->m_returnData.getAnswer(); + return m_data->m_returnData->getAnswer(); } template<> uint16_t zeus::Future::get() { - if (m_data == nullptr) { + if ( m_data == nullptr + || m_data->m_returnData == nullptr) { return 0; } - if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) { + if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) { ZEUS_WARNING("No Return value ..."); return 0; } - return m_data->m_returnData.getAnswer(); + return m_data->m_returnData->getAnswer(); } template<> uint8_t zeus::Future::get() { - if (m_data == nullptr) { + if ( m_data == nullptr + || m_data->m_returnData == nullptr) { return 0; } - if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) { + if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) { ZEUS_WARNING("No Return value ..."); return 0; } - return m_data->m_returnData.getAnswer(); + return m_data->m_returnData->getAnswer(); } template<> double zeus::Future::get() { - if (m_data == nullptr) { + if ( m_data == nullptr + || m_data->m_returnData == nullptr) { return 0; } - if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) { + if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) { ZEUS_WARNING("No Return value ..."); return 0.0; } - return m_data->m_returnData.getAnswer(); + return m_data->m_returnData->getAnswer(); } template<> float zeus::Future::get() { - if (m_data == nullptr) { + if ( m_data == nullptr + || m_data->m_returnData == nullptr) { return 0.0f; } - if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) { + if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) { ZEUS_WARNING("No Return value ..."); return 0.0f; } - return m_data->m_returnData.getAnswer(); + return m_data->m_returnData->getAnswer(); } template<> std::string zeus::Future::get() { - if (m_data == nullptr) { + if ( m_data == nullptr + || m_data->m_returnData == nullptr) { return ""; } - if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) { + if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) { ZEUS_WARNING("No Return value ..."); return ""; } - return m_data->m_returnData.getAnswer(); + return m_data->m_returnData->getAnswer(); } template<> std::vector zeus::Future>::get() { std::vector out; - if (m_data == nullptr) { + if ( m_data == nullptr + || m_data->m_returnData == nullptr) { return out; } - if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) { + if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) { ZEUS_WARNING("No Return value ..."); return out; } - out = m_data->m_returnData.getAnswer>(); + out = m_data->m_returnData->getAnswer>(); return out; } template<> std::vector zeus::Future>::get() { std::vector out; - if (m_data == nullptr) { + if ( m_data == nullptr + || m_data->m_returnData == nullptr) { return out; } - if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) { + if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) { ZEUS_WARNING("No Return value ..."); return out; } - out = m_data->m_returnData.getAnswer>(); + out = m_data->m_returnData->getAnswer>(); return out; } template<> std::vector zeus::Future>::get() { std::vector out; - if (m_data == nullptr) { + if ( m_data == nullptr + || m_data->m_returnData == nullptr) { return out; } - if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) { + if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) { ZEUS_WARNING("No Return value ..."); return out; } - out = m_data->m_returnData.getAnswer>(); + out = m_data->m_returnData->getAnswer>(); return out; } template<> std::vector zeus::Future>::get() { std::vector out; - if (m_data == nullptr) { + if ( m_data == nullptr + || m_data->m_returnData == nullptr) { return out; } - if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) { + if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) { ZEUS_WARNING("No Return value ..."); return out; } - out = m_data->m_returnData.getAnswer>(); + out = m_data->m_returnData->getAnswer>(); return out; } template<> std::vector zeus::Future>::get() { std::vector out; - if (m_data == nullptr) { + if ( m_data == nullptr + || m_data->m_returnData == nullptr) { return out; } - if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) { + if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) { ZEUS_WARNING("No Return value ..."); return out; } - out = m_data->m_returnData.getAnswer>(); + out = m_data->m_returnData->getAnswer>(); return out; } template<> std::vector zeus::Future>::get() { std::vector out; - if (m_data == nullptr) { + if ( m_data == nullptr + || m_data->m_returnData == nullptr) { return out; } - if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) { + if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) { ZEUS_WARNING("No Return value ..."); return out; } - out = m_data->m_returnData.getAnswer>(); + out = m_data->m_returnData->getAnswer>(); return out; } template<> std::vector zeus::Future>::get() { std::vector out; - if (m_data == nullptr) { + if ( m_data == nullptr + || m_data->m_returnData == nullptr) { return out; } - if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) { + if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) { ZEUS_WARNING("No Return value ..."); return out; } - out = m_data->m_returnData.getAnswer>(); + out = m_data->m_returnData->getAnswer>(); return out; } template<> std::vector zeus::Future>::get() { std::vector out; - if (m_data == nullptr) { + if ( m_data == nullptr + || m_data->m_returnData == nullptr) { return out; } - if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) { + if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) { ZEUS_WARNING("No Return value ..."); return out; } - out = m_data->m_returnData.getAnswer>(); + out = m_data->m_returnData->getAnswer>(); return out; } template<> std::vector zeus::Future>::get() { std::vector out; - if (m_data == nullptr) { + if ( m_data == nullptr + || m_data->m_returnData == nullptr) { return out; } - if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) { + if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) { ZEUS_WARNING("No Return value ..."); return out; } - out = m_data->m_returnData.getAnswer>(); + out = m_data->m_returnData->getAnswer>(); return out; } template<> std::vector zeus::Future>::get() { std::vector out; - if (m_data == nullptr) { + if ( m_data == nullptr + || m_data->m_returnData == nullptr) { return out; } - if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) { + if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) { ZEUS_WARNING("No Return value ..."); return out; } - out = m_data->m_returnData.getAnswer>(); + out = m_data->m_returnData->getAnswer>(); return out; } template<> std::vector zeus::Future>::get() { std::vector out; - if (m_data == nullptr) { + if ( m_data == nullptr + || m_data->m_returnData == nullptr) { return out; } - if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) { + if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) { ZEUS_WARNING("No Return value ..."); return out; } - out = m_data->m_returnData.getAnswer>(); + out = m_data->m_returnData->getAnswer>(); return out; } template<> std::vector zeus::Future>::get() { std::vector out; - if (m_data == nullptr) { + if ( m_data == nullptr + || m_data->m_returnData == nullptr) { return out; } - if (m_data->m_returnData.getType() != zeus::Buffer::typeMessage::answer) { + if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) { ZEUS_WARNING("No Return value ..."); return out; } - out = m_data->m_returnData.getAnswer>(); + out = m_data->m_returnData->getAnswer>(); return out; } template<> zeus::File zeus::Future::get() { zeus::File out; - if (m_data == nullptr) { + if ( m_data == nullptr + || m_data->m_returnData == nullptr) { return out; } - /* TODO : ... - ejson::Value val = m_data->m_returnData["return"]; - if (val.exist() == false) { + if (m_data->m_returnData->getType() != zeus::Buffer::typeMessage::answer) { ZEUS_WARNING("No Return value ..."); return out; } - if (val.isObject() == false) { - ZEUS_WARNING("Wrong return Type get '" << val.getType() << " instead of 'Object'"); - return out; - } - ejson::Object retVal = val.toObject(); - if (retVal["type"].toString().get() != "file") { - ZEUS_WARNING("Wrong return object-type get '" << retVal["type"].toString().get() << " instead of 'file'"); - return out; - } - out.setMineType(retVal["mine-type"].toString().get()); - out.preSetDataSize(retVal["size"].toNumber().getU64()); - // no data might be stored in the first packet ... - - uint64_t offset = 0; - // TODO: check part ID - for (auto &it : m_data->m_returnDataPart) { - ejson::String valData = it.toString(); - std::vector tmpData = ejson::base64::decode(valData.get()); - out.setData(offset, tmpData); - offset += tmpData.size(); - } - */ + out = m_data->m_returnData->getAnswer(); return out; } } diff --git a/zeus/FutureBase.cpp b/zeus/FutureBase.cpp index 605be3c..651fd2a 100644 --- a/zeus/FutureBase.cpp +++ b/zeus/FutureBase.cpp @@ -28,15 +28,14 @@ zeus::FutureBase::FutureBase(uint64_t _transactionId, zeus::FutureData::Observer m_data->m_callbackFinish = _callback; } -const zeus::Buffer& zeus::FutureBase::getRaw() { +ememory::SharedPtr zeus::FutureBase::getRaw() { if (m_data == nullptr) { - static zeus::Buffer tmpp; - return tmpp; + return nullptr; } return m_data->m_returnData; } -zeus::FutureBase::FutureBase(uint64_t _transactionId, bool _isFinished, zeus::Buffer _returnData, zeus::FutureData::ObserverFinish _callback) { +zeus::FutureBase::FutureBase(uint64_t _transactionId, bool _isFinished, const ememory::SharedPtr& _returnData, zeus::FutureData::ObserverFinish _callback) { m_data = std::make_shared(); if (m_data == nullptr) { return; @@ -69,45 +68,31 @@ zeus::FutureBase zeus::FutureBase::operator= (const zeus::FutureBase& _base) { return *this; } -bool zeus::FutureBase::setAnswer(const zeus::Buffer& _returnValue) { +bool zeus::FutureBase::setAnswer(const ememory::SharedPtr& _value) { if (m_data == nullptr) { ZEUS_ERROR(" Not a valid future ..."); return true; } m_data->m_receiveTime = std::chrono::steady_clock::now(); if (m_data->m_isSynchronous == true) { - m_data->m_returnData = _returnValue; + m_data->m_returnData = _value; if (m_data->m_callbackFinish != nullptr) { return m_data->m_callbackFinish(*this); } return true; } - /* TODO : ... - if (_returnValue.valueExist("part") == true) { - uint64_t idPart = _returnValue["part"].toNumber().getU64(); - if (idPart == 0) { - m_data->m_returnData = _returnValue; - } else { - m_data->m_returnDataPart.push_back(_returnValue["data"]); + if (_value->getType() == zeus::Buffer::typeMessage::data) { + if (m_data->m_returnData != nullptr) { + m_data->m_returnData->appendBufferData(_value); } - if (_returnValue.valueExist("finish") == true) { - if (_returnValue["finish"].toBoolean().get() == true) { - m_data->m_isFinished = true; - if (m_data->m_callbackFinish != nullptr) { - return m_data->m_callbackFinish(*this); - } - return true; - } - // finish is false ==> normal case ... - } - return false; - }*/ - m_data->m_returnData = _returnValue; - m_data->m_isFinished = true; + } else { + m_data->m_returnData = _value; + } + m_data->m_isFinished = _value->getPartFinish(); if (m_data->m_callbackFinish != nullptr) { return m_data->m_callbackFinish(*this); } - return true; + return m_data->m_isFinished; } void zeus::FutureBase::setSynchronous() { if (m_data == nullptr) { @@ -127,28 +112,30 @@ bool zeus::FutureBase::hasError() { if (m_data == nullptr) { return true; } - return m_data->m_returnData.hasError(); + return m_data->m_returnData->hasError(); } std::string zeus::FutureBase::getErrorType() { - if (m_data == nullptr) { + if ( m_data == nullptr + || m_data->m_returnData == nullptr) { return "NULL_PTR"; } - return m_data->m_returnData.getError(); + return m_data->m_returnData->getError(); } std::string zeus::FutureBase::getErrorHelp() { - if (m_data == nullptr) { + if ( m_data == nullptr + || m_data->m_returnData == nullptr) { return "Thsi is a nullptr future"; } - return m_data->m_returnData.getErrorHelp(); + return m_data->m_returnData->getErrorHelp(); } -bool zeus::FutureBase::isValid() { +bool zeus::FutureBase::isValid() const { return m_data != nullptr; } -bool zeus::FutureBase::isFinished() { +bool zeus::FutureBase::isFinished() const { if (m_data == nullptr) { return true; } @@ -184,35 +171,43 @@ zeus::FutureBase& zeus::FutureBase::waitUntil(std::chrono::steady_clock::time_po } -zeus::FutureCall::FutureCall(uint64_t _clientId, uint64_t _transactionId, zeus::Buffer& _callValue) : +zeus::FutureCall::FutureCall(uint64_t _clientId, uint64_t _transactionId, const ememory::SharedPtr& _callValue) : m_transactionId(_transactionId), m_clientId(_clientId), m_isFinished(false) { m_data = _callValue; - m_isFinished = m_data.getPartFinish(); + m_isFinished = m_data->getPartFinish(); } -void zeus::FutureCall::appendData(zeus::Buffer& _callValue) { - m_dataMultiplePack.push_back(_callValue); - m_isFinished = _callValue.getPartFinish(); +void zeus::FutureCall::appendData(const ememory::SharedPtr& _value) { + if (_value->getType() == zeus::Buffer::typeMessage::data) { + if (m_data == nullptr) { + return; + } + m_data->appendBufferData(_value); + } else { + m_data = _value; + } + m_dataMultiplePack.push_back(_value); + m_isFinished = _value->getPartFinish(); } -uint64_t zeus::FutureCall::getTransactionId() { +uint64_t zeus::FutureCall::getTransactionId() const { return m_transactionId; } -uint64_t zeus::FutureCall::getClientId() { +uint64_t zeus::FutureCall::getClientId() const { return m_clientId; } -bool zeus::FutureCall::isFinished() { +bool zeus::FutureCall::isFinished() const { return m_isFinished; } -zeus::Buffer& zeus::FutureCall::getRaw() { +ememory::SharedPtr zeus::FutureCall::getRaw() const { return m_data; } -std::chrono::nanoseconds zeus::FutureCall::getTransmitionTime() { +std::chrono::nanoseconds zeus::FutureCall::getTransmitionTime() const { return m_answerTime - m_receiveTime; } diff --git a/zeus/FutureBase.h b/zeus/FutureBase.h index fa29dc9..c9799ac 100644 --- a/zeus/FutureBase.h +++ b/zeus/FutureBase.h @@ -15,20 +15,20 @@ namespace zeus { FutureBase(const zeus::FutureBase& _base); FutureBase(); FutureBase(uint64_t _transactionId, zeus::FutureData::ObserverFinish _callback=nullptr); - FutureBase(uint64_t _transactionId, bool _isFinished, zeus::Buffer _returnData, zeus::FutureData::ObserverFinish _callback=nullptr); + FutureBase(uint64_t _transactionId, bool _isFinished, const ememory::SharedPtr& _returnData, zeus::FutureData::ObserverFinish _callback=nullptr); zeus::FutureBase operator= (const zeus::FutureBase& _base); - bool setAnswer(const zeus::Buffer& _returnValue); + bool setAnswer(const ememory::SharedPtr& _returnValue); void setSynchronous(); uint64_t getTransactionId(); bool hasError(); std::string getErrorType(); std::string getErrorHelp(); - bool isValid(); - bool isFinished(); + bool isValid() const; + bool isFinished() const; FutureBase& wait(); FutureBase& waitFor(std::chrono::microseconds _delta = std::chrono::seconds(30)); FutureBase& waitUntil(std::chrono::steady_clock::time_point _endTime); - const zeus::Buffer& getRaw(); + ememory::SharedPtr getRaw(); std::chrono::nanoseconds getTransmitionTime(); }; class FutureCall { @@ -36,18 +36,18 @@ namespace zeus { uint64_t m_transactionId; uint64_t m_clientId; bool m_isFinished; - zeus::Buffer m_data; - std::vector m_dataMultiplePack; + ememory::SharedPtr m_data; + std::vector> m_dataMultiplePack; std::chrono::steady_clock::time_point m_receiveTime; std::chrono::steady_clock::time_point m_answerTime; public: - FutureCall(uint64_t _clientId, uint64_t _transactionId, zeus::Buffer& _callValue); - void appendData(zeus::Buffer& _callValue); - uint64_t getTransactionId(); - uint64_t getClientId(); - bool isFinished(); - std::chrono::nanoseconds getTransmitionTime(); - zeus::Buffer& getRaw(); + FutureCall(uint64_t _clientId, uint64_t _transactionId, const ememory::SharedPtr& _callValue); + void appendData(const ememory::SharedPtr& _callValue); + uint64_t getTransactionId() const; + uint64_t getClientId() const; + bool isFinished() const; + std::chrono::nanoseconds getTransmitionTime() const; + ememory::SharedPtr getRaw() const; }; } diff --git a/zeus/FutureData.h b/zeus/FutureData.h index 59ff4ce..7b817f3 100644 --- a/zeus/FutureData.h +++ b/zeus/FutureData.h @@ -20,7 +20,7 @@ namespace zeus { uint64_t m_transactionId; bool m_isSynchronous; bool m_isFinished; - zeus::Buffer m_returnData; + ememory::SharedPtr m_returnData; ObserverFinish m_callbackFinish; std::chrono::steady_clock::time_point m_sendTime; std::chrono::steady_clock::time_point m_receiveTime; diff --git a/zeus/GateWay.cpp b/zeus/GateWay.cpp index 52c763e..b1a565b 100644 --- a/zeus/GateWay.cpp +++ b/zeus/GateWay.cpp @@ -129,7 +129,7 @@ std::vector zeus::GateWay::getAllServiceName() { } -void zeus::GateWay::answer(uint64_t _userSessionId, zeus::Buffer& _data) { +void zeus::GateWay::answer(uint64_t _userSessionId, const ememory::SharedPtr& _data) { for (auto &it : m_clientList) { if (it == nullptr) { continue; diff --git a/zeus/GateWay.h b/zeus/GateWay.h index 6fbdd66..32155e6 100644 --- a/zeus/GateWay.h +++ b/zeus/GateWay.h @@ -32,7 +32,7 @@ namespace zeus { void stop(); ememory::SharedPtr get(const std::string& _serviceName); std::vector getAllServiceName(); - void answer(uint64_t _userSessionId, zeus::Buffer& _data); + void answer(uint64_t _userSessionId, const ememory::SharedPtr& _data); void newService(enet::Tcp _connection); void newClient(enet::Tcp _connection); void cleanIO(); diff --git a/zeus/GateWayClient.cpp b/zeus/GateWayClient.cpp index 72eb1b4..ecdd743 100644 --- a/zeus/GateWayClient.cpp +++ b/zeus/GateWayClient.cpp @@ -66,19 +66,22 @@ void zeus::GateWayClient::answerProtocolError(uint32_t _transactionId, const std } -void zeus::GateWayClient::onClientData(zeus::Buffer& _value) { - uint32_t transactionId = _value.getTransactionId(); +void zeus::GateWayClient::onClientData(const ememory::SharedPtr& _value) { + if (_value == nullptr) { + return; + } + uint32_t transactionId = _value->getTransactionId(); if (transactionId == 0) { ZEUS_ERROR("Protocol error ==>missing id"); answerProtocolError(transactionId, "missing parameter: 'id'"); return; } - if (_value.getType() != zeus::Buffer::typeMessage::call) { + if (_value->getType() != zeus::Buffer::typeMessage::call) { ZEUS_ERROR("Protocol error ==>missing 'call'"); answerProtocolError(transactionId, "missing parameter: 'call' / wrong type 'call'"); return; } - std::string callFunction = _value.getCall(); + std::string callFunction = _value->getCall(); switch (m_state) { case zeus::GateWayClient::state::disconnect: case zeus::GateWayClient::state::unconnect: @@ -94,7 +97,7 @@ void zeus::GateWayClient::onClientData(zeus::Buffer& _value) { return; } if (callFunction == "connectToUser") { - m_userConnectionName = _value.getParameter(0); + m_userConnectionName = _value->getParameter(0); if (m_userConnectionName == "") { answerProtocolError(transactionId, "Call connectToUser with no parameter 'user'"); } else { @@ -127,8 +130,8 @@ void zeus::GateWayClient::onClientData(zeus::Buffer& _value) { return; } if (callFunction == "identify") { - std::string clientName = _value.getParameter(0); - std::string clientTocken = _value.getParameter(1); + std::string clientName = _value->getParameter(0); + std::string clientTocken = _value->getParameter(1); if (m_userService == nullptr) { answerProtocolError(transactionId, "gateWay internal error 3"); return; @@ -149,7 +152,7 @@ void zeus::GateWayClient::onClientData(zeus::Buffer& _value) { m_clientName = clientName; } if (callFunction == "auth") { - std::string password = _value.getParameter(0); + std::string password = _value->getParameter(0); zeus::Future fut = m_userService->m_interfaceClient.callClient(m_uid2, "checkAuth", password); fut.wait(); // TODO: Set timeout ... if (fut.hasError() == true) { @@ -204,7 +207,7 @@ void zeus::GateWayClient::onClientData(zeus::Buffer& _value) { break; case zeus::GateWayClient::state::clientIdentify: { - uint32_t serviceId = _value.getServiceId(); + uint32_t serviceId = _value->getServiceId(); if (serviceId == 0) { // This is 2 default service for the cient interface that manage the authorisation of view: if (callFunction == "getServiceCount") { @@ -218,7 +221,7 @@ void zeus::GateWayClient::onClientData(zeus::Buffer& _value) { } if (callFunction == "link") { // first param: - std::string serviceName = _value.getParameter(0); + std::string serviceName = _value->getParameter(0); // Check if service already link: auto it = m_listConnectedService.begin(); while (it != m_listConnectedService.end()) { @@ -259,7 +262,7 @@ void zeus::GateWayClient::onClientData(zeus::Buffer& _value) { } if (callFunction == "unlink") { // first param: the service we want to unconnect ... - int64_t localServiceID = _value.getParameter(0)-1; + int64_t localServiceID = _value->getParameter(0)-1; // Check if service already link: if (localServiceID >= m_listConnectedService.size()) { m_interfaceClient.answerError(transactionId, "NOT-CONNECTED-SERVICE"); @@ -291,7 +294,7 @@ void zeus::GateWayClient::onClientData(zeus::Buffer& _value) { ZEUS_ERROR("TODO : Manage this case ..."); return; } - uint16_t partId = _value.getPartId(); + uint16_t partId = _value->getPartId(); if (partId != 0) { m_listConnectedService[serviceId]->m_interfaceClient.callForwardMultiple( m_uid, @@ -304,21 +307,24 @@ void zeus::GateWayClient::onClientData(zeus::Buffer& _value) { _value, (uint64_t(m_uid) << 32) + uint64_t(transactionId), [=](zeus::FutureBase _ret) { - zeus::Buffer tmpp = _ret.getRaw(); - ZEUS_DEBUG(" ==> transmit : " << tmpp.getTransactionId() << " -> " << transactionId); - ZEUS_DEBUG(" msg=" << tmpp.generateHumanString()); - tmpp.setTransactionId(transactionId); - tmpp.setServiceId(serviceId+1); - ZEUS_DEBUG("transmit=" << tmpp.generateHumanString()); + ememory::SharedPtr tmpp = _ret.getRaw(); + if (tmpp == nullptr) { + return true; + } + ZEUS_DEBUG(" ==> transmit : " << tmpp->getTransactionId() << " -> " << transactionId); + ZEUS_DEBUG(" msg=" << tmpp->generateHumanString()); + tmpp->setTransactionId(transactionId); + tmpp->setServiceId(serviceId+1); + ZEUS_DEBUG("transmit=" << tmpp->generateHumanString()); m_interfaceClient.writeBinary(tmpp); // multiple send element ... - return tmpp.getPartFinish(); + return tmpp->getPartFinish(); }); } } } } -void zeus::GateWayClient::returnMessage(zeus::Buffer& _data) { +void zeus::GateWayClient::returnMessage(const ememory::SharedPtr& _data) { ZEUS_ERROR("Get call from the Service to the user ..."); } \ No newline at end of file diff --git a/zeus/GateWayClient.h b/zeus/GateWayClient.h index e1c2f87..6424791 100644 --- a/zeus/GateWayClient.h +++ b/zeus/GateWayClient.h @@ -44,8 +44,8 @@ namespace zeus { virtual ~GateWayClient(); void start(uint64_t _uid, uint64_t _uid2); void stop(); - void onClientData(zeus::Buffer& _value); - void returnMessage(zeus::Buffer& _data); + void onClientData(const ememory::SharedPtr& _value); + void returnMessage(const ememory::SharedPtr& _data); bool checkId(uint64_t _id) const { return m_uid == _id || m_uid2 == _id; diff --git a/zeus/GateWayService.cpp b/zeus/GateWayService.cpp index 96dc4f7..bd2c2b3 100644 --- a/zeus/GateWayService.cpp +++ b/zeus/GateWayService.cpp @@ -43,15 +43,18 @@ void zeus::GateWayService::stop() { } -void zeus::GateWayService::SendData(uint64_t _userSessionId, zeus::Buffer& _data) { - _data.setClientId(_userSessionId); +void zeus::GateWayService::SendData(uint64_t _userSessionId, const ememory::SharedPtr& _data) { + _data->setClientId(_userSessionId); m_interfaceClient.writeBinary(_data); } -void zeus::GateWayService::onServiceData(zeus::Buffer& _value) { - uint32_t transactionId = _value.getTransactionId(); +void zeus::GateWayService::onServiceData(const ememory::SharedPtr& _value) { + if (_value == nullptr) { + return; + } + uint32_t transactionId = _value->getTransactionId(); //data.add("from-service", ejson::String(m_name)); - if (_value.getType() == zeus::Buffer::typeMessage::event) { + if (_value->getType() == zeus::Buffer::typeMessage::event) { /* if (data.valueExist("event") == true) { // No need to have a user ID ... @@ -70,26 +73,26 @@ void zeus::GateWayService::onServiceData(zeus::Buffer& _value) { */ return; } - if (_value.getType() == zeus::Buffer::typeMessage::call) { - std::string callFunction = _value.getCall(); + if (_value->getType() == zeus::Buffer::typeMessage::call) { + std::string callFunction = _value->getCall(); if (callFunction == "connect-service") { if (m_name != "") { - ZEUS_WARNING("Service interface ==> try change the servie name after init: '" << _value.getParameter(0)); + ZEUS_WARNING("Service interface ==> try change the servie name after init: '" << _value->getParameter(0)); m_interfaceClient.answerValue(transactionId, false); return; } - m_name = _value.getParameter(0); + m_name = _value->getParameter(0); m_interfaceClient.setInterfaceName("srv-" + m_name); m_interfaceClient.answerValue(transactionId, true); return; } answerProtocolError(transactionId, "unknow function"); } - if (_value.getClientId() == 0) { + if (_value->getClientId() == 0) { ZEUS_ERROR("Service interface ==> wrong service answer ==> missing 'client-id'"); return; } - m_gatewayInterface->answer(_value.getClientId(), _value); + m_gatewayInterface->answer(_value->getClientId(), _value); } diff --git a/zeus/GateWayService.h b/zeus/GateWayService.h index 3022d10..eb0de52 100644 --- a/zeus/GateWayService.h +++ b/zeus/GateWayService.h @@ -25,9 +25,9 @@ namespace zeus { virtual ~GateWayService(); void start(); void stop(); - void onServiceData(zeus::Buffer& _value); + void onServiceData(const ememory::SharedPtr& _value); public: - void SendData(uint64_t _userSessionId, zeus::Buffer& _data); + void SendData(uint64_t _userSessionId, const ememory::SharedPtr& _data); const std::string& getName() { return m_name; } diff --git a/zeus/ParamType.cpp b/zeus/ParamType.cpp index 721092e..940c5aa 100644 --- a/zeus/ParamType.cpp +++ b/zeus/ParamType.cpp @@ -117,4 +117,5 @@ generate_basic_type(zeus::File, "file", 0x000E, false, false); generate_basic_type(zeus::FileServer, "file", 0x000E, false, false); const uint16_t zeus::paramTypeObject = 0xFFFF; +const uint16_t zeus::paramTypeRaw = 0xFFFE; diff --git a/zeus/ParamType.h b/zeus/ParamType.h index 114625b..8118ff8 100644 --- a/zeus/ParamType.h +++ b/zeus/ParamType.h @@ -29,6 +29,7 @@ namespace zeus { bool isVector() const; }; extern const uint16_t paramTypeObject; + extern const uint16_t paramTypeRaw; std::ostream& operator <<(std::ostream& _os, const zeus::ParamType& _obj); template diff --git a/zeus/Service.cpp b/zeus/Service.cpp index 1d5c85c..ccbd12a 100644 --- a/zeus/Service.cpp +++ b/zeus/Service.cpp @@ -32,9 +32,9 @@ std::vector zeus::Service::getExtention() { } -void zeus::Service::onClientData(zeus::Buffer& _value) { - uint32_t tmpID = _value.getTransactionId(); - uint32_t clientId = _value.getClientId();; +void zeus::Service::onClientData(const ememory::SharedPtr& _value) { + uint32_t tmpID = _value->getTransactionId(); + uint32_t clientId = _value->getClientId();; auto it = m_callMultiData.begin(); while (it != m_callMultiData.end()) { if ( it->getTransactionId() == tmpID @@ -119,24 +119,26 @@ void zeus::Service::pingIsAlive() { } } -void zeus::Service::callBinary(uint32_t _transactionId, zeus::Buffer& _obj) { - if (_obj.getType() == zeus::Buffer::typeMessage::event) { - +void zeus::Service::callBinary(uint32_t _transactionId, const ememory::SharedPtr& _obj) { + if (_obj == nullptr) { + return; + } + if (_obj->getType() == zeus::Buffer::typeMessage::event) { ZEUS_ERROR("Unknow event: '...'"); return; } - if (_obj.getType() == zeus::Buffer::typeMessage::answer) { + if (_obj->getType() == zeus::Buffer::typeMessage::answer) { ZEUS_ERROR("Local Answer: '...'"); return; } //if (_obj.getType() == zeus::Buffer::typeMessage::event) { - uint32_t clientId = _obj.getClientId(); - std::string callFunction = _obj.getCall(); + uint32_t clientId = _obj->getClientId(); + std::string callFunction = _obj->getCall(); if (callFunction[0] == '_') { if (callFunction == "_new") { - std::string userName = _obj.getParameter(0); - std::string clientName = _obj.getParameter(1); - std::vector clientGroup = _obj.getParameter>(2); + std::string userName = _obj->getParameter(0); + std::string clientName = _obj->getParameter(1); + std::vector clientGroup = _obj->getParameter>(2); clientConnect(clientId, userName, clientName, clientGroup); } else if (callFunction == "_delete") { clientDisconnect(clientId); diff --git a/zeus/Service.h b/zeus/Service.h index 30aa8e4..9b9b1ad 100644 --- a/zeus/Service.h +++ b/zeus/Service.h @@ -68,7 +68,7 @@ namespace zeus { void connect(const std::string& _serviceName, uint32_t _numberRetry = 1); void disconnect(); private: - void onClientData(zeus::Buffer& _value); + void onClientData(const ememory::SharedPtr& _value); public: void pingIsAlive(); bool GateWayAlive(); @@ -84,8 +84,8 @@ namespace zeus { virtual void clientConnect(uint64_t _clientId, const std::string& _userName, const std::string& _clientName, const std::vector& _groups) = 0; virtual void clientDisconnect(uint64_t _clientId) = 0; // Genenric function call: - void callBinary(uint32_t _transactionId, zeus::Buffer& _obj); - virtual void callBinary2(uint32_t _transactionId, uint64_t _clientId, const std::string& _call, zeus::Buffer& _obj) = 0; + void callBinary(uint32_t _transactionId, const ememory::SharedPtr& _obj); + virtual void callBinary2(uint32_t _transactionId, uint64_t _clientId, const std::string& _call, const ememory::SharedPtr& _obj) = 0; std::vector getExtention(); public: // Add Local fuction (depend on this class) @@ -208,7 +208,7 @@ namespace zeus { } it->second.first->setGroups(_clientGroups); } - void callBinary2(uint32_t _transactionId, uint64_t _clientId, const std::string& _call, zeus::Buffer& _obj) { + void callBinary2(uint32_t _transactionId, uint64_t _clientId, const std::string& _call, const ememory::SharedPtr& _obj) { auto it = m_interface.find(_clientId); if (it == m_interface.end()) { m_interfaceClient->answerError(_transactionId, "CLIENT-UNKNOW", "", _clientId); diff --git a/zeus/ServiceRemote.h b/zeus/ServiceRemote.h index 66ae366..d5ac72a 100644 --- a/zeus/ServiceRemote.h +++ b/zeus/ServiceRemote.h @@ -29,8 +29,10 @@ namespace zeus { template zeus::FutureBase call(const std::string& _functionName, _ARGS&&... _args) { if (m_interfaceClient == nullptr) { - zeus::Buffer ret; - ret.addError("NULLPTR", "call " + _functionName + " with no interface open"); + ememory::SharedPtr ret = zeus::Buffer::create(); + if (ret != nullptr) { + ret->addError("NULLPTR", "call " + _functionName + " with no interface open"); + } return zeus::FutureBase(0, true, ret); } return m_interfaceClient->callService(m_serviceId, _functionName, _args...); @@ -38,8 +40,10 @@ namespace zeus { template zeus::FutureBase callAction(const std::string& _functionName, _ARGS&&... _args, zeus::FutureData::ObserverFinish _callback) { if (m_interfaceClient == nullptr) { - zeus::Buffer ret; - ret.addError("NULLPTR", "call " + _functionName + " with no interface open"); + ememory::SharedPtr ret = zeus::Buffer::create(); + if (ret != nullptr) { + ret->addError("NULLPTR", "call " + _functionName + " with no interface open"); + } return zeus::FutureBase(0, true, ret, _callback); } return m_interfaceClient->callServiceAction(m_serviceId, _functionName, _args..., _callback); diff --git a/zeus/TcpString.cpp b/zeus/TcpString.cpp index 2f8d74d..c186621 100644 --- a/zeus/TcpString.cpp +++ b/zeus/TcpString.cpp @@ -90,11 +90,62 @@ void zeus::TcpString::disconnect(bool _inThreadStop){ ZEUS_DEBUG("disconnect [STOP]"); } -int32_t zeus::TcpString::writeBinary(zeus::Buffer& _data) { +class SendAsyncBinary { + private: + std::vector m_async; + uint64_t m_transactionId; + uint32_t m_serviceId; + uint32_t m_partId; + public: + SendAsyncBinary(uint64_t _transactionId, const uint32_t& _serviceId, std::vector _async) : + m_async(std::move(_async)), + m_transactionId(_transactionId), + m_serviceId(_serviceId), + m_partId(1) { + + } + bool operator() (zeus::TcpString* _interface){ + auto it = m_async.begin(); + while (it != m_async.end()) { + bool ret = (*it)(_interface, m_serviceId, m_transactionId, m_partId); + if (ret == true) { + // Remove it ... + it = m_async.erase(it); + } else { + ++it; + } + m_partId++; + } + if (m_async.size() == 0) { + ememory::SharedPtr obj = zeus::Buffer::create(); + if (obj == nullptr) { + return true; + } + obj->setType(zeus::Buffer::typeMessage::data); + obj->setServiceId(m_serviceId); + obj->setTransactionId(m_transactionId); + obj->setPartId(m_partId); + obj->setPartFinish(true); + _interface->writeBinary(obj); + return true; + } + return false; + } +}; + +int32_t zeus::TcpString::writeBinary(const ememory::SharedPtr& _obj) { if (m_connection.isAlive() == false) { return -2; } - if (_data.writeOn(m_connection) == true) { + if (_obj->haveAsync() == true) { + ZEUS_WARNING("Set Flag not finish ..."); + _obj->setPartFinish(false); + } + if (_obj->writeOn(m_connection) == true) { + if (_obj->haveAsync() == true) { + ZEUS_WARNING("Add async"); + addAsync(SendAsyncBinary(_obj->getTransactionId(), _obj->getServiceId(), std::move(_obj->moveAsync()))); + } return 1; } return -1; @@ -115,14 +166,13 @@ bool zeus::TcpString::onReceiveUri(const std::string& _uri, const std::vector& _frame, bool _isBinary) { - ZEUS_VERBOSE("Receive Frame ... " << _frame.size()); - zeus::Buffer dataRaw; + ememory::SharedPtr dataRaw = zeus::Buffer::create(); if (_isBinary == true) { ZEUS_ERROR("Receive non binary frame ..."); disconnect(true); return; } - dataRaw.composeWith(_frame); + dataRaw->composeWith(_frame); newBuffer(dataRaw); } @@ -130,10 +180,10 @@ void zeus::TcpString::ping() { m_connection.controlPing(); } -void zeus::TcpString::newBuffer(zeus::Buffer& _buffer) { - ZEUS_VERBOSE("Receive Binary :" << _buffer.generateHumanString()); +void zeus::TcpString::newBuffer(const ememory::SharedPtr& _buffer) { + ZEUS_DEBUG("Receive :" << _buffer->generateHumanString()); zeus::FutureBase future; - uint64_t tid = _buffer.getTransactionId(); + uint64_t tid = _buffer->getTransactionId(); if (tid == 0) { ZEUS_ERROR("Get a Protocol error ... No ID ..."); /* @@ -195,16 +245,28 @@ void zeus::TcpString::newBuffer(zeus::Buffer& _buffer) { } } +void zeus::TcpString::addAsync(zeus::TcpString::ActionAsync _elem) { + std::unique_lock lock(m_threadAsyncMutex); + m_threadAsyncList2.push_back(_elem); +} + void zeus::TcpString::threadAsyncCallback() { ethread::setName("Async-sender"); + ZEUS_INFO("Async Sender [START]..."); // get datas: while ( m_threadAsyncRunning == true && m_connection.isAlive() == true) { + if (m_threadAsyncList2.size() != 0) { + std::unique_lock lock(m_threadAsyncMutex); + for (auto &it : m_threadAsyncList2) { + m_threadAsyncList.push_back(it); + } + m_threadAsyncList2.clear(); + } if (m_threadAsyncList.size() == 0) { usleep(10000); continue; } - std::unique_lock lock(m_threadAsyncMutex); auto it = m_threadAsyncList.begin(); while (it != m_threadAsyncList.end()) { bool ret = (*it)(this); @@ -217,58 +279,19 @@ void zeus::TcpString::threadAsyncCallback() { } } m_threadAsyncRunning = false; - ZEUS_DEBUG("End of thread"); + ZEUS_INFO("Async Sender [STOP]"); } -class SendAsyncBinary { - private: - std::vector m_async; - uint64_t m_transactionId; - uint32_t m_serviceId; - uint32_t m_partId; - public: - SendAsyncBinary(uint64_t _transactionId, const uint32_t& _serviceId, const std::vector& _async) : - m_async(_async), - m_transactionId(_transactionId), - m_serviceId(_serviceId), - m_partId(1) { - - } - bool operator() (zeus::TcpString* _interface){ - auto it = m_async.begin(); - while (it != m_async.end()) { - bool ret = (*it)(_interface, m_serviceId, m_transactionId, m_partId); - if (ret == true) { - // Remove it ... - it = m_async.erase(it); - } else { - ++it; - } - m_partId++; - } - if (m_async.size() == 0) { - zeus::Buffer obj; - obj.setServiceId(m_serviceId); - obj.setTransactionId(m_transactionId); - obj.setPartId(m_partId); - obj.setPartFinish(true); - _interface->writeBinary(obj); - return true; - } - return false; - } -}; zeus::FutureBase zeus::TcpString::callBinary(uint64_t _transactionId, - zeus::Buffer& _obj, - const std::vector& _async, + const ememory::SharedPtr& _obj, zeus::FutureData::ObserverFinish _callback, const uint32_t& _serviceId) { - ZEUS_VERBOSE("Send Binary [START] "); + ZEUS_VERBOSE("Send [START] "); if (isActive() == false) { - zeus::Buffer obj; - obj.setType(zeus::Buffer::typeMessage::answer); - obj.addError("NOT-CONNECTED", "Client interface not connected (no TCP)"); + ememory::SharedPtr obj = zeus::Buffer::create(); + obj->setType(zeus::Buffer::typeMessage::answer); + obj->addError("NOT-CONNECTED", "Client interface not connected (no TCP)"); return zeus::FutureBase(_transactionId, true, obj, _callback); } zeus::FutureBase tmpFuture(_transactionId, _callback); @@ -276,37 +299,28 @@ zeus::FutureBase zeus::TcpString::callBinary(uint64_t _transactionId, std::unique_lock lock(m_pendingCallMutex); m_pendingCall.push_back(std::make_pair(uint64_t(0), tmpFuture)); } - if (_async.size() != 0) { - _obj.setPartFinish(false); - } else { - _obj.setPartFinish(true); - } writeBinary(_obj); - - if (_async.size() != 0) { - addAsync(SendAsyncBinary(_transactionId, _serviceId, _async)); - } - ZEUS_VERBOSE("Send Binary [STOP]"); + ZEUS_VERBOSE("Send [STOP]"); return tmpFuture; } zeus::FutureBase zeus::TcpString::callForward(uint32_t _clientId, - zeus::Buffer& _buffer, - uint64_t _singleReferenceId, - zeus::FutureData::ObserverFinish _callback) { + const ememory::SharedPtr& _buffer, + uint64_t _singleReferenceId, + zeus::FutureData::ObserverFinish _callback) { ZEUS_VERBOSE("Call Forward [START]"); //zeus::FutureBase ret = callBinary(id, _Buffer, async, _callback); //ret.setSynchronous(); if (isActive() == false) { - zeus::Buffer obj; - obj.setType(zeus::Buffer::typeMessage::answer); - obj.addError("NOT-CONNECTED", "Client interface not connected (no TCP)"); + ememory::SharedPtr obj = zeus::Buffer::create(); + obj->setType(zeus::Buffer::typeMessage::answer); + obj->addError("NOT-CONNECTED", "Client interface not connected (no TCP)"); return zeus::FutureBase(0, true, obj, _callback); } uint64_t id = getId(); - _buffer.setTransactionId(id); - _buffer.setClientId(_clientId); + _buffer->setTransactionId(id); + _buffer->setClientId(_clientId); zeus::FutureBase tmpFuture(id, _callback); tmpFuture.setSynchronous(); { @@ -319,16 +333,19 @@ zeus::FutureBase zeus::TcpString::callForward(uint32_t _clientId, } void zeus::TcpString::callForwardMultiple(uint32_t _clientId, - zeus::Buffer& _buffer, - uint64_t _singleReferenceId){ + const ememory::SharedPtr& _buffer, + uint64_t _singleReferenceId){ + if (_buffer == nullptr) { + return; + } // subMessage ... ==> try to forward message: std::unique_lock lock(m_pendingCallMutex); for (auto &itCall : m_pendingCall) { ZEUS_INFO(" compare : " << itCall.first << " =?= " << _singleReferenceId); if (itCall.first == _singleReferenceId) { // Find element ==> transit it ... - _buffer.setTransactionId(itCall.second.getTransactionId()); - _buffer.setClientId(_clientId); + _buffer->setTransactionId(itCall.second.getTransactionId()); + _buffer->setClientId(_clientId); writeBinary(_buffer); return; } @@ -337,20 +354,26 @@ void zeus::TcpString::callForwardMultiple(uint32_t _clientId, } void zeus::TcpString::answerError(uint64_t _clientTransactionId, const std::string& _errorValue, const std::string& _errorHelp, uint32_t _clientId) { - zeus::Buffer answer; - answer.setType(zeus::Buffer::typeMessage::answer); - answer.setTransactionId(_clientTransactionId); - answer.setClientId(_clientId); - answer.addError(_errorValue, _errorHelp); + ememory::SharedPtr answer = zeus::Buffer::create(); + if (answer == nullptr) { + return; + } + answer->setType(zeus::Buffer::typeMessage::answer); + answer->setTransactionId(_clientTransactionId); + answer->setClientId(_clientId); + answer->addError(_errorValue, _errorHelp); writeBinary(answer); } void zeus::TcpString::answerVoid(uint64_t _clientTransactionId, uint32_t _clientId) { - zeus::Buffer answer; - answer.setType(zeus::Buffer::typeMessage::answer); - answer.setTransactionId(_clientTransactionId); - answer.setClientId(_clientId); - answer.addParameter(); + ememory::SharedPtr answer = zeus::Buffer::create(); + if (answer == nullptr) { + return; + } + answer->setType(zeus::Buffer::typeMessage::answer); + answer->setTransactionId(_clientTransactionId); + answer->setClientId(_clientId); + answer->addParameter(); writeBinary(answer); } \ No newline at end of file diff --git a/zeus/TcpString.h b/zeus/TcpString.h index 814b08c..fd5467f 100644 --- a/zeus/TcpString.h +++ b/zeus/TcpString.h @@ -24,7 +24,7 @@ namespace zeus { std::mutex m_pendingCallMutex; std::vector> m_pendingCall; public: - using Observer = std::function; //!< Define an Observer: function pointer + using Observer = std::function&)>; //!< Define an Observer: function pointer Observer m_observerElement; /** * @brief Connect an function member on the signal with the shared_ptr object. @@ -33,8 +33,8 @@ namespace zeus { * @param[in] _args Argument optinnal the user want to add. */ template - void connect(CLASS_TYPE* _class, void (CLASS_TYPE::*_func)(zeus::Buffer&)) { - m_observerElement = [=](zeus::Buffer& _value){ + void connect(CLASS_TYPE* _class, void (CLASS_TYPE::*_func)(const ememory::SharedPtr&)) { + m_observerElement = [=](const ememory::SharedPtr& _value){ (*_class.*_func)(_value); }; } @@ -47,11 +47,11 @@ namespace zeus { void disconnect(bool _inThreadStop = false); bool isActive() const; void setInterfaceName(const std::string& _name); - int32_t writeBinary(zeus::Buffer& _data); + int32_t writeBinary(const ememory::SharedPtr& _data); void ping(); bool onReceiveUri(const std::string& _uri, const std::vector& _protocols); void onReceiveData(std::vector& _frame, bool _isBinary); - void newBuffer(zeus::Buffer& _buffer); + void newBuffer(const ememory::SharedPtr& _buffer); public: const std::chrono::steady_clock::time_point& getLastTimeReceive() { return m_connection.getLastTimeReceive(); @@ -65,49 +65,42 @@ namespace zeus { std::thread* m_threadAsync; bool m_threadAsyncRunning; std::vector m_threadAsyncList; + std::vector m_threadAsyncList2; private: void threadAsyncCallback(); public: - void addAsync(ActionAsync _elem) { - std::unique_lock lock(m_threadAsyncMutex); - m_threadAsyncList.push_back(_elem); - } + void addAsync(ActionAsync _elem); private: zeus::FutureBase callBinary(uint64_t _transactionId, - zeus::Buffer& _obj, - const std::vector& _async, + const ememory::SharedPtr& _obj, zeus::FutureData::ObserverFinish _callback=nullptr, const uint32_t& _service=0); public: // section call direct template zeus::FutureBase call(const std::string& _functionName, _ARGS&&... _args) { uint16_t id = getId(); - std::vector asyncAction; - zeus::Buffer callElem = zeus::createBinaryCall(asyncAction, id, _functionName, std::forward<_ARGS>(_args)...); - return callBinary(id, callElem, asyncAction); + ememory::SharedPtr callElem = zeus::createBinaryCall(id, _functionName, std::forward<_ARGS>(_args)...); + return callBinary(id, callElem); } template zeus::FutureBase callAction(const std::string& _functionName, _ARGS&&... _args, zeus::FutureData::ObserverFinish _callback) { uint16_t id = getId(); - std::vector asyncAction; - zeus::Buffer callElem = zeus::createBinaryCall(asyncAction, id, _functionName, std::forward<_ARGS>(_args)...); - return callBinary(id, callElem, asyncAction, _callback); + ememory::SharedPtr callElem = zeus::createBinaryCall(id, _functionName, std::forward<_ARGS>(_args)...); + return callBinary(id, callElem, _callback); } public: // section call with service ID / Client ID template zeus::FutureBase callService(uint32_t _serviceId, const std::string& _functionName, _ARGS&&... _args) { uint16_t id = getId(); - std::vector asyncActionToDo; - zeus::Buffer callElem = zeus::createBinaryCallService(asyncActionToDo, id, _serviceId, _functionName, std::forward<_ARGS>(_args)...); - return callBinary(id, callElem, asyncActionToDo); + ememory::SharedPtr callElem = zeus::createBinaryCallService(id, _serviceId, _functionName, std::forward<_ARGS>(_args)...); + return callBinary(id, callElem); } template zeus::FutureBase callServiceAction(uint32_t _serviceId, const std::string& _functionName, _ARGS&&... _args, zeus::FutureData::ObserverFinish _callback) { uint16_t id = getId(); - std::vector asyncActionToDo; - zeus::Buffer callElem = zeus::createBinaryCallService(asyncActionToDo, id, _serviceId, _functionName, std::forward<_ARGS>(_args)...); - return callBinary(id, callElem, asyncActionToDo, _callback); + ememory::SharedPtr callElem = zeus::createBinaryCallService(id, _serviceId, _functionName, std::forward<_ARGS>(_args)...); + return callBinary(id, callElem, _callback); } template zeus::FutureBase callClient(uint32_t _clientId, @@ -123,22 +116,22 @@ namespace zeus { return callServiceAction(_clientId, _functionName, _args..., _callback); } zeus::FutureBase callForward(uint32_t _clientId, - zeus::Buffer& _Buffer, + const ememory::SharedPtr& _Buffer, uint64_t _singleReferenceId, zeus::FutureData::ObserverFinish _callback); void callForwardMultiple(uint32_t _clientId, - zeus::Buffer& _Buffer, + const ememory::SharedPtr& _Buffer, uint64_t _singleReferenceId); public: // answers ... void answerProtocolError(uint32_t _transactionId, const std::string& _errorHelp); template void answerValue(uint64_t _clientTransactionId, ZEUS_ARG _value, uint32_t _clientId=0) { - zeus::Buffer answer; - answer.setType(zeus::Buffer::typeMessage::answer); - answer.setTransactionId(_clientTransactionId); - answer.setClientId(_clientId); - answer.addAnswer(_value); + ememory::SharedPtr answer = zeus::Buffer::create(); + answer->setType(zeus::Buffer::typeMessage::answer); + answer->setTransactionId(_clientTransactionId); + answer->setClientId(_clientId); + answer->addAnswer(_value); writeBinary(answer); } void answerVoid(uint64_t _clientTransactionId, uint32_t _clientId=0);