Issue 2457

Fw/Dp/DpContainer.cpp

@@ -70,10 +70,9 @@ Fw::SerializeStatus DpContainer::deserializeHeader() {
     }
     // Deserialize the user data
     if (status == Fw::FW_SERIALIZE_OK) {
-        const bool omitLength = true;
         const FwSizeType requestedSize = sizeof this->m_userData;
         FwSizeType receivedSize = requestedSize;
-        status = serializeRepr.deserialize(this->m_userData, receivedSize, omitLength);
+        status = serializeRepr.deserialize(this->m_userData, receivedSize, Fw::Serialization::OMIT_LENGTH);
         if (receivedSize != requestedSize) {
             status = Fw::FW_DESERIALIZE_SIZE_MISMATCH;
         }
@@ -111,8 +110,7 @@ void DpContainer::serializeHeader() {
     status = serializeRepr.serialize(this->m_procTypes);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));
     // Serialize the user data
-    const bool omitLength = true;
-    status = serializeRepr.serialize(this->m_userData, sizeof this->m_userData, omitLength);
+    status = serializeRepr.serialize(this->m_userData, sizeof this->m_userData, Fw::Serialization::OMIT_LENGTH);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));
     // Serialize the data product state
     status = serializeRepr.serialize(this->m_dpState);

Fw/Types/Serializable.cpp

@@ -235,9 +235,13 @@ namespace Fw {
     }
 
     SerializeStatus SerializeBufferBase::serialize(const U8* buff, NATIVE_UINT_TYPE length, bool noLength) {
+        return this->serialize(buff, static_cast<FwSizeType>(length), noLength ? Serialization::OMIT_LENGTH : Serialization::INCLUDE_LENGTH);
+    }
+
+    SerializeStatus SerializeBufferBase::serialize(const U8* buff, FwSizeType length, Fw::Serialization::t mode) {
         // First serialize length
         SerializeStatus stat;
-        if (not noLength) {
+        if (mode == Serialization::INCLUDE_LENGTH) {
             stat = this->serialize(static_cast<FwBuffSizeType>(length));
             if (stat != FW_SERIALIZE_OK) {
                 return stat;
@@ -500,10 +504,17 @@ namespace Fw {
     }
 
     SerializeStatus SerializeBufferBase::deserialize(U8* buff, NATIVE_UINT_TYPE& length, bool noLength) {
+        FwSizeType length_in_out = length;
+        SerializeStatus status = this->deserialize(buff, length_in_out, noLength ? Serialization::OMIT_LENGTH : Serialization::INCLUDE_LENGTH);
+        length = length_in_out;
+        return status;
+    }
+
+    SerializeStatus SerializeBufferBase::deserialize(U8* buff, FwSizeType& length, Serialization::t mode) {
 
         FW_ASSERT(this->getBuffAddr());
 
-        if (not noLength) {
+        if (mode == Serialization::INCLUDE_LENGTH) {
             FwBuffSizeType storedLength;
 
             SerializeStatus stat = this->deserialize(storedLength);
@@ -519,7 +530,7 @@ namespace Fw {
 
             (void) memcpy(buff, &this->getBuffAddr()[this->m_deserLoc], storedLength);
 
-            length = static_cast<NATIVE_UINT_TYPE>(storedLength);
+            length = static_cast<FwSizeType>(storedLength);
 
         } else {
             // make sure enough is left

Fw/Types/Serializable.hpp

@@ -38,6 +38,14 @@ namespace Fw {
             virtual ~Serializable(); //!< destructor
     };
 
+    class Serialization {
+      public:
+        enum t {
+            INCLUDE_LENGTH, //!< Include length as first token in serialization
+            OMIT_LENGTH //!< Omit length from serialization
+        };
+    };
+
     class SerializeBufferBase {
         public:
 
@@ -72,6 +80,17 @@ namespace Fw {
 
             SerializeStatus serialize(const U8* buff, NATIVE_UINT_TYPE length, bool noLength = false); //!< serialize data buffer
 
+            //! \brief serialize a byte buffer of a given length
+            //!
+            //! Serialize bytes from `buff` up to `length`.  If `serializationMode` is set to `INCLUDE_LENGTH` then the
+            //! length is included as the first token. Length may be omitted with `OMIT_LENGTH`.
+            //!
+            //! \param buff: buffer to serialize
+            //! \param length: length of data to serialize
+            //! \param mode: serialization type
+            //! \return status of serialization
+            SerializeStatus serialize(const U8* buff, FwSizeType length, Serialization::t mode);
+
             SerializeStatus serialize(const SerializeBufferBase& val); //!< serialize a serialized buffer
 
             SerializeStatus serialize(const Serializable &val); //!< serialize an object derived from serializable base class
@@ -105,8 +124,19 @@ namespace Fw {
             // length should be set to max, returned value is actual size stored. If noLength
             // is true, use the length variable as the actual number of bytes to deserialize
             SerializeStatus deserialize(U8* buff, NATIVE_UINT_TYPE& length, bool noLength = false); //!< deserialize data buffer
-            // serialize/deserialize Serializable
 
+            //! \brief deserialize a byte buffer of a given length
+            //!
+            //! Deserialize bytes into `buff` of `length` bytes.  If `serializationMode` is set to `INCLUDE_LENGTH` then
+            //! the length is deserialized first followed by the bytes. Length may be omitted with `OMIT_LENGTH` and
+            //! in this case `length` bytes will be deserialized. `length` will be filled with the amount of data
+            //! deserialized.
+            //!
+            //! \param buff: buffer to hold deserialized data
+            //! \param length: length of data to deserialize length is filled with deserialized length
+            //! \param mode: deserialization type
+            //! \return status of serialization
+            SerializeStatus deserialize(U8* buff, FwSizeType& length, Serialization::t mode);
 
             SerializeStatus deserialize(Serializable &val);  //!< deserialize an object derived from serializable base class