Actually, not that horrible, thanks to sed

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

@@ -4,30 +4,31 @@
 #include <framework/action/HasActionsIF.h>
 #include <framework/objectmanager/ObjectManagerIF.h>
 
-CommandActionHelper::CommandActionHelper(CommandsActionsIF* setOwner) :
+CommandActionHelper::CommandActionHelper(CommandsActionsIF *setOwner) :
 		owner(setOwner), queueToUse(NULL), ipcStore(
-				NULL), commandCount(0), lastTarget(0) {
+		NULL), commandCount(0), lastTarget(0) {
 }
 
 CommandActionHelper::~CommandActionHelper() {
 }
 
 ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
-		ActionId_t actionId, SerializeIF* data) {
+		ActionId_t actionId, SerializeIF *data) {
-	HasActionsIF* receiver = objectManager->get<HasActionsIF>(commandTo);
+	HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
 	if (receiver == NULL) {
 		return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
 	}
 	store_address_t storeId;
-	uint8_t* storePointer;
+	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;
 	}
@@ -35,11 +36,11 @@ ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
 }
 
 ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
-		ActionId_t actionId, const uint8_t* data, uint32_t size) {
+		ActionId_t actionId, const uint8_t *data, uint32_t size) {
 //	if (commandCount != 0) {
 //		return CommandsFunctionsIF::ALREADY_COMMANDING;
 //	}
-	HasActionsIF* receiver = objectManager->get<HasActionsIF>(commandTo);
+	HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
 	if (receiver == NULL) {
 		return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
 	}
@@ -71,13 +72,13 @@ ReturnValue_t CommandActionHelper::initialize() {
 	}
 
 	queueToUse = owner->getCommandQueuePtr();
-	if(queueToUse == NULL){
+	if (queueToUse == NULL) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t CommandActionHelper::handleReply(CommandMessage* reply) {
+ReturnValue_t CommandActionHelper::handleReply(CommandMessage *reply) {
 	if (reply->getSender() != lastTarget) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
@@ -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;
@@ -111,8 +115,9 @@ uint8_t CommandActionHelper::getCommandCount() const {
 	return commandCount;
 }
 
-void CommandActionHelper::extractDataForOwner(ActionId_t actionId, store_address_t storeId) {
+void CommandActionHelper::extractDataForOwner(ActionId_t actionId,
-	const uint8_t * data = NULL;
+		store_address_t storeId) {
+	const uint8_t *data = NULL;
 	uint32_t size = 0;
 	ReturnValue_t result = ipcStore->getData(storeId, &data, &size);
 	if (result != HasReturnvaluesIF::RETURN_OK) {

container/FixedMap.h

@@ -148,22 +148,22 @@ 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::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::serialize(&theMap[i].first, buffer,
-					size, max_size, bigEndian);
+					size, maxSize, streamEndianness);
 			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;
 
@@ -176,19 +176,19 @@ public:
 		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::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::deSerialize(&theMap[i].first, buffer,
-					size, bigEndian);
+					size, streamEndianness);
 			result = SerializeAdapter::deSerialize(&theMap[i].second, buffer, size,
-					bigEndian);
+					streamEndianness);
 			++i;
 		}
 		return result;

container/IndexedRingMemoryArray.h

@@ -68,46 +68,46 @@ 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 = SerializeAdapter::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 = SerializeAdapter::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 = SerializeAdapter::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 = SerializeAdapter::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 = SerializeAdapter::deSerialize(&this->size,buffer,size,bigEndian);
+		result = SerializeAdapter::deSerialize(&this->size,buffer,size,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = SerializeAdapter::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 = SerializeAdapter::getSerializedSize(&blockStartAddress);
 		size += indexType.getSerializedSize();
 		size += SerializeAdapter::getSerializedSize(&this->size);
@@ -485,22 +485,22 @@ 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 = SerializeAdapter::serialize(&this->size,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
@@ -508,14 +508,14 @@ public:
 		uint32_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->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 = SerializeAdapter::serialize(&crc,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&crc,buffer,size,maxSize,streamEndianness);
 		return result;
 	}
 
@@ -524,7 +524,7 @@ 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){
@@ -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 = SerializeAdapter::deSerialize(&tempSize,buffer,size,bigEndian);
+		result = SerializeAdapter::deSerialize(&tempSize,buffer,size,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
@@ -574,7 +574,7 @@ public:
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
 			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

@@ -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/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::serialize(&type, buffer, size, max_size,
+	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
-			bigEndian);
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
 	result = SerializeAdapter::serialize(&columns, buffer, size,
-			max_size, bigEndian);
+			maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter::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/PoolRawAccess.cpp

@@ -69,12 +69,12 @@ uint8_t* PoolRawAccess::getEntry() {
 }
 
 ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
-		uint32_t* writtenBytes, uint32_t max_size) {
+		uint32_t* writtenBytes, uint32_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)
 		return DATA_POOL_ACCESS_FAILED;
-	if (typeSize > max_size)
+	if (typeSize > maxSize)
 		return INCORRECT_SIZE;
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
@@ -149,7 +149,7 @@ ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
 		size_t maxSize, Endianness streamEndianness) const {
 	//TODO integer overflow
 	if (typeSize + *size <= maxSize) {
-#error use endian swapper
+#warning use endian swapper
 		if (1) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined

datapool/PoolRawAccess.h

@@ -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,
-			uint32_t max_size);
+			uint32_t maxSize);
 	/**
 	 * With this method, the content can be set from a big endian buffer safely.
 	 * @param buffer	Pointer to the data to set

datapool/PoolVariable.h

@@ -195,12 +195,12 @@ public:
 	}
 
 	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-			size_t max_size, Endianness streamEndianness) const override {
+			size_t maxSize, Endianness streamEndianness) const override {
-		return SerializeAdapter::serialize<T>(&value, buffer, size, max_size,
+		return SerializeAdapter::serialize<T>(&value, buffer, size, maxSize,
 				streamEndianness);
 	}
 
-	virtual uint32_t getSerializedSize() const override {
+	virtual size_t getSerializedSize() const override {
 		return SerializeAdapter::getSerializedSize(&value);
 	}
 

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::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::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::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::serialize(&objectId,
-			buffer, size, max_size, bigEndian);
+			buffer, size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 	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::deSerialize(&objectId,
-			buffer, size, bigEndian);
+			buffer, size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 	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::serialize(&ptc, buffer, size, max_size,
+	result = SerializeAdapter::serialize(&ptc, buffer, size, maxSize,
-			bigEndian);
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter::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::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::deSerialize(&ptc, buffer,
-			size, bigEndian);
+			size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
 	result = SerializeAdapter::deSerialize(&pfc, buffer, size,
-			bigEndian);
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}

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::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

@@ -26,23 +26,23 @@ public:
 		}
 	}
 
-	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t max_size,
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
 			SerializeIF::Endianness streamEndianness) const override {
 		ReturnValue_t result = SerializeAdapter::serialize(&lowerBound, buffer,
-				size, max_size, streamEndianness);
+				size, maxSize, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		result = SerializeAdapter::serialize(&upperBound, buffer, size,
-				max_size, streamEndianness);
+				maxSize, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		return SerializeAdapter::serialize(&inverted, buffer, size, max_size,
+		return SerializeAdapter::serialize(&inverted, buffer, size, maxSize,
 				streamEndianness);
 	}
 
-	uint32_t getSerializedSize() const override {
+	size_t getSerializedSize() const override {
 		return sizeof(lowerBound) + sizeof(upperBound) + sizeof(bool);
 	}
 

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::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::serialize(&iter->first,
-				&pointer, &size, maxSize, true);
+				&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
 		uint8_t health = iter->second;
 		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;

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::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::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::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::serialize(&timeRunning,
-			buffer, size, max_size, bigEndian);
+			buffer, size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 	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::deSerialize(&id, buffer,
-			size, bigEndian);
+			size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -170,12 +170,12 @@ 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::deSerialize(&timeRunning,
-			buffer, size, bigEndian);
+			buffer, size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 	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

@@ -2,41 +2,41 @@
 
 ParameterWrapper::ParameterWrapper() :
 		pointsToStream(false), type(Type::UNKNOWN_TYPE), rows(0), columns(0), data(
-				NULL), readonlyData(NULL) {
+		NULL), readonlyData(NULL) {
 }
 
 ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
-		void* data) :
+		void *data) :
 		pointsToStream(false), type(type), rows(rows), columns(columns), data(
 				data), readonlyData(data) {
 }
 
 ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
-		const void* data) :
+		const void *data) :
 		pointsToStream(false), type(type), rows(rows), columns(columns), data(
-				NULL), readonlyData(data) {
+		NULL), readonlyData(data) {
 }
 
 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::serialize(&type, buffer, size, max_size,
+	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
-			bigEndian);
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter::serialize(&columns, buffer, size,
+	result = SerializeAdapter::serialize(&columns, buffer, size, maxSize,
-			max_size, bigEndian);
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter::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;
 	uint16_t dataSize = columns * rows;
 	while (dataSize != 0) {
-		result = SerializeAdapter::serialize(element, buffer, size, max_size,
+		result = SerializeAdapter::serialize(element, buffer, size, maxSize,
-				bigEndian);
+				streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
@@ -111,21 +116,21 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 		uint8_t fromColumns) {
 
 	//treat from as a continuous Stream as we copy all of it
-	const uint8_t *fromAsStream = (const uint8_t *) from;
+	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;
 
 	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
 
 		//get the start element of this row in data
-		T *dataWithDataType = ((T *) data)
+		T *dataWithDataType = ((T*) data)
 				+ (((startingRow + fromRow) * columns) + startingColumn);
 
 		for (uint8_t fromColumn = 0; fromColumn < fromColumns; fromColumn++) {
 			result = SerializeAdapter::deSerialize(
 					dataWithDataType + fromColumn, &fromAsStream, &streamSize,
-					true);
+					SerializeIF::Endianness::BIG);
 			if (result != HasReturnvaluesIF::RETURN_OK) {
 				return result;
 			}
@@ -136,13 +141,14 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 
 }
 
-ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
+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,
+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::deSerialize(&type, &stream,
-			&streamSize, true);
+			&streamSize, SerializeIF::Endianness::BIG);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter::deSerialize(&columns, &stream,
+	result = SerializeAdapter::deSerialize(&columns, &stream, &streamSize,
-			&streamSize, true);
+			SerializeIF::Endianness::BIG);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 	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;
@@ -194,7 +200,7 @@ ReturnValue_t ParameterWrapper::set(const uint8_t* stream, int32_t streamSize,
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper* from,
+ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
 		uint16_t startWritingAtIndex) {
 	if (data == NULL) {
 		return READONLY;
@@ -261,7 +267,7 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper* from,
 		}
 	} else {
 		//need a type to do arithmetic
-		uint8_t *toDataWithType = (uint8_t *) data;
+		uint8_t *toDataWithType = (uint8_t*) data;
 		for (uint8_t fromRow = 0; fromRow < from->rows; fromRow++) {
 			memcpy(
 					toDataWithType

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 {
@@ -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

@@ -11,14 +11,15 @@
 #include <framework/parameters/ParameterHelper.h>
 #include <list>
 
-namespace Factory{
+namespace Factory {
 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
@@ -40,7 +41,7 @@ public:
 	Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
 			float maxCurrent, uint16_t confirmationCount = 2);
 	virtual ~Fuse();
-	void addDevice(PowerComponentIF* set);
+	void addDevice(PowerComponentIF *set);
 	float getPower();
 
 	bool isPowerValid();
@@ -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;
@@ -62,13 +63,13 @@ public:
 	HasHealthIF::HealthState getHealth();
 
 	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-				ParameterWrapper *parameterWrapper,
+			ParameterWrapper *parameterWrapper,
-				const ParameterWrapper *newValues, uint16_t startAtIndex);
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
 
 private:
 	uint8_t oldFuseState;
 	uint8_t fuseId;
-	PowerSwitchIF* powerIF; //could be static in our case.
+	PowerSwitchIF *powerIF; //could be static in our case.
 	AbsLimitMonitor<float> currentLimit;
 	class PowerMonitor: public MonitorReporter<float> {
 	public:
@@ -88,11 +89,11 @@ private:
 	PIDReader<float> current;
 	PIDReader<uint8_t> state;
 	db_float_t power;
-	MessageQueueIF* commandQueue;
+	MessageQueueIF *commandQueue;
 	ParameterHelper parameterHelper;
 	HealthHelper healthHelper;
 	static object_id_t powerSwitchId;
-	void calculatePowerLimits(float* low, float* high);
+	void calculatePowerLimits(float *low, float *high);
 	void calculateFusePower();
 	void checkFuseState();
 	void reportEvents(Event event);

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::serialize(&min, buffer,
-			size, max_size, bigEndian);
+			size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	return SerializeAdapter::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::deSerialize(&min, buffer,
-			size, bigEndian);
+			size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	return SerializeAdapter::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/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::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::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);
 	}
 
@@ -53,16 +53,16 @@ public:
 		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::deSerialize(&tempSize,
-				buffer, size, bigEndian);
+				buffer, size, streamEndianness);
 		if (tempSize > list->maxSize()) {
 			return SerializeIF::TOO_MANY_ELEMENTS;
 		}
@@ -71,7 +71,7 @@ public:
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
 			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 += SerializeAdapter::getSerializedSize(
 				&bufferLength);
 	}
-	if (*size + serializedLength > max_size) {
+	if (*size + serializedLength > maxSize) {
 		return BUFFER_TOO_SHORT;
 	} else {
 		if (serializeLength) {
 			SerializeAdapter::serialize(&bufferLength, buffer, size,
-					max_size, bigEndian);
+					maxSize, streamEndianness);
 		}
 		if (this->constBuffer != NULL) {
 			memcpy(*buffer, this->constBuffer, bufferLength);
@@ -50,7 +50,7 @@ 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 + SerializeAdapter::getSerializedSize(&bufferLength);
 	} else {
@@ -59,7 +59,7 @@ uint32_t SerialBufferAdapter<T>::getSerializedSize() const {
 }
 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){

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/SerializeElement.h

@@ -26,7 +26,7 @@ public:
 				streamEndianness);
 	}
 
-	uint32_t getSerializedSize() const override {
+	size_t getSerializedSize() const override {
 		return SerializeAdapter::getSerializedSize(&entry);
 	}
 

serialize/SerializeIF.h

@@ -28,7 +28,7 @@ public:
 	}
 
 	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-			size_t max_size, Endianness streamEndianness) const = 0;
+			size_t maxSize, Endianness streamEndianness) const = 0;
 
 	virtual size_t getSerializedSize() const = 0;
 

subsystem/Subsystem.cpp

@@ -13,7 +13,7 @@ Subsystem::Subsystem(object_id_t setObjectId, object_id_t parent,
 				false), uptimeStartTable(0), currentTargetTable(), targetMode(
 				0), targetSubmode(SUBMODE_NONE), initialMode(0), currentSequenceIterator(), modeTables(
 				maxNumberOfTables), modeSequences(maxNumberOfSequences), IPCStore(
-				NULL)
+		NULL)
 #ifdef USE_MODESTORE
 ,modeStore(NULL)
 #endif
@@ -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();
 			}
@@ -147,7 +150,7 @@ HybridIterator<ModeListEntry> Subsystem::getTable(Mode_t id) {
 	}
 }
 
-ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
+ReturnValue_t Subsystem::handleCommandMessage(CommandMessage *message) {
 	ReturnValue_t result;
 	switch (message->getCommand()) {
 	case HealthMessage::HEALTH_INFO: {
@@ -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::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));
@@ -339,7 +343,7 @@ void Subsystem::replyToCommand(ReturnValue_t status, uint32_t parameter) {
 	}
 }
 
-ReturnValue_t Subsystem::addSequence(ArrayList<ModeListEntry>* sequence,
+ReturnValue_t Subsystem::addSequence(ArrayList<ModeListEntry> *sequence,
 		Mode_t id, Mode_t fallbackSequence, bool inStore, bool preInit) {
 
 	ReturnValue_t result;
@@ -507,7 +511,7 @@ MessageQueueId_t Subsystem::getSequenceCommandQueue() const {
 }
 
 ReturnValue_t Subsystem::checkModeCommand(Mode_t mode, Submode_t submode,
-		uint32_t* msToReachTheMode) {
+		uint32_t *msToReachTheMode) {
 	//Need to accept all submodes to be able to inherit submodes
 //	if (submode != SUBMODE_NONE) {
 //		return INVALID_SUBMODE;
@@ -599,15 +603,15 @@ void Subsystem::transitionFailed(ReturnValue_t failureCode,
 }
 
 void Subsystem::sendSerializablesAsCommandMessage(Command_t command,
-		SerializeIF** elements, uint8_t count) {
+		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::serialize(&value1, buffer, size,
-				max_size, bigEndian);
+				maxSize, streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		result = SerializeAdapter::serialize(&value2, buffer, size,
-				max_size, bigEndian);
+				maxSize, streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		result = SerializeAdapter::serialize(&value3, buffer, size,
-				max_size, bigEndian);
+				maxSize, streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 
 		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::deSerialize(&value1, buffer, size,
-				bigEndian);
+				streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		result = SerializeAdapter::deSerialize(&value2, buffer, size,
-				bigEndian);
+				streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		result = SerializeAdapter::deSerialize(&value3, buffer, size,
-				bigEndian);
+				streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		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::deSerialize(&nopParameters.lowerNopLimit, &data,
-			&readSize, true);
+			&readSize, SerializeIF::Endianness::BIG);
 	SerializeAdapter::deSerialize(&parameters.lowerOpLimit, &data,
-			&readSize, true);
+			&readSize, SerializeIF::Endianness::BIG);
 	SerializeAdapter::deSerialize(&parameters.upperOpLimit, &data,
-			&readSize, true);
+			&readSize, SerializeIF::Endianness::BIG);
 	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::serialize(&apid,
-				buffer, size, max_size, bigEndian);
+				buffer, size, maxSize, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		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::deSerialize(&apid,
-				buffer, size, bigEndian);
+				buffer, size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		return SerializeAdapter::deSerialize(&ssc, buffer, size,
-				bigEndian);
+				streamEndianness);
 	}
 };
 
@@ -218,33 +218,33 @@ 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 = SerializeAdapter::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 = SerializeAdapter::serialize(&sourceSequenceCount,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&sourceSequenceCount,buffer,size,maxSize,streamEndianness);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = SerializeAdapter::serialize(&serviceType,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&serviceType,buffer,size,maxSize,streamEndianness);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = SerializeAdapter::serialize(&serviceSubtype,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&serviceSubtype,buffer,size,maxSize,streamEndianness);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = SerializeAdapter::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 += SerializeAdapter::getSerializedSize(&apid);
 		size += SerializeAdapter::getSerializedSize(&sourceSequenceCount);
@@ -257,35 +257,35 @@ public:
 
 	};
 
-	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::deSerialize(&apid, buffer,
-				size, bigEndian);
+				size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		result = SerializeAdapter::deSerialize(&sourceSequenceCount, buffer,
-				size, bigEndian);
+				size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		result = SerializeAdapter::deSerialize(&serviceType, buffer, size,
-				bigEndian);
+				streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		result = SerializeAdapter::deSerialize(&serviceSubtype, buffer,
-				size, bigEndian);
+				size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		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::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::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::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::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::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::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::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::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::deSerialize(&subService, buffer, size, bigEndian);
+		return SerializeAdapter::deSerialize(&subService, buffer, size, streamEndianness);
 	}
 private:
 	uint8_t subService;

tmtcpacket/pus/TmPacketStored.cpp

@@ -10,14 +10,14 @@ TmPacketStored::TmPacketStored(store_address_t setAddress) :
 }
 
 TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
-		uint8_t subservice, uint8_t packetSubcounter, const uint8_t* data,
+		uint8_t subservice, uint8_t packetSubcounter, const uint8_t *data,
-		uint32_t size, const uint8_t* headerData, uint32_t headerSize) :
+		uint32_t size, const uint8_t *headerData, uint32_t headerSize) :
 		TmPacketBase(NULL) {
 	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
 	if (!checkAndSetStore()) {
 		return;
 	}
-	uint8_t* pData = NULL;
+	uint8_t *pData = NULL;
 	ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
 			(TmPacketBase::TM_PACKET_MIN_SIZE + size + headerSize), &pData);
 
@@ -34,21 +34,21 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 }
 
 TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
-		uint8_t subservice, uint8_t packetSubcounter, SerializeIF* content,
+		uint8_t subservice, uint8_t packetSubcounter, SerializeIF *content,
-		SerializeIF* header) :
+		SerializeIF *header) :
 		TmPacketBase(NULL) {
 	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
 	if (!checkAndSetStore()) {
 		return;
 	}
-	uint32_t sourceDataSize = 0;
+	size_t sourceDataSize = 0;
 	if (content != NULL) {
 		sourceDataSize += content->getSerializedSize();
 	}
 	if (header != NULL) {
 		sourceDataSize += header->getSerializedSize();
 	}
-	uint8_t* p_data = NULL;
+	uint8_t *p_data = NULL;
 	ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
 			(TmPacketBase::TM_PACKET_MIN_SIZE + sourceDataSize), &p_data);
 	if (returnValue != store->RETURN_OK) {
@@ -56,13 +56,15 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 	}
 	setData(p_data);
 	initializeTmPacket(apid, service, subservice, packetSubcounter);
-	uint8_t* putDataHere = getSourceData();
+	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);
@@ -80,7 +82,7 @@ void TmPacketStored::deletePacket() {
 
 void TmPacketStored::setStoreAddress(store_address_t setAddress) {
 	storeAddress = setAddress;
-	const uint8_t* temp_data = NULL;
+	const uint8_t *temp_data = NULL;
 	uint32_t temp_size;
 	if (!checkAndSetStore()) {
 		return;
@@ -106,8 +108,8 @@ bool TmPacketStored::checkAndSetStore() {
 	return true;
 }
 
-StorageManagerIF* TmPacketStored::store = NULL;
+StorageManagerIF *TmPacketStored::store = NULL;
-InternalErrorReporterIF* TmPacketStored::internalErrorReporter = NULL;
+InternalErrorReporterIF *TmPacketStored::internalErrorReporter = NULL;
 
 ReturnValue_t TmPacketStored::sendPacket(MessageQueueId_t destination,
 		MessageQueueId_t sentFrom, bool doErrorReporting) {
@@ -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

@@ -235,9 +235,9 @@ void CommandingServiceBase::sendTmPacket(uint8_t subservice,
 		object_id_t objectId, const uint8_t *data, uint32_t dataLen) {
 	uint8_t buffer[sizeof(object_id_t)];
 	uint8_t* pBuffer = buffer;
-	uint32_t size = 0;
+	size_t size = 0;
 	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

@@ -33,7 +33,7 @@ PusVerificationMessage::PusVerificationMessage(uint8_t set_report_id,
 		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
 		ReturnValue_t set_error_code, uint8_t set_step, uint32_t parameter1,
 		uint32_t parameter2) {
-	uint8_t* data = this->getBuffer();
+	uint8_t *data = this->getBuffer();
 	data[messageSize] = set_report_id;
 	messageSize += sizeof(set_report_id);
 	data[messageSize] = ackFlags;
@@ -109,12 +109,12 @@ PusSuccessReport::PusSuccessReport(uint16_t setPacketId,
 		reportSize(0), pBuffer(reportBuffer) {
 	//Serialization won't fail, because we know the necessary max-size of the buffer.
 	SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
-			sizeof(reportBuffer), true);
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	SerializeAdapter::serialize(&setSequenceControl, &pBuffer,
+	SerializeAdapter::serialize(&setSequenceControl, &pBuffer, &reportSize,
-			&reportSize, sizeof(reportBuffer), true);
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 	if (setStep != 0) {
 		SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
-				sizeof(reportBuffer), true);
+				sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 	}
 }
 
@@ -136,25 +136,25 @@ PusFailureReport::PusFailureReport(uint16_t setPacketId,
 		reportSize(0), pBuffer(reportBuffer) {
 	//Serialization won't fail, because we know the necessary max-size of the buffer.
 	SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
-			sizeof(reportBuffer), true);
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	SerializeAdapter::serialize(&setSequenceControl, &pBuffer,
+	SerializeAdapter::serialize(&setSequenceControl, &pBuffer, &reportSize,
-			&reportSize, sizeof(reportBuffer), true);
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 	if (setStep != 0) {
 		SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
-				sizeof(reportBuffer), true);
+				sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 	}
-	SerializeAdapter::serialize(&setErrorCode, &pBuffer,
+	SerializeAdapter::serialize(&setErrorCode, &pBuffer, &reportSize,
-			&reportSize, sizeof(reportBuffer), true);
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 	SerializeAdapter::serialize(&parameter1, &pBuffer, &reportSize,
-			sizeof(reportBuffer), true);
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 	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();
 };