this should be better

CHANGELOG.md

@@ -11,6 +11,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 ## Changed
 
 - `UnsignedByteField` and `GenericUnsignedByteField` `new` methods are `const` now.
+- `PduError` variants which contained a tuple variant with multiple fields were converted to a
+  struct variant.
 
 # Added
 

src/cfdp/pdu/eof.rs

@@ -106,13 +106,16 @@ impl EofPdu {
         }
         generic_length_checks_pdu_deserialization(buf, min_expected_len, full_len_without_crc)?;
         let directive_type = FileDirectiveType::try_from(buf[current_idx]).map_err(|_| {
-            PduError::InvalidDirectiveType((buf[current_idx], Some(FileDirectiveType::EofPdu)))
+            PduError::InvalidDirectiveType {
+                found: buf[current_idx],
+                expected: Some(FileDirectiveType::EofPdu),
+            }
         })?;
         if directive_type != FileDirectiveType::EofPdu {
-            return Err(PduError::WrongDirectiveType((
+            return Err(PduError::WrongDirectiveType {
-                directive_type,
+                found: directive_type,
-                FileDirectiveType::EofPdu,
+                expected: FileDirectiveType::EofPdu,
-            )));
+            });
         }
         current_idx += 1;
         let condition_code = ConditionCode::try_from((buf[current_idx] >> 4) & 0b1111)

src/cfdp/pdu/finished.rs

@@ -170,13 +170,16 @@ impl<'fs_responses> FinishedPdu<'fs_responses> {
         let min_expected_len = current_idx + 2;
         generic_length_checks_pdu_deserialization(buf, min_expected_len, full_len_without_crc)?;
         let directive_type = FileDirectiveType::try_from(buf[current_idx]).map_err(|_| {
-            PduError::InvalidDirectiveType((buf[current_idx], Some(FileDirectiveType::FinishedPdu)))
+            PduError::InvalidDirectiveType {
+                found: buf[current_idx],
+                expected: Some(FileDirectiveType::FinishedPdu),
+            }
         })?;
         if directive_type != FileDirectiveType::FinishedPdu {
-            return Err(PduError::WrongDirectiveType((
+            return Err(PduError::WrongDirectiveType {
-                directive_type,
+                found: directive_type,
-                FileDirectiveType::FinishedPdu,
+                expected: FileDirectiveType::FinishedPdu,
-            )));
+            });
         }
         current_idx += 1;
         let condition_code = ConditionCode::try_from((buf[current_idx] >> 4) & 0b1111)

src/cfdp/pdu/metadata.rs

@@ -248,13 +248,16 @@ impl<'src_name, 'dest_name, 'opts> MetadataPdu<'src_name, 'dest_name, 'opts> {
         }
         generic_length_checks_pdu_deserialization(buf, min_expected_len, full_len_without_crc)?;
         let directive_type = FileDirectiveType::try_from(buf[current_idx]).map_err(|_| {
-            PduError::InvalidDirectiveType((buf[current_idx], Some(FileDirectiveType::MetadataPdu)))
+            PduError::InvalidDirectiveType {
+                found: buf[current_idx],
+                expected: Some(FileDirectiveType::MetadataPdu),
+            }
         })?;
         if directive_type != FileDirectiveType::MetadataPdu {
-            return Err(PduError::WrongDirectiveType((
+            return Err(PduError::WrongDirectiveType {
-                directive_type,
+                found: directive_type,
-                FileDirectiveType::MetadataPdu,
+                expected: FileDirectiveType::MetadataPdu,
-            )));
+            });
         }
         current_idx += 1;
         let (fss_len, file_size) =

src/cfdp/pdu/mod.rs

@@ -35,16 +35,19 @@ pub enum PduError {
     InvalidEntityLen(u8),
     /// Invalid length for the entity ID detected. Only the values 1, 2, 4 and 8 are supported.
     InvalidTransactionSeqNumLen(u8),
-    /// The first entry will be the source entity ID length, the second one the destination entity
+    SourceDestIdLenMissmatch {
-    /// ID length.
+        src_id_len: usize,
-    SourceDestIdLenMissmatch((usize, usize)),
+        dest_id_len: usize,
-    /// The first tuple entry will be the found directive type, the second entry the expected entry
+    },
-    /// type.
+    WrongDirectiveType {
-    WrongDirectiveType((FileDirectiveType, FileDirectiveType)),
+        found: FileDirectiveType,
+        expected: FileDirectiveType,
+    },
     /// The directive type field contained a value not in the range of permitted values.
-    /// The first tuple entry will be the found raw number, the second entry the expected entry
+    InvalidDirectiveType {
-    /// type when applicable.
+        found: u8,
-    InvalidDirectiveType((u8, Option<FileDirectiveType>)),
+        expected: Option<FileDirectiveType>,
+    },
     /// Invalid condition code. Contains the raw detected value.
     InvalidConditionCode(u8),
     /// Invalid checksum type which is not part of the checksums listed in the
@@ -80,10 +83,13 @@ impl Display for PduError {
                     "cfdp version missmatch, found {raw}, expected {CFDP_VERSION_2}"
                 )
             }
-            PduError::SourceDestIdLenMissmatch((src_len, dest_len)) => {
+            PduError::SourceDestIdLenMissmatch {
+                src_id_len,
+                dest_id_len,
+            } => {
                 write!(
                     f,
-                    "missmatch of PDU source length {src_len} and destination length {dest_len}"
+                    "missmatch of PDU source length {src_id_len} and destination length {dest_id_len}"
                 )
             }
             PduError::ByteConversionError(e) => {
@@ -92,13 +98,13 @@ impl Display for PduError {
             PduError::FileSizeTooLarge(value) => {
                 write!(f, "file size value {value} exceeds allowed 32 bit width")
             }
-            PduError::WrongDirectiveType((found, expected)) => {
+            PduError::WrongDirectiveType { found, expected } => {
                 write!(f, "found directive type {found:?}, expected {expected:?}")
             }
             PduError::InvalidConditionCode(raw_code) => {
                 write!(f, "found invalid condition code with raw value {raw_code}")
             }
-            PduError::InvalidDirectiveType((found, expected)) => {
+            PduError::InvalidDirectiveType { found, expected } => {
                 write!(
                     f,
                     "invalid directive type value {found}, expected {expected:?}"
@@ -216,10 +222,10 @@ impl CommonPduConfig {
         let source_id = source_id.into();
         let dest_id = dest_id.into();
         if source_id.size() != dest_id.size() {
-            return Err(PduError::SourceDestIdLenMissmatch((
+            return Err(PduError::SourceDestIdLenMissmatch {
-                source_id.size(),
+                src_id_len: source_id.size(),
-                dest_id.size(),
+                dest_id_len: dest_id.size(),
-            )));
+            });
         }
         if source_id.size() != 1
             && source_id.size() != 2
@@ -353,10 +359,10 @@ impl PduHeader {
         // Internal note: There is currently no way to pass a PDU configuration like this, but
         // this check is still kept for defensive programming.
         if self.pdu_conf.source_entity_id.size() != self.pdu_conf.dest_entity_id.size() {
-            return Err(PduError::SourceDestIdLenMissmatch((
+            return Err(PduError::SourceDestIdLenMissmatch {
-                self.pdu_conf.source_entity_id.size(),
+                src_id_len: self.pdu_conf.source_entity_id.size(),
-                self.pdu_conf.dest_entity_id.size(),
+                dest_id_len: self.pdu_conf.dest_entity_id.size(),
-            )));
+            });
         }
         if buf.len()
             < FIXED_HEADER_LEN