Added with_entry combinator for JoinMapLane.

Author: horned-sphere

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

@@ -17,7 +17,7 @@ use std::{
     borrow::Borrow,
     cell::RefCell,
     collections::{hash_map::Entry, BTreeSet, HashMap, HashSet},
-    hash::Hash,
+    hash::Hash, marker::PhantomData,
 };
 
 use bytes::BytesMut;
@@ -32,7 +32,7 @@ use crate::{
     event_handler::{
         ActionContext, EventHandler, EventHandlerError, HandlerAction, Modification, StepResult,
     },
-    item::{AgentItem, MapItem, MapLikeItem},
+    item::{AgentItem, InspectableMapLikeItem, MapItem, MapLikeItem},
     lanes::{
         join_map::default_lifecycle::DefaultJoinMapLifecycle, map::MapLaneEvent, LaneItem, MapLane,
     },
@@ -666,6 +666,51 @@ where
     }
 }
 
+pub struct JoinMapLaneWithEntry<C, L, K, V, F, B: ?Sized> {
+    projection: for<'a> fn(&'a C) -> &'a JoinMapLane<L, K, V>,
+    key: K,
+    f: Option<F>,
+    _type: PhantomData<fn(&B)>,
+}
+
+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 {
+        JoinMapLaneWithEntry {
+            projection,
+            key,
+            f: Some(f),
+            _type: PhantomData,
+        }
+    }
+}
+
+impl<'a, C, L, K, V, F, B, U> HandlerAction<C> for JoinMapLaneWithEntry<C, L, K, V, F, B>
+where
+    K: Eq + Hash + 'static,
+    C: 'a,
+    B: ?Sized + 'static,
+    V: Borrow<B>,
+    F: FnOnce(Option<&B>) -> U + Send + 'a,
+{
+    type Completion = U;
+
+    fn step(
+        &mut self,
+        _action_context: &mut ActionContext<C>,
+        _meta: AgentMetadata,
+        context: &C,
+    ) -> StepResult<Self::Completion> {
+        if let Some(f) = self.f.take() {
+            let item = (self.projection)(context);
+            StepResult::done(item.inner.with_entry(&self.key, f))
+        } else {
+            StepResult::after_done()
+        }
+    }
+}
+
 impl<L, K, V> MapLikeItem<K, V> for JoinMapLane<L, K, V>
 where
     L: Send + 'static,
@@ -688,3 +733,32 @@ where
         JoinMapLaneGetMap::new(projection)
     }
 }
+
+impl<L, K, V> InspectableMapLikeItem<K, V> for JoinMapLane<L, K, V>
+where
+    L: Send + 'static,
+    K: Clone + Eq + Hash + Send + 'static,
+    V: Send + 'static,
+{
+    type WithEntryHandler<'a, C, F, B, U> = JoinMapLaneWithEntry<C, L, K, V, F, B>
+    where
+        Self: 'static,
+        C: 'a,
+        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,
+        f: F,
+    ) -> Self::WithEntryHandler<'a, C, F, B, U>
+    where
+        Self: 'static,
+        C: 'a,
+        B: ?Sized + 'static,
+        V: Borrow<B>,
+        F: FnOnce(Option<&B>) -> U + Send + 'a {
+        JoinMapLaneWithEntry::new(projection, key, f)
+    }
+}

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

@@ -31,7 +31,7 @@ use crate::item::AgentItem;
 use crate::lanes::join::test_util::{TestDlContextInner, TestDownlinkContext};
 use crate::lanes::join_map::default_lifecycle::DefaultJoinMapLifecycle;
 use crate::lanes::join_map::{
-    AddDownlinkAction, JoinMapAddDownlink, JoinMapLaneGet, JoinMapLaneGetMap,
+    AddDownlinkAction, JoinMapAddDownlink, JoinMapLaneGet, JoinMapLaneGetMap, JoinMapLaneWithEntry,
 };
 use crate::test_context::{dummy_context, run_event_handlers, run_with_futures};
 use crate::{event_handler::StepResult, item::MapItem, meta::AgentMetadata};
@@ -324,3 +324,49 @@ async fn open_downlink_from_registered() {
 
     assert_eq!(count.load(Ordering::Relaxed), 1);
 }
+
+#[test]
+fn join_map_lane_with_entry_event_handler() {
+    let uri = make_uri();
+    let route_params = HashMap::new();
+    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 result = handler.step(
+        &mut dummy_context(&mut HashMap::new(), &mut BytesMut::new()),
+        meta,
+        &agent,
+    );
+    check_result(result, false, false, Some(Some(V1.to_string())));
+
+    let result = handler.step(
+        &mut dummy_context(&mut HashMap::new(), &mut BytesMut::new()),
+        meta,
+        &agent,
+    );
+    assert!(matches!(
+        result,
+        StepResult::Fail(EventHandlerError::SteppedAfterComplete)
+    ));
+
+    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()),
+        meta,
+        &agent,
+    );
+    check_result(result, false, false, Some(None));
+
+    let result = handler.step(
+        &mut dummy_context(&mut HashMap::new(), &mut BytesMut::new()),
+        meta,
+        &agent,
+    );
+    assert!(matches!(
+        result,
+        StepResult::Fail(EventHandlerError::SteppedAfterComplete)
+    ));
+}

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

@@ -428,7 +428,6 @@ impl<C, K, V> JoinValueAddDownlink<C, K, V> {
     }
 }
 
-
 pub struct JoinValueLaneWithEntry<C, K, V, F, B: ?Sized> {
     projection: for<'a> fn(&'a C) -> &'a JoinValueLane<K, V>,
     key: K,