diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index ad4ec358b..5e834fe26 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -12,7 +12,7 @@ SerialBufferAdapter<count_t>::SerialBufferAdapter(const uint8_t* buffer,
 template<typename count_t>
 SerialBufferAdapter<count_t>::SerialBufferAdapter(uint8_t* buffer,
 		count_t bufferLength, bool serializeLength) :
-		serializeLength(serializeLength), buffer(buffer), constBuffer(buffer),
+		serializeLength(serializeLength), constBuffer(buffer), buffer(buffer),
 		bufferLength(bufferLength) {}
 
 
@@ -21,29 +21,33 @@ SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
 }
 
 template<typename count_t>
-ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer,
-		size_t* size, const size_t max_size, bool bigEndian) const {
+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(
 				&bufferLength);
 	}
-	if (*size + serializedLength > max_size) {
+	if (*size_ + serializedLength > max_size) {
 		return BUFFER_TOO_SHORT;
 	} else {
 		if (serializeLength) {
-			AutoSerializeAdapter::serialize(&bufferLength, buffer, size,
+			AutoSerializeAdapter::serialize(&bufferLength, buffer_, size_,
 					max_size, bigEndian);
 		}
 		if (constBuffer != nullptr) {
-			memcpy(*buffer, constBuffer, bufferLength);
-		} else if (buffer != nullptr) {
-			memcpy(*buffer, buffer, bufferLength);
-		} else {
+			memcpy(*buffer_, this->constBuffer, bufferLength);
+		}
+		else if (buffer != nullptr) {
+			// This will propably be never reached, constBuffer should always be
+			// set if non-const buffer is set.
+			memcpy(*buffer_, this->buffer, bufferLength);
+		}
+		else {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
-		*size += bufferLength;
-		(*buffer) += bufferLength;
+		*size_ += bufferLength;
+		(*buffer_) += bufferLength;
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 }
@@ -93,7 +97,7 @@ 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;
+				 " Use getConstBuffer()." << std::endl;
 		return nullptr;
 	}
 	return buffer;
@@ -110,9 +114,10 @@ const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
 
 template<typename count_t>
 void SerialBufferAdapter<count_t>::setBuffer(uint8_t* buffer,
-		count_t buffer_length) {
+		count_t bufferLength) {
 	this->buffer = buffer;
-	bufferLength = buffer_length;
+	this->constBuffer = buffer;
+	this->bufferLength = bufferLength;
 }
 
 
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index cb799be5e..a30451a1a 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -45,7 +45,7 @@ public:
 
 	virtual ~SerialBufferAdapter();
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+	virtual ReturnValue_t serialize(uint8_t** buffer_, size_t* size,
 			const size_t max_size, bool bigEndian) const override;
 
 	virtual size_t getSerializedSize() const;
@@ -67,7 +67,7 @@ public:
 
 	uint8_t * getBuffer();
 	const uint8_t * getConstBuffer();
-	void setBuffer(uint8_t* buffer_, count_t bufferLength_);
+	void setBuffer(uint8_t* buffer, count_t bufferLength);
 private:
 	bool serializeLength = false;
 	const uint8_t *constBuffer = nullptr;