Merge remote-tracking branch 'upstream/master' into mueller_CSB_improvements

action/ActionHelper.cpp

@@ -71,18 +71,18 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo, ActionId_t rep
 	CommandMessage reply;
 	store_address_t storeAddress;
 	uint8_t *dataPtr;
-	uint32_t maxSize = data->getSerializedSize();
+	size_t maxSize = data->getSerializedSize();
 	if (maxSize == 0) {
 		//No error, there's simply nothing to report.
 		return HasReturnvaluesIF::RETURN_OK;
 	}
-	uint32_t size = 0;
+	size_t size = 0;
 	ReturnValue_t result = ipcStore->getFreeElement(&storeAddress, maxSize,
 			&dataPtr);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = data->serialize(&dataPtr, &size, maxSize, true);
+	result = data->serialize(&dataPtr, &size, maxSize, SerializeIF::Endianness::BIG);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		ipcStore->deleteData(storeAddress);
 		return result;

action/CommandActionHelper.cpp

@@ -20,14 +20,15 @@ ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
 	}
 	store_address_t storeId;
 	uint8_t *storePointer;
-	uint32_t maxSize = data->getSerializedSize();
+	size_t maxSize = data->getSerializedSize();
 	ReturnValue_t result = ipcStore->getFreeElement(&storeId, maxSize,
 			&storePointer);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	uint32_t size = 0;
+	size_t size = 0;
-	result = data->serialize(&storePointer, &size, maxSize, true);
+	result = data->serialize(&storePointer, &size, maxSize,
+			SerializeIF::Endianness::BIG);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -88,7 +89,8 @@ ReturnValue_t CommandActionHelper::handleReply(CommandMessage* reply) {
 		return HasReturnvaluesIF::RETURN_OK;
 	case ActionMessage::COMPLETION_FAILED:
 		commandCount--;
-		owner->completionFailedReceived(ActionMessage::getActionId(reply), ActionMessage::getReturnCode(reply));
+		owner->completionFailedReceived(ActionMessage::getActionId(reply),
+				ActionMessage::getReturnCode(reply));
 		return HasReturnvaluesIF::RETURN_OK;
 	case ActionMessage::STEP_SUCCESS:
 		owner->stepSuccessfulReceived(ActionMessage::getActionId(reply),
@@ -96,11 +98,13 @@ ReturnValue_t CommandActionHelper::handleReply(CommandMessage* reply) {
 		return HasReturnvaluesIF::RETURN_OK;
 	case ActionMessage::STEP_FAILED:
 		commandCount--;
-		owner->stepFailedReceived(ActionMessage::getActionId(reply), ActionMessage::getStep(reply),
+		owner->stepFailedReceived(ActionMessage::getActionId(reply),
+				ActionMessage::getStep(reply),
 				ActionMessage::getReturnCode(reply));
 		return HasReturnvaluesIF::RETURN_OK;
 	case ActionMessage::DATA_REPLY:
-		extractDataForOwner(ActionMessage::getActionId(reply), ActionMessage::getStoreId(reply));
+		extractDataForOwner(ActionMessage::getActionId(reply),
+				ActionMessage::getStoreId(reply));
 		return HasReturnvaluesIF::RETURN_OK;
 	default:
 		return HasReturnvaluesIF::RETURN_FAILED;

container/FixedMap.h

@@ -148,47 +148,47 @@ public:
 		return theMap.maxSize();
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+			size_t maxSize, Endianness streamEndianness) const {
-		ReturnValue_t result = SerializeAdapter<uint32_t>::serialize(&this->_size,
+		ReturnValue_t result = SerializeAdapter::serialize(&this->_size,
-				buffer, size, max_size, bigEndian);
+				buffer, size, maxSize, streamEndianness);
 		uint32_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
-			result = SerializeAdapter<key_t>::serialize(&theMap[i].first, buffer,
+			result = SerializeAdapter::serialize(&theMap[i].first, buffer,
-					size, max_size, bigEndian);
+					size, maxSize, streamEndianness);
-			result = SerializeAdapter<T>::serialize(&theMap[i].second, buffer, size,
+			result = SerializeAdapter::serialize(&theMap[i].second, buffer, size,
-					max_size, bigEndian);
+					maxSize, streamEndianness);
 			++i;
 		}
 		return result;
 	}
 
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const {
 		uint32_t printSize = sizeof(_size);
 		uint32_t i = 0;
 
 		for (i = 0; i < _size; ++i) {
-			printSize += SerializeAdapter<key_t>::getSerializedSize(
+			printSize += SerializeAdapter::getSerializedSize(
 					&theMap[i].first);
-			printSize += SerializeAdapter<T>::getSerializedSize(&theMap[i].second);
+			printSize += SerializeAdapter::getSerializedSize(&theMap[i].second);
 		}
 
 		return printSize;
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
+			Endianness streamEndianness) {
-		ReturnValue_t result = SerializeAdapter<uint32_t>::deSerialize(&this->_size,
+		ReturnValue_t result = SerializeAdapter::deSerialize(&this->_size,
-				buffer, size, bigEndian);
+				buffer, size, streamEndianness);
 		if (this->_size > theMap.maxSize()) {
 			return SerializeIF::TOO_MANY_ELEMENTS;
 		}
 		uint32_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
-			result = SerializeAdapter<key_t>::deSerialize(&theMap[i].first, buffer,
+			result = SerializeAdapter::deSerialize(&theMap[i].first, buffer,
-					size, bigEndian);
+					size, streamEndianness);
-			result = SerializeAdapter<T>::deSerialize(&theMap[i].second, buffer, size,
+			result = SerializeAdapter::deSerialize(&theMap[i].second, buffer, size,
-					bigEndian);
+					streamEndianness);
 			++i;
 		}
 		return result;

container/IndexedRingMemoryArray.h

@@ -68,50 +68,50 @@ public:
 		return this->storedPackets;
 	}
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				const uint32_t max_size, bool bigEndian) const {
+				size_t maxSize, Endianness streamEndianness) const {
-		ReturnValue_t result = AutoSerializeAdapter::serialize(&blockStartAddress,buffer,size,max_size,bigEndian);
+		ReturnValue_t result = SerializeAdapter::serialize(&blockStartAddress,buffer,size,maxSize,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = indexType.serialize(buffer,size,max_size,bigEndian);
+		result = indexType.serialize(buffer,size,maxSize,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::serialize(&this->size,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::serialize(&this->storedPackets,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&this->storedPackets,buffer,size,maxSize,streamEndianness);
 		return result;
 	}
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-				bool bigEndian){
+				Endianness streamEndianness){
-		ReturnValue_t result = AutoSerializeAdapter::deSerialize(&blockStartAddress,buffer,size,bigEndian);
+		ReturnValue_t result = SerializeAdapter::deSerialize(&blockStartAddress,buffer,size,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = indexType.deSerialize(buffer,size,bigEndian);
+		result = indexType.deSerialize(buffer,size,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::deSerialize(&this->size,buffer,size,bigEndian);
+		result = SerializeAdapter::deSerialize(&this->size,buffer,size,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::deSerialize(&this->storedPackets,buffer,size,bigEndian);
+		result = SerializeAdapter::deSerialize(&this->storedPackets,buffer,size,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
 		return result;
 	}
 
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
-		uint32_t size = AutoSerializeAdapter::getSerializedSize(&blockStartAddress);
+		uint32_t size = SerializeAdapter::getSerializedSize(&blockStartAddress);
 		size += indexType.getSerializedSize();
-		size += AutoSerializeAdapter::getSerializedSize(&this->size);
+		size += SerializeAdapter::getSerializedSize(&this->size);
-		size += AutoSerializeAdapter::getSerializedSize(&this->storedPackets);
+		size += SerializeAdapter::getSerializedSize(&this->storedPackets);
 		return size;
 	}
 
@@ -485,37 +485,37 @@ public:
 	 * Parameters according to HasSerializeIF
 	 * @param buffer
 	 * @param size
-	 * @param max_size
+	 * @param maxSize
-	 * @param bigEndian
+	 * @param streamEndianness
 	 * @return
 	 */
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				const uint32_t max_size, bool bigEndian) const{
+				size_t maxSize, Endianness streamEndianness) const{
 		uint8_t* crcBuffer = *buffer;
 		uint32_t oldSize = *size;
 		if(additionalInfo!=NULL){
-			additionalInfo->serialize(buffer,size,max_size,bigEndian);
+			additionalInfo->serialize(buffer,size,maxSize,streamEndianness);
 		}
-		ReturnValue_t result = currentWriteBlock->serialize(buffer,size,max_size,bigEndian);
+		ReturnValue_t result = currentWriteBlock->serialize(buffer,size,maxSize,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
-		result = AutoSerializeAdapter::serialize(&this->size,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
 
 		uint32_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
-			result = SerializeAdapter<Index<T> >::serialize(&this->entries[i], buffer, size,
+			result = SerializeAdapter::serialize(&this->entries[i], buffer, size,
-					max_size, bigEndian);
+					maxSize, streamEndianness);
 			++i;
 		}
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
 		uint16_t crc = Calculate_CRC(crcBuffer,(*size-oldSize));
-		result = AutoSerializeAdapter::serialize(&crc,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&crc,buffer,size,maxSize,streamEndianness);
 		return result;
 	}
 
@@ -524,17 +524,17 @@ public:
 	 * Get the serialized Size of the index
 	 * @return The serialized size of the index
 	 */
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 
 		uint32_t size = 0;
 		if(additionalInfo!=NULL){
 			size += additionalInfo->getSerializedSize();
 		}
 		size += currentWriteBlock->getSerializedSize();
-		size += AutoSerializeAdapter::getSerializedSize(&this->size);
+		size += SerializeAdapter::getSerializedSize(&this->size);
 		size += (this->entries[0].getSerializedSize()) * this->size;
 		uint16_t crc = 0;
-		size += AutoSerializeAdapter::getSerializedSize(&crc);
+		size += SerializeAdapter::getSerializedSize(&crc);
 		return size;
 	}
 	/**
@@ -542,28 +542,28 @@ public:
 	 * CRC Has to be checked before!
 	 * @param buffer
 	 * @param size
-	 * @param bigEndian
+	 * @param streamEndianness
 	 * @return
 	 */
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-				bool bigEndian){
+				Endianness streamEndianness){
 
 		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 		if(additionalInfo!=NULL){
-			result = additionalInfo->deSerialize(buffer,size,bigEndian);
+			result = additionalInfo->deSerialize(buffer,size,streamEndianness);
 		}
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
 
 		Index<T> tempIndex;
-		result = tempIndex.deSerialize(buffer,size,bigEndian);
+		result = tempIndex.deSerialize(buffer,size,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
 		uint32_t tempSize = 0;
-		result = AutoSerializeAdapter::deSerialize(&tempSize,buffer,size,bigEndian);
+		result = SerializeAdapter::deSerialize(&tempSize,buffer,size,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
@@ -572,9 +572,9 @@ public:
 		}
 		uint32_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
-			result = SerializeAdapter<Index<T> >::deSerialize(
+			result = SerializeAdapter::deSerialize(
 					&this->entries[i], buffer, size,
-					bigEndian);
+					streamEndianness);
 			++i;
 		}
 		if(result != HasReturnvaluesIF::RETURN_OK){

datapool/DataPool.cpp

@@ -39,10 +39,10 @@ PoolEntryIF* DataPool::getRawData( uint32_t data_pool_id ) {
 	}
 }
 
-//uint8_t DataPool::getRawData( uint32_t data_pool_id, uint8_t* address, uint16_t* size, uint32_t max_size ) {
+//uint8_t DataPool::getRawData( uint32_t data_pool_id, uint8_t* address, uint16_t* size, uint32_t maxSize ) {
 //	std::map<uint32_t, PoolEntryIF*>::iterator it = this->data_pool.find( data_pool_id );
 //	if ( it != this->data_pool.end() ) {
-//		if ( it->second->getByteSize() <= max_size ) {
+//		if ( it->second->getByteSize() <= maxSize ) {
 //			*size = it->second->getByteSize();
 //			memcpy( address, it->second->getRawData(), *size );
 //			return DP_SUCCESSFUL;

datapool/DataPoolAdmin.cpp

@@ -26,7 +26,7 @@ MessageQueueId_t DataPoolAdmin::getCommandQueue() const {
 }
 
 ReturnValue_t DataPoolAdmin::executeAction(ActionId_t actionId,
-		MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size) {
+		MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
 	if (actionId != SET_VALIDITY) {
 		return INVALID_ACTION_ID;
 	}
@@ -91,7 +91,7 @@ void DataPoolAdmin::handleCommand() {
 }
 
 ReturnValue_t DataPoolAdmin::handleMemoryLoad(uint32_t address,
-		const uint8_t* data, uint32_t size, uint8_t** dataPointer) {
+		const uint8_t* data, size_t size, uint8_t** dataPointer) {
 	uint32_t poolId = ::dataPool.PIDToDataPoolId(address);
 	uint8_t arrayIndex = ::dataPool.PIDToArrayIndex(address);
 	DataSet testSet;
@@ -129,7 +129,7 @@ ReturnValue_t DataPoolAdmin::handleMemoryLoad(uint32_t address,
 	return ACTIVITY_COMPLETED;
 }
 
-ReturnValue_t DataPoolAdmin::handleMemoryDump(uint32_t address, uint32_t size,
+ReturnValue_t DataPoolAdmin::handleMemoryDump(uint32_t address, size_t size,
 		uint8_t** dataPointer, uint8_t* copyHere) {
 	uint32_t poolId = ::dataPool.PIDToDataPoolId(address);
 	uint8_t arrayIndex = ::dataPool.PIDToArrayIndex(address);
@@ -151,7 +151,7 @@ ReturnValue_t DataPoolAdmin::handleMemoryDump(uint32_t address, uint32_t size,
 				PoolVariableIF::VAR_READ);
 		status = rawSet.read();
 		if (status == RETURN_OK) {
-			uint32_t temp = 0;
+			size_t temp = 0;
 			status = variable.getEntryEndianSafe(ptrToCopy, &temp, size);
 			if (status != RETURN_OK) {
 				return RETURN_FAILED;
@@ -261,7 +261,7 @@ ReturnValue_t DataPoolAdmin::handleParameterCommand(CommandMessage* command) {
 //identical to ParameterHelper::sendParameter()
 ReturnValue_t DataPoolAdmin::sendParameter(MessageQueueId_t to, uint32_t id,
 		const DataPoolParameterWrapper* wrapper) {
-	uint32_t serializedSize = wrapper->getSerializedSize();
+	size_t serializedSize = wrapper->getSerializedSize();
 
 	uint8_t *storeElement;
 	store_address_t address;
@@ -272,10 +272,10 @@ ReturnValue_t DataPoolAdmin::sendParameter(MessageQueueId_t to, uint32_t id,
 		return result;
 	}
 
-	uint32_t storeElementSize = 0;
+	size_t storeElementSize = 0;
 
 	result = wrapper->serialize(&storeElement, &storeElementSize,
-			serializedSize, true);
+			serializedSize, SerializeIF::Endianness::BIG);
 
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		storage->deleteData(address);

datapool/DataPoolAdmin.h

@@ -29,12 +29,12 @@ public:
 	MessageQueueId_t getCommandQueue() const;
 
 	ReturnValue_t handleMemoryLoad(uint32_t address, const uint8_t* data,
-			uint32_t size, uint8_t** dataPointer);
+			size_t size, uint8_t** dataPointer);
-	ReturnValue_t handleMemoryDump(uint32_t address, uint32_t size,
+	ReturnValue_t handleMemoryDump(uint32_t address, size_t size,
 			uint8_t** dataPointer, uint8_t* copyHere);
 
 	ReturnValue_t executeAction(ActionId_t actionId,
-			MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size);
+			MessageQueueId_t commandedBy, const uint8_t* data, size_t size);
 
 	//not implemented as ParameterHelper is no used
 	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,

datapool/DataPoolParameterWrapper.cpp

@@ -36,22 +36,22 @@ ReturnValue_t DataPoolParameterWrapper::set(uint8_t domainId,
 }
 
 ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
-		uint32_t* size, const uint32_t max_size, bool bigEndian) const {
+		size_t* size, size_t maxSize, Endianness streamEndianness) const {
 	ReturnValue_t result;
 
-	result = SerializeAdapter<Type>::serialize(&type, buffer, size, max_size,
+	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
-			bigEndian);
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter<uint8_t>::serialize(&columns, buffer, size,
+	result = SerializeAdapter::serialize(&columns, buffer, size,
-			max_size, bigEndian);
+			maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<uint8_t>::serialize(&rows, buffer, size, max_size,
+	result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
-			bigEndian);
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -60,7 +60,7 @@ ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
 		DataSet mySet;
 		PoolRawAccess raw(poolId, index, &mySet,PoolVariableIF::VAR_READ);
 		mySet.read();
-		result = raw.serialize(buffer,size,max_size,bigEndian);
+		result = raw.serialize(buffer,size,maxSize,streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
@@ -69,8 +69,8 @@ ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
 }
 
 //same as ParameterWrapper
-uint32_t DataPoolParameterWrapper::getSerializedSize() const {
+size_t DataPoolParameterWrapper::getSerializedSize() const {
-	uint32_t serializedSize = 0;
+	size_t serializedSize = 0;
 	serializedSize += type.getSerializedSize();
 	serializedSize += sizeof(rows);
 	serializedSize += sizeof(columns);
@@ -80,7 +80,7 @@ uint32_t DataPoolParameterWrapper::getSerializedSize() const {
 }
 
 ReturnValue_t DataPoolParameterWrapper::deSerialize(const uint8_t** buffer,
-		int32_t* size, bool bigEndian) {
+		size_t* size, Endianness streamEndianness) {
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 

datapool/DataPoolParameterWrapper.h

@@ -11,13 +11,13 @@ public:
 
 	ReturnValue_t set(uint8_t domainId, uint16_t parameterId);
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+			size_t maxSize, Endianness streamEndianness) const override;
 
-	virtual uint32_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const override;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian);
+			Endianness streamEndianness) override;
 
 	ReturnValue_t copyFrom(const ParameterWrapper *from,
 			uint16_t startWritingAtIndex);

datapool/DataSet.cpp

@@ -106,12 +106,12 @@ uint8_t DataSet::lockDataPool() {
 	return ::dataPool.lockDataPool();
 }
 
-ReturnValue_t DataSet::serialize(uint8_t** buffer, uint32_t* size,
+ReturnValue_t DataSet::serialize(uint8_t** buffer, size_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+		size_t maxSize, Endianness streamEndianness) const {
 	ReturnValue_t result = RETURN_FAILED;
 	for (uint16_t count = 0; count < fill_count; count++) {
-		result = registeredVariables[count]->serialize(buffer, size, max_size,
+		result = registeredVariables[count]->serialize(buffer, size, maxSize,
-				bigEndian);
+				streamEndianness);
 		if (result != RETURN_OK) {
 			return result;
 		}
@@ -119,8 +119,8 @@ ReturnValue_t DataSet::serialize(uint8_t** buffer, uint32_t* size,
 	return result;
 }
 
-uint32_t DataSet::getSerializedSize() const {
+size_t DataSet::getSerializedSize() const {
-	uint32_t size = 0;
+	size_t size = 0;
 	for (uint16_t count = 0; count < fill_count; count++) {
 		size += registeredVariables[count]->getSerializedSize();
 	}
@@ -136,12 +136,12 @@ void DataSet::setValid(uint8_t valid) {
 	}
 }
 
-ReturnValue_t DataSet::deSerialize(const uint8_t** buffer, int32_t* size,
+ReturnValue_t DataSet::deSerialize(const uint8_t** buffer, size_t* size,
-		bool bigEndian) {
+		Endianness streamEndianness) {
 	ReturnValue_t result = RETURN_FAILED;
 	for (uint16_t count = 0; count < fill_count; count++) {
 		result = registeredVariables[count]->deSerialize(buffer, size,
-				bigEndian);
+				streamEndianness);
 		if (result != RETURN_OK) {
 			return result;
 		}

datapool/DataSet.h

@@ -146,13 +146,13 @@ public:
 	 */
 	void setValid(uint8_t valid);
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+			size_t maxSize, Endianness streamEndianness) const override;
 
-	uint32_t getSerializedSize() const;
+	size_t getSerializedSize() const override;
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian);
+			Endianness streamEndianness) override;
 
 };
 

datapool/PIDReader.h

@@ -43,7 +43,8 @@ protected:
 	 * Empty ctor for List initialization
 	 */
 	PIDReader() :
-		parameterId(PoolVariableIF::NO_PARAMETER), valid(PoolVariableIF::INVALID), value(0) {
+			parameterId(PoolVariableIF::NO_PARAMETER), valid(
+					PoolVariableIF::INVALID), value(0) {
 
 	}
 public:
@@ -64,8 +65,8 @@ public:
 	 * 					written back to the data pool, otherwise not.
 	 */
 	PIDReader(uint32_t setParameterId, DataSetIF *dataSet) :
-			parameterId(setParameterId), valid(
+			parameterId(setParameterId), valid(PoolVariableIF::INVALID), value(
-					PoolVariableIF::INVALID), value(0) {
+					0) {
 		if (dataSet != NULL) {
 			dataSet->registerVariable(this);
 		}
@@ -126,19 +127,20 @@ public:
 		return *this;
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-			const uint32_t max_size, bool bigEndian) const {
+			size_t maxSize, Endianness streamEndianness) const override {
-		return SerializeAdapter<T>::serialize(&value, buffer, size, max_size,
+		return SerializeAdapter::serialize(&value, buffer, size, maxSize,
-				bigEndian);
+				streamEndianness);
 	}
 
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const override {
-		return SerializeAdapter<T>::getSerializedSize(&value);
+		return SerializeAdapter::getSerializedSize(&value);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-	bool bigEndian) {
+			Endianness streamEndianness) override {
-		return SerializeAdapter<T>::deSerialize(&value, buffer, size, bigEndian);
+		return SerializeAdapter::deSerialize(&value, buffer, size,
+				streamEndianness);
 	}
 };
 

datapool/PoolRawAccess.cpp

@@ -2,14 +2,15 @@
 #include <framework/datapool/PoolEntryIF.h>
 #include <framework/datapool/PoolRawAccess.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/osal/Endiness.h>
+#include <framework/serialize/EndianConverter.h>
 
 #include <cstring>
 
 PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
 		DataSetIF *data_set, ReadWriteMode_t setReadWriteMode) :
-		dataPoolId(set_id), arrayEntry(setArrayEntry), valid(false), type(Type::UNKNOWN_TYPE), typeSize(
+		dataPoolId(set_id), arrayEntry(setArrayEntry), valid(false), type(
-				0), arraySize(0), sizeTillEnd(0), readWriteMode(setReadWriteMode) {
+				Type::UNKNOWN_TYPE), typeSize(0), arraySize(0), sizeTillEnd(0), readWriteMode(
+				setReadWriteMode) {
 	memset(value, 0, sizeof(value));
 	if (data_set != NULL) {
 		data_set->registerVariable(this);
@@ -44,8 +45,8 @@ ReturnValue_t PoolRawAccess::read() {
 	} else {
 		//Error entry does not exist.
 	}
-	sif::error << "PoolRawAccess: read of DP Variable 0x" << std::hex << dataPoolId
+	sif::error << "PoolRawAccess: read of DP Variable 0x" << std::hex
-			<< std::dec << " failed." << std::endl;
+			<< dataPoolId << std::dec << " failed." << std::endl;
 	valid = INVALID;
 	typeSize = 0;
 	sizeTillEnd = 0;
@@ -71,22 +72,16 @@ uint8_t* PoolRawAccess::getEntry() {
 }
 
 ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t *buffer,
-		uint32_t* writtenBytes, uint32_t max_size) {
+		size_t *writtenBytes, size_t maxSize) {
 	uint8_t *data_ptr = getEntry();
 //	debug << "PoolRawAccess::getEntry: Array position: " << index * size_of_type << " Size of T: " << (int)size_of_type << " ByteSize: " << byte_size << " Position: " << *size << std::endl;
-	if (typeSize == 0)
+	if (typeSize == 0) {
 		return DATA_POOL_ACCESS_FAILED;
-	if (typeSize > max_size)
-		return INCORRECT_SIZE;
-#ifndef BYTE_ORDER_SYSTEM
-#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-	for (uint8_t count = 0; count < typeSize; count++) {
-		buffer[count] = data_ptr[typeSize - count - 1];
 	}
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+	if (typeSize > maxSize) {
-	memcpy(buffer, data_ptr, typeSize);
+		return INCORRECT_SIZE;
-#endif
+	}
+	EndianConverter::convertBigEndian(buffer, data_ptr, typeSize);
 	*writtenBytes = typeSize;
 	return HasReturnvaluesIF::RETURN_OK;
 }
@@ -95,11 +90,11 @@ Type PoolRawAccess::getType() {
 	return type;
 }
 
-uint8_t PoolRawAccess::getSizeOfType() {
+size_t PoolRawAccess::getSizeOfType() {
 	return typeSize;
 }
 
-uint8_t PoolRawAccess::getArraySize(){
+size_t PoolRawAccess::getArraySize() {
 	return arraySize;
 }
 
@@ -112,20 +107,13 @@ PoolVariableIF::ReadWriteMode_t PoolRawAccess::getReadWriteMode() const {
 }
 
 ReturnValue_t PoolRawAccess::setEntryFromBigEndian(const uint8_t *buffer,
-		uint32_t setSize) {
+		size_t setSize) {
 	if (typeSize == setSize) {
-#ifndef BYTE_ORDER_SYSTEM
+		EndianConverter::convertBigEndian(value, buffer, typeSize);
-#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-		for (uint8_t count = 0; count < typeSize; count++) {
-			value[count] = buffer[typeSize - count - 1];
-		}
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-		memcpy(value, buffer, typeSize);
-#endif
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
-		sif::error << "PoolRawAccess::setEntryFromBigEndian: Illegal sizes: Internal"
+		sif::error
+				<< "PoolRawAccess::setEntryFromBigEndian: Illegal sizes: Internal"
 				<< (uint32_t) typeSize << ", Requested: " << setSize
 				<< std::endl;
 		return INCORRECT_SIZE;
@@ -143,25 +131,24 @@ void PoolRawAccess::setValid(uint8_t valid) {
 	this->valid = valid;
 }
 
-uint16_t PoolRawAccess::getSizeTillEnd() const {
+size_t PoolRawAccess::getSizeTillEnd() const {
 	return sizeTillEnd;
 }
 
-ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, uint32_t* size,
+ReturnValue_t PoolRawAccess::serialize(uint8_t **buffer, size_t *size,
-		const uint32_t max_size, bool bigEndian) const {
+		size_t maxSize, Endianness streamEndianness) const {
-	if (typeSize + *size <= max_size) {
+	if (typeSize + *size <= maxSize) {
-		if (bigEndian) {
+		switch (streamEndianness) {
-#ifndef BYTE_ORDER_SYSTEM
+		case (Endianness::BIG):
-#error BYTE_ORDER_SYSTEM not defined
+			EndianConverter::convertBigEndian(*buffer, value, typeSize);
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+			break;
-			for (uint8_t count = 0; count < typeSize; count++) {
+		case (Endianness::LITTLE):
-				(*buffer)[count] = value[typeSize - count - 1];
+			EndianConverter::convertLittleEndian(*buffer, value, typeSize);
-			}
+			break;
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+		default:
-			memcpy(*buffer, value, typeSize);
+		case (Endianness::MACHINE):
-#endif
-		} else {
 			memcpy(*buffer, value, typeSize);
+			break;
 		}
 		*size += typeSize;
 		(*buffer) += typeSize;
@@ -171,28 +158,27 @@ ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, uint32_t* size,
 	}
 }
 
-uint32_t PoolRawAccess::getSerializedSize() const {
+size_t PoolRawAccess::getSerializedSize() const {
 	return typeSize;
 }
 
-ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, int32_t* size,
+ReturnValue_t PoolRawAccess::deSerialize(const uint8_t **buffer, size_t *size,
-		bool bigEndian) {
+		Endianness streamEndianness) {
-	*size -= typeSize;
-	if (*size >= 0) {
 
-		if (bigEndian) {
+	if (*size >= typeSize) {
-#ifndef BYTE_ORDER_SYSTEM
+		switch (streamEndianness) {
-#error BYTE_ORDER_SYSTEM not defined
+		case (Endianness::BIG):
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+			EndianConverter::convertBigEndian(value, *buffer, typeSize);
-			for (uint8_t count = 0; count < typeSize; count++) {
+			break;
-				value[count] = (*buffer)[typeSize - count - 1];
+		case (Endianness::LITTLE):
-			}
+			EndianConverter::convertLittleEndian(value, *buffer, typeSize);
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+			break;
-			memcpy(value, *buffer, typeSize);
+		default:
-#endif
+		case (Endianness::MACHINE):
-		} else {
 			memcpy(value, *buffer, typeSize);
+			break;
 		}
+		*size -= typeSize;
 		*buffer += typeSize;
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {

datapool/PoolRawAccess.h

@@ -32,15 +32,15 @@ private:
 	/**
 	 * \brief	This value contains the size of the data pool entry in bytes.
 	 */
-	uint8_t typeSize;
+	size_t typeSize;
 	/**
 	 * The size of the DP array (single values return 1)
 	 */
-	uint8_t arraySize;
+	size_t arraySize;
 	/**
 	 * The size (in bytes) from the selected entry till the end of this DataPool variable.
 	 */
-	uint16_t sizeTillEnd;
+	size_t sizeTillEnd;
 	/**
 	 * \brief	The information whether the class is read-write or read-only is stored here.
 	 */
@@ -90,15 +90,15 @@ public:
 	 * \details	It makes use of the getEntry call of this function, but additionally flips the
 	 * 			bytes to big endian, which is the default for external communication (as House-
 	 * 			keeping telemetry). To achieve this, the data is copied directly to the passed
-	 * 			buffer, if it fits in the given max_size.
+	 * 			buffer, if it fits in the given maxSize.
 	 * \param buffer	A pointer to a buffer to write to
 	 * \param writtenBytes	The number of bytes written is returned with this value.
-	 * \param max_size	The maximum size that the function may write to buffer.
+	 * \param maxSize	The maximum size that the function may write to buffer.
 	 * \return	- \c RETURN_OK if entry could be acquired
 	 * 			- \c RETURN_FAILED else.
 	 */
-	ReturnValue_t getEntryEndianSafe(uint8_t* buffer, uint32_t* size,
+	ReturnValue_t getEntryEndianSafe(uint8_t *buffer, size_t *size,
-			uint32_t max_size);
+			size_t maxSize);
 	/**
 	 * With this method, the content can be set from a big endian buffer safely.
 	 * @param buffer	Pointer to the data to set
@@ -107,7 +107,7 @@ public:
 	 * 			- \c RETURN_FAILED on failure
 	 */
 	ReturnValue_t setEntryFromBigEndian(const uint8_t *buffer,
-			uint32_t setSize);
+			size_t setSize);
 	/**
 	 *  \brief This operation returns the type of the entry currently stored.
 	 */
@@ -115,12 +115,12 @@ public:
 	/**
 	 *  \brief This operation returns the size of the entry currently stored.
 	 */
-	uint8_t getSizeOfType();
+	size_t getSizeOfType();
 	/**
 	 *
 	 * @return the size of the datapool array
 	 */
-	uint8_t getArraySize();
+	size_t getArraySize();
 	/**
 	 * \brief	This operation returns the data pool id of the variable.
 	 */
@@ -138,15 +138,15 @@ public:
 	/**
 	 * Getter for the remaining size.
 	 */
-	uint16_t getSizeTillEnd() const;
+	size_t getSizeTillEnd() const;
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-			const uint32_t max_size, bool bigEndian) const;
+			 Endianness streamEndianness) const override;
 
-	uint32_t getSerializedSize() const;
+	size_t getSerializedSize() const override;
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			bool bigEndian);
+			 Endianness streamEndianness) override;
 };
 
 #endif /* POOLRAWACCESS_H_ */

datapool/PoolVariable.h

@@ -194,19 +194,19 @@ public:
 		return *this;
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-			const uint32_t max_size, bool bigEndian) const {
+			size_t maxSize, Endianness streamEndianness) const override {
-		return SerializeAdapter<T>::serialize(&value, buffer, size, max_size,
+		return SerializeAdapter::serialize<T>(&value, buffer, size, maxSize,
-				bigEndian);
+				streamEndianness);
 	}
 
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const override {
-		return SerializeAdapter<T>::getSerializedSize(&value);
+		return SerializeAdapter::getSerializedSize(&value);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			bool bigEndian) {
+			Endianness streamEndianness) override {
-		return SerializeAdapter<T>::deSerialize(&value, buffer, size, bigEndian);
+		return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
 	}
 };
 

datapool/PoolVector.h

@@ -197,13 +197,13 @@ public:
 		return *this;
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+			size_t maxSize, Endianness streamEndianness) const {
 		uint16_t i;
 		ReturnValue_t result;
 		for (i = 0; i < vector_size; i++) {
-			result = SerializeAdapter<T>::serialize(&(value[i]), buffer, size,
+			result = SerializeAdapter::serialize(&(value[i]), buffer, size,
-					max_size, bigEndian);
+					maxSize, streamEndianness);
 			if (result != HasReturnvaluesIF::RETURN_OK) {
 				return result;
 			}
@@ -211,17 +211,17 @@ public:
 		return result;
 	}
 
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const {
-		return vector_size * SerializeAdapter<T>::getSerializedSize(value);
+		return vector_size * SerializeAdapter::getSerializedSize(value);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
+			Endianness streamEndianness) {
 		uint16_t i;
 		ReturnValue_t result;
 		for (i = 0; i < vector_size; i++) {
-			result = SerializeAdapter<T>::deSerialize(&(value[i]), buffer, size,
+			result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
-					bigEndian);
+					streamEndianness);
 			if (result != HasReturnvaluesIF::RETURN_OK) {
 				return result;
 			}

devicehandlers/DeviceTmReportingWrapper.cpp

@@ -12,35 +12,35 @@ DeviceTmReportingWrapper::~DeviceTmReportingWrapper() {
 }
 
 ReturnValue_t DeviceTmReportingWrapper::serialize(uint8_t** buffer,
-		uint32_t* size, const uint32_t max_size, bool bigEndian) const {
+		size_t* size, size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result = SerializeAdapter<object_id_t>::serialize(&objectId,
+	ReturnValue_t result = SerializeAdapter::serialize(&objectId,
-			buffer, size, max_size, bigEndian);
+			buffer, size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<ActionId_t>::serialize(&actionId, buffer,
+	result = SerializeAdapter::serialize(&actionId, buffer,
-			size, max_size, bigEndian);
+			size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	return data->serialize(buffer, size, max_size, bigEndian);
+	return data->serialize(buffer, size, maxSize, streamEndianness);
 }
 
-uint32_t DeviceTmReportingWrapper::getSerializedSize() const {
+size_t DeviceTmReportingWrapper::getSerializedSize() const {
 	return sizeof(objectId) + sizeof(ActionId_t) + data->getSerializedSize();
 }
 
 ReturnValue_t DeviceTmReportingWrapper::deSerialize(const uint8_t** buffer,
-		int32_t* size, bool bigEndian) {
+		size_t* size, Endianness streamEndianness) {
-	ReturnValue_t result = SerializeAdapter<object_id_t>::deSerialize(&objectId,
+	ReturnValue_t result = SerializeAdapter::deSerialize(&objectId,
-			buffer, size, bigEndian);
+			buffer, size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<ActionId_t>::deSerialize(&actionId, buffer,
+	result = SerializeAdapter::deSerialize(&actionId, buffer,
-			size, bigEndian);
+			size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	return data->deSerialize(buffer, size, bigEndian);
+	return data->deSerialize(buffer, size, streamEndianness);
 }

devicehandlers/DeviceTmReportingWrapper.h

@@ -11,13 +11,13 @@ public:
 			SerializeIF *data);
 	virtual ~DeviceTmReportingWrapper();
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+			size_t maxSize, Endianness streamEndianness) const override;
 
-	virtual uint32_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const override;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian);
+			Endianness streamEndianness) override;
 private:
 	object_id_t objectId;
 	ActionId_t actionId;

events/eventmatching/EventRangeMatcherBase.h

@@ -11,16 +11,16 @@ class EventRangeMatcherBase: public SerializeableMatcherIF<EventMessage*> {
 public:
 	EventRangeMatcherBase(T from, T till, bool inverted) : rangeMatcher(from, till, inverted) {	}
 	virtual ~EventRangeMatcherBase() { }
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+			size_t maxSize, Endianness streamEndianness) const {
-		return rangeMatcher.serialize(buffer, size, max_size, bigEndian);
+		return rangeMatcher.serialize(buffer, size, maxSize, streamEndianness);
 	}
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		return rangeMatcher.getSerializedSize();
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
+			Endianness streamEndianness) {
-		return rangeMatcher.deSerialize(buffer, size, bigEndian);
+		return rangeMatcher.deSerialize(buffer, size, streamEndianness);
 	}
 protected:
 	RangeMatcher<T> rangeMatcher;

globalfunctions/Type.cpp

@@ -59,8 +59,8 @@ uint8_t Type::getSize() const {
 	}
 }
 
-ReturnValue_t Type::serialize(uint8_t** buffer, uint32_t* size,
+ReturnValue_t Type::serialize(uint8_t** buffer, size_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+		size_t maxSize, Endianness streamEndianness) const {
 	uint8_t ptc;
 	uint8_t pfc;
 	ReturnValue_t result = getPtcPfc(&ptc, &pfc);
@@ -68,36 +68,36 @@ ReturnValue_t Type::serialize(uint8_t** buffer, uint32_t* size,
 		return result;
 	}
 
-	result = SerializeAdapter<uint8_t>::serialize(&ptc, buffer, size, max_size,
+	result = SerializeAdapter::serialize(&ptc, buffer, size, maxSize,
-			bigEndian);
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter<uint8_t>::serialize(&pfc, buffer, size, max_size,
+	result = SerializeAdapter::serialize(&pfc, buffer, size, maxSize,
-			bigEndian);
+			streamEndianness);
 
 	return result;
 
 }
 
-uint32_t Type::getSerializedSize() const {
+size_t Type::getSerializedSize() const {
 	uint8_t dontcare = 0;
-	return 2 * SerializeAdapter<uint8_t>::getSerializedSize(&dontcare);
+	return 2 * SerializeAdapter::getSerializedSize(&dontcare);
 }
 
-ReturnValue_t Type::deSerialize(const uint8_t** buffer, int32_t* size,
+ReturnValue_t Type::deSerialize(const uint8_t** buffer, size_t* size,
-		bool bigEndian) {
+		Endianness streamEndianness) {
 	uint8_t ptc;
 	uint8_t pfc;
-	ReturnValue_t result = SerializeAdapter<uint8_t>::deSerialize(&ptc, buffer,
+	ReturnValue_t result = SerializeAdapter::deSerialize(&ptc, buffer,
-			size, bigEndian);
+			size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter<uint8_t>::deSerialize(&pfc, buffer, size,
+	result = SerializeAdapter::deSerialize(&pfc, buffer, size,
-			bigEndian);
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}

globalfunctions/Type.h

@@ -39,13 +39,13 @@ public:
 
 	static ActualType_t getActualType(uint8_t ptc, uint8_t pfc);
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-			const uint32_t max_size, bool bigEndian) const;
+			size_t maxSize, Endianness streamEndianness) const override;
 
-	virtual uint32_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const override;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			bool bigEndian);
+			Endianness streamEndianness) override;
 
 private:
 	ActualType_t actualType;

globalfunctions/conversion.cpp

@@ -1,104 +0,0 @@
-#include <framework/globalfunctions/conversion.h>
-#include <framework/osal/Endiness.h>
-#include <cstring>
-
-
-
-//SHOULDDO: This shall be optimized (later)!
-void convertToByteStream( uint16_t value, uint8_t* buffer, uint32_t* size ) {
-	buffer[0] = (value & 0xFF00) >> 8;
-	buffer[1] = (value & 0x00FF);
-	*size += 2;
-}
-
-void convertToByteStream( uint32_t value, uint8_t* buffer, uint32_t* size ) {
-	buffer[0] = (value & 0xFF000000) >> 24;
-	buffer[1] = (value & 0x00FF0000) >> 16;
-	buffer[2] = (value & 0x0000FF00) >> 8;
-	buffer[3] = (value & 0x000000FF);
-	*size +=4;
-}
-
-void convertToByteStream( int16_t value, uint8_t* buffer, uint32_t* size ) {
-	buffer[0] = (value & 0xFF00) >> 8;
-	buffer[1] = (value & 0x00FF);
-	*size += 2;
-}
-
-void convertToByteStream( int32_t value, uint8_t* buffer, uint32_t* size ) {
-	buffer[0] = (value & 0xFF000000) >> 24;
-	buffer[1] = (value & 0x00FF0000) >> 16;
-	buffer[2] = (value & 0x0000FF00) >> 8;
-	buffer[3] = (value & 0x000000FF);
-	*size += 4;
-}
-
-//void convertToByteStream( uint64_t value, uint8_t* buffer, uint32_t* size ) {
-//	buffer[0] = (value & 0xFF00000000000000) >> 56;
-//	buffer[1] = (value & 0x00FF000000000000) >> 48;
-//	buffer[2] = (value & 0x0000FF0000000000) >> 40;
-//	buffer[3] = (value & 0x000000FF00000000) >> 32;
-//	buffer[4] = (value & 0x00000000FF000000) >> 24;
-//	buffer[5] = (value & 0x0000000000FF0000) >> 16;
-//	buffer[6] = (value & 0x000000000000FF00) >> 8;
-//	buffer[7] = (value & 0x00000000000000FF);
-//	*size+=8;
-//}
-//
-//void convertToByteStream( int64_t value, uint8_t* buffer, uint32_t* size ) {
-//	buffer[0] = (value & 0xFF00000000000000) >> 56;
-//	buffer[1] = (value & 0x00FF000000000000) >> 48;
-//	buffer[2] = (value & 0x0000FF0000000000) >> 40;
-//	buffer[3] = (value & 0x000000FF00000000) >> 32;
-//	buffer[4] = (value & 0x00000000FF000000) >> 24;
-//	buffer[5] = (value & 0x0000000000FF0000) >> 16;
-//	buffer[6] = (value & 0x000000000000FF00) >> 8;
-//	buffer[7] = (value & 0x00000000000000FF);
-//	*size+=8;
-//}
-
-void convertToByteStream( float in_value, uint8_t* buffer, uint32_t* size ) {
-#ifndef BYTE_ORDER_SYSTEM
-	#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-	union float_union {
-		float value;
-		uint8_t chars[4];
-	};
-	float_union temp;
-	temp.value = in_value;
-	buffer[0] = temp.chars[3];
-	buffer[1] = temp.chars[2];
-	buffer[2] = temp.chars[1];
-	buffer[3] = temp.chars[0];
-	*size += 4;
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-	memcpy(buffer, &in_value, sizeof(in_value));
-	*size += sizeof(in_value);
-#endif
-}
-
-void convertToByteStream( double in_value, uint8_t* buffer, uint32_t* size ) {
-#ifndef BYTE_ORDER_SYSTEM
-	#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-	union double_union {
-		double value;
-		uint8_t chars[8];
-	};
-	double_union temp;
-	temp.value = in_value;
-	buffer[0] = temp.chars[7];
-	buffer[1] = temp.chars[6];
-	buffer[2] = temp.chars[5];
-	buffer[3] = temp.chars[4];
-	buffer[4] = temp.chars[3];
-	buffer[5] = temp.chars[2];
-	buffer[6] = temp.chars[1];
-	buffer[7] = temp.chars[0];
-	*size += 8;
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-	memcpy(buffer, &in_value, sizeof(in_value));
-	*size += sizeof(in_value);
-#endif
-}

globalfunctions/conversion.h

@@ -1,24 +0,0 @@
-#ifndef CONVERSION_H_
-#define CONVERSION_H_
-
-
-#include <stdint.h>
-
-
-void convertToByteStream( uint16_t value, uint8_t* buffer, uint32_t* size );
-
-void convertToByteStream( uint32_t value, uint8_t* buffer, uint32_t* size );
-
-void convertToByteStream( int16_t value, uint8_t* buffer, uint32_t* size );
-
-void convertToByteStream( int32_t value, uint8_t* buffer, uint32_t* size );
-
-//void convertToByteStream( uint64_t value, uint8_t* buffer, uint32_t* size );
-//
-//void convertToByteStream( int64_t value, uint8_t* buffer, uint32_t* size );
-
-void convertToByteStream( float value, uint8_t* buffer, uint32_t* size );
-
-void convertToByteStream( double value, uint8_t* buffer, uint32_t* size );
-
-#endif /* CONVERSION_H_ */

globalfunctions/matching/MatchTree.h

@@ -45,38 +45,38 @@ public:
 		return matchSubtree(iter, number);
 	}
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+			size_t maxSize, SerializeIF::Endianness streamEndianness) const override {
 		iterator iter = this->begin();
 		uint8_t count = this->countRight(iter);
-		ReturnValue_t result = SerializeAdapter<uint8_t>::serialize(&count,
+		ReturnValue_t result = SerializeAdapter::serialize(&count,
-				buffer, size, max_size, bigEndian);
+				buffer, size, maxSize, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		if (iter == this->end()) {
 			return HasReturnvaluesIF::RETURN_OK;
 		}
-		result = iter->serialize(buffer, size, max_size, bigEndian);
+		result = iter->serialize(buffer, size, maxSize, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		if (maxDepth > 0) {
 			MatchTree<T> temp(iter.left(), maxDepth - 1);
-			result = temp.serialize(buffer, size, max_size, bigEndian);
+			result = temp.serialize(buffer, size, maxSize, streamEndianness);
 		}
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		iter = iter.right();
 		while (iter != this->end()) {
-			result = iter->serialize(buffer, size, max_size, bigEndian);
+			result = iter->serialize(buffer, size, maxSize, streamEndianness);
 			if (result != HasReturnvaluesIF::RETURN_OK) {
 				return result;
 			}
 			if (maxDepth > 0) {
 				MatchTree<T> temp(iter.left(), maxDepth - 1);
-				result = temp.serialize(buffer, size, max_size, bigEndian);
+				result = temp.serialize(buffer, size, maxSize, streamEndianness);
 			}
 			if (result != HasReturnvaluesIF::RETURN_OK) {
 				return result;
@@ -86,7 +86,7 @@ public:
 		return result;
 	}
 
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const override {
 		//Analogous to serialize!
 		uint32_t size = 1; //One for count
 		iterator iter = this->begin();
@@ -115,8 +115,8 @@ public:
 		return size;
 	}
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
+			SerializeIF::Endianness streamEndianness) override {
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 

globalfunctions/matching/RangeMatcher.h

@@ -4,7 +4,6 @@
 #include <framework/globalfunctions/matching/SerializeableMatcherIF.h>
 #include <framework/serialize/SerializeAdapter.h>
 
-
 template<typename T>
 class RangeMatcher: public SerializeableMatcherIF<T> {
 public:
@@ -27,34 +26,40 @@ public:
 		}
 	}
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-			const uint32_t max_size, bool bigEndian) const {
+			SerializeIF::Endianness streamEndianness) const override {
-		ReturnValue_t result = SerializeAdapter<T>::serialize(&lowerBound, buffer, size, max_size, bigEndian);
+		ReturnValue_t result = SerializeAdapter::serialize(&lowerBound, buffer,
+				size, maxSize, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<T>::serialize(&upperBound, buffer, size, max_size, bigEndian);
+		result = SerializeAdapter::serialize(&upperBound, buffer, size,
+				maxSize, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		return SerializeAdapter<bool>::serialize(&inverted, buffer, size, max_size, bigEndian);
+		return SerializeAdapter::serialize(&inverted, buffer, size, maxSize,
+				streamEndianness);
 	}
 
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const override {
 		return sizeof(lowerBound) + sizeof(upperBound) + sizeof(bool);
 	}
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			bool bigEndian) {
+			SerializeIF::Endianness streamEndianness) override {
-		ReturnValue_t result = SerializeAdapter<T>::deSerialize(&lowerBound, buffer, size, bigEndian);
+		ReturnValue_t result = SerializeAdapter::deSerialize(&lowerBound,
+				buffer, size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<T>::deSerialize(&upperBound, buffer, size, bigEndian);
+		result = SerializeAdapter::deSerialize(&upperBound, buffer, size,
+				streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		return SerializeAdapter<bool>::deSerialize(&inverted, buffer, size, bigEndian);
+		return SerializeAdapter::deSerialize(&inverted, buffer, size,
+				streamEndianness);
 	}
 protected:
 	bool doMatch(T input) {

health/HealthTable.cpp

@@ -63,21 +63,21 @@ bool HealthTable::hasHealth(object_id_t object) {
 	return exits;
 }
 
-void HealthTable::printAll(uint8_t* pointer, uint32_t maxSize) {
+void HealthTable::printAll(uint8_t* pointer, size_t maxSize) {
 	mutex->lockMutex(MutexIF::NO_TIMEOUT);
-	uint32_t size = 0;
+	size_t size = 0;
 	uint16_t count = healthMap.size();
-	ReturnValue_t result = SerializeAdapter<uint16_t>::serialize(&count,
+	ReturnValue_t result = SerializeAdapter::serialize(&count,
-			&pointer, &size, maxSize, true);
+			&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
 	HealthMap::iterator iter;
 	for (iter = healthMap.begin();
 			iter != healthMap.end() && result == HasReturnvaluesIF::RETURN_OK;
 			++iter) {
-		result = SerializeAdapter<object_id_t>::serialize(&iter->first,
+		result = SerializeAdapter::serialize(&iter->first,
-				&pointer, &size, maxSize, true);
+				&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
 		uint8_t health = iter->second;
-		result = SerializeAdapter<uint8_t>::serialize(&health, &pointer, &size,
+		result = SerializeAdapter::serialize(&health, &pointer, &size,
-				maxSize, true);
+				maxSize, SerializeIF::Endianness::BIG);
 	}
 	mutex->unlockMutex();
 }

health/HealthTable.h

@@ -21,7 +21,7 @@ public:
 	virtual HasHealthIF::HealthState getHealth(object_id_t);
 
 	virtual uint32_t getPrintSize();
-	virtual void printAll(uint8_t *pointer, uint32_t maxSize);
+	virtual void printAll(uint8_t *pointer, size_t maxSize);
 
 protected:
 	MutexIF* mutex;

health/HealthTableIF.h

@@ -17,7 +17,7 @@ public:
 			HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY) = 0;
 
 	virtual uint32_t getPrintSize() = 0;
-	virtual void printAll(uint8_t *pointer, uint32_t maxSize) = 0;
+	virtual void printAll(uint8_t *pointer, size_t maxSize) = 0;
 
 protected:
 	virtual ReturnValue_t iterate(std::pair<object_id_t,HasHealthIF::HealthState> *value, bool reset = false) = 0;

memory/MemoryHelper.cpp

@@ -2,7 +2,7 @@
 #include <framework/memory/MemoryHelper.h>
 #include <framework/memory/MemoryMessage.h>
 #include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/serialize/EndianSwapper.h>
+#include <framework/serialize/EndianConverter.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 MemoryHelper::MemoryHelper(HasMemoryIF* workOnThis, MessageQueueIF* useThisQueue) :
@@ -53,7 +53,7 @@ void MemoryHelper::completeLoad(ReturnValue_t errorCode,
 		memcpy(copyHere, dataToCopy, size);
 		break;
 	case HasMemoryIF::POINTS_TO_VARIABLE:
-		EndianSwapper::swap(copyHere, dataToCopy, size);
+		EndianConverter::convertBigEndian(copyHere, dataToCopy, size);
 		break;
 	case HasMemoryIF::ACTIVITY_COMPLETED:
 	case RETURN_OK:
@@ -86,7 +86,7 @@ void MemoryHelper::completeDump(ReturnValue_t errorCode,
 	case HasMemoryIF::POINTS_TO_VARIABLE:
 		//"data" must be valid pointer!
 		if (errorCode == HasMemoryIF::POINTS_TO_VARIABLE) {
-			EndianSwapper::swap(reservedSpaceInIPC, dataToCopy, size);
+			EndianConverter::convertBigEndian(reservedSpaceInIPC, dataToCopy, size);
 		} else {
 			memcpy(reservedSpaceInIPC, dataToCopy, size);
 		}
@@ -136,7 +136,7 @@ void MemoryHelper::swapMatrixCopy(uint8_t* out, const uint8_t *in,
 	}
 
 	while (totalSize > 0){
-		EndianSwapper::swap(out,in,datatypeSize);
+		EndianConverter::convertBigEndian(out,in,datatypeSize);
 		out += datatypeSize;
 		in += datatypeSize;
 		totalSize -= datatypeSize;

monitoring/LimitViolationReporter.cpp

@@ -17,7 +17,7 @@ ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF
 	}
 	store_address_t storeId;
 	uint8_t* dataTarget = NULL;
-	uint32_t maxSize = data->getSerializedSize();
+	size_t maxSize = data->getSerializedSize();
 	if (maxSize > MonitoringIF::VIOLATION_REPORT_MAX_SIZE) {
 		return MonitoringIF::INVALID_SIZE;
 	}
@@ -26,8 +26,8 @@ ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	uint32_t size = 0;
+	size_t size = 0;
-	result = data->serialize(&dataTarget, &size, maxSize, true);
+	result = data->serialize(&dataTarget, &size, maxSize, SerializeIF::Endianness::BIG);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}

osal/rtems/CpuUsage.cpp

@@ -89,15 +89,15 @@ void CpuUsage::clear() {
 	threadData.clear();
 }
 
-ReturnValue_t CpuUsage::serialize(uint8_t** buffer, uint32_t* size,
+ReturnValue_t CpuUsage::serialize(uint8_t** buffer, size_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+		size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result = SerializeAdapter<float>::serialize(
+	ReturnValue_t result = SerializeAdapter::serialize(
-			&timeSinceLastReset, buffer, size, max_size, bigEndian);
+			&timeSinceLastReset, buffer, size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 	return SerialArrayListAdapter<ThreadData>::serialize(&threadData, buffer,
-			size, max_size, bigEndian);
+			size, maxSize, streamEndianness);
 }
 
 uint32_t CpuUsage::getSerializedSize() const {
@@ -109,37 +109,37 @@ uint32_t CpuUsage::getSerializedSize() const {
 	return size;
 }
 
-ReturnValue_t CpuUsage::deSerialize(const uint8_t** buffer, int32_t* size,
+ReturnValue_t CpuUsage::deSerialize(const uint8_t** buffer, size_t* size,
-		bool bigEndian) {
+		Endianness streamEndianness) {
-	ReturnValue_t result = SerializeAdapter<float>::deSerialize(
+	ReturnValue_t result = SerializeAdapter::deSerialize(
-			&timeSinceLastReset, buffer, size, bigEndian);
+			&timeSinceLastReset, buffer, size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 	return SerialArrayListAdapter<ThreadData>::deSerialize(&threadData, buffer,
-			size, bigEndian);
+			size, streamEndianness);
 }
 
-ReturnValue_t CpuUsage::ThreadData::serialize(uint8_t** buffer, uint32_t* size,
+ReturnValue_t CpuUsage::ThreadData::serialize(uint8_t** buffer, size_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+		size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result = SerializeAdapter<uint32_t>::serialize(&id, buffer,
+	ReturnValue_t result = SerializeAdapter::serialize(&id, buffer,
-			size, max_size, bigEndian);
+			size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	if (*size + MAX_LENGTH_OF_THREAD_NAME > max_size) {
+	if (*size + MAX_LENGTH_OF_THREAD_NAME > maxSize) {
 		return BUFFER_TOO_SHORT;
 	}
 	memcpy(*buffer, name, MAX_LENGTH_OF_THREAD_NAME);
 	*size += MAX_LENGTH_OF_THREAD_NAME;
 	*buffer += MAX_LENGTH_OF_THREAD_NAME;
-	result = SerializeAdapter<float>::serialize(&timeRunning,
+	result = SerializeAdapter::serialize(&timeRunning,
-			buffer, size, max_size, bigEndian);
+			buffer, size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<float>::serialize(&percentUsage,
+	result = SerializeAdapter::serialize(&percentUsage,
-			buffer, size, max_size, bigEndian);
+			buffer, size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -158,9 +158,9 @@ uint32_t CpuUsage::ThreadData::getSerializedSize() const {
 }
 
 ReturnValue_t CpuUsage::ThreadData::deSerialize(const uint8_t** buffer,
-		int32_t* size, bool bigEndian) {
+		int32_t* size, Endianness streamEndianness) {
-	ReturnValue_t result = SerializeAdapter<uint32_t>::deSerialize(&id, buffer,
+	ReturnValue_t result = SerializeAdapter::deSerialize(&id, buffer,
-			size, bigEndian);
+			size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -169,13 +169,13 @@ ReturnValue_t CpuUsage::ThreadData::deSerialize(const uint8_t** buffer,
 	}
 	memcpy(name, *buffer, MAX_LENGTH_OF_THREAD_NAME);
 	*buffer -= MAX_LENGTH_OF_THREAD_NAME;
-	result = SerializeAdapter<float>::deSerialize(&timeRunning,
+	result = SerializeAdapter::deSerialize(&timeRunning,
-			buffer, size, bigEndian);
+			buffer, size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<float>::deSerialize(&percentUsage,
+	result = SerializeAdapter::deSerialize(&percentUsage,
-			buffer, size, bigEndian);
+			buffer, size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}

osal/rtems/CpuUsage.h

@@ -18,13 +18,13 @@ public:
 		float timeRunning;
 		float percentUsage;
 
-		virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+		virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				const uint32_t max_size, bool bigEndian) const;
+				size_t maxSize, Endianness streamEndianness) const override;
 
-		virtual uint32_t getSerializedSize() const;
+		virtual size_t getSerializedSize() const override;
 
-		virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+		virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-				bool bigEndian);
+				Endianness streamEndianness) override;
 	};
 
 	CpuUsage();
@@ -41,13 +41,13 @@ public:
 
 	void clear();
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+			size_t maxSize, Endianness streamEndianness) const override;
 
-	virtual uint32_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const override;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian);
+			Endianness streamEndianness) override;
 };
 
 #endif /* CPUUSAGE_H_ */

parameters/ParameterHelper.cpp

@@ -83,7 +83,7 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
 
 ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
 		const ParameterWrapper* description) {
-	uint32_t serializedSize = description->getSerializedSize();
+	size_t serializedSize = description->getSerializedSize();
 
 	uint8_t *storeElement;
 	store_address_t address;
@@ -94,10 +94,10 @@ ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
 		return result;
 	}
 
-	uint32_t storeElementSize = 0;
+	size_t storeElementSize = 0;
 
 	result = description->serialize(&storeElement, &storeElementSize,
-			serializedSize, true);
+			serializedSize, SerializeIF::Endianness::BIG);
 
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		storage->deleteData(address);

parameters/ParameterWrapper.cpp

@@ -20,23 +20,23 @@ ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
 ParameterWrapper::~ParameterWrapper() {
 }
 
-ReturnValue_t ParameterWrapper::serialize(uint8_t** buffer, uint32_t* size,
+ReturnValue_t ParameterWrapper::serialize(uint8_t **buffer, size_t *size,
-		const uint32_t max_size, bool bigEndian) const {
+		size_t maxSize, Endianness streamEndianness) const {
 	ReturnValue_t result;
 
-	result = SerializeAdapter<Type>::serialize(&type, buffer, size, max_size,
+	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
-			bigEndian);
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter<uint8_t>::serialize(&columns, buffer, size,
+	result = SerializeAdapter::serialize(&columns, buffer, size, maxSize,
-			max_size, bigEndian);
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<uint8_t>::serialize(&rows, buffer, size, max_size,
+	result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
-			bigEndian);
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -47,28 +47,33 @@ ReturnValue_t ParameterWrapper::serialize(uint8_t** buffer, uint32_t* size,
 	}
 	switch (type) {
 	case Type::UINT8_T:
-		result = serializeData<uint8_t>(buffer, size, max_size, bigEndian);
+		result = serializeData<uint8_t>(buffer, size, maxSize,
+				streamEndianness);
 		break;
 	case Type::INT8_T:
-		result = serializeData<int8_t>(buffer, size, max_size, bigEndian);
+		result = serializeData<int8_t>(buffer, size, maxSize, streamEndianness);
 		break;
 	case Type::UINT16_T:
-		result = serializeData<uint16_t>(buffer, size, max_size, bigEndian);
+		result = serializeData<uint16_t>(buffer, size, maxSize,
+				streamEndianness);
 		break;
 	case Type::INT16_T:
-		result = serializeData<int16_t>(buffer, size, max_size, bigEndian);
+		result = serializeData<int16_t>(buffer, size, maxSize,
+				streamEndianness);
 		break;
 	case Type::UINT32_T:
-		result = serializeData<uint32_t>(buffer, size, max_size, bigEndian);
+		result = serializeData<uint32_t>(buffer, size, maxSize,
+				streamEndianness);
 		break;
 	case Type::INT32_T:
-		result = serializeData<int32_t>(buffer, size, max_size, bigEndian);
+		result = serializeData<int32_t>(buffer, size, maxSize,
+				streamEndianness);
 		break;
 	case Type::FLOAT:
-		result = serializeData<float>(buffer, size, max_size, bigEndian);
+		result = serializeData<float>(buffer, size, maxSize, streamEndianness);
 		break;
 	case Type::DOUBLE:
-		result = serializeData<double>(buffer, size, max_size, bigEndian);
+		result = serializeData<double>(buffer, size, maxSize, streamEndianness);
 		break;
 	default:
 		result = UNKNOW_DATATYPE;
@@ -77,7 +82,7 @@ ReturnValue_t ParameterWrapper::serialize(uint8_t** buffer, uint32_t* size,
 	return result;
 }
 
-uint32_t ParameterWrapper::getSerializedSize() const {
+size_t ParameterWrapper::getSerializedSize() const {
 	uint32_t serializedSize = 0;
 	serializedSize += type.getSerializedSize();
 	serializedSize += sizeof(rows);
@@ -88,14 +93,14 @@ uint32_t ParameterWrapper::getSerializedSize() const {
 }
 
 template<typename T>
-ReturnValue_t ParameterWrapper::serializeData(uint8_t** buffer, uint32_t* size,
+ReturnValue_t ParameterWrapper::serializeData(uint8_t **buffer, size_t *size,
-		const uint32_t max_size, bool bigEndian) const {
+		size_t maxSize, Endianness streamEndianness) const {
 	const T *element = (const T*) readonlyData;
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 	uint16_t dataSize = columns * rows;
 	while (dataSize != 0) {
-		result = SerializeAdapter<T>::serialize(element, buffer, size, max_size,
+		result = SerializeAdapter::serialize(element, buffer, size, maxSize,
-				bigEndian);
+				streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
@@ -112,7 +117,7 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 
 	//treat from as a continuous Stream as we copy all of it
 	const uint8_t *fromAsStream = (const uint8_t*) from;
-	int32_t streamSize = fromRows * fromColumns * sizeof(T);
+	size_t streamSize = fromRows * fromColumns * sizeof(T);
 
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 
@@ -123,9 +128,9 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 				+ (((startingRow + fromRow) * columns) + startingColumn);
 
 		for (uint8_t fromColumn = 0; fromColumn < fromColumns; fromColumn++) {
-			result = SerializeAdapter<T>::deSerialize(
+			result = SerializeAdapter::deSerialize(
 					dataWithDataType + fromColumn, &fromAsStream, &streamSize,
-					true);
+					SerializeIF::Endianness::BIG);
 			if (result != HasReturnvaluesIF::RETURN_OK) {
 				return result;
 			}
@@ -137,12 +142,13 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 }
 
 ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
-		int32_t* size, bool bigEndian) {
+		size_t *size, Endianness streamEndianness) {
-	return deSerialize(buffer, size, bigEndian, 0);
+	return deSerialize(buffer, size, streamEndianness, 0);
 }
 
 ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
-		int32_t* size, bool bigEndian, uint16_t startWritingAtIndex) {
+		size_t *size, Endianness streamEndianness,
+		uint16_t startWritingAtIndex) {
 	ParameterWrapper streamDescription;
 
 	ReturnValue_t result = streamDescription.set(*buffer, *size, buffer, size);
@@ -153,26 +159,26 @@ ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
 	return copyFrom(&streamDescription, startWritingAtIndex);
 }
 
-ReturnValue_t ParameterWrapper::set(const uint8_t* stream, int32_t streamSize,
+ReturnValue_t ParameterWrapper::set(const uint8_t *stream, size_t streamSize,
-		const uint8_t **remainingStream, int32_t *remainingSize) {
+		const uint8_t **remainingStream, size_t *remainingSize) {
-	ReturnValue_t result = SerializeAdapter<Type>::deSerialize(&type, &stream,
+	ReturnValue_t result = SerializeAdapter::deSerialize(&type, &stream,
-			&streamSize, true);
+			&streamSize, SerializeIF::Endianness::BIG);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter<uint8_t>::deSerialize(&columns, &stream,
+	result = SerializeAdapter::deSerialize(&columns, &stream, &streamSize,
-			&streamSize, true);
+			SerializeIF::Endianness::BIG);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<uint8_t>::deSerialize(&rows, &stream, &streamSize,
+	result = SerializeAdapter::deSerialize(&rows, &stream, &streamSize,
-			true);
+			SerializeIF::Endianness::BIG);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	int32_t dataSize = type.getSize() * rows * columns;
+	size_t dataSize = type.getSize() * rows * columns;
 
 	if (streamSize < dataSize) {
 		return SerializeIF::STREAM_TOO_SHORT;

parameters/ParameterWrapper.h

@@ -25,16 +25,16 @@ public:
 			const void *data);
 	virtual ~ParameterWrapper();
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+			size_t maxSize, Endianness streamEndianness) const override;
 
-	virtual uint32_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const override;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian);
+			Endianness streamEndianness) override;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian, uint16_t startWritingAtIndex = 0);
+			Endianness streamEndianness, uint16_t startWritingAtIndex = 0);
 
 	template<typename T>
 	ReturnValue_t getElement(T *value, uint8_t row = 0, uint8_t column = 0) const {
@@ -54,7 +54,7 @@ public:
 			const uint8_t *streamWithtype = (const uint8_t *) readonlyData;
 			streamWithtype += (row * columns + column) * type.getSize();
 			int32_t size = type.getSize();
-			return SerializeAdapter<T>::deSerialize(value, &streamWithtype,
+			return SerializeAdapter::deSerialize(value, &streamWithtype,
 					&size, true);
 		} else {
 			const T *dataWithType = (const T *) readonlyData;
@@ -111,8 +111,8 @@ public:
 	void setMatrix(const T& member) {
 		this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
 	}
-	ReturnValue_t set(const uint8_t *stream, int32_t streamSize,
+	ReturnValue_t set(const uint8_t *stream, size_t streamSize,
-			const uint8_t **remainingStream = NULL, int32_t *remainingSize =
+			const uint8_t **remainingStream = NULL, size_t *remainingSize =
 					NULL);
 
 	ReturnValue_t copyFrom(const ParameterWrapper *from,
@@ -128,8 +128,8 @@ private:
 	const void *readonlyData;
 
 	template<typename T>
-	ReturnValue_t serializeData(uint8_t** buffer, uint32_t* size,
+	ReturnValue_t serializeData(uint8_t** buffer, size_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+			size_t maxSize, Endianness streamEndianness) const;
 
 	template<typename T>
 	ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,

power/Fuse.cpp

@@ -86,12 +86,12 @@ ReturnValue_t Fuse::check() {
 	return result;
 }
 
-ReturnValue_t Fuse::serialize(uint8_t** buffer, uint32_t* size,
+ReturnValue_t Fuse::serialize(uint8_t** buffer, size_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+		size_t maxSize, Endianness streamEndianness) const {
 	ReturnValue_t result = RETURN_FAILED;
 	for (DeviceList::const_iterator iter = devices.begin();
 			iter != devices.end(); iter++) {
-		result = (*iter)->serialize(buffer, size, max_size, bigEndian);
+		result = (*iter)->serialize(buffer, size, maxSize, streamEndianness);
 		if (result != RETURN_OK) {
 			return result;
 		}
@@ -99,7 +99,7 @@ ReturnValue_t Fuse::serialize(uint8_t** buffer, uint32_t* size,
 	return RETURN_OK;
 }
 
-uint32_t Fuse::getSerializedSize() const {
+size_t Fuse::getSerializedSize() const {
 	uint32_t size = 0;
 	for (DeviceList::const_iterator iter = devices.begin();
 			iter != devices.end(); iter++) {
@@ -108,12 +108,12 @@ uint32_t Fuse::getSerializedSize() const {
 	return size;
 }
 
-ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, int32_t* size,
+ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, size_t* size,
-bool bigEndian) {
+Endianness streamEndianness) {
 	ReturnValue_t result = RETURN_FAILED;
 	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
 			iter++) {
-		result = (*iter)->deSerialize(buffer, size, bigEndian);
+		result = (*iter)->deSerialize(buffer, size, streamEndianness);
 		if (result != RETURN_OK) {
 			return result;
 		}

power/Fuse.h

@@ -18,7 +18,8 @@ void setStaticFrameworkObjectIds();
 class Fuse: public SystemObject,
 		public HasHealthIF,
 		public HasReturnvaluesIF,
-		public ReceivesParameterMessagesIF {
+		public ReceivesParameterMessagesIF,
+		public SerializeIF {
 	friend void (Factory::setStaticFrameworkObjectIds)();
 private:
 	static constexpr float RESIDUAL_POWER = 0.005 * 28.5; //!< This is the upper limit of residual power lost by fuses and switches. Worst case is Fuse and one of two switches on. See PCDU ICD 1.9 p29 bottom
@@ -49,11 +50,11 @@ public:
 	uint8_t getFuseId() const;
 	ReturnValue_t initialize();
 	DeviceList devices;
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-			const uint32_t max_size, bool bigEndian) const;
+			SerializeIF::Endianness streamEndianness) const override;
-	uint32_t getSerializedSize() const;
+	size_t getSerializedSize() const override;
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-	bool bigEndian);
+			SerializeIF::Endianness streamEndianness) override;
 	void setAllMonitorsToUnchecked();
 	ReturnValue_t performOperation(uint8_t opCode);
 	MessageQueueId_t getCommandQueue() const;

power/PowerComponent.cpp

@@ -17,18 +17,18 @@ PowerComponent::PowerComponent(object_id_t setId, uint8_t moduleId, float min, f
 				twoSwitches), min(min), max(max), moduleId(moduleId) {
 }
 
-ReturnValue_t PowerComponent::serialize(uint8_t** buffer, uint32_t* size,
+ReturnValue_t PowerComponent::serialize(uint8_t** buffer, size_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+		size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result = SerializeAdapter<float>::serialize(&min, buffer,
+	ReturnValue_t result = SerializeAdapter::serialize(&min, buffer,
-			size, max_size, bigEndian);
+			size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	return SerializeAdapter<float>::serialize(&max, buffer, size, max_size,
+	return SerializeAdapter::serialize(&max, buffer, size, maxSize,
-			bigEndian);
+			streamEndianness);
 }
 
-uint32_t PowerComponent::getSerializedSize() const {
+size_t PowerComponent::getSerializedSize() const {
 	return sizeof(min) + sizeof(max);
 }
 
@@ -56,14 +56,14 @@ float PowerComponent::getMax() {
 	return max;
 }
 
-ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, int32_t* size,
+ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, size_t* size,
-bool bigEndian) {
+Endianness streamEndianness) {
-	ReturnValue_t result = SerializeAdapter<float>::deSerialize(&min, buffer,
+	ReturnValue_t result = SerializeAdapter::deSerialize(&min, buffer,
-			size, bigEndian);
+			size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	return SerializeAdapter<float>::deSerialize(&max, buffer, size, bigEndian);
+	return SerializeAdapter::deSerialize(&max, buffer, size, streamEndianness);
 }
 
 ReturnValue_t PowerComponent::getParameter(uint8_t domainId,

power/PowerComponent.h

@@ -19,13 +19,13 @@ public:
 	float getMin();
 	float getMax();
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+			size_t maxSize, Endianness streamEndianness) const override;
 
-	uint32_t getSerializedSize() const;
+	size_t getSerializedSize() const override;
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian);
+			Endianness streamEndianness) override;
 
 	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
 				ParameterWrapper *parameterWrapper,

serialize/EndianConverter.h

@@ -0,0 +1,126 @@
+#ifndef ENDIANSWAPPER_H_
+#define ENDIANSWAPPER_H_
+
+#include <framework/osal/Endiness.h>
+#include <cstring>
+#include <iostream>
+
+/**
+ * Helper class to convert variables or bitstreams between machine
+ * endian and either big or little endian.
+ * Machine endian is the endianness used by the machine running the
+ * program and is one of big or little endian. As this is portable
+ * code, it is not known at coding time which it is. At compile time
+ * it is however, which is why this is implemented using compiler
+ * macros and translates to a copy operation at runtime.
+ *
+ * This changes the layout of multi-byte variables in the machine's
+ * memory. In most cases, you should not need to use this class.
+ * Probably what you are looking for is the SerializeAdapter.
+ * If you still decide you need this class, please read and understand
+ * the code first.
+ *
+ * The order of the individual bytes of the multi-byte variable is
+ * reversed, the byte at the highest address is moved to the lowest
+ * address and vice versa, same for the bytes in between.
+ *
+ * Note that the conversion is also its inversion, that is converting
+ * from machine to a specified endianness is the same operation as
+ * converting from specified to machine (I looked it up, mathematicians
+ * would call it an involution):
+ *
+ * X == convertBigEndian(convertBigEndian(X))
+ *
+ * Thus, there is only one function supplied to do the conversion.
+ */
+class EndianConverter {
+private:
+	EndianConverter() {
+	}
+	;
+public:
+	/**
+	 * Convert a typed variable between big endian and machine endian.
+	 * Intended for plain old datatypes.
+	 */
+	template<typename T>
+	static T convertBigEndian(T in) {
+#ifndef BYTE_ORDER_SYSTEM
+#error BYTE_ORDER_SYSTEM not defined
+#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		T tmp;
+		uint8_t *pointerOut = (uint8_t*) &tmp;
+		uint8_t *pointerIn = (uint8_t*) &in;
+		for (size_t count = 0; count < sizeof(T); count++) {
+			pointerOut[sizeof(T) - count - 1] = pointerIn[count];
+		}
+		return tmp;
+#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+		return in;
+#else
+#error Unknown Byte Order
+#endif
+	}
+
+	/**
+	 * convert a bytestream representing a single variable between big endian
+	 * and machine endian.
+	 */
+	static void convertBigEndian(uint8_t *out, const uint8_t *in,
+			size_t size) {
+#ifndef BYTE_ORDER_SYSTEM
+#error BYTE_ORDER_SYSTEM not defined
+#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		for (size_t count = 0; count < size; count++) {
+			out[size - count - 1] = in[count];
+		}
+		return;
+#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+		memcpy(out, in, size);
+		return;
+#endif
+	}
+
+	/**
+	 * Convert a typed variable between little endian and machine endian.
+	 * Intended for plain old datatypes.
+	 */
+	template<typename T>
+	static T convertLittleEndian(T in) {
+#ifndef BYTE_ORDER_SYSTEM
+	#error BYTE_ORDER_SYSTEM not defined
+	#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+			T tmp;
+			uint8_t *pointerOut = (uint8_t *) &tmp;
+			uint8_t *pointerIn = (uint8_t *) &in;
+			for (size_t count = 0; count < sizeof(T); count++) {
+				pointerOut[sizeof(T) - count - 1] = pointerIn[count];
+			}
+			return tmp;
+	#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		return in;
+#else
+	#error Unknown Byte Order
+	#endif
+	}
+	/**
+	 * convert a bytestream representing a single variable between little endian
+	 * and machine endian.
+	 */
+	static void convertLittleEndian(uint8_t *out, const uint8_t *in,
+			size_t size) {
+#ifndef BYTE_ORDER_SYSTEM
+	#error BYTE_ORDER_SYSTEM not defined
+	#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+			for (size_t count = 0; count < size; count++) {
+				out[size - count - 1] = in[count];
+			}
+			return;
+	#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		memcpy(out, in, size);
+		return;
+#endif
+	}
+};
+
+#endif /* ENDIANSWAPPER_H_ */

serialize/EndianSwapper.h

@@ -1,47 +0,0 @@
-#ifndef ENDIANSWAPPER_H_
-#define ENDIANSWAPPER_H_
-
-#include <framework/osal/Endiness.h>
-#include <cstring>
-#include <iostream>
-
-class EndianSwapper {
-private:
-	EndianSwapper() {
-	}
-	;
-public:
-	template<typename T>
-	static T swap(T in) {
-#ifndef BYTE_ORDER_SYSTEM
-#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-		T tmp;
-		uint8_t *pointerOut = (uint8_t *) &tmp;
-		uint8_t *pointerIn = (uint8_t *) &in;
-		for (uint8_t count = 0; count < sizeof(T); count++) {
-			pointerOut[sizeof(T) - count - 1] = pointerIn[count];
-		}
-		return tmp;
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-		return in;
-#else
-#error Unknown Byte Order
-#endif
-	}
-	static void swap(uint8_t* out, const uint8_t* in, uint32_t size) {
-#ifndef BYTE_ORDER_SYSTEM
-#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-		for (uint8_t count = 0; count < size; count++) {
-			out[size - count - 1] = in[count];
-		}
-		return;
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-		memcpy(out, in, size);
-		return;
-#endif
-	}
-};
-
-#endif /* ENDIANSWAPPER_H_ */

serialize/SerialArrayListAdapter.h

@@ -20,25 +20,25 @@ public:
 	SerialArrayListAdapter(ArrayList<T, count_t> *adaptee) : adaptee(adaptee) {
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+			size_t maxSize, Endianness streamEndianness) const {
-		return serialize(adaptee, buffer, size, max_size, bigEndian);
+		return serialize(adaptee, buffer, size, maxSize, streamEndianness);
 	}
 
-	static ReturnValue_t serialize(const ArrayList<T, count_t>* list, uint8_t** buffer, uint32_t* size,
+	static ReturnValue_t serialize(const ArrayList<T, count_t>* list, uint8_t** buffer, size_t* size,
-			const uint32_t max_size, bool bigEndian) {
+			size_t maxSize, Endianness streamEndianness) {
-		ReturnValue_t result = SerializeAdapter<count_t>::serialize(&list->size,
+		ReturnValue_t result = SerializeAdapter::serialize(&list->size,
-				buffer, size, max_size, bigEndian);
+				buffer, size, maxSize, streamEndianness);
 		count_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
-			result = SerializeAdapter<T>::serialize(&list->entries[i], buffer, size,
+			result = SerializeAdapter::serialize(&list->entries[i], buffer, size,
-					max_size, bigEndian);
+					maxSize, streamEndianness);
 			++i;
 		}
 		return result;
 	}
 
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const {
 		return getSerializedSize(adaptee);
 	}
 
@@ -47,31 +47,31 @@ public:
 		count_t i = 0;
 
 		for (i = 0; i < list->size; ++i) {
-			printSize += SerializeAdapter<T>::getSerializedSize(&list->entries[i]);
+			printSize += SerializeAdapter::getSerializedSize(&list->entries[i]);
 		}
 
 		return printSize;
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
+			Endianness streamEndianness) {
-		return deSerialize(adaptee, buffer, size, bigEndian);
+		return deSerialize(adaptee, buffer, size, streamEndianness);
 	}
 
-	static ReturnValue_t deSerialize(ArrayList<T, count_t>* list, const uint8_t** buffer, int32_t* size,
+	static ReturnValue_t deSerialize(ArrayList<T, count_t>* list, const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
+			Endianness streamEndianness) {
 		count_t tempSize = 0;
-		ReturnValue_t result = SerializeAdapter<count_t>::deSerialize(&tempSize,
+		ReturnValue_t result = SerializeAdapter::deSerialize(&tempSize,
-				buffer, size, bigEndian);
+				buffer, size, streamEndianness);
 		if (tempSize > list->maxSize()) {
 			return SerializeIF::TOO_MANY_ELEMENTS;
 		}
 		list->size = tempSize;
 		count_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
-			result = SerializeAdapter<T>::deSerialize(
+			result = SerializeAdapter::deSerialize(
 					&list->front()[i], buffer, size,
-					bigEndian);
+					streamEndianness);
 			++i;
 		}
 		return result;

serialize/SerialBufferAdapter.cpp

@@ -22,19 +22,19 @@ SerialBufferAdapter<T>::~SerialBufferAdapter() {
 }
 
 template<typename T>
-ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, uint32_t* size,
+ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, size_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+		size_t maxSize, Endianness streamEndianness) const {
 	uint32_t serializedLength = bufferLength;
 	if (serializeLength) {
-		serializedLength += AutoSerializeAdapter::getSerializedSize(
+		serializedLength += SerializeAdapter::getSerializedSize(
 				&bufferLength);
 	}
-	if (*size + serializedLength > max_size) {
+	if (*size + serializedLength > maxSize) {
 		return BUFFER_TOO_SHORT;
 	} else {
 		if (serializeLength) {
-			AutoSerializeAdapter::serialize(&bufferLength, buffer, size,
+			SerializeAdapter::serialize(&bufferLength, buffer, size,
-					max_size, bigEndian);
+					maxSize, streamEndianness);
 		}
 		if (this->constBuffer != NULL) {
 			memcpy(*buffer, this->constBuffer, bufferLength);
@@ -50,20 +50,20 @@ ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, uint32_t* size
 }
 
 template<typename T>
-uint32_t SerialBufferAdapter<T>::getSerializedSize() const {
+size_t SerialBufferAdapter<T>::getSerializedSize() const {
 	if (serializeLength) {
-		return bufferLength + AutoSerializeAdapter::getSerializedSize(&bufferLength);
+		return bufferLength + SerializeAdapter::getSerializedSize(&bufferLength);
 	} else {
 		return bufferLength;
 	}
 }
 template<typename T>
 ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer,
-		int32_t* size, bool bigEndian) {
+		size_t* size, Endianness streamEndianness) {
 	//TODO Ignores Endian flag!
 	if (buffer != NULL) {
 		if(serializeLength){
-			T serializedSize = AutoSerializeAdapter::getSerializedSize(
+			T serializedSize = SerializeAdapter::getSerializedSize(
 					&bufferLength);
 			if((*size - bufferLength - serializedSize) >= 0){
 				*buffer +=  serializedSize;

serialize/SerialBufferAdapter.h

@@ -16,13 +16,13 @@ public:
 
 	virtual ~SerialBufferAdapter();
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+			size_t maxSize, Endianness streamEndianness) const override;
 
-	virtual uint32_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const override;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian);
+			Endianness streamEndianness) override;
 private:
 	bool serializeLength;
 	const uint8_t *constBuffer;

serialize/SerialFixedArrayListAdapter.h

@@ -13,16 +13,16 @@ public:
 	template<typename... Args>
 	SerialFixedArrayListAdapter(Args... args) : FixedArrayList<T, MAX_SIZE, count_t>(std::forward<Args>(args)...) {
 	}
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+			size_t maxSize, Endianness streamEndianness) const {
-		return SerialArrayListAdapter<T, count_t>::serialize(this, buffer, size, max_size, bigEndian);
+		return SerialArrayListAdapter<T, count_t>::serialize(this, buffer, size, maxSize, streamEndianness);
 	}
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		return SerialArrayListAdapter<T, count_t>::getSerializedSize(this);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
+			Endianness streamEndianness) {
-		return SerialArrayListAdapter<T, count_t>::deSerialize(this, buffer, size, bigEndian);
+		return SerialArrayListAdapter<T, count_t>::deSerialize(this, buffer, size, streamEndianness);
 	}
 };
 

serialize/SerialLinkedListAdapter.h

@@ -31,32 +31,32 @@ public:
 			SinglyLinkedList<T>(), printCount(printCount) {
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+			size_t maxSize, Endianness streamEndianness) const override {
 		if (printCount) {
 			count_t mySize = SinglyLinkedList<T>::getSize();
-			ReturnValue_t result = SerializeAdapter<count_t>::serialize(&mySize,
+			ReturnValue_t result = SerializeAdapter::serialize(&mySize,
-					buffer, size, max_size, bigEndian);
+					buffer, size, maxSize, streamEndianness);
 			if (result != HasReturnvaluesIF::RETURN_OK) {
 				return result;
 			}
 		}
-		return serialize(SinglyLinkedList<T>::start, buffer, size, max_size,
+		return serialize(SinglyLinkedList<T>::start, buffer, size, maxSize,
-				bigEndian);
+				streamEndianness);
 	}
 
 	static ReturnValue_t serialize(const LinkedElement<T>* element,
-			uint8_t** buffer, uint32_t* size, const uint32_t max_size,
+			uint8_t** buffer, size_t* size, size_t maxSize,
-			bool bigEndian) {
+			Endianness streamEndianness) {
 		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
-			result = element->value->serialize(buffer, size, max_size,
+			result = element->value->serialize(buffer, size, maxSize,
-					bigEndian);
+					streamEndianness);
 			element = element->getNext();
 		}
 		return result;
 	}
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const override {
 		if (printCount) {
 			return SerialLinkedListAdapter<T>::getSerializedSize()
 					+ sizeof(count_t);
@@ -64,8 +64,8 @@ public:
 			return getSerializedSize(SinglyLinkedList<T>::start);
 		}
 	}
-	static uint32_t getSerializedSize(const LinkedElement<T> *element) {
+	static size_t getSerializedSize(const LinkedElement<T> *element) {
-		uint32_t size = 0;
+		size_t size = 0;
 		while (element != NULL) {
 			size += element->value->getSerializedSize();
 			element = element->getNext();
@@ -73,16 +73,16 @@ public:
 		return size;
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
+			Endianness streamEndianness) override {
-		return deSerialize(SinglyLinkedList<T>::start, buffer, size, bigEndian);
+		return deSerialize(SinglyLinkedList<T>::start, buffer, size, streamEndianness);
 	}
 
 	static ReturnValue_t deSerialize(LinkedElement<T>* element,
-			const uint8_t** buffer, int32_t* size, bool bigEndian) {
+			const uint8_t** buffer, size_t* size, Endianness streamEndianness) {
 		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
-			result = element->value->deSerialize(buffer, size, bigEndian);
+			result = element->value->deSerialize(buffer, size, streamEndianness);
 			element = element->getNext();
 		}
 		return result;

serialize/SerializeAdapter.h

@@ -3,28 +3,58 @@
 
 #include <framework/container/IsDerivedFrom.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/serialize/EndianSwapper.h>
+#include <framework/serialize/EndianConverter.h>
 #include <framework/serialize/SerializeIF.h>
 #include <string.h>
 
 /**
  * \ingroup serialize
  */
+
+class SerializeAdapter {
+public:
+	template<typename T>
+	static ReturnValue_t serialize(const T *object, uint8_t **buffer,
+			size_t *size, size_t maxSize, SerializeIF::Endianness streamEndianness) {
+		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+		return adapter.serialize(object, buffer, size, maxSize,
+				streamEndianness);
+	}
+	template<typename T>
+	static uint32_t getSerializedSize(const T *object) {
+		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+		return adapter.getSerializedSize(object);
+	}
+	template<typename T>
+	static ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
+			size_t *size, SerializeIF::Endianness streamEndianness) {
+		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+		return adapter.deSerialize(object, buffer, size, streamEndianness);
+	}
+private:
 	template<typename T, int>
-class SerializeAdapter_ {
+	class InternalSerializeAdapter {
 	public:
 		static ReturnValue_t serialize(const T *object, uint8_t **buffer,
-			uint32_t* size, const uint32_t max_size, bool bigEndian) {
+				size_t *size, size_t max_size, SerializeIF::Endianness streamEndianness) {
-		uint32_t ignoredSize = 0;
+			size_t ignoredSize = 0;
 			if (size == NULL) {
 				size = &ignoredSize;
 			}
+			//TODO check integer overflow of *size
 			if (sizeof(T) + *size <= max_size) {
 				T tmp;
-			if (bigEndian) {
+				switch (streamEndianness) {
-				tmp = EndianSwapper::swap<T>(*object);
+				case SerializeIF::Endianness::BIG:
-			} else {
+					tmp = EndianConverter::convertBigEndian<T>(*object);
+					break;
+				case SerializeIF::Endianness::LITTLE:
+					tmp = EndianConverter::convertLittleEndian<T>(*object);
+					break;
+				default:
+				case SerializeIF::Endianness::MACHINE:
 					tmp = *object;
+					break;
 				}
 				memcpy(*buffer, &tmp, sizeof(T));
 				*size += sizeof(T);
@@ -35,17 +65,25 @@ public:
 			}
 		}
 
-	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, int32_t* size,
+		ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
-			bool bigEndian) {
+				size_t *size, SerializeIF::Endianness streamEndianness) {
 			T tmp;
+			if (*size >= sizeof(T)) {
 				*size -= sizeof(T);
-		if (*size >= 0) {
 				memcpy(&tmp, *buffer, sizeof(T));
-			if (bigEndian) {
+				switch (streamEndianness) {
-				*object = EndianSwapper::swap<T>(tmp);
+				case SerializeIF::Endianness::BIG:
-			} else {
+					*object = EndianConverter::convertBigEndian<T>(tmp);
+					break;
+				case SerializeIF::Endianness::LITTLE:
+					*object = EndianConverter::convertLittleEndian<T>(tmp);
+					break;
+				default:
+				case SerializeIF::Endianness::MACHINE:
 					*object = tmp;
+					break;
 				}
+
 				*buffer += sizeof(T);
 				return HasReturnvaluesIF::RETURN_OK;
 			} else {
@@ -60,66 +98,26 @@ public:
 	};
 
 	template<typename T>
-class SerializeAdapter_<T, 1> {
+	class InternalSerializeAdapter<T, 1> {
 	public:
-	ReturnValue_t serialize(const T* object, uint8_t** buffer, uint32_t* size,
+		ReturnValue_t serialize(const T *object, uint8_t **buffer,
-			const uint32_t max_size, bool bigEndian) const {
+				size_t *size, size_t max_size,
-		uint32_t ignoredSize = 0;
+				SerializeIF::Endianness streamEndianness) const {
+			size_t ignoredSize = 0;
 			if (size == NULL) {
 				size = &ignoredSize;
 			}
-		return object->serialize(buffer, size, max_size, bigEndian);
+			return object->serialize(buffer, size, max_size, streamEndianness);
 		}
 		uint32_t getSerializedSize(const T *object) const {
 			return object->getSerializedSize();
 		}
 
-	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, int32_t* size,
+		ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
-			bool bigEndian) {
+				size_t *size, SerializeIF::Endianness streamEndianness) {
-		return object->deSerialize(buffer, size, bigEndian);
+			return object->deSerialize(buffer, size, streamEndianness);
 		}
 	};
-
-template<typename T>
-class SerializeAdapter {
-public:
-	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
-			uint32_t* size, const uint32_t max_size, bool bigEndian) {
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.serialize(object, buffer, size, max_size, bigEndian);
-	}
-	static uint32_t getSerializedSize(const T* object) {
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.getSerializedSize(object);
-	}
-
-	static ReturnValue_t deSerialize(T* object, const uint8_t** buffer,
-			int32_t* size, bool bigEndian) {
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.deSerialize(object, buffer, size, bigEndian);
-	}
-};
-
-
-class AutoSerializeAdapter {
-public:
-	template<typename T>
-	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
-			uint32_t* size, const uint32_t max_size, bool bigEndian) {
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.serialize(object, buffer, size, max_size, bigEndian);
-	}
-	template<typename T>
-	static uint32_t getSerializedSize(const T* object) {
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.getSerializedSize(object);
-	}
-	template<typename T>
-	static ReturnValue_t deSerialize(T* object, const uint8_t** buffer,
-			int32_t* size, bool bigEndian) {
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.deSerialize(object, buffer, size, bigEndian);
-	}
 };
 
 #endif /* SERIALIZEADAPTER_H_ */

serialize/SerializeElement.h

@@ -12,24 +12,28 @@ template<typename T>
 class SerializeElement: public SerializeIF, public LinkedElement<SerializeIF> {
 public:
 	template<typename ... Args>
-	SerializeElement(Args... args) : LinkedElement<SerializeIF>(this), entry(std::forward<Args>(args)...) {
+	SerializeElement(Args ... args) :
+			LinkedElement<SerializeIF>(this), entry(std::forward<Args>(args)...) {
 
 	}
-	SerializeElement() : LinkedElement<SerializeIF>(this) {
+	SerializeElement() :
+			LinkedElement<SerializeIF>(this) {
 	}
 	T entry;
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-			const uint32_t max_size, bool bigEndian) const {
+			Endianness streamEndianness) const override {
-		return SerializeAdapter<T>::serialize(&entry, buffer, size, max_size, bigEndian);
+		return SerializeAdapter::serialize(&entry, buffer, size, maxSize,
+				streamEndianness);
 	}
 
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const override {
-		return SerializeAdapter<T>::getSerializedSize(&entry);
+		return SerializeAdapter::getSerializedSize(&entry);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			bool bigEndian) {
+			Endianness streamEndianness) override {
-		return SerializeAdapter<T>::deSerialize(&entry, buffer, size, bigEndian);
+		return SerializeAdapter::deSerialize(&entry, buffer, size,
+				streamEndianness);
 	}
 	operator T() {
 		return entry;
@@ -44,6 +48,4 @@ public:
 	}
 };
 
-
-
 #endif /* SERIALIZEELEMENT_H_ */

serialize/SerializeIF.h

@@ -2,6 +2,7 @@
 #define SERIALIZEIF_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <stddef.h>
 
 /**
  * \defgroup serialize Serialization
@@ -14,6 +15,10 @@
  */
 class SerializeIF {
 public:
+	enum class Endianness : uint8_t {
+		BIG, LITTLE, MACHINE
+	};
+
 	static const uint8_t INTERFACE_ID = CLASS_ID::SERIALIZE_IF;
 	static const ReturnValue_t BUFFER_TOO_SHORT = MAKE_RETURN_CODE(1);
 	static const ReturnValue_t STREAM_TOO_SHORT = MAKE_RETURN_CODE(2);
@@ -22,13 +27,13 @@ public:
 	virtual ~SerializeIF() {
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-			const uint32_t max_size, bool bigEndian) const = 0;
+			size_t maxSize, Endianness streamEndianness) const = 0;
 
-	virtual uint32_t getSerializedSize() const = 0;
+	virtual size_t getSerializedSize() const = 0;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			bool bigEndian) = 0;
+			Endianness streamEndianness) = 0;
 
 };
 

subsystem/Subsystem.cpp

@@ -75,7 +75,8 @@ void Subsystem::performChildOperation() {
 	if (isInTransition) {
 		if (commandsOutstanding <= 0) { //all children of the current table were commanded and replied
 			if (currentSequenceIterator.value == NULL) { //we're through with this sequence
-				if (checkStateAgainstTable(currentTargetTable, targetSubmode) == RETURN_OK) {
+				if (checkStateAgainstTable(currentTargetTable, targetSubmode)
+						== RETURN_OK) {
 					setMode(targetMode, targetSubmode);
 					isInTransition = false;
 					return;
@@ -86,7 +87,8 @@ void Subsystem::performChildOperation() {
 				}
 			}
 			if (currentSequenceIterator->checkSuccess()) {
-				if (checkStateAgainstTable(getCurrentTable(), targetSubmode) != RETURN_OK) {
+				if (checkStateAgainstTable(getCurrentTable(), targetSubmode)
+						!= RETURN_OK) {
 					transitionFailed(TABLE_CHECK_FAILED,
 							currentSequenceIterator->getTableId());
 					return;
@@ -117,7 +119,8 @@ void Subsystem::performChildOperation() {
 			childrenChangedHealth = false;
 			startTransition(mode, submode);
 		} else if (childrenChangedMode) {
-			if (checkStateAgainstTable(currentTargetTable, submode) != RETURN_OK) {
+			if (checkStateAgainstTable(currentTargetTable, submode)
+					!= RETURN_OK) {
 				triggerEvent(CANT_KEEP_MODE, mode, submode);
 				cantKeepMode();
 			}
@@ -168,12 +171,13 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 				&sizeRead);
 		if (result == RETURN_OK) {
 			Mode_t fallbackId;
-			int32_t size = sizeRead;
+			size_t size = sizeRead;
-			result = SerializeAdapter<Mode_t>::deSerialize(&fallbackId,
+			result = SerializeAdapter::deSerialize(&fallbackId, &pointer, &size,
-					&pointer, &size, true);
+					SerializeIF::Endianness::BIG);
 			if (result == RETURN_OK) {
 				result = SerialArrayListAdapter<ModeListEntry>::deSerialize(
-						&sequence, &pointer, &size, true);
+						&sequence, &pointer, &size,
+						SerializeIF::Endianness::BIG);
 				if (result == RETURN_OK) {
 					result = addSequence(&sequence,
 							ModeSequenceMessage::getSequenceId(message),
@@ -193,9 +197,9 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 				ModeSequenceMessage::getStoreAddress(message), &pointer,
 				&sizeRead);
 		if (result == RETURN_OK) {
-			int32_t size = sizeRead;
+			size_t size = sizeRead;
 			result = SerialArrayListAdapter<ModeListEntry>::deSerialize(&table,
-					&pointer, &size, true);
+					&pointer, &size, SerializeIF::Endianness::BIG);
 			if (result == RETURN_OK) {
 				result = addTable(&table,
 						ModeSequenceMessage::getSequenceId(message));
@@ -601,13 +605,13 @@ void Subsystem::transitionFailed(ReturnValue_t failureCode,
 void Subsystem::sendSerializablesAsCommandMessage(Command_t command,
 		SerializeIF **elements, uint8_t count) {
 	ReturnValue_t result;
-	uint32_t maxSize = 0;
+	size_t maxSize = 0;
 	for (uint8_t i = 0; i < count; i++) {
 		maxSize += elements[i]->getSerializedSize();
 	}
 	uint8_t *storeBuffer;
 	store_address_t address;
-	uint32_t size = 0;
+	size_t size = 0;
 
 	result = IPCStore->getFreeElement(&address, maxSize, &storeBuffer);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -615,7 +619,8 @@ void Subsystem::sendSerializablesAsCommandMessage(Command_t command,
 		return;
 	}
 	for (uint8_t i = 0; i < count; i++) {
-		elements[i]->serialize(&storeBuffer, &size, maxSize, true);
+		elements[i]->serialize(&storeBuffer, &size, maxSize,
+				SerializeIF::Endianness::BIG);
 	}
 	CommandMessage reply;
 	ModeSequenceMessage::setModeSequenceMessage(&reply, command, address);

subsystem/modes/ModeDefinitions.h

@@ -18,65 +18,65 @@ public:
 	uint8_t value3;
 	uint8_t value4;
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+			size_t maxSize, Endianness streamEndianness) const {
 
 		ReturnValue_t result;
 
-		result = SerializeAdapter<uint32_t>::serialize(&value1, buffer, size,
+		result = SerializeAdapter::serialize(&value1, buffer, size,
-				max_size, bigEndian);
+				maxSize, streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<uint32_t>::serialize(&value2, buffer, size,
+		result = SerializeAdapter::serialize(&value2, buffer, size,
-				max_size, bigEndian);
+				maxSize, streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<uint8_t>::serialize(&value3, buffer, size,
+		result = SerializeAdapter::serialize(&value3, buffer, size,
-				max_size, bigEndian);
+				maxSize, streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 
-		result = SerializeAdapter<uint8_t>::serialize(&value4, buffer, size,
+		result = SerializeAdapter::serialize(&value4, buffer, size,
-				max_size, bigEndian);
+				maxSize, streamEndianness);
 
 		return result;
 
 	}
 
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const {
 		return sizeof(value1) + sizeof(value2) + sizeof(value3) + sizeof(value4);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	bool bigEndian) {
+	Endianness streamEndianness) {
 		ReturnValue_t result;
 
-		result = SerializeAdapter<uint32_t>::deSerialize(&value1, buffer, size,
+		result = SerializeAdapter::deSerialize(&value1, buffer, size,
-				bigEndian);
+				streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<uint32_t>::deSerialize(&value2, buffer, size,
+		result = SerializeAdapter::deSerialize(&value2, buffer, size,
-				bigEndian);
+				streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<uint8_t>::deSerialize(&value3, buffer, size,
+		result = SerializeAdapter::deSerialize(&value3, buffer, size,
-				bigEndian);
+				streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<uint8_t>::deSerialize(&value4, buffer, size,
+		result = SerializeAdapter::deSerialize(&value4, buffer, size,
-				bigEndian);
+				streamEndianness);
 
 		return result;
 	}

thermal/ThermalComponent.cpp

@@ -46,15 +46,15 @@ ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, uint32_t size) {
 	if (size != 4 * sizeof(parameters.lowerOpLimit)) {
 		return MonitoringIF::INVALID_SIZE;
 	}
-	int32_t readSize = size;
+	size_t readSize = size;
-	SerializeAdapter<float>::deSerialize(&nopParameters.lowerNopLimit, &data,
+	SerializeAdapter::deSerialize(&nopParameters.lowerNopLimit, &data,
-			&readSize, true);
+			&readSize, SerializeIF::Endianness::BIG);
-	SerializeAdapter<float>::deSerialize(&parameters.lowerOpLimit, &data,
+	SerializeAdapter::deSerialize(&parameters.lowerOpLimit, &data,
-			&readSize, true);
+			&readSize, SerializeIF::Endianness::BIG);
-	SerializeAdapter<float>::deSerialize(&parameters.upperOpLimit, &data,
+	SerializeAdapter::deSerialize(&parameters.upperOpLimit, &data,
-			&readSize, true);
+			&readSize, SerializeIF::Endianness::BIG);
-	SerializeAdapter<float>::deSerialize(&nopParameters.upperNopLimit, &data,
+	SerializeAdapter::deSerialize(&nopParameters.upperNopLimit, &data,
-			&readSize, true);
+			&readSize, SerializeIF::Endianness::BIG);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 

tmstorage/TmStorePackets.h

@@ -32,31 +32,31 @@ public:
 	}
 	uint16_t apid;
 	uint16_t ssc;
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+			size_t maxSize, Endianness streamEndianness) const {
-		ReturnValue_t result = SerializeAdapter<uint16_t>::serialize(&apid,
+		ReturnValue_t result = SerializeAdapter::serialize(&apid,
-				buffer, size, max_size, bigEndian);
+				buffer, size, maxSize, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		return SerializeAdapter<uint16_t>::serialize(&ssc, buffer, size,
+		return SerializeAdapter::serialize(&ssc, buffer, size,
-				max_size, bigEndian);
+				maxSize, streamEndianness);
 
 	}
 
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		return sizeof(apid) + sizeof(ssc);
 	}
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	bool bigEndian) {
+	Endianness streamEndianness) {
-		ReturnValue_t result = SerializeAdapter<uint16_t>::deSerialize(&apid,
+		ReturnValue_t result = SerializeAdapter::deSerialize(&apid,
-				buffer, size, bigEndian);
+				buffer, size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		return SerializeAdapter<uint16_t>::deSerialize(&ssc, buffer, size,
+		return SerializeAdapter::deSerialize(&ssc, buffer, size,
-				bigEndian);
+				streamEndianness);
 	}
 };
 
@@ -218,74 +218,74 @@ public:
 	}
 
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+			size_t maxSize, Endianness streamEndianness) const {
-		ReturnValue_t result = AutoSerializeAdapter::serialize(&apid,buffer,size,max_size,bigEndian);
+		ReturnValue_t result = SerializeAdapter::serialize(&apid,buffer,size,maxSize,streamEndianness);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::serialize(&sourceSequenceCount,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&sourceSequenceCount,buffer,size,maxSize,streamEndianness);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::serialize(&serviceType,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&serviceType,buffer,size,maxSize,streamEndianness);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::serialize(&serviceSubtype,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&serviceSubtype,buffer,size,maxSize,streamEndianness);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::serialize(&subCounter,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&subCounter,buffer,size,maxSize,streamEndianness);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
 		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
-		return adapter.serialize(buffer,size,max_size,bigEndian);
+		return adapter.serialize(buffer,size,maxSize,streamEndianness);
 	}
 
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		uint32_t size = 0;
-		size += AutoSerializeAdapter::getSerializedSize(&apid);
+		size += SerializeAdapter::getSerializedSize(&apid);
-		size += AutoSerializeAdapter::getSerializedSize(&sourceSequenceCount);
+		size += SerializeAdapter::getSerializedSize(&sourceSequenceCount);
-		size += AutoSerializeAdapter::getSerializedSize(&serviceType);
+		size += SerializeAdapter::getSerializedSize(&serviceType);
-		size += AutoSerializeAdapter::getSerializedSize(&serviceSubtype);
+		size += SerializeAdapter::getSerializedSize(&serviceSubtype);
-		size += AutoSerializeAdapter::getSerializedSize(&subCounter);
+		size += SerializeAdapter::getSerializedSize(&subCounter);
 		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
 		size += adapter.getSerializedSize();
 		return size;
 
 	};
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	bool bigEndian) {
+	Endianness streamEndianness) {
-		ReturnValue_t result = AutoSerializeAdapter::deSerialize(&apid, buffer,
+		ReturnValue_t result = SerializeAdapter::deSerialize(&apid, buffer,
-				size, bigEndian);
+				size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = AutoSerializeAdapter::deSerialize(&sourceSequenceCount, buffer,
+		result = SerializeAdapter::deSerialize(&sourceSequenceCount, buffer,
-				size, bigEndian);
+				size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = AutoSerializeAdapter::deSerialize(&serviceType, buffer, size,
+		result = SerializeAdapter::deSerialize(&serviceType, buffer, size,
-				bigEndian);
+				streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = AutoSerializeAdapter::deSerialize(&serviceSubtype, buffer,
+		result = SerializeAdapter::deSerialize(&serviceSubtype, buffer,
-				size, bigEndian);
+				size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = AutoSerializeAdapter::deSerialize(&subCounter, buffer, size,
+		result = SerializeAdapter::deSerialize(&subCounter, buffer, size,
-				bigEndian);
+				streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
-		return adapter.deSerialize(buffer,size,bigEndian);
+		return adapter.deSerialize(buffer,size,streamEndianness);
 	}
 
 private:

tmtcpacket/packetmatcher/ApidMatcher.h

@@ -22,16 +22,16 @@ public:
 			return false;
 		}
 	}
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+			size_t maxSize, Endianness streamEndianness) const {
-		return SerializeAdapter<uint16_t>::serialize(&apid, buffer, size, max_size, bigEndian);
+		return SerializeAdapter::serialize(&apid, buffer, size, maxSize, streamEndianness);
 	}
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
-		return SerializeAdapter<uint16_t>::getSerializedSize(&apid);
+		return SerializeAdapter::getSerializedSize(&apid);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
+			Endianness streamEndianness) {
-		return SerializeAdapter<uint16_t>::deSerialize(&apid, buffer, size, bigEndian);
+		return SerializeAdapter::deSerialize(&apid, buffer, size, streamEndianness);
 	}
 };
 

tmtcpacket/packetmatcher/ServiceMatcher.h

@@ -22,16 +22,16 @@ public:
 			return false;
 		}
 	}
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+			size_t maxSize, Endianness streamEndianness) const {
-		return SerializeAdapter<uint8_t>::serialize(&service, buffer, size, max_size, bigEndian);
+		return SerializeAdapter::serialize(&service, buffer, size, maxSize, streamEndianness);
 	}
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
-		return SerializeAdapter<uint8_t>::getSerializedSize(&service);
+		return SerializeAdapter::getSerializedSize(&service);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
+			Endianness streamEndianness) {
-		return SerializeAdapter<uint8_t>::deSerialize(&service, buffer, size, bigEndian);
+		return SerializeAdapter::deSerialize(&service, buffer, size, streamEndianness);
 	}
 };
 

tmtcpacket/packetmatcher/SubserviceMatcher.h

@@ -20,16 +20,16 @@ public:
 			return false;
 		}
 	}
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+			size_t maxSize, Endianness streamEndianness) const {
-		return SerializeAdapter<uint8_t>::serialize(&subService, buffer, size, max_size, bigEndian);
+		return SerializeAdapter::serialize(&subService, buffer, size, maxSize, streamEndianness);
 	}
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
-		return SerializeAdapter<uint8_t>::getSerializedSize(&subService);
+		return SerializeAdapter::getSerializedSize(&subService);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
+			Endianness streamEndianness) {
-		return SerializeAdapter<uint8_t>::deSerialize(&subService, buffer, size, bigEndian);
+		return SerializeAdapter::deSerialize(&subService, buffer, size, streamEndianness);
 	}
 private:
 	uint8_t subService;

tmtcpacket/pus/TmPacketStored.cpp

@@ -41,7 +41,7 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 	if (!checkAndSetStore()) {
 		return;
 	}
-	uint32_t sourceDataSize = 0;
+	size_t sourceDataSize = 0;
 	if (content != NULL) {
 		sourceDataSize += content->getSerializedSize();
 	}
@@ -57,12 +57,14 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 	setData(p_data);
 	initializeTmPacket(apid, service, subservice, packetSubcounter);
 	uint8_t *putDataHere = getSourceData();
-	uint32_t size = 0;
+	size_t size = 0;
 	if (header != NULL) {
-		header->serialize(&putDataHere, &size, sourceDataSize, true);
+		header->serialize(&putDataHere, &size, sourceDataSize,
+				SerializeIF::Endianness::BIG);
 	}
 	if (content != NULL) {
-		content->serialize(&putDataHere, &size, sourceDataSize, true);
+		content->serialize(&putDataHere, &size, sourceDataSize,
+				SerializeIF::Endianness::BIG);
 	}
 	setPacketDataLength(
 			sourceDataSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
@@ -116,7 +118,8 @@ ReturnValue_t TmPacketStored::sendPacket(MessageQueueId_t destination,
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	TmTcMessage tmMessage(getStoreAddress());
-	ReturnValue_t result = MessageQueueSenderIF::sendMessage(destination, &tmMessage, sentFrom);
+	ReturnValue_t result = MessageQueueSenderIF::sendMessage(destination,
+			&tmMessage, sentFrom);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		deletePacket();
 		if (doErrorReporting) {

tmtcservices/CommandingServiceBase.cpp

@@ -268,8 +268,8 @@ ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
     uint8_t buffer[sizeof(object_id_t)];
     uint8_t* pBuffer = buffer;
     uint32_t size = 0;
-    SerializeAdapter<object_id_t>::serialize(&objectId, &pBuffer, &size,
+    SerializeAdapter::serialize(&objectId, &pBuffer, &size,
-            sizeof(object_id_t), true);
+                sizeof(object_id_t), SerializeIF::Endianness::BIG);
     TmPacketStored tmPacketStored(this->apid, this->service, subservice,
             this->tmPacketCounter, data, dataLen, buffer, size);
     ReturnValue_t result = tmPacketStored.sendPacket(

tmtcservices/PusVerificationReport.cpp

@@ -108,13 +108,13 @@ PusSuccessReport::PusSuccessReport(uint16_t setPacketId,
 		uint16_t setSequenceControl, uint8_t setStep) :
 		reportSize(0), pBuffer(reportBuffer) {
 	//Serialization won't fail, because we know the necessary max-size of the buffer.
-	SerializeAdapter<uint16_t>::serialize(&setPacketId, &pBuffer, &reportSize,
+	SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
-			sizeof(reportBuffer), true);
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	SerializeAdapter<uint16_t>::serialize(&setSequenceControl, &pBuffer,
+	SerializeAdapter::serialize(&setSequenceControl, &pBuffer, &reportSize,
-			&reportSize, sizeof(reportBuffer), true);
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 	if (setStep != 0) {
-		SerializeAdapter<uint8_t>::serialize(&setStep, &pBuffer, &reportSize,
+		SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
-				sizeof(reportBuffer), true);
+				sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 	}
 }
 
@@ -135,26 +135,26 @@ PusFailureReport::PusFailureReport(uint16_t setPacketId,
 		uint8_t setStep, uint32_t parameter1, uint32_t parameter2) :
 		reportSize(0), pBuffer(reportBuffer) {
 	//Serialization won't fail, because we know the necessary max-size of the buffer.
-	SerializeAdapter<uint16_t>::serialize(&setPacketId, &pBuffer, &reportSize,
+	SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
-			sizeof(reportBuffer), true);
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	SerializeAdapter<uint16_t>::serialize(&setSequenceControl, &pBuffer,
+	SerializeAdapter::serialize(&setSequenceControl, &pBuffer, &reportSize,
-			&reportSize, sizeof(reportBuffer), true);
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 	if (setStep != 0) {
-		SerializeAdapter<uint8_t>::serialize(&setStep, &pBuffer, &reportSize,
+		SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
-				sizeof(reportBuffer), true);
+				sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 	}
-	SerializeAdapter<ReturnValue_t>::serialize(&setErrorCode, &pBuffer,
+	SerializeAdapter::serialize(&setErrorCode, &pBuffer, &reportSize,
-			&reportSize, sizeof(reportBuffer), true);
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	SerializeAdapter<uint32_t>::serialize(&parameter1, &pBuffer, &reportSize,
+	SerializeAdapter::serialize(&parameter1, &pBuffer, &reportSize,
-			sizeof(reportBuffer), true);
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	SerializeAdapter<uint32_t>::serialize(&parameter2, &pBuffer, &reportSize,
+	SerializeAdapter::serialize(&parameter2, &pBuffer, &reportSize,
-			sizeof(reportBuffer), true);
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 }
 
 PusFailureReport::~PusFailureReport() {
 }
 
-uint32_t PusFailureReport::getSize() {
+size_t PusFailureReport::getSize() {
 	return reportSize;
 }
 

tmtcservices/PusVerificationReport.h

@@ -49,7 +49,7 @@ class PusSuccessReport {
 private:
 	static const uint16_t MAX_SIZE = 7;
 	uint8_t reportBuffer[MAX_SIZE];
-	uint32_t reportSize;
+	size_t reportSize;
 	uint8_t * pBuffer;
 public:
 	PusSuccessReport(uint16_t setPacketId, uint16_t setSequenceControl,
@@ -63,14 +63,14 @@ class PusFailureReport {
 private:
 	static const uint16_t MAX_SIZE = 16;
 	uint8_t reportBuffer[MAX_SIZE];
-	uint32_t reportSize;
+	size_t reportSize;
 	uint8_t * pBuffer;
 public:
 	PusFailureReport(uint16_t setPacketId, uint16_t setSequenceControl,
 			ReturnValue_t setErrorCode, uint8_t setStep = 0,
 			uint32_t parameter1 = 0, uint32_t parameter2 = 0);
 	~PusFailureReport();
-	uint32_t getSize();
+	size_t getSize();
 	uint8_t* getReport();
 };