Fix clippy warnings

commons/zenoh-buffers/src/slice.rs

@@ -123,7 +123,7 @@ impl<'s> BacktrackableWriter for &'s mut [u8] {
 }
 
 // Reader
-impl<'a> HasReader for &'a [u8] {
+impl HasReader for &[u8] {
     type Reader = Self;
 
     fn reader(self) -> Self::Reader {
@@ -196,7 +196,7 @@ impl<'a> BacktrackableReader for &'a [u8] {
     }
 }
 
-impl<'a> SiphonableReader for &'a [u8] {
+impl SiphonableReader for &[u8] {
     fn siphon<W>(&mut self, writer: &mut W) -> Result<NonZeroUsize, DidntSiphon>
     where
         W: Writer,

commons/zenoh-buffers/src/vec.rs

@@ -62,7 +62,7 @@ impl SplitBuffer for Vec<u8> {
 }
 
 // Writer
-impl<'a> HasWriter for &'a mut Vec<u8> {
+impl HasWriter for &mut Vec<u8> {
     type Writer = Self;
 
     fn writer(self) -> Self::Writer {

commons/zenoh-buffers/src/zbuf.rs

@@ -195,7 +195,7 @@ impl<'a> HasReader for &'a ZBuf {
     }
 }
 
-impl<'a> Reader for ZBufReader<'a> {
+impl Reader for ZBufReader<'_> {
     fn read(&mut self, mut into: &mut [u8]) -> Result<NonZeroUsize, DidntRead> {
         let mut read = 0;
         while let Some(slice) = self.inner.slices.get(self.cursor.slice) {
@@ -299,7 +299,7 @@ impl<'a> Reader for ZBufReader<'a> {
     }
 }
 
-impl<'a> BacktrackableReader for ZBufReader<'a> {
+impl BacktrackableReader for ZBufReader<'_> {
     type Mark = ZBufPos;
 
     fn mark(&mut self) -> Self::Mark {
@@ -312,7 +312,7 @@ impl<'a> BacktrackableReader for ZBufReader<'a> {
     }
 }
 
-impl<'a> SiphonableReader for ZBufReader<'a> {
+impl SiphonableReader for ZBufReader<'_> {
     fn siphon<W>(&mut self, writer: &mut W) -> Result<NonZeroUsize, DidntSiphon>
     where
         W: Writer,
@@ -345,7 +345,7 @@ impl<'a> SiphonableReader for ZBufReader<'a> {
 }
 
 #[cfg(feature = "std")]
-impl<'a> io::Read for ZBufReader<'a> {
+impl io::Read for ZBufReader<'_> {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         match <Self as Reader>::read(self, buf) {
             Ok(n) => Ok(n.get()),
@@ -354,7 +354,7 @@ impl<'a> io::Read for ZBufReader<'a> {
     }
 }
 
-impl<'a> AdvanceableReader for ZBufReader<'a> {
+impl AdvanceableReader for ZBufReader<'_> {
     fn skip(&mut self, offset: usize) -> Result<(), DidntRead> {
         let mut remaining_offset = offset;
         while remaining_offset > 0 {
@@ -399,7 +399,7 @@ impl<'a> AdvanceableReader for ZBufReader<'a> {
 }
 
 #[cfg(feature = "std")]
-impl<'a> io::Seek for ZBufReader<'a> {
+impl io::Seek for ZBufReader<'_> {
     fn seek(&mut self, pos: io::SeekFrom) -> io::Result<u64> {
         let current_pos = self
             .inner
@@ -570,7 +570,7 @@ impl BacktrackableWriter for ZBufWriter<'_> {
 }
 
 #[cfg(feature = "std")]
-impl<'a> io::Write for ZBufWriter<'a> {
+impl io::Write for ZBufWriter<'_> {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         if buf.is_empty() {
             return Ok(0);

commons/zenoh-collections/src/single_or_vec.rs

@@ -192,7 +192,7 @@ pub struct Drain<'a, T> {
     inner: DrainInner<'a, T>,
 }
 
-impl<'a, T> Iterator for Drain<'a, T> {
+impl<T> Iterator for Drain<'_, T> {
     type Item = T;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -209,7 +209,7 @@ impl<'a, T> Iterator for Drain<'a, T> {
         }
     }
 }
-impl<'a, T> Drop for Drain<'a, T> {
+impl<T> Drop for Drain<'_, T> {
     fn drop(&mut self) {
         if let DrainInner::Single(_) = self.inner {
             self.next();

commons/zenoh-keyexpr/src/key_expr/borrowed.rs

@@ -545,7 +545,7 @@ impl<'a> Iterator for Chunks<'a> {
         Some(unsafe { keyexpr::from_str_unchecked(next) })
     }
 }
-impl<'a> DoubleEndedIterator for Chunks<'a> {
+impl DoubleEndedIterator for Chunks<'_> {
     fn next_back(&mut self) -> Option<Self::Item> {
         if self.inner.is_empty() {
             return None;

commons/zenoh-keyexpr/src/key_expr/format/support.rs

@@ -50,7 +50,7 @@ impl<'a> TryFrom<&'a str> for Spec<'a> {
         }
     }
 }
-impl<'a> Spec<'a> {
+impl Spec<'_> {
     pub fn id(&self) -> &str {
         &self.spec[..self.id_end as usize]
     }

commons/zenoh-keyexpr/src/key_expr/utils.rs

@@ -16,7 +16,7 @@ pub struct Splitter<'a, S: ?Sized, D: ?Sized> {
     s: Option<&'a S>,
     d: &'a D,
 }
-impl<'a, S: ?Sized, D: ?Sized> Clone for Splitter<'a, S, D> {
+impl<S: ?Sized, D: ?Sized> Clone for Splitter<'_, S, D> {
     fn clone(&self) -> Self {
         Self {
             s: self.s,
@@ -84,7 +84,7 @@ impl<'a, S: Split<D> + ?Sized, D: ?Sized> Iterator for Splitter<'a, S, D> {
     }
 }
 
-impl<'a, S: Split<D> + ?Sized, D: ?Sized> DoubleEndedIterator for Splitter<'a, S, D> {
+impl<S: Split<D> + ?Sized, D: ?Sized> DoubleEndedIterator for Splitter<'_, S, D> {
     fn next_back(&mut self) -> Option<Self::Item> {
         match self.s {
             Some(s) => {

commons/zenoh-keyexpr/src/keyexpr_tree/traits/default_impls.rs

@@ -18,12 +18,12 @@ use token_cell::prelude::{TokenCell, TokenCellTrait, TokenTrait};
 
 use super::*;
 
-impl<'a, T: HasChunk> HasChunk for &'a T {
+impl<T: HasChunk> HasChunk for &T {
     fn chunk(&self) -> &keyexpr {
         T::chunk(self)
     }
 }
-impl<'a, T: HasChunk> HasChunk for &'a mut T {
+impl<T: HasChunk> HasChunk for &mut T {
     fn chunk(&self) -> &keyexpr {
         T::chunk(self)
     }

commons/zenoh-protocol/src/core/cowstr.rs

@@ -43,7 +43,7 @@ impl<'a> From<&'a str> for CowStr<'a> {
         CowStr::borrowed(value)
     }
 }
-impl<'a> From<String> for CowStr<'a> {
+impl From<String> for CowStr<'_> {
     fn from(s: String) -> Self {
         if s.is_empty() {
             CowStr::borrowed("")
@@ -70,7 +70,7 @@ impl core::ops::Deref for CowStr<'_> {
         }
     }
 }
-impl<'a> Clone for CowStr<'a> {
+impl Clone for CowStr<'_> {
     fn clone(&self) -> Self {
         self.as_str().to_owned().into()
     }

commons/zenoh-protocol/src/transport/close.rs

@@ -12,6 +12,36 @@
 //   ZettaScale Zenoh Team, <[email protected]>
 //
 
+pub mod flag {
+    pub const S: u8 = 1 << 5; // 0x20 Session close if S==1 close the whole session, close only the link otherwise
+                              // pub const X: u8 = 1 << 6; // 0x40       Reserved
+    pub const Z: u8 = 1 << 7; // 0x80 Extensions    if Z==1 then an extension will follow
+}
+
+// Reason for the Close message
+pub mod reason {
+    pub const GENERIC: u8 = 0x00;
+    pub const UNSUPPORTED: u8 = 0x01;
+    pub const INVALID: u8 = 0x02;
+    pub const MAX_SESSIONS: u8 = 0x03;
+    pub const MAX_LINKS: u8 = 0x04;
+    pub const EXPIRED: u8 = 0x05;
+    pub const UNRESPONSIVE: u8 = 0x06;
+}
+
+pub fn reason_to_str(reason: u8) -> &'static str {
+    match reason {
+        reason::GENERIC => "GENERIC",
+        reason::UNSUPPORTED => "UNSUPPORTED",
+        reason::INVALID => "INVALID",
+        reason::MAX_SESSIONS => "MAX_SESSIONS",
+        reason::MAX_LINKS => "MAX_LINKS",
+        reason::EXPIRED => "EXPIRED",
+        reason::UNRESPONSIVE => "UNRESPONSIVE",
+        _ => "UNKNOWN",
+    }
+}
+
 /// # Close message
 ///
 /// The [`Close`] message is sent in any of the following two cases:
@@ -50,37 +80,6 @@
 ///       the boundary of the serialized messages. The length is encoded as little-endian.
 ///       In any case, the length of a message must not exceed 65535 bytes.
 ///
-
-pub mod flag {
-    pub const S: u8 = 1 << 5; // 0x20 Session close if S==1 close the whole session, close only the link otherwise
-                              // pub const X: u8 = 1 << 6; // 0x40       Reserved
-    pub const Z: u8 = 1 << 7; // 0x80 Extensions    if Z==1 then an extension will follow
-}
-
-// Reason for the Close message
-pub mod reason {
-    pub const GENERIC: u8 = 0x00;
-    pub const UNSUPPORTED: u8 = 0x01;
-    pub const INVALID: u8 = 0x02;
-    pub const MAX_SESSIONS: u8 = 0x03;
-    pub const MAX_LINKS: u8 = 0x04;
-    pub const EXPIRED: u8 = 0x05;
-    pub const UNRESPONSIVE: u8 = 0x06;
-}
-
-pub fn reason_to_str(reason: u8) -> &'static str {
-    match reason {
-        reason::GENERIC => "GENERIC",
-        reason::UNSUPPORTED => "UNSUPPORTED",
-        reason::INVALID => "INVALID",
-        reason::MAX_SESSIONS => "MAX_SESSIONS",
-        reason::MAX_LINKS => "MAX_LINKS",
-        reason::EXPIRED => "EXPIRED",
-        reason::UNRESPONSIVE => "UNRESPONSIVE",
-        _ => "UNKNOWN",
-    }
-}
-
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Close {
     pub reason: u8,

commons/zenoh-protocol/src/transport/fragment.rs

@@ -16,6 +16,12 @@ use zenoh_buffers::ZSlice;
 use crate::core::Reliability;
 pub use crate::transport::TransportSn;
 
+pub mod flag {
+    pub const R: u8 = 1 << 5; // 0x20 Reliable      if R==1 then the frame is reliable
+    pub const M: u8 = 1 << 6; // 0x40 More          if M==1 then another fragment will follow
+    pub const Z: u8 = 1 << 7; // 0x80 Extensions    if Z==1 then an extension will follow
+}
+
 /// # Fragment message
 ///
 /// The [`Fragment`] message is used to transmit on the wire large [`crate::network::NetworkMessage`]
@@ -62,12 +68,6 @@ pub use crate::transport::TransportSn;
 ///       the boundary of the serialized messages. The length is encoded as little-endian.
 ///       In any case, the length of a message must not exceed 65535 bytes.
 ///
-pub mod flag {
-    pub const R: u8 = 1 << 5; // 0x20 Reliable      if R==1 then the frame is reliable
-    pub const M: u8 = 1 << 6; // 0x40 More          if M==1 then another fragment will follow
-    pub const Z: u8 = 1 << 7; // 0x80 Extensions    if Z==1 then an extension will follow
-}
-
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Fragment {
     pub reliability: Reliability,

commons/zenoh-protocol/src/transport/frame.rs

@@ -15,6 +15,12 @@ use alloc::vec::Vec;
 
 use crate::{core::Reliability, network::NetworkMessage, transport::TransportSn};
 
+pub mod flag {
+    pub const R: u8 = 1 << 5; // 0x20 Reliable      if R==1 then the frame is reliable
+                              // pub const X: u8 = 1 << 6; // 0x40       Reserved
+    pub const Z: u8 = 1 << 7; // 0x80 Extensions    if Z==1 then an extension will follow
+}
+
 /// # Frame message
 ///
 /// The [`Frame`] message is used to transmit one ore more complete serialized
@@ -61,12 +67,6 @@ use crate::{core::Reliability, network::NetworkMessage, transport::TransportSn};
 ///       the boundary of the serialized messages. The length is encoded as little-endian.
 ///       In any case, the length of a message must not exceed 65535 bytes.
 ///
-pub mod flag {
-    pub const R: u8 = 1 << 5; // 0x20 Reliable      if R==1 then the frame is reliable
-                              // pub const X: u8 = 1 << 6; // 0x40       Reserved
-    pub const Z: u8 = 1 << 7; // 0x80 Extensions    if Z==1 then an extension will follow
-}
-
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Frame {
     pub reliability: Reliability,