dypdl/
state_functions.rs

1use crate::{
2    expression::*, state::StateInterface, table_registry::TableRegistry, util, util::ModelErr,
3    variable_type::*,
4};
5
6use rustc_hash::{FxHashMap, FxHashSet};
7
8/// Definition of state functions.
9#[derive(Debug, PartialEq, Clone, Default)]
10pub struct StateFunctions {
11    /// Map from a set function id to the name.
12    pub set_function_names: Vec<String>,
13    /// Map from a name to a set function id.
14    pub name_to_set_function: FxHashMap<String, usize>,
15    /// Set functions.
16    pub set_functions: Vec<SetExpression>,
17
18    /// Map from a element function id to the name.
19    pub element_function_names: Vec<String>,
20    /// Map from a name to an element function id.
21    pub name_to_element_function: FxHashMap<String, usize>,
22    /// Element functions.
23    pub element_functions: Vec<ElementExpression>,
24
25    /// Map from an integer function id to the name.
26    pub integer_function_names: Vec<String>,
27    /// Map from a name to an integer function id.
28    pub name_to_integer_function: FxHashMap<String, usize>,
29    /// Integer functions.
30    pub integer_functions: Vec<IntegerExpression>,
31
32    /// Map from a continuous function id to the name.
33    pub continuous_function_names: Vec<String>,
34    /// Map from a name to a continuous function id.
35    pub name_to_continuous_function: FxHashMap<String, usize>,
36    /// Continuous functions.
37    pub continuous_functions: Vec<ContinuousExpression>,
38
39    /// Map from a boolean function id to the name.
40    pub boolean_function_names: Vec<String>,
41    /// Map from a name to a boolean function id.
42    pub name_to_boolean_function: FxHashMap<String, usize>,
43    /// Boolean functions.
44    pub boolean_functions: Vec<Condition>,
45}
46
47macro_rules! define_handle {
48    ($x:ident) => {
49        /// A struct wrapping an id.
50        #[derive(Debug, Clone, Copy, PartialEq, Eq)]
51        pub struct $x(usize);
52
53        impl $x {
54            /// Returns the id.
55            #[inline]
56            pub fn id(&self) -> usize {
57                self.0
58            }
59        }
60    };
61}
62
63define_handle!(SetStateFunction);
64define_handle!(ElementStateFunction);
65define_handle!(IntegerStateFunction);
66define_handle!(ContinuousStateFunction);
67define_handle!(BooleanStateFunction);
68
69impl StateFunctions {
70    /// Returns a set function given a name.
71    ///
72    /// # Errors
73    ///
74    /// If no such function.
75    pub fn get_set_function(&self, name: &str) -> Result<SetExpression, ModelErr> {
76        let id = util::get_id(name, &self.name_to_set_function)?;
77
78        Ok(SetExpression::StateFunction(id))
79    }
80
81    /// Adds and returns a set function.
82    ///
83    /// # Errors
84    ///
85    /// If the name is already used.
86    pub fn add_set_function<T>(
87        &mut self,
88        name: T,
89        expression: SetExpression,
90    ) -> Result<SetExpression, ModelErr>
91    where
92        String: From<T>,
93    {
94        let id = util::add_name(
95            name,
96            &mut self.set_function_names,
97            &mut self.name_to_set_function,
98        )?;
99        self.set_functions.push(expression);
100
101        Ok(SetExpression::StateFunction(id))
102    }
103
104    /// Returns an element function given a name.
105    ///
106    /// # Errors
107    ///
108    /// If no such function.
109    pub fn get_element_function(&self, name: &str) -> Result<ElementExpression, ModelErr> {
110        let id = util::get_id(name, &self.name_to_element_function)?;
111
112        Ok(ElementExpression::StateFunction(id))
113    }
114
115    /// Adds and returns an element function.
116    ///
117    /// # Errors
118    ///
119    /// If the name is already used.
120    pub fn add_element_function<T>(
121        &mut self,
122        name: T,
123        expression: ElementExpression,
124    ) -> Result<ElementExpression, ModelErr>
125    where
126        String: From<T>,
127    {
128        let id = util::add_name(
129            name,
130            &mut self.element_function_names,
131            &mut self.name_to_element_function,
132        )?;
133        self.element_functions.push(expression);
134
135        Ok(ElementExpression::StateFunction(id))
136    }
137
138    /// Returns an integer function given a name.
139    ///
140    /// # Errors
141    ///
142    /// If no such function.
143    pub fn get_integer_function(&self, name: &str) -> Result<IntegerExpression, ModelErr> {
144        let id = util::get_id(name, &self.name_to_integer_function)?;
145
146        Ok(IntegerExpression::StateFunction(id))
147    }
148
149    /// Adds and returns an integer function.
150    ///
151    /// # Errors
152    ///
153    /// If the name is already used.
154    pub fn add_integer_function<T>(
155        &mut self,
156        name: T,
157        expression: IntegerExpression,
158    ) -> Result<IntegerExpression, ModelErr>
159    where
160        String: From<T>,
161    {
162        let id = util::add_name(
163            name,
164            &mut self.integer_function_names,
165            &mut self.name_to_integer_function,
166        )?;
167        self.integer_functions.push(expression);
168
169        Ok(IntegerExpression::StateFunction(id))
170    }
171
172    /// Returns an continuous function given a name.
173    ///
174    /// # Errors
175    ///
176    /// If no such function.
177    pub fn get_continuous_function(&self, name: &str) -> Result<ContinuousExpression, ModelErr> {
178        let id = util::get_id(name, &self.name_to_continuous_function)?;
179
180        Ok(ContinuousExpression::StateFunction(id))
181    }
182
183    /// Adds and returns a continuous function.
184    ///
185    /// # Errors
186    ///
187    /// If the name is already used.
188    pub fn add_continuous_function<T>(
189        &mut self,
190        name: T,
191        expression: ContinuousExpression,
192    ) -> Result<ContinuousExpression, ModelErr>
193    where
194        String: From<T>,
195    {
196        let id = util::add_name(
197            name,
198            &mut self.continuous_function_names,
199            &mut self.name_to_continuous_function,
200        )?;
201        self.continuous_functions.push(expression);
202
203        Ok(ContinuousExpression::StateFunction(id))
204    }
205
206    /// Returns an boolean function given a name.
207    ///
208    /// # Errors
209    ///
210    /// If no such function.
211    pub fn get_boolean_function(&self, name: &str) -> Result<Condition, ModelErr> {
212        let id = util::get_id(name, &self.name_to_boolean_function)?;
213
214        Ok(Condition::StateFunction(id))
215    }
216
217    /// Adds and returns a boolean function.
218    ///
219    /// # Errors
220    ///
221    /// If the name is already used.
222    pub fn add_boolean_function<T>(
223        &mut self,
224        name: T,
225        expression: Condition,
226    ) -> Result<Condition, ModelErr>
227    where
228        String: From<T>,
229    {
230        let id = util::add_name(
231            name,
232            &mut self.boolean_function_names,
233            &mut self.name_to_boolean_function,
234        )?;
235        self.boolean_functions.push(expression);
236
237        Ok(Condition::StateFunction(id))
238    }
239
240    /// Returns the set function names.
241    pub fn get_name_set(&self) -> FxHashSet<String> {
242        let mut set = FxHashSet::default();
243        set.extend(self.set_function_names.iter().cloned());
244        set.extend(self.element_function_names.iter().cloned());
245        set.extend(self.integer_function_names.iter().cloned());
246        set.extend(self.continuous_function_names.iter().cloned());
247        set.extend(self.boolean_function_names.iter().cloned());
248
249        set
250    }
251}
252
253/// Data structure to cache the values of state functions.
254///
255/// This can be used multiple times for evaluating expressions with the same state.
256/// If the state is changed, the cache must be cleared.
257#[derive(Clone, Debug, Default, PartialEq)]
258pub struct StateFunctionCache {
259    current_cycle: usize,
260    set_values: Vec<Option<Set>>,
261    set_cycles: Vec<usize>,
262    element_values: Vec<Option<Element>>,
263    element_cycles: Vec<usize>,
264    integer_values: Vec<Option<Integer>>,
265    integer_cycles: Vec<usize>,
266    continuous_values: Vec<Option<Continuous>>,
267    continuous_cycles: Vec<usize>,
268    boolean_values: Vec<Option<bool>>,
269    boolean_cycles: Vec<usize>,
270}
271
272macro_rules! define_getter {
273    ($name:ident, $type:ty, $field:ident, $cycles:ident, $functions:ident) => {
274        /// Get the value of a state function.
275        ///
276        /// # Panics
277        ///
278        /// If the function with id `i` does not exists.
279        pub fn $name<S>(
280            &mut self,
281            i: usize,
282            state: &S,
283            functions: &StateFunctions,
284            registry: &TableRegistry,
285        ) -> $type
286        where
287            S: StateInterface,
288        {
289            if self.$cycles[i] < self.current_cycle {
290                self.$field[i] =
291                    Some(functions.$functions[i].eval(state, self, functions, &registry));
292                self.$cycles[i] = self.current_cycle;
293            }
294
295            self.$field[i].unwrap()
296        }
297    };
298}
299
300macro_rules! define_setter {
301    ($name:ident, $type:ty, $field:ident, $cycles:ident) => {
302        /// Set the value of the state function.
303        pub fn $name(&mut self, i: usize, value: $type) {
304            self.$field[i] = Some(value);
305            self.$cycles[i] = self.current_cycle;
306        }
307    };
308}
309
310impl StateFunctionCache {
311    /// Create a new state function cache.
312    pub fn new(state_functions: &StateFunctions) -> Self {
313        let set_values = vec![None; state_functions.set_functions.len()];
314        let set_cycles = vec![0; set_values.len()];
315        let element_values = vec![None; state_functions.element_functions.len()];
316        let element_cycles = vec![0; element_values.len()];
317        let integer_values = vec![None; state_functions.integer_functions.len()];
318        let integer_cycles = vec![0; integer_values.len()];
319        let continuous_values = vec![None; state_functions.continuous_functions.len()];
320        let continuous_cycles = vec![0; continuous_values.len()];
321        let boolean_values = vec![None; state_functions.boolean_functions.len()];
322        let boolean_cycles = vec![0; boolean_values.len()];
323
324        Self {
325            current_cycle: 1,
326            set_values,
327            set_cycles,
328            element_values,
329            element_cycles,
330            integer_values,
331            integer_cycles,
332            continuous_values,
333            continuous_cycles,
334            boolean_values,
335            boolean_cycles,
336        }
337    }
338
339    /// Get the value of a state function.
340    ///
341    /// # Panics
342    ///
343    /// If the function with id `i` does not exists.
344    pub fn get_set_value<S: StateInterface>(
345        &mut self,
346        i: usize,
347        state: &S,
348        functions: &StateFunctions,
349        registry: &TableRegistry,
350    ) -> &Set {
351        if self.set_cycles[i] < self.current_cycle {
352            self.set_values[i] =
353                Some(functions.set_functions[i].eval(state, self, functions, registry));
354            self.set_cycles[i] = self.current_cycle;
355        }
356
357        self.set_values[i].as_ref().unwrap()
358    }
359
360    /// Get the values of two set state functions.
361    ///
362    /// # Panics
363    ///
364    /// If the function with id `i` or `j` does not exists.
365    pub fn get_set_value_pair<S>(
366        &mut self,
367        i: usize,
368        j: usize,
369        state: &S,
370        functions: &StateFunctions,
371        registry: &TableRegistry,
372    ) -> (&Set, &Set)
373    where
374        S: StateInterface,
375    {
376        // Evaluate the state functions.
377        self.get_set_value(i, state, functions, registry);
378        self.get_set_value(j, state, functions, registry);
379
380        (
381            self.set_values[i].as_ref().unwrap(),
382            self.set_values[j].as_ref().unwrap(),
383        )
384    }
385
386    define_setter!(set_set_value, Set, set_values, set_cycles);
387
388    define_getter!(
389        get_element_value,
390        Element,
391        element_values,
392        element_cycles,
393        element_functions
394    );
395
396    define_setter!(set_element_value, Element, element_values, element_cycles);
397
398    define_getter!(
399        get_integer_value,
400        Integer,
401        integer_values,
402        integer_cycles,
403        integer_functions
404    );
405
406    define_setter!(set_integer_value, Integer, integer_values, integer_cycles);
407
408    define_getter!(
409        get_continuous_value,
410        Continuous,
411        continuous_values,
412        continuous_cycles,
413        continuous_functions
414    );
415
416    define_setter!(
417        set_continuous_value,
418        Continuous,
419        continuous_values,
420        continuous_cycles
421    );
422
423    define_getter!(
424        get_boolean_value,
425        bool,
426        boolean_values,
427        boolean_cycles,
428        boolean_functions
429    );
430
431    define_setter!(set_boolean_value, bool, boolean_values, boolean_cycles);
432
433    /// Clear the cache.
434    pub fn clear(&mut self) {
435        self.current_cycle += 1;
436    }
437}
438
439#[cfg(test)]
440mod tests {
441    use approx::assert_relative_eq;
442
443    use super::*;
444    use crate::state::{SignatureVariables, State, StateMetadata};
445
446    #[test]
447    fn test_add_and_get_set_function() {
448        let mut state_metadata = StateMetadata::default();
449
450        let ob = state_metadata.add_object_type("ob", 3);
451        assert!(ob.is_ok());
452        let v = state_metadata.add_set_variable("v", ob.unwrap());
453        assert!(v.is_ok());
454        let v = v.unwrap();
455
456        let mut state_functions = StateFunctions::default();
457
458        let f = state_functions.add_set_function("f", v.add(1));
459        assert!(f.is_ok());
460        assert_eq!(f.unwrap(), SetExpression::StateFunction(0));
461
462        let g = state_functions.add_set_function("g", v.remove(1));
463        assert!(g.is_ok());
464        assert_eq!(g.unwrap(), SetExpression::StateFunction(1));
465
466        let f = state_functions.add_set_function("f", v.add(1));
467        assert!(f.is_err());
468
469        let f = state_functions.get_set_function("f");
470        assert!(f.is_ok());
471        assert_eq!(f.unwrap(), SetExpression::StateFunction(0));
472
473        let g = state_functions.get_set_function("g");
474        assert!(g.is_ok());
475        assert_eq!(g.unwrap(), SetExpression::StateFunction(1));
476
477        let h = state_functions.get_set_function("h");
478        assert!(h.is_err());
479    }
480
481    #[test]
482    fn tet_add_and_get_element_function() {
483        let mut state_metadata = StateMetadata::default();
484
485        let ob = state_metadata.add_object_type("ob", 3);
486        assert!(ob.is_ok());
487        let v = state_metadata.add_element_variable("v", ob.unwrap());
488        assert!(v.is_ok());
489        let v = v.unwrap();
490
491        let mut state_functions = StateFunctions::default();
492
493        let f = state_functions.add_element_function("f", v + 1);
494        assert!(f.is_ok());
495        assert_eq!(f.unwrap(), ElementExpression::StateFunction(0));
496
497        let g = state_functions.add_element_function("g", v - 1);
498        assert!(g.is_ok());
499        assert_eq!(g.unwrap(), ElementExpression::StateFunction(1));
500
501        let f = state_functions.add_element_function("f", v - 1);
502        assert!(f.is_err());
503
504        let f = state_functions.get_element_function("f");
505        assert!(f.is_ok());
506        assert_eq!(f.unwrap(), ElementExpression::StateFunction(0));
507
508        let g = state_functions.get_element_function("g");
509        assert!(g.is_ok());
510        assert_eq!(g.unwrap(), ElementExpression::StateFunction(1));
511
512        let h = state_functions.get_element_function("h");
513        assert!(h.is_err());
514    }
515
516    #[test]
517    fn test_add_and_get_integer_function_ok() {
518        let mut state_metadata = StateMetadata::default();
519
520        let v = state_metadata.add_integer_variable("v");
521        assert!(v.is_ok());
522        let v = v.unwrap();
523
524        let mut state_functions = StateFunctions::default();
525
526        let f = state_functions.add_integer_function("f", v + 1);
527        assert!(f.is_ok());
528        assert_eq!(f.unwrap(), IntegerExpression::StateFunction(0));
529
530        let g = state_functions.add_integer_function("g", v - 1);
531        assert!(g.is_ok());
532        assert_eq!(g.unwrap(), IntegerExpression::StateFunction(1));
533
534        let f = state_functions.add_integer_function("f", v - 1);
535        assert!(f.is_err());
536
537        let f = state_functions.get_integer_function("f");
538        assert!(f.is_ok());
539        assert_eq!(f.unwrap(), IntegerExpression::StateFunction(0));
540
541        let g = state_functions.get_integer_function("g");
542        assert!(g.is_ok());
543        assert_eq!(g.unwrap(), IntegerExpression::StateFunction(1));
544
545        let h = state_functions.get_integer_function("h");
546        assert!(h.is_err());
547    }
548
549    #[test]
550    fn test_add_and_get_continuous_function() {
551        let mut state_metadata = StateMetadata::default();
552
553        let v = state_metadata.add_continuous_variable("v");
554        assert!(v.is_ok());
555        let v = v.unwrap();
556
557        let mut state_functions = StateFunctions::default();
558
559        let f = state_functions.add_continuous_function("f", v + 1);
560        assert!(f.is_ok());
561        assert_eq!(f.unwrap(), ContinuousExpression::StateFunction(0));
562
563        let g = state_functions.add_continuous_function("g", v - 1);
564        assert!(g.is_ok());
565        assert_eq!(g.unwrap(), ContinuousExpression::StateFunction(1));
566
567        let f = state_functions.add_continuous_function("f", v - 1);
568        assert!(f.is_err());
569
570        let f = state_functions.get_continuous_function("f");
571        assert!(f.is_ok());
572        assert_eq!(f.unwrap(), ContinuousExpression::StateFunction(0));
573
574        let g = state_functions.get_continuous_function("g");
575        assert!(g.is_ok());
576        assert_eq!(g.unwrap(), ContinuousExpression::StateFunction(1));
577
578        let h = state_functions.get_continuous_function("h");
579        assert!(h.is_err());
580    }
581
582    #[test]
583    fn test_add_and_get_boolean_function() {
584        let mut state_metadata = StateMetadata::default();
585
586        let v = state_metadata.add_integer_variable("v");
587        assert!(v.is_ok());
588        let v = v.unwrap();
589
590        let mut state_functions = StateFunctions::default();
591
592        let f = state_functions
593            .add_boolean_function("f", Condition::comparison_i(ComparisonOperator::Eq, v, 1));
594        assert!(f.is_ok());
595        assert_eq!(f.unwrap(), Condition::StateFunction(0));
596
597        let g = state_functions
598            .add_boolean_function("g", Condition::comparison_i(ComparisonOperator::Ne, v, 1));
599        assert!(g.is_ok());
600        assert_eq!(g.unwrap(), Condition::StateFunction(1));
601
602        let h = state_functions
603            .add_boolean_function("h", Condition::comparison_i(ComparisonOperator::Eq, v, 1));
604        assert!(h.is_ok());
605
606        let f = state_functions.get_boolean_function("f");
607        assert!(f.is_ok());
608        assert_eq!(f.unwrap(), Condition::StateFunction(0));
609
610        let g = state_functions.get_boolean_function("g");
611        assert!(g.is_ok());
612        assert_eq!(g.unwrap(), Condition::StateFunction(1));
613
614        let h = state_functions.get_boolean_function("h");
615        assert!(h.is_ok());
616    }
617
618    #[test]
619    fn test_get_name_set() {
620        let mut state_metadata = StateMetadata::default();
621
622        let ob = state_metadata.add_object_type("ob", 3);
623        assert!(ob.is_ok());
624        let v = state_metadata.add_set_variable("v", ob.unwrap());
625        assert!(v.is_ok());
626        let v = v.unwrap();
627
628        let mut state_functions = StateFunctions::default();
629
630        let result = state_functions.add_set_function("sf", v.add(0));
631        assert!(result.is_ok());
632        let result = state_functions.add_set_function("sg", v.add(1));
633        assert!(result.is_ok());
634
635        let result = state_functions.add_element_function("ef", ElementExpression::Constant(0));
636        assert!(result.is_ok());
637        let result = state_functions.add_element_function("eg", ElementExpression::Constant(1));
638        assert!(result.is_ok());
639
640        let result = state_functions.add_integer_function("if", IntegerExpression::Constant(0));
641        assert!(result.is_ok());
642        let result = state_functions.add_integer_function("ig", IntegerExpression::Constant(1));
643        assert!(result.is_ok());
644
645        let result =
646            state_functions.add_continuous_function("cf", ContinuousExpression::Constant(0.0));
647        assert!(result.is_ok());
648        let result =
649            state_functions.add_continuous_function("cg", ContinuousExpression::Constant(1.0));
650        assert!(result.is_ok());
651
652        let result = state_functions.add_boolean_function("bf", v.contains(0));
653        assert!(result.is_ok());
654        let result = state_functions.add_boolean_function("bg", v.contains(1));
655        assert!(result.is_ok());
656
657        let set = state_functions.get_name_set();
658        let expected = ["sf", "sg", "ef", "eg", "if", "ig", "cf", "cg", "bf", "bg"]
659            .iter()
660            .map(|x| x.to_string())
661            .collect::<FxHashSet<_>>();
662        assert_eq!(set, expected);
663    }
664
665    #[test]
666    fn test_get_set_value() {
667        let mut state_metadata = StateMetadata::default();
668        let ob = state_metadata.add_object_type("ob", 3);
669        assert!(ob.is_ok());
670        let ob = ob.unwrap();
671        let v = state_metadata.add_set_variable("v", ob);
672        assert!(v.is_ok());
673        let v = v.unwrap();
674
675        let mut state_functions = StateFunctions::default();
676        let f = state_functions.add_set_function("f", v.add(0));
677        assert!(f.is_ok());
678        let g = state_functions.add_set_function("g", v.add(2));
679        assert!(g.is_ok());
680
681        let set = state_metadata.create_set(ob, &[1]);
682        assert!(set.is_ok());
683        let set = set.unwrap();
684        let state = State {
685            signature_variables: SignatureVariables {
686                set_variables: vec![set],
687                ..Default::default()
688            },
689            ..Default::default()
690        };
691
692        let mut function_cache = StateFunctionCache::new(&state_functions);
693        let registry = TableRegistry::default();
694
695        let expected1 = state_metadata.create_set(ob, &[0, 1]);
696        assert!(expected1.is_ok());
697        let expected1 = expected1.unwrap();
698        assert_eq!(
699            function_cache.get_set_value(0, &state, &state_functions, &registry),
700            &expected1
701        );
702
703        let expected2 = state_metadata.create_set(ob, &[1, 2]);
704        assert!(expected2.is_ok());
705        let expected2 = expected2.unwrap();
706        assert_eq!(
707            function_cache.get_set_value(1, &state, &state_functions, &registry),
708            &expected2
709        );
710
711        assert_eq!(
712            function_cache.get_set_value(0, &state, &state_functions, &registry),
713            &expected1
714        );
715        assert_eq!(
716            function_cache.get_set_value(1, &state, &state_functions, &registry),
717            &expected2
718        );
719    }
720
721    #[should_panic]
722    #[test]
723    fn test_get_set_value_panic() {
724        let mut state_metadata = StateMetadata::default();
725        let ob = state_metadata.add_object_type("ob", 3);
726        assert!(ob.is_ok());
727        let ob = ob.unwrap();
728        let v = state_metadata.add_set_variable("v", ob);
729        assert!(v.is_ok());
730        let v = v.unwrap();
731
732        let mut state_functions = StateFunctions::default();
733        let f = state_functions.add_set_function("f", v.add(0));
734        assert!(f.is_ok());
735
736        let set = state_metadata.create_set(ob, &[1]);
737        assert!(set.is_ok());
738        let set = set.unwrap();
739        let state = State {
740            signature_variables: SignatureVariables {
741                set_variables: vec![set],
742                ..Default::default()
743            },
744            ..Default::default()
745        };
746
747        let mut function_cache = StateFunctionCache::new(&state_functions);
748        let registry = TableRegistry::default();
749
750        function_cache.get_set_value(1, &state, &state_functions, &registry);
751    }
752
753    #[test]
754    fn test_get_set_value_pairs() {
755        let mut state_metadata = StateMetadata::default();
756        let ob = state_metadata.add_object_type("ob", 3);
757        assert!(ob.is_ok());
758        let ob = ob.unwrap();
759        let v = state_metadata.add_set_variable("v", ob);
760        assert!(v.is_ok());
761        let v = v.unwrap();
762
763        let mut state_functions = StateFunctions::default();
764        let f = state_functions.add_set_function("f", v.add(0));
765        assert!(f.is_ok());
766        let g = state_functions.add_set_function("g", v.add(2));
767        assert!(g.is_ok());
768
769        let set = state_metadata.create_set(ob, &[1]);
770        assert!(set.is_ok());
771        let set = set.unwrap();
772        let state = State {
773            signature_variables: SignatureVariables {
774                set_variables: vec![set],
775                ..Default::default()
776            },
777            ..Default::default()
778        };
779
780        let mut function_cache = StateFunctionCache::new(&state_functions);
781        let registry = TableRegistry::default();
782
783        let expected1 = state_metadata.create_set(ob, &[0, 1]);
784        assert!(expected1.is_ok());
785        let expected1 = expected1.unwrap();
786        let expected2 = state_metadata.create_set(ob, &[1, 2]);
787        assert!(expected2.is_ok());
788        let expected2 = expected2.unwrap();
789        assert_eq!(
790            function_cache.get_set_value_pair(0, 1, &state, &state_functions, &registry),
791            (&expected1, &expected2)
792        );
793        assert_eq!(
794            function_cache.get_set_value_pair(0, 1, &state, &state_functions, &registry),
795            (&expected1, &expected2)
796        );
797    }
798
799    #[should_panic]
800    #[test]
801    fn test_get_set_value_pairs_panic1() {
802        let mut state_metadata = StateMetadata::default();
803        let ob = state_metadata.add_object_type("ob", 3);
804        assert!(ob.is_ok());
805        let ob = ob.unwrap();
806        let v = state_metadata.add_set_variable("v", ob);
807        assert!(v.is_ok());
808        let v = v.unwrap();
809
810        let mut state_functions = StateFunctions::default();
811        let f = state_functions.add_set_function("f", v.add(0));
812        assert!(f.is_ok());
813
814        let mut state_functions = StateFunctions::default();
815        let g = state_functions.add_set_function("g", v.add(2));
816        assert!(g.is_ok());
817
818        let set = state_metadata.create_set(ob, &[1]);
819        assert!(set.is_ok());
820        let set = set.unwrap();
821        let state = State {
822            signature_variables: SignatureVariables {
823                set_variables: vec![set],
824                ..Default::default()
825            },
826            ..Default::default()
827        };
828
829        let mut function_cache = StateFunctionCache::new(&state_functions);
830        let registry = TableRegistry::default();
831
832        function_cache.get_set_value_pair(2, 1, &state, &state_functions, &registry);
833    }
834
835    #[should_panic]
836    #[test]
837    fn test_get_set_value_pairs_panic2() {
838        let mut state_metadata = StateMetadata::default();
839        let ob = state_metadata.add_object_type("ob", 3);
840        assert!(ob.is_ok());
841        let ob = ob.unwrap();
842        let v = state_metadata.add_set_variable("v", ob);
843        assert!(v.is_ok());
844        let v = v.unwrap();
845
846        let mut state_functions = StateFunctions::default();
847        let f = state_functions.add_set_function("f", v.add(0));
848        assert!(f.is_ok());
849
850        let mut state_functions = StateFunctions::default();
851        let g = state_functions.add_set_function("g", v.add(2));
852        assert!(g.is_ok());
853
854        let set = state_metadata.create_set(ob, &[1]);
855        assert!(set.is_ok());
856        let set = set.unwrap();
857        let state = State {
858            signature_variables: SignatureVariables {
859                set_variables: vec![set],
860                ..Default::default()
861            },
862            ..Default::default()
863        };
864
865        let mut function_cache = StateFunctionCache::new(&state_functions);
866        let registry = TableRegistry::default();
867
868        function_cache.get_set_value_pair(0, 2, &state, &state_functions, &registry);
869    }
870
871    #[test]
872    fn test_set_set_value() {
873        let mut state_metadata = StateMetadata::default();
874        let ob = state_metadata.add_object_type("ob", 3);
875        assert!(ob.is_ok());
876        let ob = ob.unwrap();
877        let v = state_metadata.add_set_variable("v", ob);
878        assert!(v.is_ok());
879        let v = v.unwrap();
880
881        let mut state_functions = StateFunctions::default();
882        let f = state_functions.add_set_function("f", v.add(0));
883        assert!(f.is_ok());
884        let g = state_functions.add_set_function("g", v.add(0));
885        assert!(g.is_ok());
886
887        let set = state_metadata.create_set(ob, &[1]);
888        assert!(set.is_ok());
889        let set = set.unwrap();
890        let state = State {
891            signature_variables: SignatureVariables {
892                set_variables: vec![set],
893                ..Default::default()
894            },
895            ..Default::default()
896        };
897
898        let mut function_cache = StateFunctionCache::new(&state_functions);
899        let registry = TableRegistry::default();
900
901        let expected1 = state_metadata.create_set(ob, &[0, 1]);
902        assert!(expected1.is_ok());
903        let expected1 = expected1.unwrap();
904
905        function_cache.set_set_value(0, expected1.clone());
906
907        assert_eq!(
908            function_cache.get_set_value(0, &state, &state_functions, &registry),
909            &expected1
910        );
911
912        let expected2 = state_metadata.create_set(ob, &[1, 2]);
913        assert!(expected2.is_ok());
914        let expected2 = expected2.unwrap();
915
916        function_cache.set_set_value(1, expected2.clone());
917
918        assert_eq!(
919            function_cache.get_set_value(1, &state, &state_functions, &registry),
920            &expected2
921        );
922
923        assert_eq!(
924            function_cache.get_set_value(0, &state, &state_functions, &registry),
925            &expected1
926        );
927        assert_eq!(
928            function_cache.get_set_value(1, &state, &state_functions, &registry),
929            &expected2
930        );
931    }
932
933    #[should_panic]
934    #[test]
935    fn test_set_set_value_panic() {
936        let mut state_metadata = StateMetadata::default();
937        let ob = state_metadata.add_object_type("ob", 3);
938        assert!(ob.is_ok());
939        let ob = ob.unwrap();
940        let v = state_metadata.add_set_variable("v", ob);
941        assert!(v.is_ok());
942        let v = v.unwrap();
943
944        let mut state_functions = StateFunctions::default();
945        let f = state_functions.add_set_function("f", v.add(0));
946        assert!(f.is_ok());
947
948        let mut function_cache = StateFunctionCache::new(&state_functions);
949
950        let expected = state_metadata.create_set(ob, &[0, 1]);
951        assert!(expected.is_ok());
952        let expected = expected.unwrap();
953        function_cache.set_set_value(1, expected);
954    }
955
956    #[test]
957    fn test_get_element_value() {
958        let mut state_metadata = StateMetadata::default();
959        let ob = state_metadata.add_object_type("ob", 3);
960        assert!(ob.is_ok());
961        let ob = ob.unwrap();
962        let v = state_metadata.add_element_variable("v", ob);
963        assert!(v.is_ok());
964        let v = v.unwrap();
965
966        let mut state_functions = StateFunctions::default();
967        let f = state_functions.add_element_function("f", v + 1);
968        assert!(f.is_ok());
969        let g = state_functions.add_element_function("g", v + 2);
970        assert!(g.is_ok());
971
972        let state = State {
973            signature_variables: SignatureVariables {
974                element_variables: vec![0],
975                ..Default::default()
976            },
977            ..Default::default()
978        };
979
980        let mut function_cache = StateFunctionCache::new(&state_functions);
981        let registry = TableRegistry::default();
982
983        assert_eq!(
984            function_cache.get_element_value(0, &state, &state_functions, &registry),
985            1
986        );
987        assert_eq!(
988            function_cache.get_element_value(1, &state, &state_functions, &registry),
989            2
990        );
991        assert_eq!(
992            function_cache.get_element_value(0, &state, &state_functions, &registry),
993            1
994        );
995        assert_eq!(
996            function_cache.get_element_value(1, &state, &state_functions, &registry),
997            2
998        );
999    }
1000
1001    #[should_panic]
1002    #[test]
1003    fn test_get_element_value_panic() {
1004        let mut state_metadata = StateMetadata::default();
1005        let ob = state_metadata.add_object_type("ob", 3);
1006        assert!(ob.is_ok());
1007        let ob = ob.unwrap();
1008        let v = state_metadata.add_element_variable("v", ob);
1009        assert!(v.is_ok());
1010        let v = v.unwrap();
1011
1012        let mut state_functions = StateFunctions::default();
1013        let f = state_functions.add_element_function("f", v + 1);
1014        assert!(f.is_ok());
1015
1016        let state = State {
1017            signature_variables: SignatureVariables {
1018                element_variables: vec![0],
1019                ..Default::default()
1020            },
1021            ..Default::default()
1022        };
1023
1024        let mut function_cache = StateFunctionCache::new(&state_functions);
1025        let registry = TableRegistry::default();
1026
1027        function_cache.get_element_value(1, &state, &state_functions, &registry);
1028    }
1029
1030    #[test]
1031    fn test_set_element_value() {
1032        let mut state_metadata = StateMetadata::default();
1033        let ob = state_metadata.add_object_type("ob", 3);
1034        assert!(ob.is_ok());
1035        let ob = ob.unwrap();
1036        let v = state_metadata.add_element_variable("v", ob);
1037        assert!(v.is_ok());
1038        let v = v.unwrap();
1039
1040        let mut state_functions = StateFunctions::default();
1041        let f = state_functions.add_element_function("f", v + 1);
1042        assert!(f.is_ok());
1043        let g = state_functions.add_element_function("g", v + 2);
1044        assert!(g.is_ok());
1045
1046        let state = State {
1047            signature_variables: SignatureVariables {
1048                element_variables: vec![0],
1049                ..Default::default()
1050            },
1051            ..Default::default()
1052        };
1053
1054        let mut function_cache = StateFunctionCache::new(&state_functions);
1055        let registry = TableRegistry::default();
1056
1057        function_cache.set_element_value(0, 1);
1058
1059        assert_eq!(
1060            function_cache.get_element_value(0, &state, &state_functions, &registry),
1061            1
1062        );
1063
1064        function_cache.set_element_value(1, 2);
1065
1066        assert_eq!(
1067            function_cache.get_element_value(1, &state, &state_functions, &registry),
1068            2
1069        );
1070
1071        assert_eq!(
1072            function_cache.get_element_value(0, &state, &state_functions, &registry),
1073            1
1074        );
1075
1076        assert_eq!(
1077            function_cache.get_element_value(1, &state, &state_functions, &registry),
1078            2
1079        );
1080    }
1081
1082    #[should_panic]
1083    #[test]
1084    fn test_set_element_value_panic() {
1085        let mut state_metadata = StateMetadata::default();
1086        let ob = state_metadata.add_object_type("ob", 3);
1087        assert!(ob.is_ok());
1088        let ob = ob.unwrap();
1089        let v = state_metadata.add_element_variable("v", ob);
1090        assert!(v.is_ok());
1091        let v = v.unwrap();
1092
1093        let mut state_functions = StateFunctions::default();
1094        let f = state_functions.add_element_function("f", v + 1);
1095        assert!(f.is_ok());
1096
1097        let mut function_cache = StateFunctionCache::new(&state_functions);
1098
1099        function_cache.set_element_value(1, 1);
1100    }
1101
1102    #[test]
1103    fn test_get_integer_value() {
1104        let mut state_metadata = StateMetadata::default();
1105        let v = state_metadata.add_integer_variable("v");
1106        assert!(v.is_ok());
1107        let v = v.unwrap();
1108
1109        let mut state_functions = StateFunctions::default();
1110        let f = state_functions.add_integer_function("f", v + 1);
1111        assert!(f.is_ok());
1112        let g = state_functions.add_integer_function("g", v + 2);
1113        assert!(g.is_ok());
1114
1115        let state = State {
1116            signature_variables: SignatureVariables {
1117                integer_variables: vec![0],
1118                ..Default::default()
1119            },
1120            ..Default::default()
1121        };
1122
1123        let mut function_cache = StateFunctionCache::new(&state_functions);
1124        let registry = TableRegistry::default();
1125
1126        assert_eq!(
1127            function_cache.get_integer_value(0, &state, &state_functions, &registry),
1128            1
1129        );
1130        assert_eq!(
1131            function_cache.get_integer_value(1, &state, &state_functions, &registry),
1132            2
1133        );
1134        assert_eq!(
1135            function_cache.get_integer_value(0, &state, &state_functions, &registry),
1136            1
1137        );
1138        assert_eq!(
1139            function_cache.get_integer_value(1, &state, &state_functions, &registry),
1140            2
1141        );
1142    }
1143
1144    #[should_panic]
1145    #[test]
1146    fn test_get_integer_value_panic() {
1147        let mut state_metadata = StateMetadata::default();
1148        let v = state_metadata.add_integer_variable("v");
1149        assert!(v.is_ok());
1150        let v = v.unwrap();
1151
1152        let mut state_functions = StateFunctions::default();
1153        let f = state_functions.add_integer_function("f", v + 1);
1154        assert!(f.is_ok());
1155
1156        let state = State {
1157            signature_variables: SignatureVariables {
1158                integer_variables: vec![0],
1159                ..Default::default()
1160            },
1161            ..Default::default()
1162        };
1163
1164        let mut function_cache = StateFunctionCache::new(&state_functions);
1165        let registry = TableRegistry::default();
1166
1167        function_cache.get_integer_value(1, &state, &state_functions, &registry);
1168    }
1169
1170    #[test]
1171    fn test_set_integer_value() {
1172        let mut state_metadata = StateMetadata::default();
1173        let v = state_metadata.add_integer_variable("v");
1174        assert!(v.is_ok());
1175        let v = v.unwrap();
1176
1177        let mut state_functions = StateFunctions::default();
1178        let f = state_functions.add_integer_function("f", v + 1);
1179        assert!(f.is_ok());
1180        let g = state_functions.add_integer_function("g", v + 2);
1181        assert!(g.is_ok());
1182
1183        let state = State {
1184            signature_variables: SignatureVariables {
1185                integer_variables: vec![0],
1186                ..Default::default()
1187            },
1188            ..Default::default()
1189        };
1190
1191        let mut function_cache = StateFunctionCache::new(&state_functions);
1192        let registry = TableRegistry::default();
1193
1194        function_cache.set_integer_value(0, 1);
1195
1196        assert_eq!(
1197            function_cache.get_integer_value(0, &state, &state_functions, &registry),
1198            1
1199        );
1200
1201        function_cache.set_integer_value(1, 2);
1202
1203        assert_eq!(
1204            function_cache.get_integer_value(1, &state, &state_functions, &registry),
1205            2
1206        );
1207
1208        assert_eq!(
1209            function_cache.get_integer_value(0, &state, &state_functions, &registry),
1210            1
1211        );
1212
1213        assert_eq!(
1214            function_cache.get_integer_value(1, &state, &state_functions, &registry),
1215            2
1216        );
1217    }
1218
1219    #[should_panic]
1220    #[test]
1221    fn test_set_integer_value_panic() {
1222        let mut state_metadata = StateMetadata::default();
1223        let v = state_metadata.add_integer_variable("v");
1224        assert!(v.is_ok());
1225        let v = v.unwrap();
1226
1227        let mut state_functions = StateFunctions::default();
1228        let f = state_functions.add_integer_function("f", v + 1);
1229        assert!(f.is_ok());
1230
1231        let mut function_cache = StateFunctionCache::new(&state_functions);
1232
1233        function_cache.set_integer_value(1, 1);
1234    }
1235
1236    #[test]
1237    fn test_get_continuous_value() {
1238        let mut state_metadata = StateMetadata::default();
1239        let v = state_metadata.add_continuous_variable("v");
1240        assert!(v.is_ok());
1241        let v = v.unwrap();
1242
1243        let mut state_functions = StateFunctions::default();
1244        let f = state_functions.add_continuous_function("f", v + 1);
1245        assert!(f.is_ok());
1246        let g = state_functions.add_continuous_function("g", v + 2);
1247        assert!(g.is_ok());
1248
1249        let state = State {
1250            signature_variables: SignatureVariables {
1251                continuous_variables: vec![0.0],
1252                ..Default::default()
1253            },
1254            ..Default::default()
1255        };
1256
1257        let mut function_cache = StateFunctionCache::new(&state_functions);
1258        let registry = TableRegistry::default();
1259
1260        assert_relative_eq!(
1261            function_cache.get_continuous_value(0, &state, &state_functions, &registry),
1262            1.0
1263        );
1264        assert_relative_eq!(
1265            function_cache.get_continuous_value(1, &state, &state_functions, &registry),
1266            2.0
1267        );
1268        assert_relative_eq!(
1269            function_cache.get_continuous_value(0, &state, &state_functions, &registry),
1270            1.0
1271        );
1272        assert_relative_eq!(
1273            function_cache.get_continuous_value(1, &state, &state_functions, &registry),
1274            2.0
1275        );
1276    }
1277
1278    #[should_panic]
1279    #[test]
1280    fn test_get_continuous_value_panic() {
1281        let mut state_metadata = StateMetadata::default();
1282        let v = state_metadata.add_continuous_variable("v");
1283        assert!(v.is_ok());
1284        let v = v.unwrap();
1285
1286        let mut state_functions = StateFunctions::default();
1287        let f = state_functions.add_continuous_function("f", v + 1);
1288        assert!(f.is_ok());
1289
1290        let state = State {
1291            signature_variables: SignatureVariables {
1292                continuous_variables: vec![0.0],
1293                ..Default::default()
1294            },
1295            ..Default::default()
1296        };
1297
1298        let mut function_cache = StateFunctionCache::new(&state_functions);
1299        let registry = TableRegistry::default();
1300
1301        function_cache.get_continuous_value(1, &state, &state_functions, &registry);
1302    }
1303
1304    #[test]
1305    fn test_set_continuous_value() {
1306        let mut state_metadata = StateMetadata::default();
1307        let v = state_metadata.add_continuous_variable("v");
1308        assert!(v.is_ok());
1309        let v = v.unwrap();
1310
1311        let mut state_functions = StateFunctions::default();
1312        let f = state_functions.add_continuous_function("f", v + 1);
1313        assert!(f.is_ok());
1314        let g = state_functions.add_continuous_function("g", v + 2);
1315        assert!(g.is_ok());
1316
1317        let state = State {
1318            signature_variables: SignatureVariables {
1319                continuous_variables: vec![0.0],
1320                ..Default::default()
1321            },
1322            ..Default::default()
1323        };
1324
1325        let mut function_cache = StateFunctionCache::new(&state_functions);
1326        let registry = TableRegistry::default();
1327
1328        function_cache.set_continuous_value(0, 1.0);
1329
1330        assert_relative_eq!(
1331            function_cache.get_continuous_value(0, &state, &state_functions, &registry),
1332            1.0
1333        );
1334
1335        function_cache.set_continuous_value(1, 2.0);
1336
1337        assert_relative_eq!(
1338            function_cache.get_continuous_value(1, &state, &state_functions, &registry),
1339            2.0
1340        );
1341
1342        assert_relative_eq!(
1343            function_cache.get_continuous_value(0, &state, &state_functions, &registry),
1344            1.0
1345        );
1346        assert_relative_eq!(
1347            function_cache.get_continuous_value(1, &state, &state_functions, &registry),
1348            2.0
1349        );
1350    }
1351
1352    #[should_panic]
1353    #[test]
1354    fn test_set_continuous_value_panic() {
1355        let mut state_metadata = StateMetadata::default();
1356        let v = state_metadata.add_continuous_variable("v");
1357        assert!(v.is_ok());
1358        let v = v.unwrap();
1359
1360        let mut state_functions = StateFunctions::default();
1361        let f = state_functions.add_continuous_function("f", v + 1);
1362        assert!(f.is_ok());
1363
1364        let mut function_cache = StateFunctionCache::new(&state_functions);
1365
1366        function_cache.set_continuous_value(1, 1.0);
1367    }
1368
1369    #[test]
1370    fn test_get_boolean_value() {
1371        let mut state_metadata = StateMetadata::default();
1372        let v = state_metadata.add_integer_variable("v");
1373        assert!(v.is_ok());
1374        let v = v.unwrap();
1375
1376        let mut state_functions = StateFunctions::default();
1377        let f = state_functions
1378            .add_boolean_function("f", Condition::comparison_i(ComparisonOperator::Eq, v, 0));
1379        assert!(f.is_ok());
1380        let g = state_functions
1381            .add_boolean_function("g", Condition::comparison_i(ComparisonOperator::Ne, v, 0));
1382        assert!(g.is_ok());
1383
1384        let state = State {
1385            signature_variables: SignatureVariables {
1386                integer_variables: vec![0],
1387                ..Default::default()
1388            },
1389            ..Default::default()
1390        };
1391
1392        let mut function_cache = StateFunctionCache::new(&state_functions);
1393        let registry = TableRegistry::default();
1394
1395        assert!(function_cache.get_boolean_value(0, &state, &state_functions, &registry));
1396        assert!(!function_cache.get_boolean_value(1, &state, &state_functions, &registry));
1397        assert!(function_cache.get_boolean_value(0, &state, &state_functions, &registry));
1398        assert!(!function_cache.get_boolean_value(1, &state, &state_functions, &registry));
1399    }
1400
1401    #[should_panic]
1402    #[test]
1403    fn test_get_boolean_value_panic() {
1404        let mut state_metadata = StateMetadata::default();
1405        let v = state_metadata.add_integer_variable("v");
1406        assert!(v.is_ok());
1407        let v = v.unwrap();
1408
1409        let mut state_functions = StateFunctions::default();
1410        let f = state_functions
1411            .add_boolean_function("f", Condition::comparison_i(ComparisonOperator::Eq, v, 0));
1412        assert!(f.is_ok());
1413
1414        let state = State {
1415            signature_variables: SignatureVariables {
1416                integer_variables: vec![0],
1417                ..Default::default()
1418            },
1419            ..Default::default()
1420        };
1421
1422        let mut function_cache = StateFunctionCache::new(&state_functions);
1423        let registry = TableRegistry::default();
1424
1425        function_cache.get_boolean_value(1, &state, &state_functions, &registry);
1426    }
1427
1428    #[test]
1429    fn test_set_boolean_value() {
1430        let mut state_metadata = StateMetadata::default();
1431        let v = state_metadata.add_integer_variable("v");
1432        assert!(v.is_ok());
1433        let v = v.unwrap();
1434
1435        let mut state_functions = StateFunctions::default();
1436        let f = state_functions
1437            .add_boolean_function("f", Condition::comparison_i(ComparisonOperator::Eq, v, 0));
1438        assert!(f.is_ok());
1439        let g = state_functions
1440            .add_boolean_function("g", Condition::comparison_i(ComparisonOperator::Ne, v, 0));
1441        assert!(g.is_ok());
1442
1443        let state = State {
1444            signature_variables: SignatureVariables {
1445                integer_variables: vec![0],
1446                ..Default::default()
1447            },
1448            ..Default::default()
1449        };
1450
1451        let mut function_cache = StateFunctionCache::new(&state_functions);
1452        let registry = TableRegistry::default();
1453
1454        function_cache.set_boolean_value(0, true);
1455
1456        assert!(function_cache.get_boolean_value(0, &state, &state_functions, &registry),);
1457
1458        function_cache.set_boolean_value(1, false);
1459
1460        assert!(!function_cache.get_boolean_value(1, &state, &state_functions, &registry),);
1461
1462        assert!(function_cache.get_boolean_value(0, &state, &state_functions, &registry),);
1463        assert!(!function_cache.get_boolean_value(1, &state, &state_functions, &registry),);
1464    }
1465
1466    #[should_panic]
1467    #[test]
1468    fn test_set_boolean_value_panic() {
1469        let mut state_metadata = StateMetadata::default();
1470        let v = state_metadata.add_integer_variable("v");
1471        assert!(v.is_ok());
1472        let v = v.unwrap();
1473
1474        let mut state_functions = StateFunctions::default();
1475        let f = state_functions
1476            .add_boolean_function("f", Condition::comparison_i(ComparisonOperator::Eq, v, 0));
1477        assert!(f.is_ok());
1478
1479        let mut function_cache = StateFunctionCache::new(&state_functions);
1480
1481        function_cache.set_boolean_value(1, true);
1482    }
1483
1484    #[test]
1485    fn test_clear() {
1486        let mut state_metadata = StateMetadata::default();
1487        let v = state_metadata.add_integer_variable("v");
1488        assert!(v.is_ok());
1489        let v = v.unwrap();
1490
1491        let mut state_functions = StateFunctions::default();
1492        let f = state_functions.add_integer_function("f", v + 1);
1493        assert!(f.is_ok());
1494        let g = state_functions.add_integer_function("g", v + 2);
1495        assert!(g.is_ok());
1496
1497        let state = State {
1498            signature_variables: SignatureVariables {
1499                integer_variables: vec![0],
1500                ..Default::default()
1501            },
1502            ..Default::default()
1503        };
1504
1505        let mut function_cache = StateFunctionCache::new(&state_functions);
1506        let registry = TableRegistry::default();
1507
1508        assert_eq!(
1509            function_cache.get_integer_value(0, &state, &state_functions, &registry),
1510            1
1511        );
1512        assert_eq!(
1513            function_cache.get_integer_value(1, &state, &state_functions, &registry),
1514            2
1515        );
1516
1517        let state = State {
1518            signature_variables: SignatureVariables {
1519                integer_variables: vec![1],
1520                ..Default::default()
1521            },
1522            ..Default::default()
1523        };
1524
1525        function_cache.clear();
1526
1527        assert_eq!(
1528            function_cache.get_integer_value(0, &state, &state_functions, &registry),
1529            2
1530        );
1531
1532        let state = State {
1533            signature_variables: SignatureVariables {
1534                integer_variables: vec![2],
1535                ..Default::default()
1536            },
1537            ..Default::default()
1538        };
1539
1540        function_cache.clear();
1541
1542        assert_eq!(
1543            function_cache.get_integer_value(0, &state, &state_functions, &registry),
1544            3
1545        );
1546        assert_eq!(
1547            function_cache.get_integer_value(1, &state, &state_functions, &registry),
1548            4
1549        );
1550    }
1551}
dypdl/state_functions.rs

dypdl/
state_functions.rs
