Change Sv2Frame from struct to enum

`Sv2Frame` can handle serialized and non-serliazed data, both scenarios
were previously in the same struct wrapped by Option, where if one is
Some, the other is None but never both None or Some.

protocols/v2/framing-sv2/src/framing.rs

@@ -44,11 +44,9 @@ impl<T: Serialize + GetSize, B: AsMut<[u8]> + AsRef<[u8]>> From<Sv2Frame<T, B>>
 
 /// Abstraction for a SV2 Frame.
 #[derive(Debug, Clone)]
-pub struct Sv2Frame<T, B> {
-    header: Header,
-    payload: Option<T>,
-    /// Serialized header + payload
-    serialized: Option<B>,
+pub enum Sv2Frame<T, B> {
+    Payload { header: Header, payload: T },
+    Raw { header: Header, serialized: B },
 }
 
 impl<T: Serialize + GetSize, B: AsMut<[u8]> + AsRef<[u8]>> Sv2Frame<T, B> {
@@ -57,23 +55,23 @@ impl<T: Serialize + GetSize, B: AsMut<[u8]> + AsRef<[u8]>> Sv2Frame<T, B> {
     /// When called on a non serialized frame, it is not so cheap (because it serializes it).
     #[inline]
     pub fn serialize(self, dst: &mut [u8]) -> Result<(), Error> {
-        if let Some(mut serialized) = self.serialized {
-            dst.swap_with_slice(serialized.as_mut());
-            Ok(())
-        } else if let Some(payload) = self.payload {
-            #[cfg(not(feature = "with_serde"))]
-            to_writer(self.header, dst).map_err(Error::BinarySv2Error)?;
-            #[cfg(not(feature = "with_serde"))]
-            to_writer(payload, &mut dst[Header::SIZE..]).map_err(Error::BinarySv2Error)?;
-            #[cfg(feature = "with_serde")]
-            to_writer(&self.header, dst.as_mut()).map_err(Error::BinarySv2Error)?;
-            #[cfg(feature = "with_serde")]
-            to_writer(&payload, &mut dst.as_mut()[Header::SIZE..])
-                .map_err(Error::BinarySv2Error)?;
-            Ok(())
-        } else {
-            // Sv2Frame always has a payload or a serialized payload
-            panic!("Impossible state")
+        match self {
+            Sv2Frame::Raw { mut serialized, .. } => {
+                dst.swap_with_slice(serialized.as_mut());
+                Ok(())
+            }
+            Sv2Frame::Payload { header, payload } => {
+                #[cfg(not(feature = "with_serde"))]
+                to_writer(header, dst).map_err(Error::BinarySv2Error)?;
+                #[cfg(not(feature = "with_serde"))]
+                to_writer(payload, &mut dst[Header::SIZE..]).map_err(Error::BinarySv2Error)?;
+                #[cfg(feature = "with_serde")]
+                to_writer(&header, dst.as_mut()).map_err(Error::BinarySv2Error)?;
+                #[cfg(feature = "with_serde")]
+                to_writer(&payload, &mut dst.as_mut()[Header::SIZE..])
+                    .map_err(Error::BinarySv2Error)?;
+                Ok(())
+            }
         }
     }
 
@@ -83,16 +81,18 @@ impl<T: Serialize + GetSize, B: AsMut<[u8]> + AsRef<[u8]>> Sv2Frame<T, B> {
     /// already serialized payload. If the frame has not yet been
     /// serialized, this function should never be used (it will panic).
     pub fn payload(&mut self) -> Option<&mut [u8]> {
-        if let Some(serialized) = self.serialized.as_mut() {
-            Some(&mut serialized.as_mut()[Header::SIZE..])
-        } else {
-            None
+        match self {
+            Sv2Frame::Raw { serialized, .. } => Some(&mut serialized.as_mut()[Header::SIZE..]),
+            Sv2Frame::Payload { .. } => None,
         }
     }
 
     /// `Sv2Frame` always returns `Some(self.header)`.
     pub fn header(&self) -> crate::header::Header {
-        self.header
+        match self {
+            Self::Payload { header, .. } => *header,
+            Self::Raw { header, .. } => *header,
+        }
     }
 
     /// Tries to build a `Sv2Frame` from raw bytes, assuming they represent a serialized `Sv2Frame` frame (`Self.serialized`).
@@ -113,10 +113,9 @@ impl<T: Serialize + GetSize, B: AsMut<[u8]> + AsRef<[u8]>> Sv2Frame<T, B> {
     pub fn from_bytes_unchecked(mut bytes: B) -> Self {
         // Unchecked function caller is supposed to already know that the passed bytes are valid
         let header = Header::from_bytes(bytes.as_mut()).expect("Invalid header");
-        Self {
+        Self::Raw {
             header,
-            payload: None,
-            serialized: Some(bytes),
+            serialized: bytes,
         }
     }
 
@@ -150,13 +149,9 @@ impl<T: Serialize + GetSize, B: AsMut<[u8]> + AsRef<[u8]>> Sv2Frame<T, B> {
     /// otherwise, returns the length of `self.payload`.
     #[inline]
     pub fn encoded_length(&self) -> usize {
-        if let Some(serialized) = self.serialized.as_ref() {
-            serialized.as_ref().len()
-        } else if let Some(payload) = self.payload.as_ref() {
-            payload.get_size() + Header::SIZE
-        } else {
-            // Sv2Frame always has a payload or a serialized payload
-            panic!("Impossible state")
+        match self {
+            Sv2Frame::Raw { serialized, .. } => serialized.as_ref().len(),
+            Sv2Frame::Payload { payload, .. } => payload.get_size() + Header::SIZE,
         }
     }
 
@@ -170,25 +165,26 @@ impl<T: Serialize + GetSize, B: AsMut<[u8]> + AsRef<[u8]>> Sv2Frame<T, B> {
     ) -> Option<Self> {
         let extension_type = update_extension_type(extension_type, channel_msg);
         let len = message.get_size() as u32;
-        Header::from_len(len, message_type, extension_type).map(|header| Self {
+        Header::from_len(len, message_type, extension_type).map(|header| Self::Payload {
             header,
-            payload: Some(message),
-            serialized: None,
+            payload: message,
         })
     }
 }
 
 impl<A: Serialize + GetSize, B: AsMut<[u8]> + AsRef<[u8]>> Sv2Frame<A, B> {
     /// Maps a `Sv2Frame<A, B>` to `Sv2Frame<C, B>` by applying `fun`,
     /// which is assumed to be a closure that converts `A` to `C`
-    pub fn map<C>(self, fun: fn(A) -> C) -> Sv2Frame<C, B> {
-        let serialized = self.serialized;
-        let header = self.header;
-        let payload = self.payload.map(fun);
-        Sv2Frame {
-            header,
-            payload,
-            serialized,
+    pub fn map<C>(self, fun: fn(A) -> C) -> Sv2Frame<C, B>
+    where
+        C: Serialize + GetSize,
+    {
+        match self {
+            Sv2Frame::Raw { header, serialized } => Sv2Frame::Raw { header, serialized },
+            Sv2Frame::Payload { header, payload } => Sv2Frame::Payload {
+                header,
+                payload: fun(payload),
+            },
         }
     }
 }