176 lines
8.3 KiB
C++
176 lines
8.3 KiB
C++
/** @file
|
|
* @author Edouard DUPIN
|
|
* @copyright 2016, Edouard DUPIN, all right reserved
|
|
* @license APACHE v2.0 (see license file)
|
|
*/
|
|
#include <etk/types.hpp>
|
|
#include <zeus/Buffer.hpp>
|
|
#include <zeus/BufferData.hpp>
|
|
#include <zeus/debug.hpp>
|
|
#include <zeus/ParamType.hpp>
|
|
#include <etk/stdTools.hpp>
|
|
#include <zeus/BufferParameter.hpp>
|
|
#include <zeus/File.hpp>
|
|
|
|
bool zeus::BufferParameter::writeOn(enet::WebSocket& _interface) {
|
|
uint8_t* data = nullptr;
|
|
uint32_t dataSize = 0;
|
|
uint16_t nbParameters = m_parameter.size();
|
|
size_t size = _interface.writeData((uint8_t*)&nbParameters, sizeof(uint16_t));
|
|
for (auto &it : m_parameter) {
|
|
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;
|
|
}
|
|
|
|
void zeus::BufferParameter::composeWith(const uint8_t* _buffer, uint32_t _lenght) {
|
|
m_parameter.clear();
|
|
uint16_t nbParameters = 0;
|
|
if (_lenght < sizeof(uint16_t)) {
|
|
ZEUS_ERROR("wrong size of the buffer ==> missing parameter count");
|
|
return;
|
|
}
|
|
uint32_t offset = 0;
|
|
memcpy(&nbParameters, &_buffer[offset], sizeof(uint16_t));
|
|
offset += sizeof(uint16_t);
|
|
m_parameter.resize(nbParameters, std::make_pair(-1, std::vector<uint8_t>()));
|
|
// Load all Parameters
|
|
nbParameters = 0;
|
|
while ( nbParameters < m_parameter.size()
|
|
&& offset < _lenght) {
|
|
// parameters is contituated with size + data assiciated
|
|
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;
|
|
}
|
|
std::vector<uint8_t> data;
|
|
data.resize(sizeParam);
|
|
memcpy(&data[0], &_buffer[offset], data.size() * sizeof(uint8_t));
|
|
offset += data.size() * sizeof(uint8_t);
|
|
m_parameter[nbParameters].second = data;
|
|
nbParameters++;
|
|
}
|
|
}
|
|
|
|
zeus::ParamType zeus::BufferParameter::getParameterType(int32_t _id) const {
|
|
if (m_parameter.size() <= _id) {
|
|
ZEUS_ERROR("out of range Id for parameter ... " << _id << " have " << m_parameter.size());
|
|
return createType<void>();
|
|
}
|
|
if (m_parameter[_id].second.size() < 2) {
|
|
ZEUS_ERROR("try to get type with no ID value Type (not enouth data)");
|
|
return createType<void>();
|
|
}
|
|
uint16_t typeId = (uint16_t(m_parameter[_id].second[0]) << 8) + uint16_t(m_parameter[_id].second[1]);
|
|
if (typeId == createType<void>().getId()) { m_parameter[_id].first = 2; return createType<void>(); }
|
|
if (typeId == createType<bool>().getId()) { m_parameter[_id].first = 2; return createType<bool>(); }
|
|
if (typeId == createType<float>().getId()) { m_parameter[_id].first = 2; return createType<float>(); }
|
|
if (typeId == createType<double>().getId()) { m_parameter[_id].first = 2; return createType<double>(); }
|
|
if (typeId == createType<int64_t>().getId()) { m_parameter[_id].first = 2; return createType<int64_t>(); }
|
|
if (typeId == createType<int32_t>().getId()) { m_parameter[_id].first = 2; return createType<int32_t>(); }
|
|
if (typeId == createType<int16_t>().getId()) { m_parameter[_id].first = 2; return createType<int16_t>(); }
|
|
if (typeId == createType<int8_t>().getId()) { m_parameter[_id].first = 2; return createType<int8_t>(); }
|
|
if (typeId == createType<uint64_t>().getId()) { m_parameter[_id].first = 2; return createType<uint64_t>(); }
|
|
if (typeId == createType<uint32_t>().getId()) { m_parameter[_id].first = 2; return createType<uint32_t>(); }
|
|
if (typeId == createType<uint16_t>().getId()) { m_parameter[_id].first = 2; return createType<uint16_t>(); }
|
|
if (typeId == createType<uint8_t>().getId()) { m_parameter[_id].first = 2; return createType<uint8_t>(); }
|
|
if (typeId == createType<std::string>().getId()) { m_parameter[_id].first = 2; return createType<std::string>(); }
|
|
if (typeId == createType<std::vector<void>>().getId()) { m_parameter[_id].first = 2; return createType<std::vector<void>>(); }
|
|
if (typeId == createType<std::vector<bool>>().getId()) { m_parameter[_id].first = 2; return createType<std::vector<bool>>(); }
|
|
if (typeId == createType<std::vector<float>>().getId()) { m_parameter[_id].first = 2; return createType<std::vector<float>>(); }
|
|
if (typeId == createType<std::vector<double>>().getId()) { m_parameter[_id].first = 2; return createType<std::vector<double>>(); }
|
|
if (typeId == createType<std::vector<int64_t>>().getId()) { m_parameter[_id].first = 2; return createType<std::vector<int64_t>>(); }
|
|
if (typeId == createType<std::vector<int32_t>>().getId()) { m_parameter[_id].first = 2; return createType<std::vector<int32_t>>(); }
|
|
if (typeId == createType<std::vector<int16_t>>().getId()) { m_parameter[_id].first = 2; return createType<std::vector<int16_t>>(); }
|
|
if (typeId == createType<std::vector<int8_t>>().getId()) { m_parameter[_id].first = 2; return createType<std::vector<int8_t>>(); }
|
|
if (typeId == createType<std::vector<uint64_t>>().getId()) { m_parameter[_id].first = 2; return createType<std::vector<uint64_t>>(); }
|
|
if (typeId == createType<std::vector<uint32_t>>().getId()) { m_parameter[_id].first = 2; return createType<std::vector<uint32_t>>(); }
|
|
if (typeId == createType<std::vector<uint16_t>>().getId()) { m_parameter[_id].first = 2; return createType<std::vector<uint16_t>>(); }
|
|
if (typeId == createType<std::vector<uint8_t>>().getId()) { m_parameter[_id].first = 2; return createType<std::vector<uint8_t>>(); }
|
|
if (typeId == createType<std::vector<std::string>>().getId()) { m_parameter[_id].first = 2; return createType<std::vector<std::string>>(); }
|
|
if (typeId == createType<zeus::File>().getId()) { m_parameter[_id].first = 2; return createType<zeus::File>(); }
|
|
if (typeId == paramTypeRaw) {
|
|
m_parameter[_id].first = sizeof(uint16_t);
|
|
return zeus::ParamType("raw", paramTypeRaw);
|
|
}
|
|
if (typeId == paramTypeObject) {
|
|
std::string type = reinterpret_cast<const char*>(&m_parameter[_id].second[2]);
|
|
m_parameter[_id].first = type.size() + sizeof(uint16_t);
|
|
// TODO : Check error of \0 ==> limit at 256 char ...
|
|
return zeus::ParamType(type, paramTypeObject);
|
|
}
|
|
ZEUS_ERROR("Can not get type of parameter ... ");
|
|
return createType<void>();
|
|
}
|
|
|
|
const uint8_t* zeus::BufferParameter::getParameterPointer(int32_t _id) const {
|
|
const uint8_t* out = nullptr;
|
|
if (m_parameter.size() <= _id) {
|
|
ZEUS_ERROR("out of range Id for parameter ... " << _id << " have " << m_parameter.size());
|
|
return out;
|
|
}
|
|
if (m_parameter[_id].first <= -1) {
|
|
getParameterType(_id); // this function initialize this parameter if needed ...
|
|
}
|
|
out = reinterpret_cast<const uint8_t*>(&m_parameter[_id].second[m_parameter[_id].first]);
|
|
return out;
|
|
}
|
|
|
|
uint32_t zeus::BufferParameter::getParameterSize(int32_t _id) const {
|
|
int32_t out = 0;
|
|
if (m_parameter.size() <= _id) {
|
|
ZEUS_ERROR("out of range Id for parameter ... " << _id << " have " << m_parameter.size());
|
|
return 0;
|
|
}
|
|
if (m_parameter[_id].first <= -1) {
|
|
getParameterType(_id); // this function initialize this parameter if needed ...
|
|
}
|
|
return m_parameter[_id].second.size() - m_parameter[_id].first;
|
|
}
|
|
|
|
uint16_t zeus::BufferParameter::getNumberParameter() const {
|
|
return m_parameter.size();
|
|
}
|
|
|
|
std::string zeus::BufferParameter::simpleStringParam(uint32_t _id) const {
|
|
zeus::ParamType paramType = getParameterType(_id);
|
|
if (paramType.isVector() == false) {
|
|
if (paramType.isNumber() == true) {
|
|
return etk::to_string(getParameter<int64_t>(_id));
|
|
}
|
|
}
|
|
if (paramType == createType<bool>()) {
|
|
return etk::to_string(getParameter<bool>(_id));
|
|
}
|
|
if (paramType == createType<std::string>()) {
|
|
return "{" + getParameter<std::string>(_id) + "}";
|
|
}
|
|
if (paramType == createType<std::vector<std::string>>()) {
|
|
return "[" + etk::to_string(getParameter<std::vector<std::string>>(_id)) + "]";
|
|
}
|
|
return paramType.getName();
|
|
}
|
|
|
|
void zeus::BufferParameter::parameterAppendBufferData(ememory::SharedPtr<zeus::BufferData> _obj) {
|
|
// At this point we just add data at the parameter value:
|
|
uint16_t parameterID = _obj->getParameterId();
|
|
|
|
if (_obj->getData().size() == 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 + _obj->getData().size());
|
|
memcpy(&m_parameter[parameterID].second[offset], &_obj->getData()[0], _obj->getData().size());
|
|
}
|