Reformatted.

Author: horned-sphere

server/swimos_agent/src/agent_lifecycle/utility/mod.rs

@@ -44,7 +44,7 @@ use crate::event_handler::{
 };
 use crate::event_handler::{GetAgentUri, HandlerAction, SideEffect};
 use crate::item::{
-    InspectableMapLikeItem, MapLikeItem, MutableMapLikeItem, MutableValueLikeItem, ValueLikeItem
+    InspectableMapLikeItem, MapLikeItem, MutableMapLikeItem, MutableValueLikeItem, ValueLikeItem,
 };
 use crate::lanes::command::{CommandLane, DoCommand};
 use crate::lanes::demand::{Cue, DemandLane};
@@ -186,7 +186,7 @@ impl<Agent: 'static> HandlerContext<Agent> {
     }
 
     /// Create an event handler that will transform the value of a value lane or store of the agent.
-    /// 
+    ///
     /// #Arguments
     /// * `item` - Projection to the value lane or store.
     /// * `f` - A closure that produces a new value from a reference to the existing value.
@@ -207,7 +207,7 @@ impl<Agent: 'static> HandlerContext<Agent> {
 
     /// Create an event handler that will inspect the value of a value lane or store and generate a result from it.
     /// This differs from using [`Self::get_value`] in that it does not require a clone to be made of the existing value.
-    /// 
+    ///
     /// #Arguments
     /// * `item` - Projection to the value lane or store.
     /// * `f` - A closure that produces a value from a reference to the current value of the item.
@@ -257,10 +257,10 @@ impl<Agent: 'static> HandlerContext<Agent> {
         &self,
         item: fn(&Agent) -> &Item,
         key: K,
-        f: F
+        f: F,
     ) -> impl HandlerAction<Agent, Completion = U> + Send + 'a
     where
-        Agent: 'static, 
+        Agent: 'static,
         Item: InspectableMapLikeItem<K, V> + 'static,
         K: Send + Clone + Eq + Hash + 'static,
         V: Borrow<B> + 'static,
@@ -270,7 +270,6 @@ impl<Agent: 'static> HandlerContext<Agent> {
         Item::with_entry_handler::<Agent, F, B, U>(item, key, f)
     }
 
-
     /// Create an event handler that will transform the value in an entry of a map lane or store of the agent.
     /// If map contains an entry with that key, it will be updated (or removed) based on the result of the calling
     /// the closure on it. If the map does not contain an entry with that key, the closure will be called with [`None`]
@@ -775,7 +774,6 @@ impl<Agent: 'static> HandlerContext<Agent> {
     pub fn stop(&self) -> impl EventHandler<Agent> + Send + 'static {
         HandlerActionExt::<Agent>::discard(Stop)
     }
-
 }
 
 pub struct JoinValueContext<Agent, K, V> {

server/swimos_agent/src/item.rs

@@ -145,5 +145,4 @@ pub trait MutableValueLikeItem<T> {
         C: 'static;
 
     fn set_handler<C: 'static>(projection: fn(&C) -> &Self, value: T) -> Self::SetHandler<C>;
-
 }

server/swimos_agent/src/lanes/join/map/mod.rs

@@ -17,7 +17,8 @@ use std::{
     borrow::Borrow,
     cell::RefCell,
     collections::{hash_map::Entry, BTreeSet, HashMap, HashSet},
-    hash::Hash, marker::PhantomData,
+    hash::Hash,
+    marker::PhantomData,
 };
 
 use bytes::BytesMut;
@@ -674,9 +675,7 @@ pub struct JoinMapLaneWithEntry<C, L, K, V, F, B: ?Sized> {
 }
 
 impl<C, L, K, V, F, B: ?Sized> JoinMapLaneWithEntry<C, L, K, V, F, B> {
-
-    pub fn new(projection: for<'a> fn(&'a C) -> &'a JoinMapLane<L, K, V>,
-    key: K, f: F) -> Self {
+    pub fn new(projection: for<'a> fn(&'a C) -> &'a JoinMapLane<L, K, V>, key: K, f: F) -> Self {
         JoinMapLaneWithEntry {
             projection,
             key,
@@ -758,7 +757,8 @@ where
         C: 'a,
         B: ?Sized + 'static,
         V: Borrow<B>,
-        F: FnOnce(Option<&B>) -> U + Send + 'a {
+        F: FnOnce(Option<&B>) -> U + Send + 'a,
+    {
         JoinMapLaneWithEntry::new(projection, key, f)
     }
-}
+}

server/swimos_agent/src/lanes/join/map/tests.rs

@@ -332,7 +332,8 @@ fn join_map_lane_with_entry_event_handler() {
     let meta = make_meta(&uri, &route_params);
     let agent = TestAgent::with_init();
 
-    let mut handler = JoinMapLaneWithEntry::new(TestAgent::LANE, K1, |v: Option<&str>| v.map(str::to_owned));
+    let mut handler =
+        JoinMapLaneWithEntry::new(TestAgent::LANE, K1, |v: Option<&str>| v.map(str::to_owned));
 
     let result = handler.step(
         &mut dummy_context(&mut HashMap::new(), &mut BytesMut::new()),
@@ -351,7 +352,9 @@ fn join_map_lane_with_entry_event_handler() {
         StepResult::Fail(EventHandlerError::SteppedAfterComplete)
     ));
 
-    let mut handler = JoinMapLaneWithEntry::new(TestAgent::LANE, ABSENT, |v: Option<&str>| v.map(str::to_owned));
+    let mut handler = JoinMapLaneWithEntry::new(TestAgent::LANE, ABSENT, |v: Option<&str>| {
+        v.map(str::to_owned)
+    });
 
     let result = handler.step(
         &mut dummy_context(&mut HashMap::new(), &mut BytesMut::new()),

server/swimos_agent/src/lanes/join/value/mod.rs

@@ -436,9 +436,7 @@ pub struct JoinValueLaneWithEntry<C, K, V, F, B: ?Sized> {
 }
 
 impl<C, K, V, F, B: ?Sized> JoinValueLaneWithEntry<C, K, V, F, B> {
-
-    pub fn new(projection: for<'a> fn(&'a C) -> &'a JoinValueLane<K, V>,
-    key: K, f: F) -> Self {
+    pub fn new(projection: for<'a> fn(&'a C) -> &'a JoinValueLane<K, V>, key: K, f: F) -> Self {
         JoinValueLaneWithEntry {
             projection,
             key,
@@ -473,7 +471,6 @@ where
     }
 }
 
-
 impl<K, V> MapLikeItem<K, V> for JoinValueLane<K, V>
 where
     K: Clone + Eq + Hash + Send + 'static,
@@ -519,7 +516,8 @@ where
         C: 'a,
         B: ?Sized + 'static,
         V: Borrow<B>,
-        F: FnOnce(Option<&B>) -> U + Send + 'a {
+        F: FnOnce(Option<&B>) -> U + Send + 'a,
+    {
         JoinValueLaneWithEntry::new(projection, key, f)
     }
-}
+}

server/swimos_agent/src/lanes/join/value/tests.rs

@@ -195,7 +195,8 @@ fn join_value_lane_with_entry_event_handler() {
     let meta = make_meta(&uri, &route_params);
     let agent = TestAgent::with_init();
 
-    let mut handler = JoinValueLaneWithEntry::new(TestAgent::LANE, K1, |v: Option<&str>| v.map(str::to_owned));
+    let mut handler =
+        JoinValueLaneWithEntry::new(TestAgent::LANE, K1, |v: Option<&str>| v.map(str::to_owned));
 
     let result = handler.step(
         &mut dummy_context(&mut HashMap::new(), &mut BytesMut::new()),
@@ -214,7 +215,9 @@ fn join_value_lane_with_entry_event_handler() {
         StepResult::Fail(EventHandlerError::SteppedAfterComplete)
     ));
 
-    let mut handler = JoinValueLaneWithEntry::new(TestAgent::LANE, ABSENT, |v: Option<&str>| v.map(str::to_owned));
+    let mut handler = JoinValueLaneWithEntry::new(TestAgent::LANE, ABSENT, |v: Option<&str>| {
+        v.map(str::to_owned)
+    });
 
     let result = handler.step(
         &mut dummy_context(&mut HashMap::new(), &mut BytesMut::new()),

server/swimos_agent/src/lanes/map/mod.rs

@@ -150,7 +150,6 @@ impl<K, V> MapLane<K, V>
 where
     K: Eq + Hash,
 {
-   
     pub fn with_entry<F, B, U>(&self, key: &K, f: F) -> U
     where
         B: ?Sized,
@@ -159,7 +158,6 @@ where
     {
         self.inner.borrow().with_entry(key, f)
     }
-
 }
 
 const INFALLIBLE_SER: &str = "Serializing lane responses to recon should be infallible.";
@@ -670,7 +668,7 @@ where
         B: ?Sized +'static,
         V: Borrow<B>,
         F: FnOnce(Option<&B>) -> U + Send + 'a;
-    
+
     fn with_entry_handler<'a, C, F, B, U>(
         projection: fn(&C) -> &Self,
         key: K,
@@ -679,9 +677,10 @@ where
     where
         Self: 'static,
         C: 'a,
-        B: ?Sized +'static,
+        B: ?Sized + 'static,
         V: Borrow<B>,
-        F: FnOnce(Option<&B>) -> U + Send + 'a {
+        F: FnOnce(Option<&B>) -> U + Send + 'a,
+    {
         MapLaneWithEntry::new(projection, key, f)
     }
 }
@@ -718,13 +717,13 @@ where
     fn clear_handler<C: 'static>(projection: fn(&C) -> &Self) -> Self::ClearHandler<C> {
         MapLaneClear::new(projection)
     }
-    
+
     type TransformEntryHandler<'a, C, F> = MapLaneTransformEntry<C, K, V, F>
     where
         Self: 'static,
         C: 'a,
         F: FnOnce(Option<&V>) -> Option<V> + Send + 'a;
-    
+
     fn transform_entry_handler<'a, C, F>(
         projection: fn(&C) -> &Self,
         key: K,
@@ -733,8 +732,8 @@ where
     where
         Self: 'static,
         C: 'a,
-        F: FnOnce(Option<&V>) -> Option<V> + Send + 'a {
-            MapLaneTransformEntry::new(projection, key, f)
+        F: FnOnce(Option<&V>) -> Option<V> + Send + 'a,
+    {
+        MapLaneTransformEntry::new(projection, key, f)
     }
-
 }

server/swimos_agent/src/lanes/map/tests.rs

@@ -37,7 +37,7 @@ use crate::{
     lanes::{
         map::{
             MapLane, MapLaneClear, MapLaneEvent, MapLaneGet, MapLaneGetMap, MapLaneRemove,
-            MapLaneSync, MapLaneUpdate, MapLaneTransformEntry,
+            MapLaneSync, MapLaneTransformEntry, MapLaneUpdate,
         },
         LaneItem,
     },
@@ -824,7 +824,9 @@ fn map_lane_with_entry_handler_absent() {
     let meta = make_meta(&uri, &route_params);
     let agent = TestAgent::with_init();
 
-    let mut handler = MapLaneWithEntry::new(TestAgent::LANE, ABSENT, |maybe_v: Option<&str>| maybe_v.map(str::to_owned));
+    let mut handler = MapLaneWithEntry::new(TestAgent::LANE, ABSENT, |maybe_v: Option<&str>| {
+        maybe_v.map(str::to_owned)
+    });
 
     let result = handler.step(
         &mut dummy_context(&mut HashMap::new(), &mut BytesMut::new()),
@@ -841,12 +843,14 @@ fn map_lane_with_entry_handler_present() {
     let meta = make_meta(&uri, &route_params);
     let agent = TestAgent::with_init();
 
-    let mut handler = MapLaneWithEntry::new(TestAgent::LANE, K1, |maybe_v: Option<&str>| maybe_v.map(str::to_owned));
+    let mut handler = MapLaneWithEntry::new(TestAgent::LANE, K1, |maybe_v: Option<&str>| {
+        maybe_v.map(str::to_owned)
+    });
 
     let result = handler.step(
         &mut dummy_context(&mut HashMap::new(), &mut BytesMut::new()),
         meta,
         &agent,
     );
     check_result(result, false, false, Some(Some(V1.to_owned())));
-}
+}

server/swimos_agent/src/lanes/value/mod.rs

@@ -274,17 +274,19 @@ impl<C, T> HandlerAction<C> for ValueLaneSync<C, T> {
     }
 }
 
-pub struct ValueLaneWithValue<C, T, F,  B: ?Sized> {
+pub struct ValueLaneWithValue<C, T, F, B: ?Sized> {
     projection: for<'a> fn(&'a C) -> &'a ValueLane<T>,
     f: Option<F>,
     _type: PhantomData<fn(&B)>,
 }
 
-impl<C, T, F,  B: ?Sized,> ValueLaneWithValue<C, T, F, B> {
-
-    pub fn new(projection: for<'a> fn(&'a C) -> &'a ValueLane<T>,
-    f: F) -> Self {
-        ValueLaneWithValue { projection, f: Some(f), _type: PhantomData }
+impl<C, T, F, B: ?Sized> ValueLaneWithValue<C, T, F, B> {
+    pub fn new(projection: for<'a> fn(&'a C) -> &'a ValueLane<T>, f: F) -> Self {
+        ValueLaneWithValue {
+            projection,
+            f: Some(f),
+            _type: PhantomData,
+        }
     }
 }
 
@@ -377,5 +379,4 @@ where
     fn set_handler<C: 'static>(projection: fn(&C) -> &Self, value: T) -> Self::SetHandler<C> {
         ValueLaneSet::new(projection, value)
     }
-
 }

server/swimos_agent/src/lanes/value/tests.rs

@@ -287,7 +287,7 @@ impl Default for TestAgent {
     fn default() -> Self {
         Self {
             lane: ValueLane::new(LANE_ID, 0),
-            str_lane: ValueLane::new(STR_LANE_ID, "hello".to_string())
+            str_lane: ValueLane::new(STR_LANE_ID, "hello".to_string()),
         }
     }
 }
@@ -478,5 +478,4 @@ fn value_lane_with_value_event_handler() {
         result,
         StepResult::Fail(EventHandlerError::SteppedAfterComplete)
     ));
-
 }