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

serialize changes. #35

Closed
muellerr wants to merge 21 commits from KSat:mueller_Serialization into master
pull from: KSat:mueller_Serialization
merge into: fsfw:master
Conversation 4 Commits 21 Files Changed 50 +49 -128
3 changed files with 49 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 059f05ee48 - Show all commits

6
container/FixedMap.h
View File

@ -148,7 +148,7 @@ public:
return theMap.maxSize();
}
virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const {
ReturnValue_t result = SerializeAdapter<uint32_t>::serialize(&this->_size,
buffer, size, max_size, bigEndian);
@ -163,7 +163,7 @@ public:
return result;
}
virtual uint32_t getSerializedSize() const {
virtual size_t getSerializedSize() const {
uint32_t printSize = sizeof(_size);
uint32_t i = 0;
@ -176,7 +176,7 @@ public:
return printSize;
}
virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) {
ReturnValue_t result = SerializeAdapter<uint32_t>::deSerialize(&this->_size,
buffer, size, bigEndian);

104
serialize/SerialBufferAdapter.cpp
View File

@ -1,33 +1,29 @@
#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 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(uint8_t* buffer, T bufferLength,
bool serializeLenght) :
serializeLength(serializeLenght), constBuffer(NULL), buffer(buffer), bufferLength(
bufferLength) {
}
template<typename count_t>
SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
template<typename T>
SerialBufferAdapter<T>::~SerialBufferAdapter() {
}
template<typename count_t>
ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer,
size_t* size, const size_t max_size, bool bigEndian) const {
template<typename T>
ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const {
uint32_t serializedLength = bufferLength;
if (serializeLength) {
serializedLength += AutoSerializeAdapter::getSerializedSize(
@ -40,10 +36,10 @@ ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer,
AutoSerializeAdapter::serialize(&bufferLength, buffer, size,
max_size, bigEndian);
}
if (constBuffer != nullptr) {
memcpy(*buffer, constBuffer, bufferLength);
} else if (m_buffer != nullptr) {
memcpy(*buffer, m_buffer, bufferLength);
if (this->constBuffer != NULL) {
memcpy(*buffer, this->constBuffer, bufferLength);
} else if (this->buffer != NULL) {
memcpy(*buffer, this->buffer, bufferLength);
} else {
return HasReturnvaluesIF::RETURN_FAILED;
}
@ -53,77 +49,43 @@ ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer,
}
}
template<typename count_t>
size_t SerialBufferAdapter<count_t>::getSerializedSize() const {
template<typename T>
size_t SerialBufferAdapter<T>::getSerializedSize() const {
if (serializeLength) {
return bufferLength + AutoSerializeAdapter::getSerializedSize(&bufferLength);
} else {
return bufferLength;
}
}
template<typename count_t>
ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
template<typename T>
ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer,
size_t* size, bool bigEndian) {
//TODO Ignores Endian flag!
// (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(
if (buffer != NULL) {
if(serializeLength){
T serializedSize = AutoSerializeAdapter::getSerializedSize(
&bufferLength);
if(bufferLength + serializedSize >= *size) {
if((*size - bufferLength - serializedSize) >= 0){
*buffer += serializedSize;
*size -= serializedSize;
}
else {
}else{
return STREAM_TOO_SHORT;
}
}
//No Else If, go on with buffer
if (bufferLength >= *size) {
if (*size - bufferLength >= 0) {
*size -= bufferLength;
memcpy(m_buffer, *buffer, bufferLength);
memcpy(this->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>;

67
serialize/SerialBufferAdapter.h
View File

@ -5,73 +5,32 @@
#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 count_t>
template<typename T>
class SerialBufferAdapter: public SerializeIF {
public:
/**
* 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);
SerialBufferAdapter(const uint8_t * buffer, T bufferLength,
bool serializeLenght = false);
SerialBufferAdapter(uint8_t* buffer, T bufferLength,
bool serializeLenght = false);
virtual ~SerialBufferAdapter();
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const override;
const uint32_t max_size, bool bigEndian) const;
virtual size_t getSerializedSize() const;
/**
* @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_);
bool bigEndian);
private:
bool serializeLength = false;
const uint8_t *constBuffer = nullptr;
uint8_t *m_buffer = nullptr;
count_t bufferLength = 0;
bool serializeLength;
const uint8_t *constBuffer;
uint8_t *buffer;
T bufferLength;
};
#endif /* SERIALBUFFERADAPTER_H_ */