initial commit for github
This commit is contained in:
Pierre
commit
60968612de
370 changed files with 68427 additions and 0 deletions
445
mapping/engine/element.cpp
Normal file
445
mapping/engine/element.cpp
Normal file
|
|
@ -0,0 +1,445 @@
|
|||
/**
|
||||
* @file
|
||||
*
|
||||
* @copyright
|
||||
* @verbatim
|
||||
Copyright @ 2017 Audi Electronics Venture GmbH. All rights reserved.
|
||||
|
||||
This Source Code Form is subject to the terms of the Mozilla
|
||||
Public License, v. 2.0. If a copy of the MPL was not distributed
|
||||
with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
|
||||
|
||||
If it is not possible or desirable to put the notice in a particular file, then
|
||||
You may include the notice in a location (such as a LICENSE file in a
|
||||
relevant directory) where a recipient would be likely to look for such a notice.
|
||||
|
||||
You may add additional accurate notices of copyright ownership.
|
||||
@endverbatim
|
||||
*/
|
||||
|
||||
#include "element.h"
|
||||
|
||||
using namespace mapping;
|
||||
using namespace mapping::rt;
|
||||
|
||||
namespace mapping
|
||||
{
|
||||
namespace rt
|
||||
{
|
||||
//define all needed error types and values locally
|
||||
_MAKE_RESULT(-3, ERR_UNEXPECTED)
|
||||
_MAKE_RESULT(-5, ERR_INVALID_ARG)
|
||||
_MAKE_RESULT(-42, ERR_INVALID_TYPE)
|
||||
}
|
||||
}
|
||||
|
||||
/// Helper method that sets a casted value in the coder
|
||||
template <typename T>
|
||||
static void SetCastedValue(void* pDestination, unsigned int nArrayIndex, T* pData,
|
||||
uint32_t type32)
|
||||
{
|
||||
switch (type32)
|
||||
{
|
||||
case e_uint8:
|
||||
{
|
||||
uint8_t ui8Temp = static_cast<uint8_t>(*pData);
|
||||
a_util::memory::copy((uint8_t*)pDestination + nArrayIndex, sizeof(uint8_t), &ui8Temp, sizeof(uint8_t));
|
||||
}
|
||||
break;
|
||||
case e_uint16:
|
||||
{
|
||||
uint16_t ui16Temp = static_cast<uint16_t>(*pData);
|
||||
a_util::memory::copy((uint16_t*)pDestination + nArrayIndex, sizeof(uint16_t), &ui16Temp, sizeof(uint16_t));
|
||||
}
|
||||
break;
|
||||
case e_uint32:
|
||||
{
|
||||
uint32_t ui32Temp = static_cast<uint32_t>(*pData);
|
||||
a_util::memory::copy((uint32_t*)pDestination + nArrayIndex, sizeof(uint32_t), &ui32Temp, sizeof(uint32_t));
|
||||
}
|
||||
break;
|
||||
case e_uint64:
|
||||
{
|
||||
uint64_t ui64Temp = static_cast<uint64_t>(*pData);
|
||||
a_util::memory::copy((uint64_t*)pDestination + nArrayIndex, sizeof(uint64_t), &ui64Temp, sizeof(uint64_t));
|
||||
}
|
||||
break;
|
||||
case e_int8:
|
||||
{
|
||||
int8_t i8Temp = static_cast<int8_t>(*pData);
|
||||
a_util::memory::copy((int8_t*)pDestination + nArrayIndex, sizeof(int8_t), &i8Temp, sizeof(int8_t));
|
||||
}
|
||||
break;
|
||||
case e_int16:
|
||||
{
|
||||
int16_t i16Temp = static_cast<int16_t>(*pData);
|
||||
a_util::memory::copy((int16_t*)pDestination + nArrayIndex, sizeof(int16_t), &i16Temp, sizeof(int16_t));
|
||||
}
|
||||
break;
|
||||
case e_int32:
|
||||
{
|
||||
int32_t i32Temp = static_cast<int32_t>(*pData);
|
||||
a_util::memory::copy((int32_t*)pDestination + nArrayIndex, sizeof(int32_t), &i32Temp, sizeof(int32_t));
|
||||
}
|
||||
break;
|
||||
case e_int64:
|
||||
{
|
||||
int64_t i64Temp = static_cast<int64_t>(*pData);
|
||||
a_util::memory::copy((int64_t*)pDestination + nArrayIndex, sizeof(int64_t), &i64Temp, sizeof(int64_t));
|
||||
}
|
||||
break;
|
||||
case e_float32:
|
||||
{
|
||||
float f32Temp = static_cast<float>(*pData);
|
||||
a_util::memory::copy((float*)pDestination + nArrayIndex, sizeof(float), &f32Temp, sizeof(float));
|
||||
}
|
||||
break;
|
||||
case e_float64:
|
||||
{
|
||||
double f64Temp = static_cast<double>(*pData);
|
||||
a_util::memory::copy((double*)pDestination + nArrayIndex, sizeof(double), &f64Temp, sizeof(double));
|
||||
}
|
||||
break;
|
||||
case e_bool:
|
||||
{
|
||||
bool bTemp = *pData != 0 ? true : false;
|
||||
a_util::memory::copy((bool*)pDestination + nArrayIndex, sizeof(bool), &bTemp, sizeof(bool));
|
||||
}
|
||||
break;
|
||||
case e_char:
|
||||
{
|
||||
char cTemp = static_cast<char>(*pData);
|
||||
a_util::memory::copy((char*)pDestination + nArrayIndex, sizeof(char), &cTemp, sizeof(char));
|
||||
}
|
||||
break;
|
||||
default:
|
||||
assert(false);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
template <>
|
||||
void SetCastedValue<bool>(void* pDestination, unsigned int nArrayIndex, bool* pData,
|
||||
uint32_t type32)
|
||||
{
|
||||
int nBool = *pData ? 1 : 0;
|
||||
switch (type32)
|
||||
{
|
||||
case e_uint8:
|
||||
{
|
||||
uint8_t ui8Temp = static_cast<uint8_t>(nBool);
|
||||
a_util::memory::copy((uint8_t*)pDestination + nArrayIndex, sizeof(uint8_t), &ui8Temp, sizeof(uint8_t));
|
||||
}
|
||||
break;
|
||||
case e_uint16:
|
||||
{
|
||||
uint16_t ui16Temp = static_cast<uint16_t>(nBool);
|
||||
a_util::memory::copy((uint16_t*)pDestination + nArrayIndex, sizeof(uint16_t), &ui16Temp, sizeof(uint16_t));
|
||||
}
|
||||
break;
|
||||
case e_uint32:
|
||||
{
|
||||
uint32_t ui32Temp = static_cast<uint32_t>(nBool);
|
||||
a_util::memory::copy((uint32_t*)pDestination + nArrayIndex, sizeof(uint32_t), &ui32Temp, sizeof(uint32_t));
|
||||
}
|
||||
break;
|
||||
case e_uint64:
|
||||
{
|
||||
uint64_t ui64Temp = static_cast<uint64_t>(nBool);
|
||||
a_util::memory::copy((uint64_t*)pDestination + nArrayIndex, sizeof(uint64_t), &ui64Temp, sizeof(uint64_t));
|
||||
}
|
||||
break;
|
||||
case e_int8:
|
||||
{
|
||||
int8_t i8Temp = static_cast<int8_t>(nBool);
|
||||
a_util::memory::copy((int8_t*)pDestination + nArrayIndex, sizeof(int8_t), &i8Temp, sizeof(int8_t));
|
||||
}
|
||||
break;
|
||||
case e_int16:
|
||||
{
|
||||
int16_t i16Temp = static_cast<int16_t>(nBool);
|
||||
a_util::memory::copy((int16_t*)pDestination + nArrayIndex, sizeof(int16_t), &i16Temp, sizeof(int16_t));
|
||||
}
|
||||
break;
|
||||
case e_int32:
|
||||
{
|
||||
int32_t i32Temp = static_cast<int32_t>(nBool);
|
||||
a_util::memory::copy((int32_t*)pDestination + nArrayIndex, sizeof(int32_t), &i32Temp, sizeof(int32_t));
|
||||
}
|
||||
break;
|
||||
case e_int64:
|
||||
{
|
||||
int64_t i64Temp = static_cast<int64_t>(nBool);
|
||||
a_util::memory::copy((int64_t*)pDestination + nArrayIndex, sizeof(int64_t), &i64Temp, sizeof(int64_t));
|
||||
}
|
||||
break;
|
||||
case e_float32:
|
||||
{
|
||||
float f32Temp = static_cast<float>(nBool);
|
||||
a_util::memory::copy((float*)pDestination + nArrayIndex, sizeof(float), &f32Temp, sizeof(float));
|
||||
}
|
||||
break;
|
||||
case e_float64:
|
||||
{
|
||||
double f64Temp = static_cast<double>(nBool);
|
||||
a_util::memory::copy((double*)pDestination + nArrayIndex, sizeof(double), &f64Temp, sizeof(double));
|
||||
}
|
||||
break;
|
||||
case e_bool:
|
||||
a_util::memory::copy((bool*)pDestination + nArrayIndex, sizeof(bool), pData, sizeof(bool));
|
||||
break;
|
||||
case e_char:
|
||||
{
|
||||
char cTemp = static_cast<char>(nBool);
|
||||
a_util::memory::copy((char*)pDestination + nArrayIndex, sizeof(char), &cTemp, sizeof(char));
|
||||
}
|
||||
break;
|
||||
default:
|
||||
assert(false);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
static inline void TransformAndSetValueImpl(const void* pData, void* pDestination,
|
||||
unsigned int nArraySize, const oo::MapTransformationBase* pTrans, uint32_t type32)
|
||||
{
|
||||
assert(pTrans);
|
||||
assert(pData);
|
||||
for(unsigned int i = 0; i < nArraySize; i++)
|
||||
{
|
||||
double fValue = pTrans->evaluate(static_cast<double>(*((T*)pData + i)));
|
||||
SetCastedValue(pDestination, i, &fValue, type32);
|
||||
}
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
static inline void SetValueImpl(const void* pData, void* pDestination, unsigned int nArraySize,
|
||||
uint32_t type32)
|
||||
{
|
||||
assert(pData);
|
||||
for(unsigned int i = 0; i < nArraySize; i++)
|
||||
{
|
||||
SetCastedValue<T>(pDestination, i, (T*)pData + i, type32);
|
||||
}
|
||||
}
|
||||
|
||||
TargetElement::TargetElement(Target* pTarget) :
|
||||
_target(pTarget), _element_ptr(NULL), _type_int(0),
|
||||
_type(NULL), _struct(NULL),
|
||||
_array_size(0), _transformation(NULL)
|
||||
{
|
||||
_type_map["tUInt8"] = e_uint8;
|
||||
_type_map["tUInt16"] = e_uint16;
|
||||
_type_map["tUInt32"] = e_uint32;
|
||||
_type_map["tUInt64"] = e_uint64;
|
||||
_type_map["tInt8"] = e_int8;
|
||||
_type_map["tInt16"] = e_int16;
|
||||
_type_map["tInt32"] = e_int32;
|
||||
_type_map["tInt64"] = e_int64;
|
||||
_type_map["tFloat32"] = e_float32;
|
||||
_type_map["tFloat64"] = e_float64;
|
||||
_type_map["tBool"] = e_bool;
|
||||
_type_map["tChar"] = e_char;
|
||||
}
|
||||
|
||||
TargetElement::~TargetElement()
|
||||
{
|
||||
delete _transformation;
|
||||
_transformation = NULL;
|
||||
}
|
||||
|
||||
a_util::result::Result TargetElement::create(void* pElementPtr, ddl::IDDLDataType* pDataType,
|
||||
const unsigned int nArraySize, const std::string& strElementName)
|
||||
{
|
||||
_element_ptr = pElementPtr;
|
||||
_array_size = nArraySize;
|
||||
_element_name = strElementName;
|
||||
|
||||
_type = dynamic_cast<ddl::DDLDataType*>(pDataType);
|
||||
_struct = dynamic_cast<ddl::DDLComplex*>(pDataType);
|
||||
_enum = dynamic_cast<ddl::DDLEnum*>(pDataType);
|
||||
|
||||
if (_enum)
|
||||
{
|
||||
_type = dynamic_cast<ddl::DDLDataType*>(_enum->getTypeObject());
|
||||
if (!_type)
|
||||
{
|
||||
return ERR_UNEXPECTED;
|
||||
}
|
||||
|
||||
_enum = NULL;
|
||||
}
|
||||
|
||||
if(_type)
|
||||
{
|
||||
TypeMap::const_iterator it = _type_map.find(_type->getName());
|
||||
if(it != _type_map.end())
|
||||
{
|
||||
_type_int = it->second;
|
||||
}
|
||||
}
|
||||
|
||||
return a_util::result::SUCCESS;
|
||||
}
|
||||
|
||||
a_util::result::Result TargetElement::setTransformation(const oo::MapTransformationBase* pTransformation)
|
||||
{
|
||||
if (_transformation)
|
||||
{
|
||||
delete _transformation;
|
||||
_transformation = NULL;
|
||||
}
|
||||
|
||||
if (pTransformation)
|
||||
{
|
||||
_transformation = pTransformation->clone();
|
||||
}
|
||||
|
||||
return a_util::result::SUCCESS;
|
||||
}
|
||||
|
||||
a_util::result::Result TargetElement::setValue(const void* pData, uint32_t ui32SrcType, size_t szMem)
|
||||
{
|
||||
// Scalars (and enums converted to scalars)
|
||||
if(_type)
|
||||
{
|
||||
if(_transformation)
|
||||
{
|
||||
switch(ui32SrcType)
|
||||
{
|
||||
case e_uint8:
|
||||
TransformAndSetValueImpl<uint8_t>(pData, _element_ptr, _array_size, _transformation, _type_int);
|
||||
break;
|
||||
case e_uint16:
|
||||
TransformAndSetValueImpl<uint16_t>(pData, _element_ptr, _array_size, _transformation, _type_int);
|
||||
break;
|
||||
case e_uint32:
|
||||
TransformAndSetValueImpl<uint32_t>(pData, _element_ptr, _array_size, _transformation, _type_int);
|
||||
break;
|
||||
case e_uint64:
|
||||
TransformAndSetValueImpl<uint64_t>(pData, _element_ptr, _array_size, _transformation, _type_int);
|
||||
break;
|
||||
case e_int8:
|
||||
TransformAndSetValueImpl<int8_t>(pData, _element_ptr, _array_size, _transformation, _type_int);
|
||||
break;
|
||||
case e_int16:
|
||||
TransformAndSetValueImpl<int16_t>(pData, _element_ptr, _array_size, _transformation, _type_int);
|
||||
break;
|
||||
case e_int32:
|
||||
TransformAndSetValueImpl<int32_t>(pData, _element_ptr, _array_size, _transformation, _type_int);
|
||||
break;
|
||||
case e_int64:
|
||||
TransformAndSetValueImpl<int64_t>(pData, _element_ptr, _array_size, _transformation, _type_int);
|
||||
break;
|
||||
case e_float32:
|
||||
TransformAndSetValueImpl<float>(pData, _element_ptr, _array_size, _transformation, _type_int);
|
||||
break;
|
||||
case e_float64:
|
||||
TransformAndSetValueImpl<double>(pData, _element_ptr, _array_size, _transformation, _type_int);
|
||||
break;
|
||||
case e_bool:
|
||||
TransformAndSetValueImpl<uint8_t>(pData, _element_ptr, _array_size, _transformation, _type_int);
|
||||
break;
|
||||
case e_char:
|
||||
TransformAndSetValueImpl<char>(pData, _element_ptr, _array_size, _transformation, _type_int);
|
||||
break;
|
||||
default:
|
||||
return ERR_INVALID_TYPE;
|
||||
}
|
||||
}
|
||||
else if(_type_int == ui32SrcType)
|
||||
{
|
||||
// Source and target have the same type
|
||||
a_util::memory::copy(_element_ptr, szMem, pData, szMem);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Source and target have different types
|
||||
switch(ui32SrcType)
|
||||
{
|
||||
case e_uint8:
|
||||
SetValueImpl<uint8_t>(pData, _element_ptr, _array_size, _type_int);
|
||||
break;
|
||||
case e_uint16:
|
||||
SetValueImpl<uint16_t>(pData, _element_ptr, _array_size, _type_int);
|
||||
break;
|
||||
case e_uint32:
|
||||
SetValueImpl<uint32_t>(pData, _element_ptr, _array_size, _type_int);
|
||||
break;
|
||||
case e_uint64:
|
||||
SetValueImpl<uint64_t>(pData, _element_ptr, _array_size, _type_int);
|
||||
break;
|
||||
case e_int8:
|
||||
SetValueImpl<int8_t>(pData, _element_ptr, _array_size, _type_int);
|
||||
break;
|
||||
case e_int16:
|
||||
SetValueImpl<int16_t>(pData, _element_ptr, _array_size, _type_int);
|
||||
break;
|
||||
case e_int32:
|
||||
SetValueImpl<int32_t>(pData, _element_ptr, _array_size, _type_int);
|
||||
break;
|
||||
case e_int64:
|
||||
SetValueImpl<int64_t>(pData, _element_ptr, _array_size, _type_int);
|
||||
break;
|
||||
case e_float32:
|
||||
SetValueImpl<float>(pData, _element_ptr, _array_size, _type_int);
|
||||
break;
|
||||
case e_float64:
|
||||
SetValueImpl<double>(pData, _element_ptr, _array_size, _type_int);
|
||||
break;
|
||||
case e_bool:
|
||||
SetValueImpl<uint8_t>(pData, _element_ptr, _array_size, _type_int);
|
||||
break;
|
||||
case e_char:
|
||||
SetValueImpl<char>(pData, _element_ptr, _array_size, _type_int);
|
||||
break;
|
||||
default:
|
||||
return ERR_INVALID_TYPE;
|
||||
}
|
||||
}
|
||||
}
|
||||
else if(_struct) // Structures
|
||||
{
|
||||
// Transformations are not allowed
|
||||
a_util::memory::copy(_element_ptr, szMem, pData, szMem);
|
||||
}
|
||||
else
|
||||
{
|
||||
return ERR_INVALID_ARG;
|
||||
}
|
||||
|
||||
return a_util::result::SUCCESS;
|
||||
}
|
||||
|
||||
Target* TargetElement::getTarget()
|
||||
{
|
||||
return _target;
|
||||
}
|
||||
|
||||
a_util::result::Result TargetElement::setDefaultValue(const std::string& strDefault)
|
||||
{
|
||||
// Scalars and arrays
|
||||
if(_type)
|
||||
{
|
||||
double fVal = 0;
|
||||
if(!strDefault.empty() && a_util::strings::isDouble(strDefault))
|
||||
{
|
||||
fVal = a_util::strings::toDouble(strDefault);
|
||||
}
|
||||
|
||||
for(unsigned int i = 0; i < _array_size; i++)
|
||||
{
|
||||
SetCastedValue<double>(_element_ptr, i, &fVal, _type_int);
|
||||
}
|
||||
}
|
||||
|
||||
//Structures
|
||||
if(_struct)
|
||||
{
|
||||
//TODO: What is default value for a structure?
|
||||
return ERR_INVALID_ARG;
|
||||
}
|
||||
|
||||
return a_util::result::SUCCESS;
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue