chore(clippy): resolve clippy warnings

Author: mbehr1

src/bin/adlt/main.rs

@@ -55,20 +55,18 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         o!("version"=>clap::crate_version!(), "log_level"=>format!("{}",min_log_level)),
     );
 
-    return match matches.subcommand() {
+    match matches.subcommand() {
         Some(("convert", sub_m)) => {
             convert::convert(&log, sub_m, std::io::BufWriter::new(std::io::stdout()))
                 .map_err(|e| e.into())
                 .map(|_x| ())
         } // dont return anything here
         Some(("remote", sub_m)) => remote::remote(&log, sub_m, false),
-        _ => {
-            return Err(Box::new(io::Error::new(
-                io::ErrorKind::Unsupported,
-                "unknown subcommand",
-            )));
-        }
-    };
+        _ => Err(Box::new(io::Error::new(
+            io::ErrorKind::Unsupported,
+            "unknown subcommand",
+        ))),
+    }
     // return Ok(());
     /*
     let input_file_name = matches.value_of("file").unwrap();

src/bin/adlt/remote.rs

@@ -615,7 +615,6 @@ fn file_names_to_file_streams(
 ///   - change the window for an existing stream
 /// - `plugin_cmd`
 ///   - execute a command for a plugin (e.g. FileTransfer save file)
-
 fn process_incoming_text_message<T: Read + Write>(
     log: &slog::Logger,
     t: String,
@@ -2699,7 +2698,6 @@ mod tests {
     /// test a remote "open" command with 'collect:"one_pass_streams"' that can be used to
     /// use streams that cannot be seeked, searched,... but no messages are collected
     /// so it has little memory usage and is used e.g. by fba-cli to execute once all fishbone queries
-
     fn process_file_context_one_pass_streams() {
         let log = new_logger();
         let port = pick_unused_port().expect("no ports free");

src/serde_verb_payload/ser_verb_payload.rs

@@ -57,7 +57,7 @@ macro_rules! dlt_args {
     };
 }
 
-impl<'a> ser::Serializer for &'a mut Serializer {
+impl ser::Serializer for &mut Serializer {
     // The output type produced by this `Serializer` during successful
     // serialization. Most serializers that produce text or binary output should
     // set `Ok = ()` and serialize into an `io::Write` or buffer contained
@@ -335,7 +335,7 @@ impl<'a> ser::Serializer for &'a mut Serializer {
 //
 // This impl is SerializeSeq so these methods are called after `serialize_seq`
 // is called on the Serializer.
-impl<'a> ser::SerializeSeq for &'a mut Serializer {
+impl ser::SerializeSeq for &mut Serializer {
     // Must match the `Ok` type of the serializer.
     type Ok = ();
     // Must match the `Error` type of the serializer.
@@ -360,7 +360,7 @@ impl<'a> ser::SerializeSeq for &'a mut Serializer {
 }
 
 // Same thing but for tuples.
-impl<'a> ser::SerializeTuple for &'a mut Serializer {
+impl ser::SerializeTuple for &mut Serializer {
     type Ok = ();
     type Error = Error;
 
@@ -381,7 +381,7 @@ impl<'a> ser::SerializeTuple for &'a mut Serializer {
 }
 
 // Same thing but for tuple structs.
-impl<'a> ser::SerializeTupleStruct for &'a mut Serializer {
+impl ser::SerializeTupleStruct for &mut Serializer {
     type Ok = ();
     type Error = Error;
 
@@ -410,7 +410,7 @@ impl<'a> ser::SerializeTupleStruct for &'a mut Serializer {
 //
 // So the `end` method in this impl is responsible for closing both the `]` and
 // the `}`.
-impl<'a> ser::SerializeTupleVariant for &'a mut Serializer {
+impl ser::SerializeTupleVariant for &mut Serializer {
     type Ok = ();
     type Error = Error;
 
@@ -438,7 +438,7 @@ impl<'a> ser::SerializeTupleVariant for &'a mut Serializer {
 // `serialize_entry` method allows serializers to optimize for the case where
 // key and value are both available simultaneously. In JSON it doesn't make a
 // difference so the default behavior for `serialize_entry` is fine.
-impl<'a> ser::SerializeMap for &'a mut Serializer {
+impl ser::SerializeMap for &mut Serializer {
     type Ok = ();
     type Error = Error;
 
@@ -479,7 +479,7 @@ impl<'a> ser::SerializeMap for &'a mut Serializer {
 
 // Structs are like maps in which the keys are constrained to be compile-time
 // constant strings.
-impl<'a> ser::SerializeStruct for &'a mut Serializer {
+impl ser::SerializeStruct for &mut Serializer {
     type Ok = ();
     type Error = Error;
 
@@ -501,7 +501,7 @@ impl<'a> ser::SerializeStruct for &'a mut Serializer {
     }
 }
 
-impl<'a> ser::SerializeStructVariant for &'a mut Serializer {
+impl ser::SerializeStructVariant for &mut Serializer {
     type Ok = ();
     type Error = Error;
 

src/utils/asc2dltmsgiterator.rs

@@ -224,7 +224,7 @@ fn parse_signed_time_str(timestamp: &str) -> i64 {
     }
 }
 
-impl<'a, R> Iterator for Asc2DltMsgIterator<'a, R>
+impl<R> Iterator for Asc2DltMsgIterator<'_, R>
 where
     R: BufRead,
 {

src/utils/blf2dltmsgiterator.rs

@@ -330,7 +330,7 @@ impl<'a, R: BufRead + Seek> BLF2DltMsgIterator<'a, R> {
     }
 }
 
-impl<'a, R> Iterator for BLF2DltMsgIterator<'a, R>
+impl<R> Iterator for BLF2DltMsgIterator<'_, R>
 where
     R: BufRead + Seek,
 {

src/utils/dltmessageiterator.rs

@@ -30,7 +30,7 @@ impl<'a, R> DltMessageIterator<'a, R> {
     }
 }
 
-impl<'a, R> Iterator for DltMessageIterator<'a, R>
+impl<R> Iterator for DltMessageIterator<'_, R>
 where
     R: BufRead,
 {

src/utils/genlog2dltmsgiterator.rs

@@ -18,7 +18,6 @@ use std::{
 /// a reader/parser for generic (text) log files to DLT msgs
 ///
 /// Needed: an absolute timestamp, a log level, a tag and a log message
-
 pub struct GenLog2DltMsgIterator<'a, R> {
     lines: Lines<R>,
     pub index: DltMessageIndexType,
@@ -190,7 +189,7 @@ impl<'a, R: BufRead> GenLog2DltMsgIterator<'a, R> {
     }
 }
 
-impl<'a, R: BufRead> Iterator for GenLog2DltMsgIterator<'a, R> {
+impl<R: BufRead> Iterator for GenLog2DltMsgIterator<'_, R> {
     type Item = DltMessage;
     fn next(&mut self) -> Option<Self::Item> {
         if let Some(msg) = self.msgs_deque.pop_front() {

src/utils/logcat2dltmsgiterator.rs

@@ -291,7 +291,7 @@ lazy_static! {
 
 }
 
-impl<'a, R> Iterator for LogCat2DltMsgIterator<'a, R>
+impl<R> Iterator for LogCat2DltMsgIterator<'_, R>
 where
     R: BufRead,
 {

src/utils/mod.rs

@@ -282,7 +282,6 @@ pub struct DltFileInfos {
 /// assert!(dfi.first_msg.is_some());
 /// assert!(dfi.ecus_seen.contains(&DltChar4::from_buf(b"CAN1")));
 /// ```
-
 pub fn get_dlt_infos_from_file(
     file_ext: &str,
     file: &mut std::fs::File,

src/utils/sorting_multi_readeriterator.rs

@@ -7,24 +7,24 @@ struct MinHeapEntry<'a> {
     it: Box<dyn Iterator<Item = DltMessage> + 'a>,
 }
 
-impl<'a> Ord for MinHeapEntry<'a> {
+impl Ord for MinHeapEntry<'_> {
     fn cmp(&self, other: &Self) -> Ordering {
         // self.m.reception_time_us.cmp(&other.m.reception_time_us) // regular, we do need reverse
         other.m.reception_time_us.cmp(&self.m.reception_time_us) // reversed
     }
 }
 
-impl<'a> PartialOrd for MinHeapEntry<'a> {
+impl PartialOrd for MinHeapEntry<'_> {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         Some(self.cmp(other))
     }
 }
-impl<'a> PartialEq for MinHeapEntry<'a> {
+impl PartialEq for MinHeapEntry<'_> {
     fn eq(&self, other: &Self) -> bool {
         self.m.reception_time_us == other.m.reception_time_us
     }
 }
-impl<'a> Eq for MinHeapEntry<'a> {}
+impl Eq for MinHeapEntry<'_> {}
 
 /// Iterator that processes other iterators in "parallel"
 /// i.e. it merges the msgs by reception time.
@@ -74,7 +74,7 @@ impl<'a> SortingMultiReaderIterator<'a> {
     }
 }
 
-impl<'a> Iterator for SortingMultiReaderIterator<'a> {
+impl Iterator for SortingMultiReaderIterator<'_> {
     type Item = DltMessage;
     fn next(&mut self) -> Option<Self::Item> {
         let heap_entry = self.min_heap.pop();