seems to work well

CHANGELOG.md

@@ -8,6 +8,11 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 # [unreleased]
 
+## Added
+
+- Added `value` and `to_vec` methods for the `UnsignedEnum` trait. The value is returned as
+  as `u64`.
+
 # [v0.9.0] 2024-02-07
 
 ## Added

src/cfdp/pdu/finished.rs

@@ -581,7 +581,7 @@ mod tests {
         assert_eq!(finished_pdu_vec.len(), 12);
         assert_eq!(finished_pdu_vec[9], TlvType::EntityId.into());
         assert_eq!(finished_pdu_vec[10], 1);
-        assert_eq!(finished_pdu_vec[11], TEST_DEST_ID.value());
+        assert_eq!(finished_pdu_vec[11], TEST_DEST_ID.value_typed());
         assert_eq!(
             finished_pdu.fault_location().unwrap().entity_id(),
             &TEST_DEST_ID.into()

src/ecss/mod.rs

@@ -315,11 +315,11 @@ pub trait EcssEnumerationExt: EcssEnumeration + Debug + Copy + Clone + PartialEq
 
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct GenericEcssEnumWrapper<TYPE: Copy> {
+pub struct GenericEcssEnumWrapper<TYPE: Copy + Into<u64>> {
     field: GenericUnsignedByteField<TYPE>,
 }
 
-impl<TYPE: Copy> GenericEcssEnumWrapper<TYPE> {
+impl<TYPE: Copy + Into<u64>> GenericEcssEnumWrapper<TYPE> {
     pub const fn ptc() -> PacketTypeCodes {
         PacketTypeCodes::Enumerated
     }
@@ -331,7 +331,7 @@ impl<TYPE: Copy> GenericEcssEnumWrapper<TYPE> {
     }
 }
 
-impl<TYPE: Copy + ToBeBytes> UnsignedEnum for GenericEcssEnumWrapper<TYPE> {
+impl<TYPE: Copy + ToBeBytes + Into<u64>> UnsignedEnum for GenericEcssEnumWrapper<TYPE> {
     fn size(&self) -> usize {
         (self.pfc() / 8) as usize
     }
@@ -339,15 +339,25 @@ impl<TYPE: Copy + ToBeBytes> UnsignedEnum for GenericEcssEnumWrapper<TYPE> {
     fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
         self.field.write_to_be_bytes(buf)
     }
+
+    fn value(&self) -> u64 {
+        self.field.value()
+    }
+
+    fn to_vec(&self) -> alloc::vec::Vec<u8> {
+        let mut buf = alloc::vec![0; self.size()];
+        self.write_to_be_bytes(&mut buf).unwrap();
+        buf
+    }
 }
 
-impl<TYPE: Copy + ToBeBytes> EcssEnumeration for GenericEcssEnumWrapper<TYPE> {
+impl<TYPE: Copy + ToBeBytes + Into<u64>> EcssEnumeration for GenericEcssEnumWrapper<TYPE> {
     fn pfc(&self) -> u8 {
         size_of::<TYPE>() as u8 * 8_u8
     }
 }
 
-impl<TYPE: Debug + Copy + Clone + PartialEq + Eq + ToBeBytes> EcssEnumerationExt
+impl<TYPE: Debug + Copy + Clone + PartialEq + Eq + ToBeBytes + Into<u64>> EcssEnumerationExt
     for GenericEcssEnumWrapper<TYPE>
 {
 }

src/util.rs

@@ -73,6 +73,7 @@ pub trait UnsignedEnum {
     fn size(&self) -> usize;
     /// Write the unsigned enumeration to a raw buffer. Returns the written size on success.
     fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError>;
+    fn value(&self) -> u64;
 
     #[cfg(feature = "alloc")]
     fn to_vec(&self) -> alloc::vec::Vec<u8> {
@@ -139,10 +140,6 @@ impl UnsignedByteField {
         Self { width, value }
     }
 
-    pub fn value(&self) -> u64 {
-        self.value
-    }
-
     pub fn new_from_be_bytes(width: usize, buf: &[u8]) -> Result<Self, UnsignedByteFieldError> {
         if width > buf.len() {
             return Err(ByteConversionError::FromSliceTooSmall {
@@ -179,6 +176,10 @@ impl UnsignedEnum for UnsignedByteField {
         self.width
     }
 
+    fn value(&self) -> u64 {
+        self.value
+    }
+
     fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
         if buf.len() < self.size() {
             return Err(ByteConversionError::ToSliceTooSmall {
@@ -214,21 +215,21 @@ impl UnsignedEnum for UnsignedByteField {
 
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct GenericUnsignedByteField<TYPE: Copy> {
+pub struct GenericUnsignedByteField<TYPE: Copy + Into<u64>> {
     value: TYPE,
 }
 
-impl<TYPE: Copy> GenericUnsignedByteField<TYPE> {
+impl<TYPE: Copy + Into<u64>> GenericUnsignedByteField<TYPE> {
     pub const fn new(val: TYPE) -> Self {
         Self { value: val }
     }
 
-    pub const fn value(&self) -> TYPE {
+    pub const fn value_typed(&self) -> TYPE {
         self.value
     }
 }
 
-impl<TYPE: Copy + ToBeBytes> UnsignedEnum for GenericUnsignedByteField<TYPE> {
+impl<TYPE: Copy + ToBeBytes + Into<u64>> UnsignedEnum for GenericUnsignedByteField<TYPE> {
     fn size(&self) -> usize {
         self.value.written_len()
     }
@@ -243,6 +244,10 @@ impl<TYPE: Copy + ToBeBytes> UnsignedEnum for GenericUnsignedByteField<TYPE> {
         buf[0..self.size()].copy_from_slice(self.value.to_be_bytes().as_ref());
         Ok(self.value.written_len())
     }
+
+    fn value(&self) -> u64 {
+        self.value_typed().into()
+    }
 }
 
 pub type UnsignedByteFieldEmpty = GenericUnsignedByteField<()>;