important bugfix for serial buffer adapter

serialize/SerialBufferAdapter.cpp

@@ -1,29 +1,28 @@
 #include <framework/serialize/SerialBufferAdapter.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <cstring>
 
+template<typename count_t>
+SerialBufferAdapter<count_t>::SerialBufferAdapter(const uint8_t* buffer,
+		count_t bufferLength, bool serializeLength) :
+		serializeLength(serializeLength),
+		constBuffer(buffer), buffer(nullptr),
+		bufferLength(bufferLength) {}
+
+template<typename count_t>
+SerialBufferAdapter<count_t>::SerialBufferAdapter(uint8_t* buffer,
+		count_t bufferLength, bool serializeLength) :
+		serializeLength(serializeLength), buffer(buffer), constBuffer(buffer),
+		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() {
 }
 
-template<typename T>
-SerialBufferAdapter<T>::SerialBufferAdapter(uint8_t* buffer, T bufferLength,
-		bool serializeLenght) :
-		serializeLength(serializeLenght), constBuffer(NULL), buffer(buffer), bufferLength(
-				bufferLength) {
-}
-
-template<typename T>
-SerialBufferAdapter<T>::~SerialBufferAdapter() {
-}
-
-template<typename T>
-ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, size_t* size,
-		const size_t max_size, bool bigEndian) const {
+template<typename count_t>
+ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer,
+		size_t* size, const size_t max_size, bool bigEndian) const {
 	uint32_t serializedLength = bufferLength;
 	if (serializeLength) {
 		serializedLength += AutoSerializeAdapter::getSerializedSize(
@@ -36,10 +35,10 @@ ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, size_t* size,
 			AutoSerializeAdapter::serialize(&bufferLength, buffer, size,
 					max_size, bigEndian);
 		}
-		if (this->constBuffer != NULL) {
-			memcpy(*buffer, this->constBuffer, bufferLength);
-		} else if (this->buffer != NULL) {
-			memcpy(*buffer, this->buffer, bufferLength);
+		if (constBuffer != nullptr) {
+			memcpy(*buffer, constBuffer, bufferLength);
+		} else if (buffer != nullptr) {
+			memcpy(*buffer, buffer, bufferLength);
 		} else {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
@@ -49,46 +48,76 @@ ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, size_t* size,
 	}
 }
 
-template<typename T>
-size_t SerialBufferAdapter<T>::getSerializedSize() const {
+template<typename count_t>
+size_t SerialBufferAdapter<count_t>::getSerializedSize() const {
 	if (serializeLength) {
 		return bufferLength + AutoSerializeAdapter::getSerializedSize(&bufferLength);
 	} else {
 		return bufferLength;
 	}
 }
-template<typename T>
-ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer,
+
+template<typename count_t>
+ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
 		size_t* size, bool bigEndian) {
 	//TODO Ignores Endian flag!
-	if (buffer != NULL) {
-		if(serializeLength){
-			T serializedSize = AutoSerializeAdapter::getSerializedSize(
+	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(this->buffer, *buffer, bufferLength);
+			memcpy(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(buffer == nullptr) {
+		sif::error << "Wrong access function for stored type !"
+				 " Use getConstBuffer()" << std::endl;
+		return nullptr;
+	}
+	return buffer;
+}
+
+template<typename count_t>
+const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
+	if(constBuffer == nullptr) {
+		sif::error << "SerialBufferAdapter: Buffers are unitialized!" << std::endl;
+		return nullptr;
+	}
+	return constBuffer;
+}
+
+template<typename count_t>
+void SerialBufferAdapter<count_t>::setBuffer(uint8_t* buffer,
+		count_t buffer_length) {
+	this->buffer = buffer;
+	bufferLength = buffer_length;
+}
+
 
 //forward Template declaration for linker
 template class SerialBufferAdapter<uint8_t>;
 template class SerialBufferAdapter<uint16_t>;
 template class SerialBufferAdapter<uint32_t>;
-template class SerialBufferAdapter<size_t>;
+

serialize/SerialBufferAdapter.h

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