(De)Serialization clean up of temporary workarounds (#3971)

* Staging DEPRECATE changes in preparation for new FPP alpha. Removed backwards compat hacks. Updated some uses of the legacy functions that were missed originally.

* Remove declaration of serialize and deserialize from RawTime as those should be inherited now

* Removing FW_SERIALIZE_UNIMPLEMENTED and FW_DESERIALIZE_UNIMPLEMENTED from SerializeStatus

* Removing superfluous comma

* Missed AmpcsEvrLogPacket. Fixing a minor whitespace issue in Serializable.

* Un-deprecating serialize/deserialize for this release

* Restoring DEPRECATED for the noLength functions

* Pulling in fpp 3.0.0a17. Fixing some lingering issues with refactoring.

* Format files

* Update fprime-fpp package

* Fixing some lingering issues with serialization modernization.

* Fixing weird merge issue with AmpcsEvrLogPacket

* More clang issue fixes

* Still pesky clang formatting issues. Superfluous whitespace.

* Removing redundant virtuals for overriden methods

* Incorporating PR comments

* clang formatted Serializable.hpp

* Removing redundant serialize and deserialize methods in TestAbsType. Inherit from parent.

---------

Co-authored-by: thomas-bc <thomas.boyerchammard@gmail.com>

Author: vincewoo

FppTestProject/FppTest/state_machine/internal/harness/TestAbsType.hpp

@@ -56,24 +56,10 @@ struct TestAbsType final : public Fw::Serializable {
     //! Deserialize method
     //! \return status
     Fw::SerializeStatus deserializeFrom(Fw::SerializeBufferBase& sbb  //!< The serialize buffer base
-                                    ) final {
+                                        ) final {
         return sbb.deserializeTo(this->m_data);
     }
 
-    // ----------------------------------------------------------------------
-    // Methods
-    // ----------------------------------------------------------------------
-
-    Fw::SerializeStatus serialize(Fw::SerializeBufferBase& sbb) const final
-    {
-        return this->serializeTo(sbb);
-    }
-
-    Fw::SerializeStatus deserialize(Fw::SerializeBufferBase& sbb) final
-    {
-        return this->deserializeFrom(sbb);
-    }
-
 #if FW_SERIALIZABLE_TO_STRING
     //! Convert TestAbsType to string
     void toString(Fw::StringBase& sb  //!< The StringBase object to hold the result

Fw/Buffer/Buffer.cpp

@@ -189,12 +189,4 @@ std::ostream& operator<<(std::ostream& os, const Buffer& obj) {
 }
 #endif
 
-Fw::SerializeStatus Buffer::serialize(Fw::SerializeBufferBase& serialBuffer) const {
-    return this->serializeTo(serialBuffer);
-}
-
-Fw::SerializeStatus Buffer::deserialize(Fw::SerializeBufferBase& buffer) {
-    return this->deserializeFrom(buffer);
-}
-
 }  // end namespace Fw

Fw/Buffer/Buffer.hpp

@@ -137,14 +137,6 @@ class Buffer : public Fw::Serializable {
     //! \return: status of serialization
     Fw::SerializeStatus deserializeFrom(Fw::SerializeBufferBase& buffer);
 
-    // ----------------------------------------------------------------------
-    // Deprecated methods
-    // ----------------------------------------------------------------------
-
-    Fw::SerializeStatus serialize(Fw::SerializeBufferBase& serialBuffer) const;
-
-    Fw::SerializeStatus deserialize(Fw::SerializeBufferBase& buffer);
-
     // ----------------------------------------------------------------------
     // Accessor functions
     // ----------------------------------------------------------------------

Fw/Cmd/CmdPacket.cpp

@@ -35,7 +35,7 @@ SerializeStatus CmdPacket::deserializeFrom(SerializeBufferBase& buffer) {
         return FW_DESERIALIZE_TYPE_MISMATCH;
     }
 
-    stat = buffer.deserialize(this->m_opcode);
+    stat = buffer.deserializeTo(this->m_opcode);
     if (stat != FW_SERIALIZE_OK) {
         return stat;
     }
@@ -49,15 +49,6 @@ SerializeStatus CmdPacket::deserializeFrom(SerializeBufferBase& buffer) {
     return stat;
 }
 
-// Deprecated methods for backward compatibility - these call the new interface
-SerializeStatus CmdPacket::serialize(SerializeBufferBase& buffer) const {
-    return this->serializeTo(buffer);
-}
-
-SerializeStatus CmdPacket::deserialize(SerializeBufferBase& buffer) {
-    return this->deserializeFrom(buffer);
-}
-
 FwOpcodeType CmdPacket::getOpCode() const {
     return this->m_opcode;
 }

Fw/Cmd/CmdPacket.hpp

@@ -22,9 +22,6 @@ class CmdPacket : public ComPacket {
     SerializeStatus serializeTo(SerializeBufferBase& buffer) const;
     SerializeStatus deserializeFrom(SerializeBufferBase& buffer);
 
-    // Legacy serialization methods (backward compatibility)
-    SerializeStatus serialize(SerializeBufferBase& buffer) const;  //!< serialize contents
-    SerializeStatus deserialize(SerializeBufferBase& buffer);
     FwOpcodeType getOpCode() const;
     CmdArgBuffer& getArgBuffer();
 

Fw/Com/ComPacket.cpp

@@ -14,35 +14,16 @@ ComPacket::ComPacket() : m_type(ComPacketType::FW_PACKET_UNKNOWN) {}
 ComPacket::~ComPacket() {}
 
 SerializeStatus ComPacket::serializeBase(SerializeBufferBase& buffer) const {
-    return buffer.serialize(static_cast<FwPacketDescriptorType>(this->m_type));
+    return buffer.serializeFrom(static_cast<FwPacketDescriptorType>(this->m_type));
 }
 
 SerializeStatus ComPacket::deserializeBase(SerializeBufferBase& buffer) {
     FwPacketDescriptorType serVal;
-    SerializeStatus stat = buffer.deserialize(serVal);
+    SerializeStatus stat = buffer.deserializeTo(serVal);
     if (FW_SERIALIZE_OK == stat) {
         this->m_type = static_cast<ComPacketType>(serVal);
     }
     return stat;
 }
 
-SerializeStatus ComPacket::serializeTo(SerializeBufferBase& buffer) const {
-    // Default implementation for base class - derived classes should override this method
-    return FW_SERIALIZE_UNIMPLEMENTED;
-}
-
-SerializeStatus ComPacket::deserializeFrom(SerializeBufferBase& buffer) {
-    // Default implementation for base class - derived classes should override this method
-    return FW_DESERIALIZE_UNIMPLEMENTED;
-}
-
-// Deprecated methods for backward compatibility
-SerializeStatus ComPacket::serialize(SerializeBufferBase& buffer) const {
-    return this->serializeTo(buffer);
-}
-
-SerializeStatus ComPacket::deserialize(SerializeBufferBase& buffer) {
-    return this->deserializeFrom(buffer);
-}
-
 } /* namespace Fw */

Fw/Com/ComPacket.hpp

@@ -24,14 +24,6 @@ class ComPacket : public Serializable {
     ComPacket();
     virtual ~ComPacket();
 
-    // New serialization interface
-    SerializeStatus serializeTo(SerializeBufferBase& buffer) const override;
-    SerializeStatus deserializeFrom(SerializeBufferBase& buffer) override;
-
-    // Deprecated methods for backward compatibility
-    SerializeStatus serialize(SerializeBufferBase& buffer) const override;
-    SerializeStatus deserialize(SerializeBufferBase& buffer) override;
-
   protected:
     ComPacketType m_type;
     SerializeStatus serializeBase(

Fw/Log/AmpcsEvrLogPacket.cpp

@@ -14,74 +14,64 @@ namespace Fw {
 AmpcsEvrLogPacket::AmpcsEvrLogPacket() : m_eventID(0), m_overSeqNum(0), m_catSeqNum(0) {
     this->m_type = FW_PACKET_LOG;
 }
-
 AmpcsEvrLogPacket::~AmpcsEvrLogPacket() {}
 
-SerializeStatus AmpcsEvrLogPacket::serialize(SerializeBufferBase& buffer) const {
-    // Deprecated method - calls new interface for backward compatibility
-    return this->serializeTo(buffer);
-}
-
-SerializeStatus AmpcsEvrLogPacket::deserialize(SerializeBufferBase& buffer) {
-    // Deprecated method - calls new interface for backward compatibility
-    return this->deserializeFrom(buffer);
-}
-
 SerializeStatus AmpcsEvrLogPacket::serializeTo(SerializeBufferBase& buffer) const {
     SerializeStatus stat;
 
-    stat = buffer.serialize(this->m_taskName, AMPCS_EVR_TASK_NAME_LEN, Fw::Serialization::OMIT_LENGTH);
+    stat = buffer.serializeFrom(this->m_taskName, AMPCS_EVR_TASK_NAME_LEN, Fw::Serialization::OMIT_LENGTH);
     if (stat != FW_SERIALIZE_OK) {
         return stat;
     }
 
-    stat = buffer.serialize(this->m_eventID);
+    stat = buffer.serializeFrom(this->m_eventID);
     if (stat != FW_SERIALIZE_OK) {
         return stat;
     }
 
-    stat = buffer.serialize(this->m_overSeqNum);
+    stat = buffer.serializeFrom(this->m_overSeqNum);
     if (stat != FW_SERIALIZE_OK) {
         return stat;
     }
 
-    stat = buffer.serialize(this->m_catSeqNum);
+    stat = buffer.serializeFrom(this->m_catSeqNum);
     if (stat != FW_SERIALIZE_OK) {
         return stat;
     }
 
-    return buffer.serialize(this->m_logBuffer.getBuffAddr(), m_logBuffer.getBuffLength(),
-                            Fw::Serialization::OMIT_LENGTH);
+    return buffer.serializeFrom(this->m_logBuffer.getBuffAddr(), m_logBuffer.getBuffLength(),
+                                Fw::Serialization::OMIT_LENGTH);
 }
 
 SerializeStatus AmpcsEvrLogPacket::deserializeFrom(SerializeBufferBase& buffer) {
     FwSizeType len;
 
+    SerializeStatus stat;
     SerializeStatus stat;
 
     len = AMPCS_EVR_TASK_NAME_LEN;
-    stat = buffer.deserialize(this->m_taskName, len, true);
+    stat = buffer.deserializeTo(this->m_taskName, len, true);
     if (stat != FW_SERIALIZE_OK) {
         return stat;
     }
 
-    stat = buffer.deserialize(this->m_eventID);
+    stat = buffer.deserializeTo(this->m_eventID);
     if (stat != FW_SERIALIZE_OK) {
         return stat;
     }
 
-    stat = buffer.deserialize(this->m_overSeqNum);
+    stat = buffer.deserializeTo(this->m_overSeqNum);
     if (stat != FW_SERIALIZE_OK) {
         return stat;
     }
 
-    stat = buffer.deserialize(this->m_catSeqNum);
+    stat = buffer.deserializeTo(this->m_catSeqNum);
     if (stat != FW_SERIALIZE_OK) {
         return stat;
     }
 
     FwSizeType size = buffer.getBuffLeft();
-    stat = buffer.deserialize(this->m_logBuffer.getBuffAddr(), size, true);
+    stat = buffer.deserializeTo(this->m_logBuffer.getBuffAddr(), size, true);
     if (stat == FW_SERIALIZE_OK) {
         // Shouldn't fail
         stat = this->m_logBuffer.setBuffLen(size);

Fw/Log/AmpcsEvrLogPacket.hpp

@@ -23,11 +23,8 @@ class AmpcsEvrLogPacket : public ComPacket {
     AmpcsEvrLogPacket();
     virtual ~AmpcsEvrLogPacket();
 
-    SerializeStatus serialize(SerializeBufferBase& buffer) const override;  //!< serialize contents
-    SerializeStatus deserialize(SerializeBufferBase& buffer) override;
-
-    SerializeStatus serializeTo(SerializeBufferBase& buffer) const override;  //!< serialize contents
-    SerializeStatus deserializeFrom(SerializeBufferBase& buffer) override;
+    SerializeStatus serializeTo(SerializeBufferBase& buffer) const;  //!< serialize contents
+    SerializeStatus deserializeFrom(SerializeBufferBase& buffer);
 
     void setTaskName(U8* taskName, U8 len);
     void setId(U32 eventID);

Fw/Log/LogPacket.cpp

@@ -16,35 +16,25 @@ LogPacket::LogPacket() : m_id(0) {
 
 LogPacket::~LogPacket() {}
 
-SerializeStatus LogPacket::serialize(SerializeBufferBase& buffer) const {
-    // Deprecated method - calls new interface for backward compatibility
-    return this->serializeTo(buffer);
-}
-
-SerializeStatus LogPacket::deserialize(SerializeBufferBase& buffer) {
-    // Deprecated method - calls new interface for backward compatibility
-    return this->deserializeFrom(buffer);
-}
-
 SerializeStatus LogPacket::serializeTo(SerializeBufferBase& buffer) const {
     SerializeStatus stat = ComPacket::serializeBase(buffer);
     if (stat != FW_SERIALIZE_OK) {
         return stat;
     }
 
-    stat = buffer.serialize(this->m_id);
+    stat = buffer.serializeFrom(this->m_id);
     if (stat != FW_SERIALIZE_OK) {
         return stat;
     }
 
-    stat = buffer.serialize(this->m_timeTag);
+    stat = buffer.serializeFrom(this->m_timeTag);
     if (stat != FW_SERIALIZE_OK) {
         return stat;
     }
 
     // We want to add data but not size for the ground software
-    return buffer.serialize(this->m_logBuffer.getBuffAddr(), m_logBuffer.getBuffLength(),
-                            Fw::Serialization::OMIT_LENGTH);
+    return buffer.serializeFrom(this->m_logBuffer.getBuffAddr(), m_logBuffer.getBuffLength(),
+                                Fw::Serialization::OMIT_LENGTH);
 }
 
 SerializeStatus LogPacket::deserializeFrom(SerializeBufferBase& buffer) {
@@ -53,19 +43,19 @@ SerializeStatus LogPacket::deserializeFrom(SerializeBufferBase& buffer) {
         return stat;
     }
 
-    stat = buffer.deserialize(this->m_id);
+    stat = buffer.deserializeTo(this->m_id);
     if (stat != FW_SERIALIZE_OK) {
         return stat;
     }
 
-    stat = buffer.deserialize(this->m_timeTag);
+    stat = buffer.deserializeTo(this->m_timeTag);
     if (stat != FW_SERIALIZE_OK) {
         return stat;
     }
 
     // remainder of buffer must be telemetry value
     FwSizeType size = buffer.getBuffLeft();
-    stat = buffer.deserialize(this->m_logBuffer.getBuffAddr(), size, Fw::Serialization::OMIT_LENGTH);
+    stat = buffer.deserializeTo(this->m_logBuffer.getBuffAddr(), size, Fw::Serialization::OMIT_LENGTH);
     if (stat == FW_SERIALIZE_OK) {
         // Shouldn't fail
         stat = this->m_logBuffer.setBuffLen(size);