diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 6ac2894fe..978d8029a 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -2,83 +2,79 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <cstring>
 
-template<typename T>
-SerialBufferAdapter<T>::SerialBufferAdapter(const uint8_t* buffer,
-		T bufferLength, bool serializeLength) :
-		currentBufferType(bufferType::CONST), serializeLength(serializeLength),
-		constBuffer(buffer), buffer(NULL), bufferLength(bufferLength) {
+template<typename count_t>
+SerialBufferAdapter<count_t>::SerialBufferAdapter(const void* buffer,
+		count_t bufferLength, bool serializeLength) :
+		m_serialize_length(serializeLength),
+		m_const_buffer(static_cast<const uint8_t *>(buffer)), m_buffer(nullptr),
+		m_buffer_length(bufferLength) {
 
 }
 
-template<typename T>
-SerialBufferAdapter<T>::SerialBufferAdapter(uint8_t* buffer, T bufferLength,
+template<typename count_t>
+SerialBufferAdapter<count_t>::SerialBufferAdapter(void* buffer, count_t bufferLength,
 		bool serializeLength) :
-		currentBufferType(bufferType::NORMAL),serializeLength(serializeLength), constBuffer(NULL), buffer(buffer),
-		bufferLength(bufferLength) {
+		m_serialize_length(serializeLength), m_buffer_length(bufferLength) {
+	uint8_t * member_buffer = static_cast<uint8_t *>(buffer);
+	m_buffer = member_buffer;
+	m_const_buffer = member_buffer;
 }
 
-template<typename T>
-SerialBufferAdapter<T>::SerialBufferAdapter(uint32_t* buffer,
-		T bufferLength, bool serializeLength) :
-		currentBufferType(bufferType::NORMAL),serializeLength(serializeLength),
-		constBuffer(NULL), buffer(reinterpret_cast<uint8_t *>(buffer)),
-		bufferLength(bufferLength*4) {
+
+template<typename count_t>
+SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
 }
 
-template<typename T>
-SerialBufferAdapter<T>::~SerialBufferAdapter() {
-}
-
-template<typename T>
-ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, uint32_t* size,
+template<typename count_t>
+ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer, uint32_t* size,
 		const uint32_t max_size, bool bigEndian) const {
-	uint32_t serializedLength = bufferLength;
-	if (serializeLength) {
+	uint32_t serializedLength = m_buffer_length;
+	if (m_serialize_length) {
 		serializedLength += AutoSerializeAdapter::getSerializedSize(
-				&bufferLength);
+				&m_buffer_length);
 	}
 	if (*size + serializedLength > max_size) {
 		return BUFFER_TOO_SHORT;
 	} else {
-		if (serializeLength) {
-			AutoSerializeAdapter::serialize(&bufferLength, buffer, size,
+		if (m_serialize_length) {
+			AutoSerializeAdapter::serialize(&m_buffer_length, 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 (this->m_const_buffer != nullptr) {
+			memcpy(*buffer, m_const_buffer, m_buffer_length);
+		} else if (this->m_buffer != nullptr) {
+			memcpy(*buffer, m_buffer, m_buffer_length);
 		} else {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
-		*size += bufferLength;
-		(*buffer) += bufferLength;
+		*size += m_buffer_length;
+		(*buffer) += m_buffer_length;
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 }
 
-template<typename T>
-uint32_t SerialBufferAdapter<T>::getSerializedSize() const {
-	if (serializeLength) {
-		return bufferLength + AutoSerializeAdapter::getSerializedSize(&bufferLength);
+template<typename count_t>
+uint32_t SerialBufferAdapter<count_t>::getSerializedSize() const {
+	if (m_serialize_length) {
+		return m_buffer_length + AutoSerializeAdapter::getSerializedSize(&m_buffer_length);
 	} else {
-		return bufferLength;
+		return m_buffer_length;
 	}
 }
-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,
 		int32_t* size, bool bigEndian) {
 	//TODO Ignores Endian flag!
 	if (buffer != NULL) {
-		if(serializeLength){
+		if(m_serialize_length){
 			// 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;
 			//}
-			T serializedSize = AutoSerializeAdapter::getSerializedSize(
-					&bufferLength);
-			if((*size - bufferLength - serializedSize) >= 0){
+			count_t serializedSize = AutoSerializeAdapter::getSerializedSize(
+					&m_buffer_length);
+			if((*size - m_buffer_length - serializedSize) >= 0){
 				*buffer +=  serializedSize;
 				*size -= serializedSize;
 			}else{
@@ -86,10 +82,10 @@ ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer,
 			}
 		}
 		//No Else If, go on with buffer
-		if (*size - bufferLength >= 0) {
-			*size -= bufferLength;
-			memcpy(this->buffer, *buffer, bufferLength);
-			(*buffer) += bufferLength;
+		if (*size - m_buffer_length >= 0) {
+			*size -= m_buffer_length;
+			memcpy(m_buffer, *buffer, m_buffer_length);
+			(*buffer) += m_buffer_length;
 			return HasReturnvaluesIF::RETURN_OK;
 		} else {
 			return STREAM_TOO_SHORT;
@@ -99,35 +95,30 @@ ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer,
 	}
 }
 
-template<typename T>
-uint8_t * SerialBufferAdapter<T>::getBuffer() {
-	if(currentBufferType != NORMAL) {
-		warning << "Wrong access function for stored type ! Use getConstBuffer()" << std::endl;
-		return 0;
+template<typename count_t>
+uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
+	if(m_buffer == nullptr) {
+		error << "Wrong access function for stored type ! Use getConstBuffer()" << std::endl;
+		return nullptr;
 	}
-	return buffer;
+	return m_buffer;
 }
 
-template<typename T>
-const uint8_t * SerialBufferAdapter<T>::getConstBuffer() {
-	if(currentBufferType != CONST) {
-		warning << "Wrong access function for stored type ! Use getBuffer()" << std::endl;
-		return 0;
+template<typename count_t>
+const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
+	if(m_const_buffer == nullptr) {
+		error << "Wrong access function for stored type ! Use getBuffer()" << std::endl;
+		return nullptr;
 	}
-	return constBuffer;
+	return m_const_buffer;
 }
 
-template<typename T>
-void SerialBufferAdapter<T>::setBuffer(uint8_t * buffer_, T bufferLength_) {
-	buffer = buffer_;
-	bufferLength = bufferLength_;
+template<typename count_t>
+void SerialBufferAdapter<count_t>::setBuffer(void * buffer, count_t buffer_length) {
+	m_buffer = static_cast<uint8_t *>(buffer);
+	m_buffer_length = buffer_length;
 }
 
-template<typename T>
-void SerialBufferAdapter<T>::setBuffer(uint32_t * buffer_, T bufferLength_) {
-	buffer = reinterpret_cast<uint8_t *>(buffer_);
-	bufferLength = 4 * bufferLength_;
-}
 
 //forward Template declaration for linker
 template class SerialBufferAdapter<uint8_t>;
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index 600bd692a..4ee4ca0b8 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -16,9 +16,10 @@
  *
  * \ingroup serialize
  */
-template<typename T>
+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.
@@ -26,7 +27,7 @@ public:
 	 * @param bufferLength
 	 * @param serializeLength
 	 */
-	SerialBufferAdapter(const uint8_t * buffer, T bufferLength, bool serializeLength = false);
+	SerialBufferAdapter(const void* buffer, count_t bufferLength, bool serializeLength = false);
 
 	/**
 	 * Constructor for non-constant uint8_t buffer. Length field can be serialized optionally.
@@ -35,16 +36,7 @@ public:
 	 * @param bufferLength
 	 * @param serializeLength
 	 */
-	SerialBufferAdapter(uint8_t* buffer, T bufferLength, bool serializeLength = false);
-
-	/**
-	 * Constructoor for non-constant uint32_t buffer. Length field can be serialized optionally.
-	 * Type of length can be supplied as template type.
-	 * @param buffer
-	 * @param bufferLength
-	 * @param serializeLength
-	 */
-	SerialBufferAdapter(uint32_t* buffer,T bufferLength, bool serializeLength = false);
+	SerialBufferAdapter(void* buffer, count_t bufferLength, bool serializeLength = false);
 
 	virtual ~SerialBufferAdapter();
 
@@ -58,20 +50,12 @@ public:
 
 	uint8_t * getBuffer();
 	const uint8_t * getConstBuffer();
-	void setBuffer(uint8_t * buffer_, T bufferLength_);
-	void setBuffer(uint32_t * buffer_, T bufferLength_);
+	void setBuffer(void* buffer_, count_t bufferLength_);
 private:
-
-	enum bufferType {
-		NORMAL,
-		CONST
-	};
-	bufferType currentBufferType;
-
-	bool serializeLength;
-	const uint8_t *constBuffer;
-	uint8_t *buffer;
-	T bufferLength;
+	bool m_serialize_length = false;
+	const uint8_t *m_const_buffer = nullptr;
+	uint8_t *m_buffer = nullptr;
+	count_t m_buffer_length = 0;
 };