Renaming serialize/deserialize methods to serializeTo/serializeFrom and deserializeTo/deserializeFrom (#3880)

* Deprecating serialize/deserialize methods for clearer serializeTo/serializeFrom and deserializeTo/deserializeFrom methods to indicate direction.

* Cleaned up some GCC directives that was used for an experimenting. Fixed some bugs in Serializable.

* Un-deprecating serialize/deserialize methods to decouple the required FPP changes

* Further modenized more child classes. Added some backwards compatibility fall-back logic to aid in FPP decoupling.

* Fixing clang formatting violation

* Removing redundant virtual keyword since the functions are already overrides

* Incorporating PR comments

* Fixing clang format issue

* Incorporating PR comments

* Updating documentation for new serialize/deserialize methods

Author: vincewoo

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

@@ -48,16 +48,30 @@ struct TestAbsType final : public Fw::Serializable {
 
     //! Serialize function
     //! \return Status
-    Fw::SerializeStatus serialize(Fw::SerializeBufferBase& sbb  //!< The serialize buffer base
+    Fw::SerializeStatus serializeTo(Fw::SerializeBufferBase& sbb  //!< The serialize buffer base
     ) const final {
-        return sbb.serialize(this->m_data);
+        return sbb.serializeFrom(this->m_data);
     }
 
     //! Deserialize method
     //! \return status
-    Fw::SerializeStatus deserialize(Fw::SerializeBufferBase& sbb  //!< The serialize buffer base
+    Fw::SerializeStatus deserializeFrom(Fw::SerializeBufferBase& sbb  //!< The serialize buffer base
                                     ) final {
-        return sbb.deserialize(this->m_data);
+        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

Fw/Buffer/Buffer.cpp

@@ -113,36 +113,36 @@ Fw::ExternalSerializeBufferWithMemberCopy Buffer::getDeserializer() {
     }
 }
 
-Fw::SerializeStatus Buffer::serialize(Fw::SerializeBufferBase& buffer) const {
+Fw::SerializeStatus Buffer::serializeTo(Fw::SerializeBufferBase& buffer) const {
     Fw::SerializeStatus stat;
 #if FW_SERIALIZATION_TYPE_ID
-    stat = buffer.serialize(static_cast<U32>(Buffer::TYPE_ID));
+    stat = buffer.serializeFrom(static_cast<U32>(Buffer::TYPE_ID));
     if (stat != Fw::FW_SERIALIZE_OK) {
         return stat;
     }
 #endif
-    stat = buffer.serialize(reinterpret_cast<PlatformPointerCastType>(this->m_bufferData));
+    stat = buffer.serializeFrom(reinterpret_cast<PlatformPointerCastType>(this->m_bufferData));
     if (stat != Fw::FW_SERIALIZE_OK) {
         return stat;
     }
-    stat = buffer.serialize(this->m_size);
+    stat = buffer.serializeFrom(this->m_size);
     if (stat != Fw::FW_SERIALIZE_OK) {
         return stat;
     }
-    stat = buffer.serialize(this->m_context);
+    stat = buffer.serializeFrom(this->m_context);
     if (stat != Fw::FW_SERIALIZE_OK) {
         return stat;
     }
     return stat;
 }
 
-Fw::SerializeStatus Buffer::deserialize(Fw::SerializeBufferBase& buffer) {
+Fw::SerializeStatus Buffer::deserializeFrom(Fw::SerializeBufferBase& buffer) {
     Fw::SerializeStatus stat;
 
 #if FW_SERIALIZATION_TYPE_ID
     U32 typeId;
 
-    stat = buffer.deserialize(typeId);
+    stat = buffer.deserializeTo(typeId);
     if (stat != Fw::FW_SERIALIZE_OK) {
         return stat;
     }
@@ -152,17 +152,17 @@ Fw::SerializeStatus Buffer::deserialize(Fw::SerializeBufferBase& buffer) {
     }
 #endif
     PlatformPointerCastType pointer;
-    stat = buffer.deserialize(pointer);
+    stat = buffer.deserializeTo(pointer);
     if (stat != Fw::FW_SERIALIZE_OK) {
         return stat;
     }
     this->m_bufferData = reinterpret_cast<U8*>(pointer);
 
-    stat = buffer.deserialize(this->m_size);
+    stat = buffer.deserializeTo(this->m_size);
     if (stat != Fw::FW_SERIALIZE_OK) {
         return stat;
     }
-    stat = buffer.deserialize(this->m_context);
+    stat = buffer.deserializeTo(this->m_context);
     if (stat != Fw::FW_SERIALIZE_OK) {
         return stat;
     }
@@ -188,4 +188,13 @@ std::ostream& operator<<(std::ostream& os, const Buffer& obj) {
     return os;
 }
 #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

@@ -125,7 +125,7 @@ class Buffer : public Fw::Serializable {
     //! or the serialize buffer base representation and serialize from that.
     //! \param serialBuffer: serialize buffer to write data into
     //! \return: status of serialization
-    Fw::SerializeStatus serialize(Fw::SerializeBufferBase& serialBuffer) const;
+    Fw::SerializeStatus serializeTo(Fw::SerializeBufferBase& serialBuffer) const;
 
     //! Deserializes this buffer from a SerializeBufferBase
     //!
@@ -135,6 +135,14 @@ class Buffer : public Fw::Serializable {
     //! or the serialize buffer base representation and deserialize from that.
     //! \param buffer: serialize buffer to read data into
     //! \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);
 
     // ----------------------------------------------------------------------

Fw/Buffer/docs/sdd.md

@@ -73,15 +73,15 @@ managed by the caller and only affects the data of the underlying buffer.
 U32 my_data = 10001;
 U8  my_byte = 2;
 auto sb = my_fw_buffer.getSerializer();
-sb.serialize(my_data);
-sb.serialize(my_byte);
+sb.serializeFrom(my_data);
+sb.serializeFrom(my_byte);
 ```
 
 **Deserializing from `Fw::Buffer`**
 ```c++
 U32 my_data = 0;
 U8  my_byte = 0;
 auto sb = my_fw_buffer.getDeserializer();
-sb.deserialize(my_data);
-sb.deserialize(my_byte);
+sb.deserializeTo(my_data);
+sb.deserializeTo(my_byte);
 ```

Fw/Cmd/CmdPacket.cpp

@@ -17,13 +17,14 @@ CmdPacket::CmdPacket() : m_opcode(0) {
 
 CmdPacket::~CmdPacket() {}
 
-SerializeStatus CmdPacket::serialize(SerializeBufferBase& buffer) const {
-    // Shouldn't be called
+// New serialization interface methods
+SerializeStatus CmdPacket::serializeTo(SerializeBufferBase& buffer) const {
+    // Shouldn't be called, no use case for serializing CmdPackets in FSW (currently)
     FW_ASSERT(0);
     return FW_SERIALIZE_OK;  // for compiler
 }
 
-SerializeStatus CmdPacket::deserialize(SerializeBufferBase& buffer) {
+SerializeStatus CmdPacket::deserializeFrom(SerializeBufferBase& buffer) {
     SerializeStatus stat = ComPacket::deserializeBase(buffer);
     if (stat != FW_SERIALIZE_OK) {
         return stat;
@@ -48,6 +49,15 @@ SerializeStatus CmdPacket::deserialize(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

@@ -18,6 +18,11 @@ class CmdPacket : public ComPacket {
     CmdPacket();
     virtual ~CmdPacket();
 
+    // New serialization interface methods
+    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;

Fw/Com/ComPacket.cpp

@@ -26,4 +26,23 @@ SerializeStatus ComPacket::deserializeBase(SerializeBufferBase& buffer) {
     return stat;
 }
 
+SerializeStatus ComPacket::serializeTo(SerializeBufferBase& buffer) const {
+    // Default implementation for base class - derived classes should override this method
+    return FW_SERIALIZE_FORMAT_ERROR;
+}
+
+SerializeStatus ComPacket::deserializeFrom(SerializeBufferBase& buffer) {
+    // Default implementation for base class - derived classes should override this method
+    return FW_DESERIALIZE_FORMAT_ERROR;
+}
+
+// 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,6 +24,14 @@ 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

@@ -22,6 +22,16 @@ namespace Fw {
     }
 
     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;
 
@@ -49,7 +59,7 @@ namespace Fw {
 
     }
 
-    SerializeStatus AmpcsEvrLogPacket::deserialize(SerializeBufferBase& buffer) {
+    SerializeStatus AmpcsEvrLogPacket::deserializeFrom(SerializeBufferBase& buffer) {
         FwSizeType len;
 
         SerializeStatus stat;

Fw/Log/AmpcsEvrLogPacket.hpp

@@ -24,8 +24,11 @@ namespace Fw {
             AmpcsEvrLogPacket();
             virtual ~AmpcsEvrLogPacket();
 
-            SerializeStatus serialize(SerializeBufferBase& buffer) const; //!< serialize contents
-            SerializeStatus deserialize(SerializeBufferBase& buffer);
+            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;
 
             void setTaskName(U8 *taskName, U8 len);
             void setId(U32 eventID);