eive/fsfw
15
1
Fork 0
forked from fsfw/fsfw
Code Issues Pull Requests Releases 1 Wiki Activity

Actually, not that horrible, thanks to sed

Browse Source
This commit is contained in:
Uli
2020-04-21 22:28:43 +02:00
parent a42832ca01
commit 6553450b4b
51 changed files with 458 additions and 566 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
parameters/ParameterHelper.cpp
View File

@ -83,7 +83,7 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
const ParameterWrapper* description) {
uint32_t serializedSize = description->getSerializedSize();
size_t serializedSize = description->getSerializedSize();
uint8_t *storeElement;
store_address_t address;
@ -94,10 +94,10 @@ ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
return result;
}
uint32_t storeElementSize = 0;
size_t storeElementSize = 0;
result = description->serialize(&storeElement, &storeElementSize,
serializedSize, true);
serializedSize, SerializeIF::Endianness::BIG);
if (result != HasReturnvaluesIF::RETURN_OK) {
storage->deleteData(address);

92
parameters/ParameterWrapper.cpp
View File

@ -2,41 +2,41 @@
ParameterWrapper::ParameterWrapper() :
pointsToStream(false), type(Type::UNKNOWN_TYPE), rows(0), columns(0), data(
NULL), readonlyData(NULL) {
NULL), readonlyData(NULL) {
}
ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
void* data) :
void *data) :
pointsToStream(false), type(type), rows(rows), columns(columns), data(
data), readonlyData(data) {
}
ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
const void* data) :
const void *data) :
pointsToStream(false), type(type), rows(rows), columns(columns), data(
NULL), readonlyData(data) {
NULL), readonlyData(data) {
}
ParameterWrapper::~ParameterWrapper() {
}
ReturnValue_t ParameterWrapper::serialize(uint8_t** buffer, uint32_t* size,
const uint32_t max_size, bool bigEndian) const {
ReturnValue_t ParameterWrapper::serialize(uint8_t **buffer, size_t *size,
size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result;
result = SerializeAdapter::serialize(&type, buffer, size, max_size,
bigEndian);
result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter::serialize(&columns, buffer, size,
max_size, bigEndian);
result = SerializeAdapter::serialize(&columns, buffer, size, maxSize,
streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter::serialize(&rows, buffer, size, max_size,
bigEndian);
result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
@ -47,28 +47,33 @@ ReturnValue_t ParameterWrapper::serialize(uint8_t** buffer, uint32_t* size,
}
switch (type) {
case Type::UINT8_T:
result = serializeData<uint8_t>(buffer, size, max_size, bigEndian);
result = serializeData<uint8_t>(buffer, size, maxSize,
streamEndianness);
break;
case Type::INT8_T:
result = serializeData<int8_t>(buffer, size, max_size, bigEndian);
result = serializeData<int8_t>(buffer, size, maxSize, streamEndianness);
break;
case Type::UINT16_T:
result = serializeData<uint16_t>(buffer, size, max_size, bigEndian);
result = serializeData<uint16_t>(buffer, size, maxSize,
streamEndianness);
break;
case Type::INT16_T:
result = serializeData<int16_t>(buffer, size, max_size, bigEndian);
result = serializeData<int16_t>(buffer, size, maxSize,
streamEndianness);
break;
case Type::UINT32_T:
result = serializeData<uint32_t>(buffer, size, max_size, bigEndian);
result = serializeData<uint32_t>(buffer, size, maxSize,
streamEndianness);
break;
case Type::INT32_T:
result = serializeData<int32_t>(buffer, size, max_size, bigEndian);
result = serializeData<int32_t>(buffer, size, maxSize,
streamEndianness);
break;
case Type::FLOAT:
result = serializeData<float>(buffer, size, max_size, bigEndian);
result = serializeData<float>(buffer, size, maxSize, streamEndianness);
break;
case Type::DOUBLE:
result = serializeData<double>(buffer, size, max_size, bigEndian);
result = serializeData<double>(buffer, size, maxSize, streamEndianness);
break;
default:
result = UNKNOW_DATATYPE;
@ -77,7 +82,7 @@ ReturnValue_t ParameterWrapper::serialize(uint8_t** buffer, uint32_t* size,
return result;
}
uint32_t ParameterWrapper::getSerializedSize() const {
size_t ParameterWrapper::getSerializedSize() const {
uint32_t serializedSize = 0;
serializedSize += type.getSerializedSize();
serializedSize += sizeof(rows);
@ -88,14 +93,14 @@ uint32_t ParameterWrapper::getSerializedSize() const {
}
template<typename T>
ReturnValue_t ParameterWrapper::serializeData(uint8_t** buffer, uint32_t* size,
const uint32_t max_size, bool bigEndian) const {
ReturnValue_t ParameterWrapper::serializeData(uint8_t **buffer, size_t *size,
size_t maxSize, Endianness streamEndianness) const {
const T *element = (const T*) readonlyData;
ReturnValue_t result;
uint16_t dataSize = columns * rows;
while (dataSize != 0) {
result = SerializeAdapter::serialize(element, buffer, size, max_size,
bigEndian);
result = SerializeAdapter::serialize(element, buffer, size, maxSize,
streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
@ -111,21 +116,21 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
uint8_t fromColumns) {
//treat from as a continuous Stream as we copy all of it
const uint8_t *fromAsStream = (const uint8_t *) from;
int32_t streamSize = fromRows * fromColumns * sizeof(T);
const uint8_t *fromAsStream = (const uint8_t*) from;
size_t streamSize = fromRows * fromColumns * sizeof(T);
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
//get the start element of this row in data
T *dataWithDataType = ((T *) data)
T *dataWithDataType = ((T*) data)
+ (((startingRow + fromRow) * columns) + startingColumn);
for (uint8_t fromColumn = 0; fromColumn < fromColumns; fromColumn++) {
result = SerializeAdapter::deSerialize(
dataWithDataType + fromColumn, &fromAsStream, &streamSize,
true);
SerializeIF::Endianness::BIG);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
@ -136,13 +141,14 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
}
ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
int32_t* size, bool bigEndian) {
return deSerialize(buffer, size, bigEndian, 0);
ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
size_t *size, Endianness streamEndianness) {
return deSerialize(buffer, size, streamEndianness, 0);
}
ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
int32_t* size, bool bigEndian, uint16_t startWritingAtIndex) {
ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
size_t *size, Endianness streamEndianness,
uint16_t startWritingAtIndex) {
ParameterWrapper streamDescription;
ReturnValue_t result = streamDescription.set(*buffer, *size, buffer, size);
@ -153,26 +159,26 @@ ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
return copyFrom(&streamDescription, startWritingAtIndex);
}
ReturnValue_t ParameterWrapper::set(const uint8_t* stream, int32_t streamSize,
const uint8_t **remainingStream, int32_t *remainingSize) {
ReturnValue_t ParameterWrapper::set(const uint8_t *stream, size_t streamSize,
const uint8_t **remainingStream, size_t *remainingSize) {
ReturnValue_t result = SerializeAdapter::deSerialize(&type, &stream,
&streamSize, true);
&streamSize, SerializeIF::Endianness::BIG);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter::deSerialize(&columns, &stream,
&streamSize, true);
result = SerializeAdapter::deSerialize(&columns, &stream, &streamSize,
SerializeIF::Endianness::BIG);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter::deSerialize(&rows, &stream, &streamSize,
true);
SerializeIF::Endianness::BIG);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
int32_t dataSize = type.getSize() * rows * columns;
size_t dataSize = type.getSize() * rows * columns;
if (streamSize < dataSize) {
return SerializeIF::STREAM_TOO_SHORT;
@ -194,7 +200,7 @@ ReturnValue_t ParameterWrapper::set(const uint8_t* stream, int32_t streamSize,
return HasReturnvaluesIF::RETURN_OK;
}
ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper* from,
ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
uint16_t startWritingAtIndex) {
if (data == NULL) {
return READONLY;
@ -261,7 +267,7 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper* from,
}
} else {
//need a type to do arithmetic
uint8_t *toDataWithType = (uint8_t *) data;
uint8_t *toDataWithType = (uint8_t*) data;
for (uint8_t fromRow = 0; fromRow < from->rows; fromRow++) {
memcpy(
toDataWithType

22
parameters/ParameterWrapper.h
View File

@ -25,16 +25,16 @@ public:
const void *data);
virtual ~ParameterWrapper();
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,
size_t maxSize, Endianness streamEndianness) const override;
virtual uint32_t getSerializedSize() const;
virtual size_t getSerializedSize() const override;
virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
bool bigEndian);
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
Endianness streamEndianness) override;
virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
bool bigEndian, uint16_t startWritingAtIndex = 0);
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
Endianness streamEndianness, uint16_t startWritingAtIndex = 0);
template<typename T>
ReturnValue_t getElement(T *value, uint8_t row = 0, uint8_t column = 0) const {
@ -111,8 +111,8 @@ public:
void setMatrix(const T& member) {
this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
}
ReturnValue_t set(const uint8_t *stream, int32_t streamSize,
const uint8_t **remainingStream = NULL, int32_t *remainingSize =
ReturnValue_t set(const uint8_t *stream, size_t streamSize,
const uint8_t **remainingStream = NULL, size_t *remainingSize =
NULL);
ReturnValue_t copyFrom(const ParameterWrapper *from,
@ -128,8 +128,8 @@ private:
const void *readonlyData;
template<typename T>
ReturnValue_t serializeData(uint8_t** buffer, uint32_t* size,
const uint32_t max_size, bool bigEndian) const;
ReturnValue_t serializeData(uint8_t** buffer, size_t* size,
size_t maxSize, Endianness streamEndianness) const;
template<typename T>
ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,