Clippy pass.

fleck/src/msg.rs

@@ -4,6 +4,7 @@ use std::{
 };
 
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
+use std::collections::HashMap;
 
 const MESSAGE_MAGIC: u64 = 0x1234123412341234;
 
@@ -30,8 +31,9 @@ impl Message {
     }
 }
 
+type Deserializer = dyn Fn(&[u8]) -> Option<Box<dyn std::any::Any>>;
 pub(crate) struct MessageRegistry {
-    deser: std::collections::HashMap<u16, Box<dyn Fn(&[u8]) -> Option<Box<dyn std::any::Any>>>>,
+    deser: HashMap<u16, Box<Deserializer>>,
 }
 
 pub trait MessageParams {
@@ -53,8 +55,7 @@ impl MessageRegistry {
         self.deser.insert(
             derived_typeid,
             Box::new(|data| {
-                let r = bincode::deserialize(data).ok()?;
-                let boxed: Box<dyn Any> = Box::new(r);
+                let boxed: Box<dyn Any> = Box::new(bincode::deserialize(data).ok()?);
                 Some(boxed)
             }),
         );

fleck/src/service.rs

@@ -122,7 +122,6 @@ impl ServiceStack {
         self.incoming_cache = None;
         self.outgoing_cache = None;
 
-        self.services.push(srv.clone());
         if !<<S as IncomingPriority>::Priority as AbstractServicePriority>::NEVER {
             self.incoming_order
                 .add_priority::<<S as IncomingPriority>::Priority>(srv.clone());
@@ -131,6 +130,7 @@ impl ServiceStack {
             self.incoming_order
                 .add_priority::<<S as OutgoingPriority>::Priority>(srv.clone());
         }
+        self.services.push(srv);
     }
 }
 
@@ -179,22 +179,3 @@ impl Service for ServiceStack {
         }
     }
 }
-/*
-
-    pub(crate) fn process<SP: FnMut(&mut dyn Service, &dyn API) -> ()>(&mut self, mut sp: SP) {
-    }
-
-    pub(crate) fn process_reverse<SP: FnMut(&mut dyn Service, &dyn API) -> ()>(
-        &mut self,
-        mut sp: SP,
-    ) {
-        let services = self.incoming_cache.get_or_insert_with(|| {
-            self.incoming_order.clone().order()
-        });
-
-        for srv in self.services.iter_mut().rev() {
-            sp(srv.as_ref().borrow_mut().deref_mut(), self.api.as_ref().unwrap().as_ref());
-        }
-    }
-}
-*/

fleck/src/service/lowlevel.rs

@@ -1,4 +1,4 @@
-use super::{order, priority, IncomingPriority, Never, OutgoingPriority, Priority, Service, API};
+use super::{order, Priority, Service, API};
 use crate::io::Packet;
 
 use crate as fleck;
@@ -19,11 +19,8 @@ impl Service for SendPacket {
         }
 
         // serialize if needed
-        match (packet.data.as_ref().is_some(), packet.msg.take()) {
-            (false, Some(msg)) => {
-                packet.data = Some(bincode::serialize(&msg).expect("failed to serialize message"));
-            }
-            _ => {}
+        if let (false, Some(msg)) = (packet.data.as_ref().is_some(), packet.msg.take()) {
+            packet.data = Some(bincode::serialize(&msg).expect("failed to serialize message"));
         }
 
         match &mut packet.channel {
@@ -47,7 +44,7 @@ impl LocalDiscovery {
 impl Service for LocalDiscovery {
     fn process_major_tick(&mut self, api: &dyn API) {
         api.send_packet(Packet {
-            addr: Some(crate::io::MULTICAST_ADDRESS.clone().into()),
+            addr: Some((*crate::io::MULTICAST_ADDRESS).into()),
             data: None,
             channel: Some(api.raw_io().local().clone()),
             msg: Some(crate::msg::Message::build(crate::msg::HeaderType::Hello)),

fleck/src/service/priority.rs

@@ -36,7 +36,9 @@ pub struct Never;
 pub struct MaxTag;
 pub struct MinTag;
 
+#[allow(unused)]
 pub type MinPriority = Fixpoint<MinTag>;
+#[allow(unused)]
 pub type MaxPriority = Fixpoint<MaxTag>;
 
 pub struct Fixpoint<Tag: 'static> {
@@ -104,11 +106,11 @@ impl<Assoc: Clone> TotalOrder<Assoc> {
         let before_id = TypeId::of::<SP::Before>();
         self.nodes
             .entry(tid)
-            .or_insert_with(|| Default::default())
+            .or_insert_with(Default::default)
             .insert(after_id);
         self.nodes
             .entry(before_id)
-            .or_insert_with(|| Default::default())
+            .or_insert_with(Default::default)
             .insert(tid);
 
         // if we're not at an internal node, continue
@@ -128,7 +130,7 @@ impl<Assoc: Clone> TotalOrder<Assoc> {
         let tid = TypeId::of::<SP>();
         self.associated
             .entry(tid)
-            .or_insert_with(|| vec![])
+            .or_insert_with(Vec::new)
             .push(assoc.clone());
 
         let mut visited = VisitedSet::default();
@@ -162,14 +164,13 @@ impl<Assoc: Clone> TotalOrder<Assoc> {
         let mut tid_order = vec![];
         while tsort.pop().map(|tid| tid_order.push(tid)).is_some() {}
         // we expect there to be two items left in the tsort: MaxPriority and Never
-        if tsort.len() != 0 {
+        if !tsort.is_empty()  {
             panic!("Circular dependency detected! tsort: {:?}", tsort);
         }
 
         tid_order
             .iter()
-            .map(|tid| self.associated.remove(tid))
-            .flatten()
+            .flat_map(|tid| self.associated.remove(tid))
             .flatten()
             .map(|a| a.unwrap())
             .collect()