KSat/fsfw
15
4
Fork 0
forked from fsfw/fsfw
Code Issues Pull Requests 3 Releases Wiki Activity

WIP: somethings wrong.. #19

Closed
muellerr wants to merge 808 commits from source/master into master
pull from: source/master
merge into: KSat:master
Conversation 0 Commits 808 Files Changed 512 +33 -32
3 changed files with 33 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 30ed08005f - Show all commits

3
datapool/DataPool.h
View File

@ -42,7 +42,8 @@ private:
/** /**
* \brief This is the actual data pool itself. * \brief This is the actual data pool itself.
* \details It is represented by a map * \details It is represented by a map
* with the data pool id as index and a pointer to a single PoolEntry as value. * with the data pool id as index and a pointer to a single
* PoolEntry as value.
*/ */
std::map<uint32_t, PoolEntryIF*> data_pool; std::map<uint32_t, PoolEntryIF*> data_pool;
public: public:

56
serialize/SerialBufferAdapter.cpp
View File

@ -5,19 +5,19 @@
template<typename count_t> template<typename count_t>
SerialBufferAdapter<count_t>::SerialBufferAdapter(const void* buffer, SerialBufferAdapter<count_t>::SerialBufferAdapter(const void* buffer,
count_t bufferLength, bool serializeLength) : count_t bufferLength, bool serializeLength) :
m_serialize_length(serializeLength), serializeLength(serializeLength),
m_const_buffer(static_cast<const uint8_t *>(buffer)), m_buffer(nullptr), constBuffer(static_cast<const uint8_t *>(buffer)), m_buffer(nullptr),
m_buffer_length(bufferLength) { bufferLength(bufferLength) {
} }
template<typename count_t> template<typename count_t>
SerialBufferAdapter<count_t>::SerialBufferAdapter(void* buffer, count_t bufferLength, SerialBufferAdapter<count_t>::SerialBufferAdapter(void* buffer, count_t bufferLength,
bool serializeLength) : bool serializeLength) :
m_serialize_length(serializeLength), m_buffer_length(bufferLength) { serializeLength(serializeLength), bufferLength(bufferLength) {
uint8_t * member_buffer = static_cast<uint8_t *>(buffer); uint8_t * member_buffer = static_cast<uint8_t *>(buffer);
m_buffer = member_buffer; m_buffer = member_buffer;
m_const_buffer = member_buffer; constBuffer = member_buffer;
} }
@ -28,37 +28,37 @@ SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
template<typename count_t> template<typename count_t>
ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer, size_t* size, ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const { const size_t max_size, bool bigEndian) const {
uint32_t serializedLength = m_buffer_length; uint32_t serializedLength = bufferLength;
if (m_serialize_length) { if (serializeLength) {
serializedLength += AutoSerializeAdapter::getSerializedSize( serializedLength += AutoSerializeAdapter::getSerializedSize(
&m_buffer_length); &bufferLength);
} }
if (*size + serializedLength > max_size) { if (*size + serializedLength > max_size) {
return BUFFER_TOO_SHORT; return BUFFER_TOO_SHORT;
} else { } else {
if (m_serialize_length) { if (serializeLength) {
AutoSerializeAdapter::serialize(&m_buffer_length, buffer, size, AutoSerializeAdapter::serialize(&bufferLength, buffer, size,
max_size, bigEndian); max_size, bigEndian);
} }
if (m_const_buffer != nullptr) { if (constBuffer != nullptr) {
memcpy(*buffer, m_const_buffer, m_buffer_length); memcpy(*buffer, constBuffer, bufferLength);
} else if (m_buffer != nullptr) { } else if (m_buffer != nullptr) {
memcpy(*buffer, m_buffer, m_buffer_length); memcpy(*buffer, m_buffer, bufferLength);
} else { } else {
return HasReturnvaluesIF::RETURN_FAILED; return HasReturnvaluesIF::RETURN_FAILED;
} }
*size += m_buffer_length; *size += bufferLength;
(*buffer) += m_buffer_length; (*buffer) += bufferLength;
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }
} }
template<typename count_t> template<typename count_t>
size_t SerialBufferAdapter<count_t>::getSerializedSize() const { size_t SerialBufferAdapter<count_t>::getSerializedSize() const {
if (m_serialize_length) { if (serializeLength) {
return m_buffer_length + AutoSerializeAdapter::getSerializedSize(&m_buffer_length); return bufferLength + AutoSerializeAdapter::getSerializedSize(&bufferLength);
} else { } else {
return m_buffer_length; return bufferLength;
} }
} }
template<typename count_t> template<typename count_t>
@ -66,15 +66,15 @@ ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
ssize_t* size, bool bigEndian) { ssize_t* size, bool bigEndian) {
//TODO Ignores Endian flag! //TODO Ignores Endian flag!
if (buffer != NULL) { if (buffer != NULL) {
if(m_serialize_length){ if(serializeLength){
// Suggestion (would require removing rest of the block inside this if clause !): // Suggestion (would require removing rest of the block inside this if clause !):
//ReturnValue_t result = AutoSerializeAdapter::deSerialize(&bufferLength,buffer,size,bigEndian); //ReturnValue_t result = AutoSerializeAdapter::deSerialize(&bufferLength,buffer,size,bigEndian);
//if (result != HasReturnvaluesIF::RETURN_OK) { //if (result != HasReturnvaluesIF::RETURN_OK) {
// return result; // return result;
//} //}
count_t serializedSize = AutoSerializeAdapter::getSerializedSize( count_t serializedSize = AutoSerializeAdapter::getSerializedSize(
&m_buffer_length); &bufferLength);
if((*size - m_buffer_length - serializedSize) >= 0){ if((*size - bufferLength - serializedSize) >= 0){
*buffer += serializedSize; *buffer += serializedSize;
*size -= serializedSize; *size -= serializedSize;
}else{ }else{
@ -82,10 +82,10 @@ ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
} }
} }
//No Else If, go on with buffer //No Else If, go on with buffer
if (*size - m_buffer_length >= 0) { if (*size - bufferLength >= 0) {
*size -= m_buffer_length; *size -= bufferLength;
memcpy(m_buffer, *buffer, m_buffer_length); memcpy(m_buffer, *buffer, bufferLength);
(*buffer) += m_buffer_length; (*buffer) += bufferLength;
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} else { } else {
return STREAM_TOO_SHORT; return STREAM_TOO_SHORT;
@ -106,17 +106,17 @@ uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
template<typename count_t> template<typename count_t>
const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() { const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
if(m_const_buffer == nullptr) { if(constBuffer == nullptr) {
error << "Wrong access function for stored type ! Use getBuffer()" << std::endl; error << "Wrong access function for stored type ! Use getBuffer()" << std::endl;
return nullptr; return nullptr;
} }
return m_const_buffer; return constBuffer;
} }
template<typename count_t> template<typename count_t>
void SerialBufferAdapter<count_t>::setBuffer(void * buffer, count_t buffer_length) { void SerialBufferAdapter<count_t>::setBuffer(void * buffer, count_t buffer_length) {
m_buffer = static_cast<uint8_t *>(buffer); m_buffer = static_cast<uint8_t *>(buffer);
m_buffer_length = buffer_length; bufferLength = buffer_length;
} }

6
serialize/SerialBufferAdapter.h
View File

@ -52,10 +52,10 @@ public:
const uint8_t * getConstBuffer(); const uint8_t * getConstBuffer();
void setBuffer(void* buffer_, count_t bufferLength_); void setBuffer(void* buffer_, count_t bufferLength_);
private: private:
bool m_serialize_length = false; bool serializeLength = false;
const uint8_t *m_const_buffer = nullptr; const uint8_t *constBuffer = nullptr;
uint8_t *m_buffer = nullptr; uint8_t *m_buffer = nullptr;
count_t m_buffer_length = 0; count_t bufferLength = 0;
}; };