Merge remote-tracking branch 'upstream/mohr_serialize' into mueller_merge_mohr_serialize

power/Fuse.cpp

@@ -87,11 +87,11 @@ ReturnValue_t Fuse::check() {
 }
 
 ReturnValue_t Fuse::serialize(uint8_t** buffer, size_t* size,
-		const size_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,8 +99,8 @@ ReturnValue_t Fuse::serialize(uint8_t** buffer, size_t* size,
 	return RETURN_OK;
 }
 
-uint32_t Fuse::getSerializedSize() const {
-	size_t size = 0;
+size_t Fuse::getSerializedSize() const {
+	uint32_t size = 0;
 	for (DeviceList::const_iterator iter = devices.begin();
 			iter != devices.end(); iter++) {
 		size += (*iter)->getSerializedSize();
@@ -109,11 +109,11 @@ uint32_t Fuse::getSerializedSize() const {
 }
 
 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

@@ -12,14 +12,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
@@ -41,7 +42,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();
@@ -50,11 +51,11 @@ public:
 	uint8_t getFuseId() const;
 	ReturnValue_t initialize();
 	DeviceList devices;
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const;
-	uint32_t getSerializedSize() const;
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-				bool bigEndian);
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+			SerializeIF::Endianness streamEndianness) const override;
+	size_t getSerializedSize() const override;
+	ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			SerializeIF::Endianness streamEndianness) override;
 	void setAllMonitorsToUnchecked();
 	ReturnValue_t performOperation(uint8_t opCode);
 	MessageQueueId_t getCommandQueue() const;
@@ -63,13 +64,13 @@ public:
 	HasHealthIF::HealthState getHealth();
 
 	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-				ParameterWrapper *parameterWrapper,
-				const ParameterWrapper *newValues, uint16_t startAtIndex);
+			ParameterWrapper *parameterWrapper,
+			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:
@@ -93,7 +94,7 @@ private:
 	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

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

power/PowerComponent.h

@@ -20,12 +20,21 @@ public:
 	float getMax();
 
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+<<<<<<< HEAD
 			const size_t max_size, bool bigEndian) const;
 
 	size_t getSerializedSize() const;
 
 	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian);
+=======
+			size_t maxSize, Endianness streamEndianness) const override;
+
+	size_t getSerializedSize() const override;
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override;
+>>>>>>> upstream/mohr_serialize
 
 	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
 				ParameterWrapper *parameterWrapper,