caldyn 0.4.3

Dynamic evaluation of mathematical expressions
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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

use std::collections::BTreeMap;
use std::fmt;

/// A context hold values for variables, that can be used to evaluate
/// expressions.
///
/// # Examples
///
/// ```
/// # use caldyn::Context;
/// let mut context = Context::new();
/// context.set("a", 3.0);
/// context.set("b", -2.5);
///
/// assert_eq!(context.get("a"), Some(3.0));
/// assert_eq!(context.get("d"), None);
/// ```
pub struct Context<'a> {
    values: BTreeMap<String, f64>,
    query: Option<Box<Fn(&str) -> Option<f64> + 'a>>,
}

impl<'a> fmt::Debug for Context<'a> {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        let query = match self.query {
            Some(_) => "Some(<boxed closure>)",
            None => "None",
        };
        fmt.debug_struct("Context")
           .field("value", &self.values)
           .field("query", &query)
           .finish()
    }
}

impl<'a> Context<'a> {
    /// Create a new empty context
    pub fn new() -> Context<'a> {
        Context {
            values: BTreeMap::new(),
            query: None,
        }
    }

    /// Set a variable with the given `name` and `value`. If the variable
    /// already exists, the value is updated.
    ///
    /// # Examples
    ///
    /// ```
    /// # use caldyn::Context;
    /// let mut context = Context::new();
    /// context.set("a", 3.0);
    /// assert_eq!(context.get("a"), Some(3.0));
    /// assert_eq!(context.get("d"), None);
    ///
    /// context.set("d", 5.0);
    /// context.set("a", 8.0);
    /// assert_eq!(context.get("a"), Some(8.0));
    /// assert_eq!(context.get("d"), Some(5.0));
    /// ```
    pub fn set<S: Into<String>>(&mut self, name: S, value: f64) {
        self.values.insert(name.into(), value);
    }

    /// Get the value of the variable with `name`, or `None` if the variable
    /// is not defined.
    ///
    /// # Examples
    ///
    /// ```
    /// # use caldyn::Context;
    /// let mut context = Context::new();
    /// context.set("a", 3.0);
    /// assert_eq!(context.get("a"), Some(3.0));
    /// assert_eq!(context.get("d"), None);
    /// ```
    pub fn get(&self, name: &str) -> Option<f64> {
        self.values.get(name).cloned().or_else(|| {
            self.query.as_ref().and_then(|function| function(name))
        })
    }

    /// Set a `function` to be called when a variable is not found in the
    /// context.
    ///
    /// # Examples
    ///
    /// ```
    /// # use caldyn::Context;
    /// let mut context = Context::new();
    /// context.set("a", 3.0);
    /// assert_eq!(context.get("a"), Some(3.0));
    /// assert_eq!(context.get("b"), None);
    ///
    /// context.set_query(|name| {
    ///     if name == "a" || name == "b" {
    ///         Some(28.0)
    ///     } else {
    ///         None
    ///     }
    /// });
    ///
    /// // The function is only called for "b", because "a" is already present
    /// // in the context.
    /// assert_eq!(context.get("a"), Some(3.0));
    /// assert_eq!(context.get("b"), Some(28.0));
    ///
    /// // If we set the variable "b", the function will not be called
    /// context.set("b", 1.0);
    /// assert_eq!(context.get("b"), Some(1.0));
    /// ```
    pub fn set_query<F>(&mut self, function: F)
    where
        F: Fn(&str) -> Option<f64> + 'a,
    {
        self.query = Some(Box::new(function));
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::fmt::Write;

    #[test]
    fn variables() {
        let mut context = Context::new();
        context.set("a", 2.0);
        assert_eq!(context.get("a"), Some(2.0));
        assert_eq!(context.get("b"), None);

        context.set("a", 5.0);
        context.set("b", 1.0);
        assert_eq!(context.get("a"), Some(5.0));
        assert_eq!(context.get("b"), Some(1.0));
    }

    #[test]
    fn debug() {
        let mut context = Context::new();
        context.set("a", 2.4);

        let mut string = String::new();
        let _ = write!(string, "{:?}", context);
        assert_eq!(string, "Context { value: {\"a\": 2.4}, query: \"None\" }");

        let mut string = String::new();
        let _ = write!(string, "{:#?}", context);
        assert_eq!(string, "Context {\n    value: {\n        \"a\": 2.4\n    },\n    query: \"None\"\n}");

        context.set_query(|_| None);
        let mut string = String::new();
        let _ = write!(string, "{:?}", context);
        assert_eq!(string, "Context { value: {\"a\": 2.4}, query: \"Some(<boxed closure>)\" }");
    }
}