mohr/fsfw
1
0
Fork 0
forked from fsfw/fsfw
Code Pull Requests Activity

ssize_t in deSerialize replaced by size_t

Browse Source
This commit is contained in:
Robin Müller
2020-04-15 15:53:46 +02:00
parent af27a2441a
commit 906f941f32
47 changed files with 191 additions and 129 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
serialize/SerialArrayListAdapter.h
View File

@ -56,16 +56,19 @@ public:
return printSize;
}
virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) {
return deSerialize(adaptee, buffer, size, bigEndian);
}
static ReturnValue_t deSerialize(ArrayList<T, count_t>* list,
const uint8_t** buffer, ssize_t* size, bool bigEndian) {
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;
}

28
serialize/SerialBufferAdapter.cpp
View File

@ -61,36 +61,38 @@ size_t SerialBufferAdapter<count_t>::getSerializedSize() const {
return bufferLength;
}
}
template<typename count_t>
ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
ssize_t* size, bool bigEndian) {
size_t* size, bool bigEndian) {
//TODO Ignores Endian flag!
if (buffer != NULL) {
if(serializeLength){
// Suggestion (would require removing rest of the block inside this if clause !):
//ReturnValue_t result = AutoSerializeAdapter::deSerialize(&bufferLength,buffer,size,bigEndian);
//if (result != HasReturnvaluesIF::RETURN_OK) {
// return result;
//}
// (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(m_buffer, *buffer, bufferLength);
(*buffer) += bufferLength;
return HasReturnvaluesIF::RETURN_OK;
} else {
}
else {
return STREAM_TOO_SHORT;
}
} else {
}
else {
return HasReturnvaluesIF::RETURN_FAILED;
}
}

14
serialize/SerialBufferAdapter.h
View File

@ -49,7 +49,19 @@ public:
virtual size_t getSerializedSize() const;
virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
/**
* @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);
uint8_t * getBuffer();

20
serialize/SerialFixedArrayListAdapter.h
View File

@ -22,32 +22,38 @@
* @ingroup serialize
*/
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 {
class SerialFixedArrayListAdapter :
public FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>,
public SerializeIF {
public:
/**
* Constructor Arguments are forwarded to FixedArrayList constructor
* @param args
*/
template<typename... Args>
SerialFixedArrayListAdapter(Args... args) : FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>(std::forward<Args>(args)...) {
}
SerialFixedArrayListAdapter(Args... args) :
FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>(std::forward<Args>(args)...)
{}
ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const {
return SerialArrayListAdapter<BUFFER_TYPE, count_t>::serialize(this, buffer, size, max_size, bigEndian);
return SerialArrayListAdapter<BUFFER_TYPE, count_t>::serialize(this,
buffer, size, max_size, bigEndian);
}
size_t getSerializedSize() const {
return SerialArrayListAdapter<BUFFER_TYPE, count_t>::getSerializedSize(this);
return SerialArrayListAdapter<BUFFER_TYPE, count_t>::
getSerializedSize(this);
}
ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) {
return SerialArrayListAdapter<BUFFER_TYPE, count_t>::deSerialize(this,
buffer, size, bigEndian);
}
void swapArrayListEndianness() {
SerialArrayListAdapter<BUFFER_TYPE, count_t>::swapArrayListEndianness(this);
SerialArrayListAdapter<BUFFER_TYPE, count_t>::
swapArrayListEndianness(this);
}
};

4
serialize/SerialLinkedListAdapter.h
View File

@ -122,13 +122,13 @@ public:
* @param bigEndian Specify endianness
* @return
*/
virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) {
return deSerialize(SinglyLinkedList<T>::start, buffer, size, bigEndian);
}
static ReturnValue_t deSerialize(LinkedElement<T>* element,
const uint8_t** buffer, ssize_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);

4
serialize/SerializeAdapter.h
View File

@ -78,7 +78,7 @@ public:
}
template<typename T>
static ReturnValue_t deSerialize(T* object, const uint8_t** buffer,
ssize_t* size, bool bigEndian) {
size_t* size, bool bigEndian) {
SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
return adapter.deSerialize(object, buffer, size, bigEndian);
}
@ -98,7 +98,7 @@ public:
}
static ReturnValue_t deSerialize(T* object, const uint8_t** buffer,
ssize_t* size, bool bigEndian) {
size_t* size, bool bigEndian) {
SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
return adapter.deSerialize(object, buffer, size, bigEndian);
}

17
serialize/SerializeAdapterInternal.h
View File

@ -33,7 +33,7 @@ public:
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);
// static_assert(std::is_fundamental<T>::value);
size_t ignoredSize = 0;
if (size == nullptr) {
size = &ignoredSize;
@ -57,18 +57,17 @@ public:
/**
* Deserialize buffer into object
* @param object [out] Object to be deserialized with buffer data
* @param buffer buffer containing the data. Non-Const pointer to non-const
* pointer to const buffer.
* @param size int32_t type to allow value to be values smaller than 0,
* needed for range/size checking
* @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, ssize_t* size,
ReturnValue_t deSerialize(T* object, const uint8_t** buffer, size_t* size,
bool bigEndian) {
T tmp;
*size -= sizeof(T);
if (*size >= 0) {
if (*size >= sizeof(T)) {
*size -= sizeof(T);
memcpy(&tmp, *buffer, sizeof(T));
if (bigEndian) {
*object = EndianSwapper::swap<T>(tmp);
@ -109,7 +108,7 @@ public:
return object->getSerializedSize();
}
ReturnValue_t deSerialize(T* object, const uint8_t** buffer, ssize_t* size,
ReturnValue_t deSerialize(T* object, const uint8_t** buffer, size_t* size,
bool bigEndian) {
return object->deSerialize(buffer, size, bigEndian);
}

2
serialize/SerializeElement.h
View File

@ -41,7 +41,7 @@ public:
return SerializeAdapter<T>::getSerializedSize(&entry);
}
virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) {
return SerializeAdapter<T>::deSerialize(&entry, buffer, size, bigEndian);
}

2
serialize/SerializeIF.h
View File

@ -47,7 +47,7 @@ public:
virtual size_t getSerializedSize() const = 0;
virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) = 0;
};