pass messages by reference instead of by value

commons/zenoh-codec/src/network/mod.rs

@@ -25,35 +25,49 @@ use zenoh_buffers::{
 use zenoh_protocol::{
     common::{imsg, ZExtZ64, ZExtZBufHeader},
     core::{EntityId, Reliability, ZenohIdProto},
-    network::{ext::EntityGlobalIdType, *},
+    network::{
+        ext::{self, EntityGlobalIdType},
+        id, NetworkBody, NetworkBodyRef, NetworkMessage, NetworkMessageExt, NetworkMessageRef,
+    },
 };
 
 use crate::{
     LCodec, RCodec, WCodec, Zenoh080, Zenoh080Header, Zenoh080Length, Zenoh080Reliability,
 };
 
 // NetworkMessage
-impl<W> WCodec<&NetworkMessage, &mut W> for Zenoh080
+impl<W> WCodec<NetworkMessageRef<'_>, &mut W> for Zenoh080
 where
     W: Writer,
 {
     type Output = Result<(), DidntWrite>;
 
-    fn write(self, writer: &mut W, x: &NetworkMessage) -> Self::Output {
-        let NetworkMessage { body, .. } = x;
+    fn write(self, writer: &mut W, x: NetworkMessageRef) -> Self::Output {
+        let NetworkMessageRef { body, .. } = x;
 
         match body {
-            NetworkBody::Push(b) => self.write(&mut *writer, b),
-            NetworkBody::Request(b) => self.write(&mut *writer, b),
-            NetworkBody::Response(b) => self.write(&mut *writer, b),
-            NetworkBody::ResponseFinal(b) => self.write(&mut *writer, b),
-            NetworkBody::Interest(b) => self.write(&mut *writer, b),
-            NetworkBody::Declare(b) => self.write(&mut *writer, b),
-            NetworkBody::OAM(b) => self.write(&mut *writer, b),
+            NetworkBodyRef::Push(b) => self.write(&mut *writer, b),
+            NetworkBodyRef::Request(b) => self.write(&mut *writer, b),
+            NetworkBodyRef::Response(b) => self.write(&mut *writer, b),
+            NetworkBodyRef::ResponseFinal(b) => self.write(&mut *writer, b),
+            NetworkBodyRef::Interest(b) => self.write(&mut *writer, b),
+            NetworkBodyRef::Declare(b) => self.write(&mut *writer, b),
+            NetworkBodyRef::OAM(b) => self.write(&mut *writer, b),
         }
     }
 }
 
+impl<W> WCodec<&NetworkMessage, &mut W> for Zenoh080
+where
+    W: Writer,
+{
+    type Output = Result<(), DidntWrite>;
+
+    fn write(self, writer: &mut W, x: &NetworkMessage) -> Self::Output {
+        self.write(writer, x.as_ref())
+    }
+}
+
 impl<R> RCodec<NetworkMessage, &mut R> for Zenoh080
 where
     R: Reader,

commons/zenoh-codec/src/transport/batch.rs

@@ -20,7 +20,7 @@ use zenoh_buffers::{
 };
 use zenoh_protocol::{
     core::Reliability,
-    network::NetworkMessage,
+    network::{NetworkMessageExt, NetworkMessageRef},
     transport::{
         Fragment, FragmentHeader, Frame, FrameHeader, TransportBody, TransportMessage, TransportSn,
     },
@@ -111,14 +111,14 @@ where
     }
 }
 
-impl<W> WCodec<&NetworkMessage, &mut W> for &mut Zenoh080Batch
+impl<W> WCodec<NetworkMessageRef<'_>, &mut W> for &mut Zenoh080Batch
 where
     W: Writer + BacktrackableWriter,
     <W as BacktrackableWriter>::Mark: Copy,
 {
     type Output = Result<(), BatchError>;
 
-    fn write(self, writer: &mut W, x: &NetworkMessage) -> Self::Output {
+    fn write(self, writer: &mut W, x: NetworkMessageRef) -> Self::Output {
         // Eventually update the current frame and sn based on the current status
         if let (CurrentFrame::Reliable, false)
         | (CurrentFrame::BestEffort, true)
@@ -140,14 +140,14 @@ where
     }
 }
 
-impl<W> WCodec<(&NetworkMessage, &FrameHeader), &mut W> for &mut Zenoh080Batch
+impl<W> WCodec<(NetworkMessageRef<'_>, &FrameHeader), &mut W> for &mut Zenoh080Batch
 where
     W: Writer + BacktrackableWriter,
     <W as BacktrackableWriter>::Mark: Copy,
 {
     type Output = Result<(), BatchError>;
 
-    fn write(self, writer: &mut W, x: (&NetworkMessage, &FrameHeader)) -> Self::Output {
+    fn write(self, writer: &mut W, x: (NetworkMessageRef, &FrameHeader)) -> Self::Output {
         let (m, f) = x;
 
         if let (Reliability::Reliable, false) | (Reliability::BestEffort, true) =

commons/zenoh-codec/src/transport/mod.rs

@@ -34,19 +34,19 @@ use zenoh_protocol::{
 use crate::{RCodec, WCodec, Zenoh080, Zenoh080Header};
 
 // TransportMessageLowLatency
-impl<W> WCodec<&TransportMessageLowLatency, &mut W> for Zenoh080
+impl<W> WCodec<TransportMessageLowLatencyRef<'_>, &mut W> for Zenoh080
 where
     W: Writer,
 {
     type Output = Result<(), DidntWrite>;
 
-    fn write(self, writer: &mut W, x: &TransportMessageLowLatency) -> Self::Output {
-        let TransportMessageLowLatency { body } = x;
+    fn write(self, writer: &mut W, x: TransportMessageLowLatencyRef) -> Self::Output {
+        let TransportMessageLowLatencyRef { body } = x;
 
         match body {
-            TransportBodyLowLatency::Network(b) => self.write(&mut *writer, b),
-            TransportBodyLowLatency::KeepAlive(b) => self.write(&mut *writer, b),
-            TransportBodyLowLatency::Close(b) => self.write(&mut *writer, b),
+            TransportBodyLowLatencyRef::Network(b) => self.write(&mut *writer, b),
+            TransportBodyLowLatencyRef::KeepAlive(b) => self.write(&mut *writer, &b),
+            TransportBodyLowLatencyRef::Close(b) => self.write(&mut *writer, &b),
         }
     }
 }

commons/zenoh-protocol/src/common/extension.rs

@@ -307,8 +307,9 @@ impl<const ID: u8> Debug for ZExtZBufHeader<{ ID }> {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Default, Clone, PartialEq, Eq)]
 pub enum ZExtBody {
+    #[default]
     Unit,
     Z64(u64),
     ZBuf(ZBuf),