depends 0.11.0

Ergonomic, performant, incremental computation between arbitrary types
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

mod dep_state;
mod dependency_edge;
mod impls;

use std::cell::{Ref, RefCell};

pub use dep_state::DependencyState;
pub use dependency_edge::DependencyEdge;
pub use impls::*;

use super::{HashValue, NodeHash, Resolve};
use crate::execution::{error::ResolveResult, NodeState, Visitor};

/// Short-hand for a reference to a single dependency.
pub type DepRef<'a, T> = DependencyEdge<'a, Ref<'a, NodeState<T>>>;

/// Wraps a dependency and tracks the hashed value each time it's resolved. This
/// allows the resolver to know if a dependency is 'dirty' from the perspective
/// of the Dependee.
#[derive(Debug)]
pub struct Dependency<T> {
    /// The state observed of the inner dependency when it was last resolved.
    last_state: RefCell<Option<NodeHash>>,
    /// The wrapped node.
    dependency: T,
}

impl<T> Dependency<T>
where
    T: Resolve,
    for<'a> <T as Resolve>::Output<'a>: HashValue,
{
    pub fn new(dependency: T) -> Self {
        Self {
            last_state: RefCell::new(None),
            dependency,
        }
    }
}

impl<T> Resolve for Dependency<T>
where
    T: Resolve,
    for<'a> <T as Resolve>::Output<'a>: HashValue,
{
    type Output<'a>
        = DependencyEdge<'a, T::Output<'a>>
    where
        Self: 'a;

    fn resolve(&self, visitor: &mut impl Visitor) -> ResolveResult<Self::Output<'_>> {
        let mut last_state = self.last_state.try_borrow_mut()?;
        let data = self.dependency.resolve(visitor)?;
        let current_state = data.hash_value(&mut visitor.hasher());
        if last_state.map(|s| s == current_state).unwrap_or(false) {
            Ok(DependencyEdge::new(DependencyState::Clean, data))
        } else {
            *last_state = Some(current_state);
            Ok(DependencyEdge::new(DependencyState::Dirty, data))
        }
    }
}

#[cfg(test)]
mod tests {
    use std::rc::Rc;

    use serial_test::serial;

    use super::*;
    use crate::execution::{
        identifiable::reset_node_id, internal_test_utils::TestData, HashSetVisitor, InputNode,
        IsDirty,
    };

    #[test]
    #[serial]
    fn test_dependency() {
        reset_node_id();
        let node = InputNode::new(TestData::new(57));
        let dependency = Dependency::new(Rc::clone(&node));
        assert_eq!(
            r#"
Dependency {
    last_state: RefCell {
        value: None,
    },
    dependency: InputNode {
        resolve_state: RefCell {
            value: Updating,
        },
        value: RefCell {
            value: NodeState {
                node_hash: NotHashed,
                value: TestData {
                    inner: 57,
                    recent: [],
                },
            },
        },
        id: 0,
    },
}"#
            .trim(),
            format!("{:#?}", dependency)
        );
        let mut visitor = HashSetVisitor::new();
        {
            let output = dependency.resolve_root(&mut visitor).unwrap();
            assert_eq!(***output, TestData::new(57));
            assert!(output.is_dirty());
        }
        {
            let output = dependency.resolve_root(&mut visitor).unwrap();
            assert_eq!(***output, TestData::new(57));
            assert!(!output.is_dirty());
        }
        node.update(42).unwrap();
        {
            let output = dependency.resolve_root(&mut visitor).unwrap();
            assert_eq!(
                ***output,
                TestData {
                    inner: 42,
                    recent: vec![57]
                }
            );
            assert!(output.is_dirty());
        }
    }
}