Using FnOnce

quartiq · Sep 13, 2023 · 3113135 · 3113135
1 parent 49dad7a
commit 3113135
Show file tree

Hide file tree

Showing 2 changed files with 12 additions and 11 deletions.
diff --git a/src/publication.rs b/src/publication.rs
@@ -7,13 +7,13 @@ use crate::{
 
 pub trait ToPayload {
     type Error;
-    fn serialize(&mut self, buffer: &mut [u8]) -> Result<usize, Self::Error>;
+    fn serialize(self, buffer: &mut [u8]) -> Result<usize, Self::Error>;
 }
 
 impl<'a> ToPayload for &'a [u8] {
     type Error = ();
 
-    fn serialize(&mut self, buffer: &mut [u8]) -> Result<usize, Self::Error> {
+    fn serialize(self, buffer: &mut [u8]) -> Result<usize, Self::Error> {
         if buffer.len() < self.len() {
             return Err(());
         }
@@ -25,39 +25,39 @@ impl<'a> ToPayload for &'a [u8] {
 impl<'a> ToPayload for &'a str {
     type Error = ();
 
-    fn serialize(&mut self, buffer: &mut [u8]) -> Result<usize, Self::Error> {
+    fn serialize(self, buffer: &mut [u8]) -> Result<usize, Self::Error> {
         self.as_bytes().serialize(buffer)
     }
 }
 
 impl<const N: usize> ToPayload for [u8; N] {
     type Error = ();
 
-    fn serialize(&mut self, buffer: &mut [u8]) -> Result<usize, ()> {
+    fn serialize(self, buffer: &mut [u8]) -> Result<usize, ()> {
         (&self[..]).serialize(buffer)
     }
 }
 impl<const N: usize> ToPayload for &[u8; N] {
     type Error = ();
 
-    fn serialize(&mut self, buffer: &mut [u8]) -> Result<usize, ()> {
+    fn serialize(self, buffer: &mut [u8]) -> Result<usize, ()> {
         (&self[..]).serialize(buffer)
     }
 }
 
-pub struct DeferredPublication<E, F: FnMut(&mut [u8]) -> Result<usize, E>> {
+pub struct DeferredPublication<E, F: FnOnce(&mut [u8]) -> Result<usize, E>> {
     func: F,
 }
 
-impl<E, F: FnMut(&mut [u8]) -> Result<usize, E>> DeferredPublication<E, F> {
+impl<E, F: FnOnce(&mut [u8]) -> Result<usize, E>> DeferredPublication<E, F> {
     pub fn new<'a>(func: F) -> Publication<'a, Self> {
         Publication::new(Self { func })
     }
 }
 
-impl<E, F: FnMut(&mut [u8]) -> Result<usize, E>> ToPayload for DeferredPublication<E, F> {
+impl<E, F: FnOnce(&mut [u8]) -> Result<usize, E>> ToPayload for DeferredPublication<E, F> {
     type Error = E;
-    fn serialize(&mut self, buffer: &mut [u8]) -> Result<usize, E> {
+    fn serialize(self, buffer: &mut [u8]) -> Result<usize, E> {
         (self.func)(buffer)
     }
 }

diff --git a/src/ser/mod.rs b/src/ser/mod.rs
@@ -133,14 +133,15 @@ impl<'a> MqttSerializer<'a> {
 
     pub fn pub_to_buffer_meta<P: crate::publication::ToPayload>(
         buf: &'a mut [u8],
-        mut pub_packet: Pub<'_, P>,
+        pub_packet: Pub<'_, P>,
     ) -> Result<(usize, &'a [u8]), PubError<P::Error>> {
         let mut serializer = crate::ser::MqttSerializer::new(buf);
         pub_packet
             .serialize(&mut serializer)
             .map_err(PubError::Error)?;
 
         // Next, serialize the payload into the remaining buffer
+        let flags = pub_packet.fixed_header_flags();
         let len = pub_packet
             .payload
             .serialize(serializer.remainder())
@@ -149,7 +150,7 @@ impl<'a> MqttSerializer<'a> {
 
         // Finally, finish the packet and send it.
         let (offset, packet) = serializer
-            .finalize(MessageType::Publish, pub_packet.fixed_header_flags())
+            .finalize(MessageType::Publish, flags)
             .map_err(PubError::Error)?;
         Ok((offset, packet))
     }