atria-soft/zeus
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[DEBUG] start correct android RPC segfault ==> pointer alignement error

Browse Source
This commit is contained in:
Edouard DUPIN 2017-06-07 00:24:06 +02:00
parent f15e8d450d
commit 0bf98b19fb
5 changed files with 276 additions and 176 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
tools/player-video/appl/MediaDecoder.cpp
View File

@ -400,9 +400,9 @@ void appl::MediaDecoder::init(ememory::SharedPtr<ClientProperty> _property, uint
[=](uint64_t _value) mutable {
APPL_WARNING("Receive FileSize to index property");
APPL_WARNING("pppllloooppp " << _value);
m_remote->m_buffer.resize(_value, 0);
//m_remote->m_buffer.resize(_value, 0);
APPL_WARNING("pppllloooppp");
m_remote->checkIfWeNeedMoreDataFromNetwork();
//m_remote->checkIfWeNeedMoreDataFromNetwork();
APPL_WARNING("pppppplllllloooooopppppp");
return true;
});

6
zeus/message/ParamType.cpp
View File

@ -130,11 +130,5 @@ generate_basic_type(std::vector<uint16_t>, "vector:uint16", 0x010B, true, true);
generate_basic_type(std::vector<uint8_t>, "vector:uint8", 0x010C, true, true);
generate_basic_type(std::vector<std::string>, "vector:string", 0x010D, false, true);
#if 0
generate_basic_type(zeus::File, "file", 0x000E, false, false);
generate_basic_type(zeus::FileServer, "file", 0x000E, false, false);
#endif
const uint16_t zeus::message::paramTypeObject = 0xFFFF;

28
zeus/message/Parameter.cpp
View File

@ -16,6 +16,9 @@ zeus::message::Parameter::Parameter(ememory::SharedPtr<zeus::WebServer> _iface):
Message(_iface) {
}
zeus::message::Parameter::~Parameter() {
ZEUS_ERROR("remove MESSAGE parameter ...");
}
bool zeus::message::Parameter::writeOn(enet::WebSocket& _interface) {
uint8_t* data = nullptr;
@ -31,6 +34,7 @@ bool zeus::message::Parameter::writeOn(enet::WebSocket& _interface) {
}
void zeus::message::Parameter::composeWith(const uint8_t* _buffer, uint32_t _lenght) {
ZEUS_ERROR("MESSAGE parameter ... ==> clear() ...");
m_parameter.clear();
uint16_t nbParameters = 0;
if (_lenght < sizeof(uint16_t)) {
@ -40,6 +44,7 @@ void zeus::message::Parameter::composeWith(const uint8_t* _buffer, uint32_t _len
uint32_t offset = 0;
memcpy(&nbParameters, &_buffer[offset], sizeof(uint16_t));
offset += sizeof(uint16_t);
ZEUS_ERROR("MESSAGE parameter ... ==> resize() ...");
m_parameter.resize(nbParameters, std::make_pair(-1, std::vector<uint8_t>()));
// Load all Parameters
nbParameters = 0;
@ -63,7 +68,8 @@ void zeus::message::Parameter::composeWith(const uint8_t* _buffer, uint32_t _len
}
zeus::message::ParamType zeus::message::Parameter::getParameterType(int32_t _id) const {
if (m_parameter.size() <= _id) {
if (m_parameter.size() <= _id
&& _id < 0) {
ZEUS_ERROR("out of range Id for parameter ... " << _id << " have " << m_parameter.size());
return createType<void>();
}
@ -123,20 +129,34 @@ zeus::message::ParamType zeus::message::Parameter::getParameterType(int32_t _id)
const uint8_t* zeus::message::Parameter::getParameterPointer(int32_t _id) const {
const uint8_t* out = nullptr;
if (m_parameter.size() <= _id) {
if ( m_parameter.size() <= _id
&& _id < 0) {
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]);
if (m_parameter[_id].second.size() == 0) {
ZEUS_ERROR("Second parameter have no size ... ");
return out;
}
ZEUS_ERROR("Second parameter size=" << m_parameter[_id].second.size() << " first elem=" << m_parameter[_id].first);
out = static_cast<const uint8_t*>(&(m_parameter[_id].second[m_parameter[_id].first]));
{
std::vector<int16_t> tmppppp;
for (auto &it:m_parameter[_id].second) {
tmppppp.push_back(it);
}
ZEUS_ERROR(" buffer=" << tmppppp);
}
return out;
}
uint32_t zeus::message::Parameter::getParameterSize(int32_t _id) const {
int32_t out = 0;
if (m_parameter.size() <= _id) {
if (m_parameter.size() <= _id
&& _id < 0) {
ZEUS_ERROR("out of range Id for parameter ... " << _id << " have " << m_parameter.size());
return 0;
}

1
zeus/message/Parameter.hpp
View File

@ -18,6 +18,7 @@ namespace zeus {
mutable std::vector<std::pair<int32_t,std::vector<uint8_t>>> m_parameter; //!< list of the parameter (offset of start data and buffer of data (subprotocol...)
public:
Parameter(ememory::SharedPtr<zeus::WebServer> _iface);
~Parameter();
/**
* @brief Template to get a parameter with a specific type
* @param[in] _id Number of the parameter

413
zeus/message/Parameter_getParameter.cpp
View File

@ -42,6 +42,11 @@ namespace zeus {
return out;
}
// NOTE: The use of reinterpret cast is correct for all the generic machine but not for
// the small ex: ARM, whe the pointer need to be alligned ex: int64_t have all
// time an address where @%4 = 0.
// The it is better to use the copy of valu at the correct positions ...
// TODO: Do it work for CPU in BIG endien ...
template<>
uint8_t Parameter::getParameter<uint8_t>(int32_t _id) const {
@ -53,32 +58,40 @@ namespace zeus {
const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
return *tmp;
} else if (createType<uint16_t>() == type) {
const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
return std::min(*tmp, uint16_t(UCHAR_MAX));
uint16_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return std::min(tmp, uint16_t(UCHAR_MAX));
} else if (createType<uint32_t>() == type) {
const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
return std::min(*tmp, uint32_t(UCHAR_MAX));
uint32_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return std::min(tmp, uint32_t(UCHAR_MAX));
} else if (createType<uint64_t>() == type) {
const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
return std::min(*tmp, uint64_t(UCHAR_MAX));
uint64_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return std::min(tmp, uint64_t(UCHAR_MAX));
} else if (createType<int8_t>() == type) {
const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
return std::max(int8_t(0), *tmp);
} else if (createType<int16_t>() == type) {
const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
return etk::avg(int16_t(0), *tmp, int16_t(UCHAR_MAX));
int16_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return etk::avg(int16_t(0), tmp, int16_t(UCHAR_MAX));
} else if (createType<int32_t>() == type) {
const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
return etk::avg(int32_t(0), *tmp, int32_t(UCHAR_MAX));
int32_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return etk::avg(int32_t(0), tmp, int32_t(UCHAR_MAX));
} else if (createType<int64_t>() == type) {
const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
return etk::avg(int64_t(0), *tmp, int64_t(UCHAR_MAX));
int64_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return etk::avg(int64_t(0), tmp, int64_t(UCHAR_MAX));
} else if (createType<float>() == type) {
const float* tmp = reinterpret_cast<const float*>(pointer);
return uint8_t(etk::avg(float(0), *tmp, float(UCHAR_MAX)));
float tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return uint8_t(etk::avg(float(0), tmp, float(UCHAR_MAX)));
} else if (createType<double>() == type) {
const double* tmp = reinterpret_cast<const double*>(pointer);
return uint8_t(etk::avg(double(0), *tmp, double(UCHAR_MAX)));
double tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return uint8_t(etk::avg(double(0), tmp, double(UCHAR_MAX)));
}
ZEUS_ERROR("Can not get type from '" << type << "'");
return 0;
@ -93,32 +106,40 @@ namespace zeus {
const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
return *tmp;
} else if (createType<uint16_t>() == type) {
const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
return *tmp;
uint16_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return tmp;
} else if (createType<uint32_t>() == type) {
const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
return std::min(*tmp, uint32_t(USHRT_MAX));
uint32_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return std::min(tmp, uint32_t(USHRT_MAX));
} else if (createType<uint64_t>() == type) {
const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
return std::min(*tmp, uint64_t(USHRT_MAX));
uint64_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return std::min(tmp, uint64_t(USHRT_MAX));
} else if (createType<int8_t>() == type) {
const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
return std::max(int8_t(0), *tmp);
} else if (createType<int16_t>() == type) {
const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
return std::max(int16_t(0), *tmp);
int16_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return std::max(int16_t(0), tmp);
} else if (createType<int32_t>() == type) {
const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
return etk::avg(int32_t(0), *tmp, int32_t(USHRT_MAX));
int32_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return etk::avg(int32_t(0), tmp, int32_t(USHRT_MAX));
} else if (createType<int64_t>() == type) {
const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
return etk::avg(int64_t(0), *tmp, int64_t(USHRT_MAX));
int64_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return etk::avg(int64_t(0), tmp, int64_t(USHRT_MAX));
} else if (createType<float>() == type) {
const float* tmp = reinterpret_cast<const float*>(pointer);
return uint16_t(etk::avg(float(0), *tmp, float(USHRT_MAX)));
float tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return uint16_t(etk::avg(float(0), tmp, float(USHRT_MAX)));
} else if (createType<double>() == type) {
const double* tmp = reinterpret_cast<const double*>(pointer);
return uint16_t(etk::avg(double(0), *tmp, double(USHRT_MAX)));
double tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return uint16_t(etk::avg(double(0), tmp, double(USHRT_MAX)));
}
ZEUS_ERROR("Can not get type from '" << type << "'");
return 0;
@ -135,32 +156,40 @@ namespace zeus {
const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
return *tmp;
} else if (createType<uint16_t>() == type) {
const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
return *tmp;
uint16_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return tmp;
} else if (createType<uint32_t>() == type) {
const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
return *tmp;
uint32_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return tmp;
} else if (createType<uint64_t>() == type) {
const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
return std::min(*tmp, uint64_t(ULONG_MAX));
uint64_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return std::min(tmp, uint64_t(ULONG_MAX));
} else if (createType<int8_t>() == type) {
const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
return std::max(int8_t(0), *tmp);
} else if (createType<int16_t>() == type) {
const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
return std::max(int16_t(0), *tmp);
int16_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return std::max(int16_t(0), tmp);
} else if (createType<int32_t>() == type) {
const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
return std::max(int32_t(0), *tmp);
int32_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return std::max(int32_t(0), tmp);
} else if (createType<int64_t>() == type) {
const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
return etk::avg(int64_t(0), *tmp, int64_t(ULONG_MAX));
int64_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return etk::avg(int64_t(0), tmp, int64_t(ULONG_MAX));
} else if (createType<float>() == type) {
const float* tmp = reinterpret_cast<const float*>(pointer);
return uint32_t(etk::avg(float(0), *tmp, float(ULONG_MAX)));
float tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return uint32_t(etk::avg(float(0), tmp, float(ULONG_MAX)));
} else if (createType<double>() == type) {
const double* tmp = reinterpret_cast<const double*>(pointer);
return uint32_t(etk::avg(double(0), *tmp, double(ULONG_MAX)));
double tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return uint32_t(etk::avg(double(0), tmp, double(ULONG_MAX)));
}
ZEUS_ERROR("Can not get type from '" << type << "'");
return 0;
@ -169,40 +198,48 @@ namespace zeus {
template<>
uint64_t Parameter::getParameter<uint64_t>(int32_t _id) const {
zeus::message::ParamType type = getParameterType(_id);
const uint8_t* pointer = getParameterPointer(_id);
uint32_t dataSize = getParameterSize(_id);
//ZEUS_WARNING("get type " << type << " with size=" << dataSize);
uint8_t* pointer = const_cast<uint8_t*>(getParameterPointer(_id));
ZEUS_WARNING("get type " << type << " with size=" << dataSize << " pointer=" << uint64_t(pointer) << " sizeof(uint64_t)=" << int32_t(sizeof(uint64_t)));
// TODO : Check size ...
if (createType<uint8_t>() == type) {
const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
uint8_t* tmp = reinterpret_cast<uint8_t*>(pointer);
return *tmp;
} else if (createType<uint16_t>() == type) {
const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
return *tmp;
uint16_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return tmp;
} else if (createType<uint32_t>() == type) {
const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
return *tmp;
uint32_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return tmp;
} else if (createType<uint64_t>() == type) {
const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
return *tmp;
uint64_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return tmp;
} else if (createType<int8_t>() == type) {
const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
int8_t* tmp = reinterpret_cast<int8_t*>(pointer);
return std::max(int8_t(0), *tmp);
} else if (createType<int16_t>() == type) {
const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
return std::max(int16_t(0), *tmp);
int16_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return std::max(int16_t(0), tmp);
} else if (createType<int32_t>() == type) {
const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
return std::max(int32_t(0), *tmp);
int32_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return std::max(int32_t(0), tmp);
} else if (createType<int64_t>() == type) {
const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
return std::max(int64_t(0), *tmp);
int64_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return std::max(int64_t(0), tmp);
} else if (createType<float>() == type) {
const float* tmp = reinterpret_cast<const float*>(pointer);
return uint64_t(etk::avg(float(0), *tmp, float(ULONG_MAX)));
float tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return uint64_t(etk::avg(float(0), tmp, float(ULONG_MAX)));
} else if (createType<double>() == type) {
const double* tmp = reinterpret_cast<const double*>(pointer);
return uint64_t(etk::avg(double(0), *tmp, double(ULONG_MAX)));
double tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return uint64_t(etk::avg(double(0), tmp, double(ULONG_MAX)));
}
ZEUS_ERROR("Can not get type from '" << type << "'");
return 0;
@ -225,32 +262,40 @@ namespace zeus {
const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
return std::min(*tmp, uint8_t(SCHAR_MAX));
} else if (createType<uint16_t>() == type) {
const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
return std::min(*tmp, uint16_t(SCHAR_MAX));
uint16_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return std::min(tmp, uint16_t(SCHAR_MAX));
} else if (createType<uint32_t>() == type) {
const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
return std::min(*tmp, uint32_t(SCHAR_MAX));
uint32_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return std::min(tmp, uint32_t(SCHAR_MAX));
} else if (createType<uint64_t>() == type) {
const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
return std::min(*tmp, uint64_t(SCHAR_MAX));
uint64_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return std::min(tmp, uint64_t(SCHAR_MAX));
} else if (createType<int8_t>() == type) {
const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
return *tmp;
} else if (createType<int16_t>() == type) {
const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
return etk::avg(int16_t(SCHAR_MIN), *tmp, int16_t(SCHAR_MAX));
int16_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return etk::avg(int16_t(SCHAR_MIN), tmp, int16_t(SCHAR_MAX));
} else if (createType<int32_t>() == type) {
const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
return etk::avg(int32_t(SCHAR_MIN), *tmp, int32_t(SCHAR_MAX));
int32_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return etk::avg(int32_t(SCHAR_MIN), tmp, int32_t(SCHAR_MAX));
} else if (createType<int64_t>() == type) {
const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
return etk::avg(int64_t(SCHAR_MIN), *tmp, int64_t(SCHAR_MAX));
int64_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return etk::avg(int64_t(SCHAR_MIN), tmp, int64_t(SCHAR_MAX));
} else if (createType<float>() == type) {
const float* tmp = reinterpret_cast<const float*>(pointer);
return int8_t(etk::avg(float(SCHAR_MIN), *tmp, float(SCHAR_MAX)));
float tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return int8_t(etk::avg(float(SCHAR_MIN), tmp, float(SCHAR_MAX)));
} else if (createType<double>() == type) {
const double* tmp = reinterpret_cast<const double*>(pointer);
return int8_t(etk::avg(double(SCHAR_MIN), *tmp, double(SCHAR_MAX)));
double tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return int8_t(etk::avg(double(SCHAR_MIN), tmp, double(SCHAR_MAX)));
}
ZEUS_ERROR("Can not get type from '" << type << "'");
return 0;
@ -266,32 +311,40 @@ namespace zeus {
const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
return *tmp;
} else if (createType<uint16_t>() == type) {
const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
return std::min(*tmp, uint16_t(SHRT_MAX));
uint16_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return std::min(tmp, uint16_t(SHRT_MAX));
} else if (createType<uint32_t>() == type) {
const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
return std::min(*tmp, uint32_t(SHRT_MAX));
uint32_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return std::min(tmp, uint32_t(SHRT_MAX));
} else if (createType<uint64_t>() == type) {
const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
return std::min(*tmp, uint64_t(SHRT_MAX));
uint64_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return std::min(tmp, uint64_t(SHRT_MAX));
} else if (createType<int8_t>() == type) {
const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
return *tmp;
} else if (createType<int16_t>() == type) {
const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
return *tmp;
uint16_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return tmp;
} else if (createType<int32_t>() == type) {
const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
return etk::avg(int32_t(SHRT_MIN), *tmp, int32_t(SHRT_MAX));
int32_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return etk::avg(int32_t(SHRT_MIN), tmp, int32_t(SHRT_MAX));
} else if (createType<int64_t>() == type) {
const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
return etk::avg(int64_t(SHRT_MIN), *tmp, int64_t(SHRT_MAX));
int64_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return etk::avg(int64_t(SHRT_MIN), tmp, int64_t(SHRT_MAX));
} else if (createType<float>() == type) {
const float* tmp = reinterpret_cast<const float*>(pointer);
return int16_t(etk::avg(float(SHRT_MIN), *tmp, float(SHRT_MAX)));
float tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return int16_t(etk::avg(float(SHRT_MIN), tmp, float(SHRT_MAX)));
} else if (createType<double>() == type) {
const double* tmp = reinterpret_cast<const double*>(pointer);
return int16_t(etk::avg(double(SHRT_MIN), *tmp, double(SHRT_MAX)));
double tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return int16_t(etk::avg(double(SHRT_MIN), tmp, double(SHRT_MAX)));
}
ZEUS_ERROR("Can not get type from '" << type << "'");
return 0;
@ -308,32 +361,40 @@ namespace zeus {
const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
return *tmp;
} else if (createType<uint16_t>() == type) {
const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
return *tmp;
uint16_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return tmp;
} else if (createType<uint32_t>() == type) {
const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
return std::min(*tmp, uint32_t(LONG_MAX));
uint32_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return std::min(tmp, uint32_t(LONG_MAX));
} else if (createType<uint64_t>() == type) {
const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
return std::min(*tmp, uint64_t(LONG_MAX));
uint64_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return std::min(tmp, uint64_t(LONG_MAX));
} else if (createType<int8_t>() == type) {
const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
return *tmp;
} else if (createType<int16_t>() == type) {
const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
return *tmp;
int16_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return tmp;
} else if (createType<int32_t>() == type) {
const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
return *tmp;
int32_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return tmp;
} else if (createType<int64_t>() == type) {
const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
return etk::avg(int64_t(LONG_MIN), *tmp, int64_t(LONG_MAX));
int64_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return etk::avg(int64_t(LONG_MIN), tmp, int64_t(LONG_MAX));
} else if (createType<float>() == type) {
const float* tmp = reinterpret_cast<const float*>(pointer);
return int32_t(etk::avg(float(LONG_MIN), *tmp, float(LONG_MAX)));
float tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return int32_t(etk::avg(float(LONG_MIN), tmp, float(LONG_MAX)));
} else if (createType<double>() == type) {
const double* tmp = reinterpret_cast<const double*>(pointer);
return int32_t(etk::avg(double(LONG_MIN), *tmp, double(LONG_MAX)));
double tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return int32_t(etk::avg(double(LONG_MIN), tmp, double(LONG_MAX)));
}
ZEUS_ERROR("Can not get type from '" << type << "'");
return 0;
@ -350,32 +411,40 @@ namespace zeus {
const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
return *tmp;
} else if (createType<uint16_t>() == type) {
const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
return *tmp;
uint16_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return tmp;
} else if (createType<uint32_t>() == type) {
const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
return *tmp;
uint32_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return tmp;
} else if (createType<uint64_t>() == type) {
const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
return std::min(*tmp, uint64_t(LLONG_MAX));
uint64_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return std::min(tmp, uint64_t(LLONG_MAX));
} else if (createType<int8_t>() == type) {
const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
return *tmp;
} else if (createType<int16_t>() == type) {
const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
return *tmp;
int16_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return tmp;
} else if (createType<int32_t>() == type) {
const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
return *tmp;
int32_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return tmp;
} else if (createType<int64_t>() == type) {
const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
return *tmp;
int64_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return tmp;
} else if (createType<float>() == type) {
const float* tmp = reinterpret_cast<const float*>(pointer);
return int64_t(etk::avg(float(LLONG_MIN), *tmp, float(LLONG_MAX)));
float tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return int64_t(etk::avg(float(LLONG_MIN), tmp, float(LLONG_MAX)));
} else if (createType<double>() == type) {
const double* tmp = reinterpret_cast<const double*>(pointer);
return int64_t(etk::avg(double(LLONG_MIN), *tmp, double(LLONG_MAX)));
double tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return int64_t(etk::avg(double(LLONG_MIN), tmp, double(LLONG_MAX)));
}
ZEUS_ERROR("Can not get type from '" << type << "'");
return 0;
@ -391,32 +460,40 @@ namespace zeus {
const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
return *tmp;
} else if (createType<uint16_t>() == type) {
const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
return *tmp;
uint16_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return tmp;
} else if (createType<uint32_t>() == type) {
const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
return *tmp;
uint32_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return tmp;
} else if (createType<uint64_t>() == type) {
const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
return *tmp;
uint64_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return tmp;
} else if (createType<int8_t>() == type) {
const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
return *tmp;
} else if (createType<int16_t>() == type) {
const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
return *tmp;
int16_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return tmp;
} else if (createType<int32_t>() == type) {
const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
return *tmp;
int32_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return tmp;
} else if (createType<int64_t>() == type) {
const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
return *tmp;
int64_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return tmp;
} else if (createType<float>() == type) {
const float* tmp = reinterpret_cast<const float*>(pointer);
return *tmp;
float tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return tmp;
} else if (createType<double>() == type) {
const double* tmp = reinterpret_cast<const double*>(pointer);
return *tmp;
double tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return tmp;
}
ZEUS_ERROR("Can not get type from '" << type << "'");
return 0.0f;
@ -431,32 +508,40 @@ namespace zeus {
const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
return *tmp;
} else if (createType<uint16_t>() == type) {
const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
return *tmp;
uint16_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return tmp;
} else if (createType<uint32_t>() == type) {
const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
return *tmp;
uint32_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return tmp;
} else if (createType<uint64_t>() == type) {
const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
return *tmp;
uint64_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return tmp;
} else if (createType<int8_t>() == type) {
const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
return *tmp;
} else if (createType<int16_t>() == type) {
const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
return *tmp;
int16_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return tmp;
} else if (createType<int32_t>() == type) {
const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
return *tmp;
int32_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return tmp;
} else if (createType<int64_t>() == type) {
const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
return *tmp;
int64_t tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return tmp;
} else if (createType<float>() == type) {
const float* tmp = reinterpret_cast<const float*>(pointer);
return *tmp;
float tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return tmp;
} else if (createType<double>() == type) {
const double* tmp = reinterpret_cast<const double*>(pointer);
return *tmp;
double tmp;
memcpy(&tmp, pointer, sizeof(tmp));
return tmp;
}
ZEUS_ERROR("Can not get type from '" << type << "'");
return 0.0;