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

deletd serial buffer adapter2

Browse Source
This commit is contained in:
Robin Müller 2020-04-05 15:33:24 +02:00
parent 4a35035b28
commit a65a19f583
2 changed files with 2 additions and 150 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
serialize/SerialBufferAdapter.cpp
View File

@ -40,9 +40,9 @@ ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer, uint32_t
AutoSerializeAdapter::serialize(&m_buffer_length, buffer, size,
max_size, bigEndian);
}
if (this->m_const_buffer != nullptr) {
if (m_const_buffer != nullptr) {
memcpy(*buffer, m_const_buffer, m_buffer_length);
} else if (this->m_buffer != nullptr) {
} else if (m_buffer != nullptr) {
memcpy(*buffer, m_buffer, m_buffer_length);
} else {
return HasReturnvaluesIF::RETURN_FAILED;

148
serialize/SerialBufferAdapter2.h
View File

@ -1,148 +0,0 @@
#ifndef SERIALBUFFERADAPTER2_H_
#define SERIALBUFFERADAPTER2_H_
#include <framework/serialize/SerializeIF.h>
#include <framework/serialize/SerializeAdapter.h>
#include <framework/serviceinterface/ServiceInterfaceStream.h>
#include <cstring>
/**
* 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)>> serialBufferElement.
* Right now, the SerialBufferAdapter must always be initialized with the buffer and size !
*
* \ingroup serialize
*/
template<typename BUFFER_TYPE = uint8_t, typename count_t = uint8_t>
class SerialBufferAdapter2: 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
*/
SerialBufferAdapter2(void * buffer_, count_t bufferLength_, bool serializeLength_ = false):
bufferLength(bufferLength_), serializeLength(serializeLength_) {
determineLengthInBytes(sizeof(BUFFER_TYPE));
buffer = reinterpret_cast<const uint8_t *>(buffer_);
constBuffer = NULL;
}
SerialBufferAdapter2(const void * buffer_, count_t bufferLength_, bool serializeLength_ = false):
bufferLength(bufferLength_), serializeLength(serializeLength_) {
determineLengthInBytes(sizeof(BUFFER_TYPE));
constBuffer = reinterpret_cast<const uint8_t *>(buffer_);
buffer = NULL;
}
ReturnValue_t serialize(uint8_t ** buffer, uint32_t* size,
const uint32_t max_size, bool bigEndian) const {
uint32_t serializedLength = bufferLength;
if (serializeLength) {
serializedLength += AutoSerializeAdapter::getSerializedSize(
&bufferLength);
}
if (*size + serializedLength > max_size) {
return BUFFER_TOO_SHORT;
} else {
if (serializeLength) {
AutoSerializeAdapter::serialize(&bufferLength, buffer, size,
max_size, bigEndian);
}
memcpy(*buffer, this->buffer, bufferLength);
*size += bufferLength;
(*buffer) += bufferLength;
return HasReturnvaluesIF::RETURN_OK;
}
}
uint32_t getSerializedSize() const {
if (serializeLength) {
return bufferLength + AutoSerializeAdapter::getSerializedSize(&bufferLength);
} else {
return bufferLength;
}
}
ReturnValue_t deSerialize(const uint8_t** buffer,
int32_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;
//}
count_t serializedSize = AutoSerializeAdapter::getSerializedSize(
&bufferLength);
if((*size - bufferLength - serializedSize) >= 0){
*buffer += serializedSize;
*size -= serializedSize;
}else{
return STREAM_TOO_SHORT;
}
}
//No Else If, go on with buffer
if (*size - bufferLength >= 0) {
*size -= bufferLength;
memcpy(this->buffer, *buffer, bufferLength);
(*buffer) += bufferLength;
return HasReturnvaluesIF::RETURN_OK;
} else {
return STREAM_TOO_SHORT;
}
} else {
return HasReturnvaluesIF::RETURN_FAILED;
}
}
BUFFER_TYPE * getBuffer() {
return reinterpret_cast<BUFFER_TYPE *>(buffer);
}
void setBuffer(void * buffer_, count_t bufferLength_, bool serializeLength_ = false) {
buffer = buffer_;
bufferLength = bufferLength_;
serializeLength = serializeLength_;
determineLengthInBytes(sizeof(BUFFER_TYPE));
}
void setConstBuffer(const void * buffer_, count_t bufferLength_, bool serializeLength_ = false) {
constBuffer = buffer_;
bufferLength = bufferLength_;
serializeLength = serializeLength_;
determineLengthInBytes(sizeof(BUFFER_TYPE));
}
private:
uint8_t * buffer;
const uint8_t * constBuffer;
count_t bufferLength;
bool serializeLength;
void determineLengthInBytes(uint8_t typeSize) {
switch(typeSize) {
case(1): break;
case(2):
bufferLength *= 2; break;
case(4):
bufferLength *= 4; break;
case(8):
bufferLength *= 8; break;
default:
error << "Serial Buffer Adapter 2: Invalid type size, assuming regular uint8_t." << std::endl;
error << "Detected type size: " << (int) typeSize << std::endl;
}
}
};
#endif /* SERIALBUFFERADAPTER2_H_ */