fee 0.2.4

Expression evaluator supporting numeric, logical and bitwise operators
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
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174

use std::marker::PhantomData;

use crate::Ptr;
use crate::resolver::Locked;
use crate::resolver::LockedResolver;
use crate::resolver::ResolverState;
use crate::resolver::Unlocked;
use crate::resolver::UnlockedResolver;
use crate::{EmptyResolver, ExprFn, IndexedResolver, prelude::*};

/// Container for the resolvers required to compile and evaluate
/// expressions.
///
/// `Context` holds:
/// - a variable resolver (`V`) that implements `Resolver<f64>`
/// - a function resolver (`F`) that implements `Resolver<ExprFn>`
///
/// This struct is passed to evaluators to provide variable values and function
/// implementations.
///
/// # Locking
/// It is possible to 'lock' the resolvers held by the context to prevent
/// them from being reallocated in memory. This can be done by calling the
/// [`Context::lock`] method, allowing a better performance when evaluating
/// expressions taking advantage of the use of pointers to the values held by
/// the resolvers.
///
/// If the Context is locked, the user can obtain a [`Ptr`] to a value held
/// by one of the resolvers and modify it directly.
pub struct Context<S, V, F, LV, LF>
where
    S: ResolverState,
    V: Resolver<S, f64>,
    F: Resolver<S, ExprFn>,
{
    vars: V,
    fns: F,

    _state: S,
    _locked_vars: PhantomData<LV>,
    _locked_fns: PhantomData<LF>,
}

/// Unlocked context type alias
pub type UContext<V, F, LV, LF> = Context<Unlocked, V, F, LV, LF>;

/// Locked context type alias
pub type LContext<LV, LF> = Context<Locked, LV, LF, LV, LF>;

impl<V, F, LV, LF> UContext<V, F, LV, LF>
where
    V: UnlockedResolver<f64, LV>,
    F: UnlockedResolver<ExprFn, LF>,
    LV: LockedResolver<f64>,
    LF: LockedResolver<ExprFn>,
{
    pub fn new(vals: V, funcs: F) -> Self
    {
        Context {
            vars: vals,
            fns: funcs,

            _state: Unlocked,
            _locked_vars: PhantomData,
            _locked_fns: PhantomData,
        }
    }

    pub fn lock(self) -> LContext<LV, LF>
    {
        Context {
            vars: self.vars.lock(),
            fns: self.fns.lock(),

            _state: Locked,
            _locked_vars: PhantomData,
            _locked_fns: PhantomData,
        }
    }
}

impl<S, V, F, LV, LF> Context<S, V, F, LV, LF>
where
    V: Resolver<S, f64>,
    F: Resolver<S, ExprFn>,
    S: ResolverState,
{
    pub(crate) fn get_var(&self, name: &str) -> Option<&f64>
    {
        self.vars.resolve(name)
    }

    pub(crate) fn get_fn(&self, name: &str) -> Option<&ExprFn>
    {
        self.fns.resolve(name)
    }

    pub fn vars(&self) -> &V
    {
        &self.vars
    }

    pub fn fns(&self) -> &F
    {
        &self.fns
    }

    pub fn vars_mut(&mut self) -> &mut V
    {
        &mut self.vars
    }

    pub fn fns_mut(&mut self) -> &mut F
    {
        &mut self.fns
    }
}

impl<'a, V, F> LContext<V, F>
where
    V: LockedResolver<f64>,
    F: LockedResolver<ExprFn>,
{
    pub fn get_var_ptr(&'a self, name: &str) -> Option<Ptr<'a, f64>>
    {
        self.vars.get_ptr(name)
    }

    pub fn get_fn_ptr(&'a self, name: &str) -> Option<Ptr<'a, ExprFn>>
    {
        self.fns.get_ptr(name)
    }
}

impl<S, F, LF> Context<S, IndexedResolver<S, f64>, F, IndexedResolver<Locked, f64>, LF>
where
    S: ResolverState,
    F: Resolver<S, ExprFn>,
{
    pub(crate) fn get_var_by_index(&self, identifier: usize, index: usize) -> Option<&f64>
    {
        self.vars.get(identifier, index)
    }
}

impl<S, V, LV> Context<S, V, IndexedResolver<S, ExprFn>, LV, IndexedResolver<Locked, ExprFn>>
where
    S: ResolverState,
    V: Resolver<S, f64>,
{
    pub(crate) fn call_fn_by_index(
        &self,
        identifier: usize,
        index: usize,
        args: &[f64],
    ) -> Option<f64>
    {
        Some(self.fns.get(identifier, index)?(args))
    }
}

impl
    UContext<
        EmptyResolver<Unlocked>,
        EmptyResolver<Unlocked>,
        EmptyResolver<Locked>,
        EmptyResolver<Locked>,
    >
{
    pub fn empty() -> Self
    {
        Context::new(EmptyResolver::new(), EmptyResolver::new())
    }
}