diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 1c11afd4b..812cd34b2 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -1,129 +1,129 @@
-#include "../serialize/SerialBufferAdapter.h"
-#include "../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), constBuffer(buffer), buffer(buffer),
-		bufferLength(bufferLength) {}
-
-
-template<typename count_t>
-SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
-}
-
-template<typename count_t>
-ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer,
-		size_t* size, size_t maxSize, Endianness streamEndianness) const {
-	if (serializeLength) {
-		ReturnValue_t result = SerializeAdapter::serialize(&bufferLength,
-				buffer, size, maxSize, streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-	}
-
-	if (*size + bufferLength > maxSize) {
-		return BUFFER_TOO_SHORT;
-	}
-
-	if (this->constBuffer != nullptr) {
-		std::memcpy(*buffer, this->constBuffer, bufferLength);
-	}
-	else if (this->buffer != nullptr) {
-		// This will propably be never reached, constBuffer should always be
-		// set if non-const buffer is set.
-		std::memcpy(*buffer, this->buffer, bufferLength);
-	}
-	else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	*size += bufferLength;
-	(*buffer) += bufferLength;
-	return HasReturnvaluesIF::RETURN_OK;
-
-}
-
-template<typename count_t>
-size_t SerialBufferAdapter<count_t>::getSerializedSize() const {
-	if (serializeLength) {
-		return bufferLength + SerializeAdapter::getSerializedSize(&bufferLength);
-	} else {
-		return bufferLength;
-	}
-}
-
-template<typename count_t>
-ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
-		size_t* size, Endianness streamEndianness) {
-	if (this->buffer == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	if(serializeLength){
-		count_t lengthField = 0;
-		ReturnValue_t result = SerializeAdapter::deSerialize(&lengthField,
-				buffer, size, streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		if(lengthField > bufferLength) {
-			return TOO_MANY_ELEMENTS;
-		}
-		bufferLength = lengthField;
-	}
-
-	if (bufferLength <= *size) {
-		*size -= bufferLength;
-		std::memcpy(this->buffer, *buffer, bufferLength);
-		(*buffer) += bufferLength;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-		return STREAM_TOO_SHORT;
-	}
-}
-
-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::getConstBuffer:"
-				" Buffers are unitialized!" << std::endl;
-		return nullptr;
-	}
-	return constBuffer;
-}
-
-template<typename count_t>
-void SerialBufferAdapter<count_t>::setBuffer(uint8_t* buffer,
-		count_t bufferLength) {
-	this->buffer = buffer;
-	this->constBuffer = buffer;
-	this->bufferLength = bufferLength;
-}
-
-
-//forward Template declaration for linker
-template class SerialBufferAdapter<uint8_t>;
-template class SerialBufferAdapter<uint16_t>;
-template class SerialBufferAdapter<uint32_t>;
-template class SerialBufferAdapter<uint64_t>;
-
+#include "../serialize/SerialBufferAdapter.h"
+#include "../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), constBuffer(buffer), buffer(buffer),
+		bufferLength(bufferLength) {}
+
+
+template<typename count_t>
+SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
+}
+
+template<typename count_t>
+ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer,
+		size_t* size, size_t maxSize, Endianness streamEndianness) const {
+	if (serializeLength) {
+		ReturnValue_t result = SerializeAdapter::serialize(&bufferLength,
+				buffer, size, maxSize, streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+	}
+
+	if (*size + bufferLength > maxSize) {
+		return BUFFER_TOO_SHORT;
+	}
+
+	if (this->constBuffer != nullptr) {
+		std::memcpy(*buffer, this->constBuffer, bufferLength);
+	}
+	else if (this->buffer != nullptr) {
+		// This will propably be never reached, constBuffer should always be
+		// set if non-const buffer is set.
+		std::memcpy(*buffer, this->buffer, bufferLength);
+	}
+	else {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	*size += bufferLength;
+	(*buffer) += bufferLength;
+	return HasReturnvaluesIF::RETURN_OK;
+
+}
+
+template<typename count_t>
+size_t SerialBufferAdapter<count_t>::getSerializedSize() const {
+	if (serializeLength) {
+		return bufferLength + SerializeAdapter::getSerializedSize(&bufferLength);
+	} else {
+		return bufferLength;
+	}
+}
+
+template<typename count_t>
+ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
+		size_t* size, Endianness streamEndianness) {
+	if (this->buffer == nullptr) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	if(serializeLength){
+		count_t lengthField = 0;
+		ReturnValue_t result = SerializeAdapter::deSerialize(&lengthField,
+				buffer, size, streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		if(lengthField > bufferLength) {
+			return TOO_MANY_ELEMENTS;
+		}
+		bufferLength = lengthField;
+	}
+
+	if (bufferLength <= *size) {
+		*size -= bufferLength;
+		std::memcpy(this->buffer, *buffer, bufferLength);
+		(*buffer) += bufferLength;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return STREAM_TOO_SHORT;
+	}
+}
+
+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::getConstBuffer:"
+				" Buffers are unitialized!" << std::endl;
+		return nullptr;
+	}
+	return constBuffer;
+}
+
+template<typename count_t>
+void SerialBufferAdapter<count_t>::setBuffer(uint8_t* buffer,
+		count_t bufferLength) {
+	this->buffer = buffer;
+	this->constBuffer = buffer;
+	this->bufferLength = bufferLength;
+}
+
+
+//forward Template declaration for linker
+template class SerialBufferAdapter<uint8_t>;
+template class SerialBufferAdapter<uint16_t>;
+template class SerialBufferAdapter<uint32_t>;
+template class SerialBufferAdapter<uint64_t>;
+
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index 9a89e18ba..c3dfcd8fb 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -1,78 +1,78 @@
-#ifndef SERIALBUFFERADAPTER_H_
-#define SERIALBUFFERADAPTER_H_
-
-#include "../serialize/SerializeIF.h"
-#include "../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 count_t>
-class SerialBufferAdapter: 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
-     */
-    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,
-            size_t maxSize, Endianness streamEndianness) const override;
-
-    virtual size_t getSerializedSize() const override;
-
-    /**
-     * @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,
-            Endianness streamEndianness) override;
-
-    uint8_t * getBuffer();
-    const uint8_t * getConstBuffer();
-    void setBuffer(uint8_t* buffer, count_t bufferLength);
-private:
-	bool serializeLength = false;
-	const uint8_t *constBuffer = nullptr;
-	uint8_t *buffer = nullptr;
-	count_t bufferLength = 0;
-};
-
-#endif /* SERIALBUFFERADAPTER_H_ */
+#ifndef SERIALBUFFERADAPTER_H_
+#define SERIALBUFFERADAPTER_H_
+
+#include "../serialize/SerializeIF.h"
+#include "../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 count_t>
+class SerialBufferAdapter: 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
+     */
+    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,
+            size_t maxSize, Endianness streamEndianness) const override;
+
+    virtual size_t getSerializedSize() const override;
+
+    /**
+     * @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,
+            Endianness streamEndianness) override;
+
+    uint8_t * getBuffer();
+    const uint8_t * getConstBuffer();
+    void setBuffer(uint8_t* buffer, count_t bufferLength);
+private:
+	bool serializeLength = false;
+	const uint8_t *constBuffer = nullptr;
+	uint8_t *buffer = nullptr;
+	count_t bufferLength = 0;
+};
+
+#endif /* SERIALBUFFERADAPTER_H_ */