fsfw/fsfw
fsfw/fsfw
10
3
Fork 6
Code Issues 31 Pull Requests 4 Releases 10 Wiki Activity

serialize changes.

Browse Source 
1. a lot of documentation
2. size_t introduced for both serialize and serialize
3. some features which could be useful
4. SerializeAdapter split up in interface file and internal file.
5. rest of size_t replacements (a lot of them..) will come in separate merge
   request
This commit is contained in:
Robin Müller 2020-04-15 21:10:04 +02:00
parent 9d5a30a1f6
commit 05d89e1777
10 changed files with 540 additions and 192 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
container/FixedArrayList.h
View File

@ -2,18 +2,44 @@
#define FIXEDARRAYLIST_H_
#include <framework/container/ArrayList.h>
/**
* \ingroup container
* @brief Array List with a fixed maximum size
* @ingroup container
*/
template<typename T, uint32_t MAX_SIZE, typename count_t = uint8_t>
class FixedArrayList: public ArrayList<T, count_t> {
private:
T data[MAX_SIZE];
public:
/**
* (Robin) Maybe we should also implement move assignment and move ctor.
* Or at least delete them.
*/
FixedArrayList() :
ArrayList<T, count_t>(data, MAX_SIZE) {
}
// (Robin): We could create a constructor to initialize the fixed array list with data and the known size field
// so it can be used for serialization too (with SerialFixedArrrayListAdapter)
// is this feasible?
/**
* Initialize a fixed array list with data and number of data fields.
* Endianness of entries can be swapped optionally.
* @param data_
* @param count
* @param swapArrayListEndianess
*/
FixedArrayList(T * data_, count_t count,
bool swapArrayListEndianess = false):
ArrayList<T, count_t>(data, MAX_SIZE) {
memcpy(this->data, data_, count * sizeof(T));
this->size = count;
if(swapArrayListEndianess) {
ArrayList<T, count_t>::swapArrayListEndianness();
}
}
FixedArrayList(const FixedArrayList& other) :
ArrayList<T, count_t>(data, MAX_SIZE) {
memcpy(this->data, other.data, sizeof(this->data));

31
serialize/SerialArrayListAdapter.h
View File

@ -12,7 +12,8 @@
#include <utility>
/**
* \ingroup serialize
* Also serializes length field !
* @ingroup serialize
*/
template<typename T, typename count_t = uint8_t>
class SerialArrayListAdapter : public SerializeIF {
@ -20,13 +21,15 @@ public:
SerialArrayListAdapter(ArrayList<T, count_t> *adaptee) : adaptee(adaptee) {
}
virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
const uint32_t max_size, bool bigEndian) const {
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const override {
return serialize(adaptee, buffer, size, max_size, bigEndian);
}
static ReturnValue_t serialize(const ArrayList<T, count_t>* list, uint8_t** buffer, uint32_t* size,
const uint32_t max_size, bool bigEndian) {
static ReturnValue_t serialize(const ArrayList<T, count_t>* list,
uint8_t** buffer, size_t* size, const size_t max_size,
bool bigEndian) {
// Serialize length field first
ReturnValue_t result = SerializeAdapter<count_t>::serialize(&list->size,
buffer, size, max_size, bigEndian);
count_t i = 0;
@ -38,7 +41,7 @@ public:
return result;
}
virtual uint32_t getSerializedSize() const {
virtual size_t getSerializedSize() const override {
return getSerializedSize(adaptee);
}
@ -53,16 +56,19 @@ public:
return printSize;
}
virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
bool bigEndian) {
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) override {
return deSerialize(adaptee, buffer, size, bigEndian);
}
static ReturnValue_t deSerialize(ArrayList<T, count_t>* list, const uint8_t** buffer, int32_t* size,
bool bigEndian) {
static ReturnValue_t deSerialize(ArrayList<T, count_t>* list,
const uint8_t** buffer, size_t* size, bool bigEndian) {
count_t tempSize = 0;
ReturnValue_t result = SerializeAdapter<count_t>::deSerialize(&tempSize,
buffer, size, bigEndian);
if(result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
if (tempSize > list->maxSize()) {
return SerializeIF::TOO_MANY_ELEMENTS;
}
@ -76,6 +82,11 @@ public:
}
return result;
}
static void swapArrayListEndianness(ArrayList<T, count_t>* list) {
list->swapArrayListEndianness();
}
private:
ArrayList<T, count_t> *adaptee;
};

106
serialize/SerialBufferAdapter.cpp
View File

@ -1,29 +1,33 @@
#include <framework/serialize/SerialBufferAdapter.h>
#include <framework/serviceinterface/ServiceInterfaceStream.h>
#include <cstring>
template<typename count_t>
SerialBufferAdapter<count_t>::SerialBufferAdapter(const void* buffer,
count_t bufferLength, bool serializeLength) :
serializeLength(serializeLength),
constBuffer(static_cast<const uint8_t *>(buffer)), m_buffer(nullptr),
bufferLength(bufferLength) {
template<typename T>
SerialBufferAdapter<T>::SerialBufferAdapter(const uint8_t* buffer,
T bufferLength, bool serializeLenght) :
serializeLength(serializeLenght), constBuffer(buffer), buffer(NULL), bufferLength(
bufferLength) {
}
template<typename T>
SerialBufferAdapter<T>::SerialBufferAdapter(uint8_t* buffer, T bufferLength,
bool serializeLenght) :
serializeLength(serializeLenght), constBuffer(NULL), buffer(buffer), bufferLength(
bufferLength) {
template<typename count_t>
SerialBufferAdapter<count_t>::SerialBufferAdapter(void* buffer,
count_t bufferLength, bool serializeLength) :
serializeLength(serializeLength), bufferLength(bufferLength) {
uint8_t * member_buffer = static_cast<uint8_t *>(buffer);
m_buffer = member_buffer;
constBuffer = member_buffer;
}
template<typename T>
SerialBufferAdapter<T>::~SerialBufferAdapter() {
template<typename count_t>
SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
}
template<typename T>
ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, uint32_t* size,
const uint32_t max_size, bool bigEndian) const {
template<typename count_t>
ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer,
size_t* size, const size_t max_size, bool bigEndian) const {
uint32_t serializedLength = bufferLength;
if (serializeLength) {
serializedLength += AutoSerializeAdapter::getSerializedSize(
@ -36,10 +40,10 @@ ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, uint32_t* size
AutoSerializeAdapter::serialize(&bufferLength, buffer, size,
max_size, bigEndian);
}
if (this->constBuffer != NULL) {
memcpy(*buffer, this->constBuffer, bufferLength);
} else if (this->buffer != NULL) {
memcpy(*buffer, this->buffer, bufferLength);
if (constBuffer != nullptr) {
memcpy(*buffer, constBuffer, bufferLength);
} else if (m_buffer != nullptr) {
memcpy(*buffer, m_buffer, bufferLength);
} else {
return HasReturnvaluesIF::RETURN_FAILED;
}
@ -49,43 +53,77 @@ ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, uint32_t* size
}
}
template<typename T>
uint32_t SerialBufferAdapter<T>::getSerializedSize() const {
template<typename count_t>
size_t SerialBufferAdapter<count_t>::getSerializedSize() const {
if (serializeLength) {
return bufferLength + AutoSerializeAdapter::getSerializedSize(&bufferLength);
} else {
return bufferLength;
}
}
template<typename T>
ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer,
int32_t* size, bool bigEndian) {
template<typename count_t>
ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
size_t* size, bool bigEndian) {
//TODO Ignores Endian flag!
if (buffer != NULL) {
if(serializeLength){
T serializedSize = AutoSerializeAdapter::getSerializedSize(
// (Robin) the one of the buffer? wouldn't that be an issue for serialize
// as well? SerialFixedArrayListAdapter implements swapping of buffer
// fields (if buffer type is not uint8_t)
if (buffer != nullptr) {
if(serializeLength) {
count_t serializedSize = AutoSerializeAdapter::getSerializedSize(
&bufferLength);
if((*size - bufferLength - serializedSize) >= 0){
if(bufferLength + serializedSize >= *size) {
*buffer += serializedSize;
*size -= serializedSize;
}else{
}
else {
return STREAM_TOO_SHORT;
}
}
//No Else If, go on with buffer
if (*size - bufferLength >= 0) {
if (bufferLength >= *size) {
*size -= bufferLength;
memcpy(this->buffer, *buffer, bufferLength);
memcpy(m_buffer, *buffer, bufferLength);
(*buffer) += bufferLength;
return HasReturnvaluesIF::RETURN_OK;
} else {
}
else {
return STREAM_TOO_SHORT;
}
} else {
}
else {
return HasReturnvaluesIF::RETURN_FAILED;
}
}
template<typename count_t>
uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
if(m_buffer == nullptr) {
error << "Wrong access function for stored type !"
" Use getConstBuffer()" << std::endl;
return nullptr;
}
return m_buffer;
}
template<typename count_t>
const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
if(constBuffer == nullptr) {
error << "Wrong access function for stored type !"
" Use getBuffer()" << std::endl;
return nullptr;
}
return constBuffer;
}
template<typename count_t>
void SerialBufferAdapter<count_t>::setBuffer(void * buffer,
count_t buffer_length) {
m_buffer = static_cast<uint8_t *>(buffer);
bufferLength = buffer_length;
}
//forward Template declaration for linker
template class SerialBufferAdapter<uint8_t>;

72
serialize/SerialBufferAdapter.h
View File

@ -5,31 +5,73 @@
#include <framework/serialize/SerializeAdapter.h>
/**
* This adapter provides an interface for SerializeIF to serialize or deserialize
* buffers with no length header but a known size.
*
* Additionally, the buffer length can be serialized too and will be put in
* front of the serialized buffer.
*
* Can be used with SerialLinkedListAdapter by declaring a SerializeElement with
* SerialElement<SerialBufferAdapter<bufferLengthType(will be uint8_t mostly)>>.
* Right now, the SerialBufferAdapter must always
* be initialized with the buffer and size !
*
* \ingroup serialize
*/
template<typename T>
template<typename count_t>
class SerialBufferAdapter: public SerializeIF {
public:
SerialBufferAdapter(const uint8_t * buffer, T bufferLength, bool serializeLenght = false);
SerialBufferAdapter(uint8_t* buffer, T bufferLength,
bool serializeLenght = false);
/**
* Constructor for constant uint8_t buffer. Length field can be serialized optionally.
* Type of length can be supplied as template type.
* @param buffer
* @param bufferLength
* @param serializeLength
*/
SerialBufferAdapter(const void* buffer, count_t bufferLength,
bool serializeLength = false);
/**
* Constructor for non-constant uint8_t buffer.
* Length field can be serialized optionally.
* Type of length can be supplied as template type.
* @param buffer
* @param bufferLength
* @param serializeLength Length field will be serialized with size count_t
*/
SerialBufferAdapter(void* buffer, count_t bufferLength, bool serializeLength = false);
virtual ~SerialBufferAdapter();
virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
const uint32_t max_size, bool bigEndian) const;
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const override;
virtual uint32_t getSerializedSize() const;
virtual size_t getSerializedSize() const;
virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
bool bigEndian);
/**
* @brief This function deserializes a buffer into the member buffer.
* @details
* If a length field is present, it is ignored, as the size should have
* been set in the constructor. If the size is not known beforehand,
* consider using SerialFixedArrayListAdapter instead.
* @param buffer [out] Resulting buffer
* @param size remaining size to deserialize, should be larger than buffer
* + size field size
* @param bigEndian
* @return
*/
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) override;
uint8_t * getBuffer();
const uint8_t * getConstBuffer();
void setBuffer(void* buffer_, count_t bufferLength_);
private:
bool serializeLength;
const uint8_t *constBuffer;
uint8_t *buffer;
T bufferLength;
bool serializeLength = false;
const uint8_t *constBuffer = nullptr;
uint8_t *m_buffer = nullptr;
count_t bufferLength = 0;
};
#endif /* SERIALBUFFERADAPTER_H_ */

62
serialize/SerialFixedArrayListAdapter.h
View File

@ -5,24 +5,62 @@
#include <framework/serialize/SerialArrayListAdapter.h>
/**
* \ingroup serialize
* @brief This adapter provides an interface for SerializeIF to serialize and
* deserialize buffers with a header containing the buffer length.
* @details
* Can be used by SerialLinkedListAdapter by declaring
* as a linked element with SerializeElement<SerialFixedArrayListAdapter<...>>.
* The sequence of objects is defined in the constructor by
* using the setStart and setNext functions.
*
* 1. Buffers with a size header inside that class can be declared with
* @code
* SerialFixedArrayListAdapter<BUFFER_TYPE,
* MAX_BUFFER_LENGTH, LENGTH_FIELD_TYPE> mySerialFixedArrayList(...).
* @endcode
* 2. MAX_BUFFER_LENGTH specifies the maximum allowed number of elements
* in FixedArrayList.
* 3. LENGTH_FIELD_TYPE specifies the data type of the buffer header
* containing the buffer size (defaults to 1 byte length field)
* that follows.
*
* @ingroup serialize
*/
template<typename T, uint32_t MAX_SIZE, typename count_t = uint8_t>
class SerialFixedArrayListAdapter : public FixedArrayList<T, MAX_SIZE, count_t>, public SerializeIF {
template<typename BUFFER_TYPE, uint32_t MAX_SIZE, typename count_t = uint8_t>
class SerialFixedArrayListAdapter :
public FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>,
public SerializeIF {
public:
/**
* Constructor Arguments are forwarded to FixedArrayList constructor.
* Refer to the fixed array list constructors for different options.
* @param args
*/
template<typename... Args>
SerialFixedArrayListAdapter(Args... args) : FixedArrayList<T, MAX_SIZE, count_t>(std::forward<Args>(args)...) {
SerialFixedArrayListAdapter(Args... args) :
FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>(std::forward<Args>(args)...)
{}
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const override {
return SerialArrayListAdapter<BUFFER_TYPE, count_t>::serialize(this,
buffer, size, max_size, bigEndian);
}
ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
const uint32_t max_size, bool bigEndian) const {
return SerialArrayListAdapter<T, count_t>::serialize(this, buffer, size, max_size, bigEndian);
size_t getSerializedSize() const {
return SerialArrayListAdapter<BUFFER_TYPE, count_t>::
getSerializedSize(this);
}
uint32_t getSerializedSize() const {
return SerialArrayListAdapter<T, count_t>::getSerializedSize(this);
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) override {
return SerialArrayListAdapter<BUFFER_TYPE, count_t>::deSerialize(this,
buffer, size, bigEndian);
}
ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
bool bigEndian) {
return SerialArrayListAdapter<T, count_t>::deSerialize(this, buffer, size, bigEndian);
void swapArrayListEndianness() {
SerialArrayListAdapter<BUFFER_TYPE, count_t>::
swapArrayListEndianness(this);
}
};

78
serialize/SerialLinkedListAdapter.h
View File

@ -13,26 +13,73 @@
#include <framework/serialize/SerializeIF.h>
//This is where we need the SerializeAdapter!
/**
* \ingroup serialize
/**
* @brief Implement the conversion of object data to data streams
* or vice-versa, using linked lists.
* @details
* An alternative to the AutoSerializeAdapter functions
* - All object members with a datatype are declared as
* SerializeElement<element_type> members inside the class
* implementing this adapter.
* - The element type can also be a SerialBufferAdapter to
* de-/serialize buffers with a known size
* - The element type can also be a SerialFixedArrayListAdapter to
* de-/serialize buffers with a size header, which is scanned automatically.
*
* The sequence of objects is defined in the constructor by using
* the setStart and setNext functions.
*
* 1. The serialization process is done by instantiating the class and
* calling serialize after all SerializeElement entries have been set by
* using the constructor or setter functions. An additional size variable
* can be supplied which is calculated/incremented automatically.
* 2. The deserialization process is done by instantiating the class and
* supplying a buffer with the data which is converted into an object.
* The size of data to serialize can be supplied and is
* decremented in the function. Range checking is done internally.
*
* @ingroup serialize
*/
template<typename T, typename count_t = uint8_t>
class SerialLinkedListAdapter: public SinglyLinkedList<T>, public SerializeIF {
public:
/**
* Copying is forbidden by deleting the copy constructor and the copy
* assignment operator because of the pointers to the linked list members.
* Unless the child class implements an own copy constructor or
* copy assignment operator, these operation will throw a compiler error.
* @param
*/
SerialLinkedListAdapter(const SerialLinkedListAdapter &) = delete;
SerialLinkedListAdapter& operator=(const SerialLinkedListAdapter&) = delete;
SerialLinkedListAdapter(typename LinkedElement<T>::Iterator start,
bool printCount = false) :
SinglyLinkedList<T>(start), printCount(printCount) {
}
SerialLinkedListAdapter(LinkedElement<T>* first, bool printCount = false) :
SinglyLinkedList<T>(first), printCount(printCount) {
}
SerialLinkedListAdapter(bool printCount = false) :
SinglyLinkedList<T>(), printCount(printCount) {
}
virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
const uint32_t max_size, bool bigEndian) const {
/**
* Serialize object implementing this adapter into the supplied buffer
* and calculate the serialized size
* @param buffer [out] Object is serialized into this buffer.
* Note that the buffer pointer *buffer is incremented automatically
* inside the respective serialize functions
* @param size [out] Calculated serialized size. Don't forget to set to 0.
* @param max_size
* @param bigEndian Specify endianness
* @return
*/
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const override{
if (printCount) {
count_t mySize = SinglyLinkedList<T>::getSize();
ReturnValue_t result = SerializeAdapter<count_t>::serialize(&mySize,
@ -46,7 +93,7 @@ public:
}
static ReturnValue_t serialize(const LinkedElement<T>* element,
uint8_t** buffer, uint32_t* size, const uint32_t max_size,
uint8_t** buffer, size_t* size, const size_t max_size,
bool bigEndian) {
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
@ -56,7 +103,9 @@ public:
}
return result;
}
virtual uint32_t getSerializedSize() const {
virtual size_t getSerializedSize() const override {
if (printCount) {
return SerialLinkedListAdapter<T>::getSerializedSize()
+ sizeof(count_t);
@ -64,6 +113,7 @@ public:
return getSerializedSize(SinglyLinkedList<T>::start);
}
}
static uint32_t getSerializedSize(const LinkedElement<T> *element) {
uint32_t size = 0;
while (element != NULL) {
@ -73,13 +123,22 @@ public:
return size;
}
virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
bool bigEndian) {
/**
* Deserialize supplied buffer with supplied size into object
* implementing this adapter.
* @param buffer
* @param size Decremented in respective deSerialize functions automatically
* @param bigEndian Specify endianness
* @return
*/
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) override {
return deSerialize(SinglyLinkedList<T>::start, buffer, size, bigEndian);
}
static ReturnValue_t deSerialize(LinkedElement<T>* element,
const uint8_t** buffer, int32_t* size, bool bigEndian) {
const uint8_t** buffer, size_t* size, bool bigEndian) {
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
result = element->value->deSerialize(buffer, size, bigEndian);
@ -89,7 +148,6 @@ public:
}
bool printCount;
};
#endif /* SERIALLINKEDLISTADAPTER_H_ */

166
serialize/SerializeAdapter.h
View File

@ -1,82 +1,86 @@
#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 <string.h>
#include <framework/serialize/SerializeAdapterInternal.h>
#include <type_traits>
/**
* \ingroup serialize
/**
* @brief These adapters provides an interface to use the SerializeIF functions
* with arbitrary template objects to facilitate and simplify the
* 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_ {
// No type specification necessary here.
class AutoSerializeAdapter {
public:
template<typename T>
static ReturnValue_t serialize(const T* object, uint8_t** buffer,
uint32_t* size, const uint32_t max_size, bool bigEndian) {
uint32_t ignoredSize = 0;
if (size == NULL) {
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;
}
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);
}
ReturnValue_t deSerialize(T* object, const uint8_t** buffer, int32_t* size,
bool bigEndian) {
T tmp;
*size -= sizeof(T);
if (*size >= 0) {
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;
}
template<typename T>
static size_t getSerializedSize(const T* object) {
SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
return adapter.getSerializedSize(object);
}
uint32_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, uint32_t* size,
const uint32_t max_size, bool bigEndian) const {
uint32_t ignoredSize = 0;
if (size == NULL) {
size = &ignoredSize;
}
return object->serialize(buffer, size, max_size, bigEndian);
}
uint32_t getSerializedSize(const T* object) const {
return object->getSerializedSize();
}
ReturnValue_t deSerialize(T* object, const uint8_t** buffer, int32_t* size,
bool bigEndian) {
return object->deSerialize(buffer, size, bigEndian);
template<typename T>
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);
}
};
@ -84,7 +88,7 @@ template<typename T>
class SerializeAdapter {
public:
static ReturnValue_t serialize(const T* object, uint8_t** buffer,
uint32_t* size, const uint32_t max_size, bool bigEndian) {
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);
}
@ -94,29 +98,7 @@ public:
}
static ReturnValue_t deSerialize(T* object, const uint8_t** buffer,
int32_t* size, bool bigEndian) {
SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
return adapter.deSerialize(object, buffer, size, bigEndian);
}
};
class AutoSerializeAdapter {
public:
template<typename T>
static ReturnValue_t serialize(const T* object, uint8_t** buffer,
uint32_t* size, const uint32_t max_size, bool bigEndian) {
SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
return adapter.serialize(object, buffer, size, max_size, bigEndian);
}
template<typename T>
static uint32_t getSerializedSize(const T* object) {
SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
return adapter.getSerializedSize(object);
}
template<typename T>
static ReturnValue_t deSerialize(T* object, const uint8_t** buffer,
int32_t* size, bool bigEndian) {
size_t* size, bool bigEndian) {
SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
return adapter.deSerialize(object, buffer, size, bigEndian);
}

118
serialize/SerializeAdapterInternal.h Normal file
View File

@ -0,0 +1,118 @@
/**
* @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_ */

38
serialize/SerializeElement.h
View File

@ -6,31 +6,47 @@
#include <utility>
/**
* \ingroup serialize
* @brief This class is used to mark datatypes for serialization with the
* SerialLinkedListAdapter
* @details
* Used by declaring any arbitrary datatype with SerializeElement<T> myVariable,
* inside a SerialLinkedListAdapter implementation and setting the sequence
* of objects with setNext() and setStart().
* Serilization and Deserialization is then performed automatically in
* specified sequence order.
* @ingroup serialize
*/
template<typename T>
class SerializeElement : public SerializeIF, public LinkedElement<SerializeIF> {
public:
/**
* Arguments are forwarded to the element datatype constructor
* @param args
*/
template<typename... Args>
SerializeElement(Args... args) : LinkedElement<SerializeIF>(this), entry(std::forward<Args>(args)...) {
SerializeElement(Args... args):
LinkedElement<SerializeIF>(this),
entry(std::forward<Args>(args)...) {}
SerializeElement() : LinkedElement<SerializeIF>(this) {}
}
SerializeElement() : LinkedElement<SerializeIF>(this) {
}
T entry;
ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
const uint32_t max_size, bool bigEndian) const {
return SerializeAdapter<T>::serialize(&entry, buffer, size, max_size, bigEndian);
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const override {
return SerializeAdapter<T>::serialize(&entry, buffer, size,
max_size, bigEndian);
}
uint32_t getSerializedSize() const {
size_t getSerializedSize() const {
return SerializeAdapter<T>::getSerializedSize(&entry);
}
virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
bool bigEndian) {
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) override {
return SerializeAdapter<T>::deSerialize(&entry, buffer, size, bigEndian);
}
operator T() {
return entry;
}

33
serialize/SerializeIF.h
View File

@ -2,15 +2,34 @@
#define SERIALIZEIF_H_
#include <framework/returnvalues/HasReturnvaluesIF.h>
#include <cstddef>
/**
* \defgroup serialize Serialization
* @defgroup serialize Serialization
* Contains serialisation services.
*/
/**
* Translation of objects into data streams.
* \ingroup serialize
* @brief An interface for alle classes which require
* translation of objects data into data streams and vice-versa.
* @details
* If the target architecture is little endian (e.g. ARM), any data types
* created might have the wrong endianess if they are to be used for the FSFW.
* Depending on the system architecture, endian correctness must be assured,
* This is important for incoming and outgoing data. The internal handling
* of data should be performed in the native system endianness.
* There are three ways to copy data (with different options to ensure
* endian correctness):
*
* 1. Use the @c AutoSerializeAdapter::deSerialize function (with
* the endian flag)
* 2. Perform a bitshift operation (with correct order)
* 3. @c memcpy (with @c EndianSwapper if necessary)
*
* When serializing for downlink, the packets are generally serialized
* assuming big endian data format like seen in TmPacketStored.cpp for example.
*
* @ingroup serialize
*/
class SerializeIF {
public:
@ -22,12 +41,12 @@ public:
virtual ~SerializeIF() {
}
virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
const uint32_t max_size, bool bigEndian) const = 0;
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const = 0;
virtual uint32_t getSerializedSize() const = 0;
virtual size_t getSerializedSize() const = 0;
virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) = 0;
};