removed internal file. reverted most changes
is going to be refactored anyway.
This commit is contained in:
parent
a88a73a9be
commit
d71a4ab654
@ -1,10 +1,11 @@
|
||||
#ifndef SERIALIZEADAPTER_H_
|
||||
#define SERIALIZEADAPTER_H_
|
||||
|
||||
#include <framework/container/IsDerivedFrom.h>
|
||||
#include <framework/returnvalues/HasReturnvaluesIF.h>
|
||||
#include <framework/serialize/EndianSwapper.h>
|
||||
#include <framework/serialize/SerializeIF.h>
|
||||
#include <framework/serialize/SerializeAdapterInternal.h>
|
||||
#include <type_traits>
|
||||
#include <string.h>
|
||||
|
||||
/**
|
||||
* @brief These adapters provides an interface to use the SerializeIF functions
|
||||
@ -12,57 +13,98 @@
|
||||
* serialization of classes with different multiple different data types
|
||||
* into buffers and vice-versa.
|
||||
* @details
|
||||
*
|
||||
* A report class is converted into a TM buffer. The report class implements a
|
||||
* serialize functions and calls the AutoSerializeAdapter::serialize function
|
||||
* repeatedly on all object data fields. The getSerializedSize function is
|
||||
* implemented by calling the AutoSerializeAdapter::getSerializedSize function
|
||||
* repeatedly on all data fields.
|
||||
*
|
||||
* The AutoSerializeAdapter functions can also be used as an alternative to
|
||||
* memcpy to retrieve data out of a buffer directly into a class variable
|
||||
* with data type T while being able to specify endianness. The boolean
|
||||
* bigEndian specifies whether an endian swap is performed on the data before
|
||||
* serialization or deserialization.
|
||||
*
|
||||
* There are three ways to retrieve data out of a buffer to be used in the FSFW
|
||||
* to use regular aligned (big endian) data. Examples:
|
||||
*
|
||||
* 1. Use the AutoSerializeAdapter::deSerialize function
|
||||
* The pointer *buffer will be incremented automatically by the typeSize
|
||||
* of the object, so this function can be called on &buffer repeatedly
|
||||
* without adjusting pointer position. Set bigEndian parameter to true
|
||||
* to perform endian swapping, if necessary
|
||||
* @code
|
||||
* uint16_t data;
|
||||
* int32_t dataLen = sizeof(data);
|
||||
* ReturnValue_t result =
|
||||
* AutoSerializeAdapter::deSerialize(&data,&buffer,&dataLen,true);
|
||||
* @endcode
|
||||
*
|
||||
* 2. Perform a bitshift operation. Watch for for endianness:
|
||||
* @code
|
||||
* uint16_t data;
|
||||
* data = buffer[targetByte1] << 8 | buffer[targetByte2];
|
||||
* data = EndianSwapper::swap(data); //optional, or swap order above
|
||||
* @endcode
|
||||
*
|
||||
* 3. memcpy or std::copy can also be used, but watch out if system
|
||||
* endianness is different from required data endianness.
|
||||
* Perform endian-swapping if necessary.
|
||||
* @code
|
||||
* uint16_t data;
|
||||
* memcpy(&data,buffer + positionOfTargetByte1,sizeof(data));
|
||||
* data = EndianSwapper::swap(data); //optional
|
||||
* @endcode
|
||||
*
|
||||
* When serializing for downlink, the packets are generally serialized assuming
|
||||
* big endian data format like seen in TmPacketStored.cpp for example.
|
||||
*
|
||||
* @ingroup serialize
|
||||
*/
|
||||
template<typename T, int>
|
||||
class SerializeAdapter_ {
|
||||
public:
|
||||
static ReturnValue_t serialize(const T* object, uint8_t** buffer,
|
||||
size_t* size, const size_t max_size, bool bigEndian) {
|
||||
size_t ignoredSize = 0;
|
||||
if (size == nullptr) {
|
||||
size = &ignoredSize;
|
||||
}
|
||||
if (sizeof(T) + *size <= max_size) {
|
||||
T tmp;
|
||||
if (bigEndian) {
|
||||
tmp = EndianSwapper::swap<T>(*object);
|
||||
} else {
|
||||
tmp = *object;
|
||||
}
|
||||
memcpy(*buffer, &tmp, sizeof(T));
|
||||
*size += sizeof(T);
|
||||
(*buffer) += sizeof(T);
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
} else {
|
||||
return SerializeIF::BUFFER_TOO_SHORT;
|
||||
}
|
||||
}
|
||||
|
||||
ReturnValue_t deSerialize(T* object, const uint8_t** buffer, size_t* size,
|
||||
bool bigEndian) {
|
||||
T tmp;
|
||||
if (*size >= sizeof(T)) {
|
||||
memcpy(&tmp, *buffer, sizeof(T));
|
||||
if (bigEndian) {
|
||||
*object = EndianSwapper::swap<T>(tmp);
|
||||
} else {
|
||||
*object = tmp;
|
||||
}
|
||||
*buffer += sizeof(T);
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
} else {
|
||||
return SerializeIF::STREAM_TOO_SHORT;
|
||||
}
|
||||
}
|
||||
|
||||
size_t getSerializedSize(const T * object) {
|
||||
return sizeof(T);
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
class SerializeAdapter_<T, 1> {
|
||||
public:
|
||||
ReturnValue_t serialize(const T* object, uint8_t** buffer, size_t* size,
|
||||
const size_t max_size, bool bigEndian) const {
|
||||
size_t ignoredSize = 0;
|
||||
if (size == nullptr) {
|
||||
size = &ignoredSize;
|
||||
}
|
||||
return object->serialize(buffer, size, max_size, bigEndian);
|
||||
}
|
||||
size_t getSerializedSize(const T* object) const {
|
||||
return object->getSerializedSize();
|
||||
}
|
||||
|
||||
ReturnValue_t deSerialize(T* object, const uint8_t** buffer, size_t* size,
|
||||
bool bigEndian) {
|
||||
return object->deSerialize(buffer, size, bigEndian);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
class SerializeAdapter {
|
||||
public:
|
||||
static ReturnValue_t serialize(const T* object, uint8_t** buffer,
|
||||
size_t* size, const size_t max_size, bool bigEndian) {
|
||||
SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
|
||||
return adapter.serialize(object, buffer, size, max_size, bigEndian);
|
||||
}
|
||||
static size_t getSerializedSize(const T* object) {
|
||||
SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
|
||||
return adapter.getSerializedSize(object);
|
||||
}
|
||||
|
||||
static ReturnValue_t deSerialize(T* object, const uint8_t** buffer,
|
||||
size_t* size, bool bigEndian) {
|
||||
SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
|
||||
return adapter.deSerialize(object, buffer, size, bigEndian);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
// No type specification necessary here.
|
||||
class AutoSerializeAdapter {
|
||||
public:
|
||||
template<typename T>
|
||||
@ -84,24 +126,4 @@ public:
|
||||
}
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
class SerializeAdapter {
|
||||
public:
|
||||
static ReturnValue_t serialize(const T* object, uint8_t** buffer,
|
||||
size_t* size, const size_t max_size, bool bigEndian) {
|
||||
SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
|
||||
return adapter.serialize(object, buffer, size, max_size, bigEndian);
|
||||
}
|
||||
static uint32_t getSerializedSize(const T* object) {
|
||||
SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
|
||||
return adapter.getSerializedSize(object);
|
||||
}
|
||||
|
||||
static ReturnValue_t deSerialize(T* object, const uint8_t** buffer,
|
||||
size_t* size, bool bigEndian) {
|
||||
SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
|
||||
return adapter.deSerialize(object, buffer, size, bigEndian);
|
||||
}
|
||||
};
|
||||
|
||||
#endif /* SERIALIZEADAPTER_H_ */
|
||||
|
@ -1,118 +0,0 @@
|
||||
/**
|
||||
* @file SerializeAdapterInternal.h
|
||||
*
|
||||
* @date 13.04.2020
|
||||
* @author R. Mueller
|
||||
*/
|
||||
|
||||
#ifndef FRAMEWORK_SERIALIZE_SERIALIZEADAPTERINTERNAL_H_
|
||||
#define FRAMEWORK_SERIALIZE_SERIALIZEADAPTERINTERNAL_H_
|
||||
#include <framework/returnvalues/HasReturnvaluesIF.h>
|
||||
#include <framework/container/IsDerivedFrom.h>
|
||||
#include <framework/serialize/EndianSwapper.h>
|
||||
|
||||
/**
|
||||
* This template specialization will be chosen for fundamental types or
|
||||
* anything else not implementing SerializeIF, based on partial
|
||||
* template specialization.
|
||||
* @tparam T
|
||||
* @tparam
|
||||
*/
|
||||
template<typename T, int>
|
||||
class SerializeAdapter_ {
|
||||
public:
|
||||
/**
|
||||
*
|
||||
* @param object
|
||||
* @param buffer
|
||||
* @param size
|
||||
* @param max_size
|
||||
* @param bigEndian
|
||||
* @return
|
||||
*/
|
||||
static ReturnValue_t serialize(const T* object, uint8_t** buffer,
|
||||
size_t* size, const size_t max_size, bool bigEndian) {
|
||||
// function eventuelly serializes structs here.
|
||||
// does this work on every architecture?
|
||||
// static_assert(std::is_fundamental<T>::value);
|
||||
size_t ignoredSize = 0;
|
||||
if (size == nullptr) {
|
||||
size = &ignoredSize;
|
||||
}
|
||||
if (sizeof(T) + *size <= max_size) {
|
||||
T tmp;
|
||||
if (bigEndian) {
|
||||
tmp = EndianSwapper::swap<T>(*object);
|
||||
} else {
|
||||
tmp = *object;
|
||||
}
|
||||
memcpy(*buffer, &tmp, sizeof(T));
|
||||
*size += sizeof(T);
|
||||
(*buffer) += sizeof(T);
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
} else {
|
||||
return SerializeIF::BUFFER_TOO_SHORT;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Deserialize buffer into object
|
||||
* @param object [out] Object to be deserialized with buffer data
|
||||
* @param buffer contains the data. Non-Const pointer to non-const
|
||||
* pointer to const data.
|
||||
* @param size Size to deSerialize. wil be decremented by sizeof(T)
|
||||
* @param bigEndian Specify endianness
|
||||
* @return
|
||||
*/
|
||||
ReturnValue_t deSerialize(T* object, const uint8_t** buffer, size_t* size,
|
||||
bool bigEndian) {
|
||||
T tmp;
|
||||
if (*size >= sizeof(T)) {
|
||||
*size -= sizeof(T);
|
||||
memcpy(&tmp, *buffer, sizeof(T));
|
||||
if (bigEndian) {
|
||||
*object = EndianSwapper::swap<T>(tmp);
|
||||
} else {
|
||||
*object = tmp;
|
||||
}
|
||||
*buffer += sizeof(T);
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
} else {
|
||||
return SerializeIF::STREAM_TOO_SHORT;
|
||||
}
|
||||
}
|
||||
|
||||
size_t getSerializedSize(const T * object) {
|
||||
return sizeof(T);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* This template specialization will be chosen for class derived from
|
||||
* SerializeIF, based on partial template specialization.
|
||||
* @tparam T
|
||||
* @tparam
|
||||
*/
|
||||
template<typename T>
|
||||
class SerializeAdapter_<T, true> {
|
||||
public:
|
||||
ReturnValue_t serialize(const T* object, uint8_t** buffer, size_t* size,
|
||||
const size_t max_size, bool bigEndian) const {
|
||||
size_t ignoredSize = 0;
|
||||
if (size == NULL) {
|
||||
size = &ignoredSize;
|
||||
}
|
||||
return object->serialize(buffer, size, max_size, bigEndian);
|
||||
}
|
||||
|
||||
size_t getSerializedSize(const T* object) const {
|
||||
return object->getSerializedSize();
|
||||
}
|
||||
|
||||
ReturnValue_t deSerialize(T* object, const uint8_t** buffer, size_t* size,
|
||||
bool bigEndian) {
|
||||
return object->deSerialize(buffer, size, bigEndian);
|
||||
}
|
||||
};
|
||||
|
||||
#endif /* FRAMEWORK_SERIALIZE_SERIALIZEADAPTERINTERNAL_H_ */
|
Loading…
Reference in New Issue
Block a user