wip

Author: togglebyte

anathema-state/src/value/list.rs

@@ -107,6 +107,33 @@ impl<T: State> Value<List<T>> {
         });
     }
 
+    /// Return all values matching the predicate.
+    ///
+    /// Note that unlike `Vec::extract_if`, this will allocate a vector for the result
+    pub fn extract_if<F>(&mut self, mut f: F) -> Vec<Value<T>>
+    where
+        F: FnMut(&Value<T>) -> bool,
+    {
+        let key = self.key;
+        self.with_mut(|List { inner: list, .. }| {
+            let mut extraction = vec![];
+
+            let mut del = 0;
+
+            for i in 0..list.len() {
+                let index = i - del;
+                if f(&list[index]) {
+                    let value = list.remove(index).expect("value is present");
+                    extraction.push(value);
+                    changed(key, Change::Removed(index as u32));
+                    del += 1;
+                }
+            }
+
+            extraction
+        })
+    }
+
     /// Get a reference to a value
     pub fn get<'a>(&'a self, index: usize) -> Option<Shared<'a, T>> {
         let list = &*self.to_ref();
@@ -361,6 +388,26 @@ mod test {
         assert!(matches!(changes.remove(0), (_, Change::Removed(1))));
     }
 
+    #[test]
+    fn notify_extract_if() {
+        let mut list = Value::new(List::<u32>::empty());
+        list.push_back(1);
+        list.push_back(2);
+        list.push_back(3);
+        list.push_back(4);
+
+        list.reference().subscribe(Subscriber::ZERO);
+
+        let result = list.extract_if(|val| *val.to_ref() % 2 == 0);
+
+        let mut changes = drain_changes();
+        assert!(matches!(changes.remove(0), (_, Change::Removed(2))));
+        assert!(matches!(changes.remove(0), (_, Change::Removed(1))));
+
+        assert_eq!(*result[0].to_ref(), 2);
+        assert_eq!(*result[1].to_ref(), 4);
+    }
+
     #[test]
     fn notify_pop_back() {
         let mut list = Value::new(List::<u32>::empty());

anathema-state/src/value/maybe.rs

@@ -141,6 +141,8 @@ impl<T: State + TypeId> Value<Maybe<T>> {
 #[cfg(test)]
 mod test {
     use super::*;
+    use crate::store::testing::drain_changes;
+    use crate::{Change, Subscriber};
 
     #[test]
     fn nullable_int() {
@@ -155,4 +157,13 @@ mod test {
         let one = value.and_then_ref(|inner_map| inner_map.map_ref(|m| *m)).unwrap();
         assert_eq!(one, 1);
     }
+
+    #[test]
+    fn changing_value() {
+        let mut value = Value::new(Maybe::<u32>::none());
+        value.reference().subscribe(Subscriber::ZERO);
+        value.to_mut().update(Some(1));
+        let mut changes = drain_changes();
+        assert!(matches!(changes.remove(0), (_, Change::Changed)));
+    }
 }

anathema-value-resolver/src/expression.rs

@@ -349,7 +349,10 @@ fn resolve_pending<'bp>(val: PendingValue, ctx: &mut ValueResolutionContext<'_,
             let maybe = or_null!(state.as_maybe());
             // If there is no value, subscribe to the `Maybe`
             let inner = match maybe.get() {
-                Some(inner) => inner,
+                Some(inner) => {
+                    ctx.maybe_subscribe(&val);
+                    inner
+                }
                 None => {
                     ctx.maybe_subscribe(&val);
                     return ValueExpr::Null;
@@ -377,11 +380,11 @@ fn resolve_index<'bp>(
             let val = map.lookup(&key);
 
             let val = match val {
-                Some(key) => {
+                Some(val) => {
                     if ctx.is_partially_resolved() {
                         value.unsubscribe(ctx.sub);
                     }
-                    key
+                    val
                 }
                 None => {
                     ctx.partially_resolved(value);