ixa 1.0.0

A framework for building agent-based models
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

use crate::context::{Context, ContextBase};
use crate::{
    ContextGlobalPropertiesExt, ContextNetworkExt, ContextPeopleExt, ContextRandomExt,
    ContextReportExt,
};

/// A supertrait that exposes useful methods from [`Context`]
/// for plugins implementing [`Context`] extensions.
///
/// Usage:
// This example triggers the error "#[ctor]/#[dtor] is not supported
// on the current target," which appears to be spurious, so we
// ignore it.
/// ```ignore
/// use ixa::prelude_for_plugins::*;
/// define_data_plugin!(MyData, bool, false);
/// pub trait MyPlugin: PluginContext {
///     fn set_my_data(&mut self) {
///         let my_data = self.get_data_container_mut(MyData);
///         *my_data = true;
///     }
/// }
pub trait PluginContext:
    ContextBase
    + ContextPeopleExt
    + ContextRandomExt
    + ContextReportExt
    + ContextNetworkExt
    + ContextGlobalPropertiesExt
{
}

impl PluginContext for Context {}

// Tests for the PluginContext trait, including:
// - Making sure all the methods work identically to Context
// - Defining a trait extension that uses it compiles correctly
// - External functions can use impl PluginContext if necessary
#[cfg(test)]
mod test_plugin_context {
    use crate::prelude_for_plugins::*;
    #[derive(Copy, Clone, IxaEvent)]
    struct MyEvent {
        pub data: usize,
    }

    define_data_plugin!(MyData, i32, 0);

    fn do_stuff_with_context(context: &mut impl PluginContext) {
        context.add_plan(1.0, |context| {
            let data = context.get_data(MyData);
            assert_eq!(*data, 42);
        });
    }

    trait MyDataExt: PluginContext {
        fn all_methods(&mut self) {
            assert_eq!(self.get_current_time(), 0.0);
        }
        fn all_methods_mut(&mut self) {
            self.setup();
            self.subscribe_to_event(|_: &mut Context, event: MyEvent| {
                assert_eq!(event.data, 42);
            });
            self.emit_event(MyEvent { data: 42 });
            self.add_plan_with_phase(
                1.0,
                |context| {
                    let data = context.get_data(MyData);
                    assert_eq!(*data, 42);
                    context.set_my_data(100);
                },
                crate::ExecutionPhase::Last,
            );
            self.add_plan(1.0, |context| {
                assert_eq!(context.get_my_data(), 42);
            });
            self.add_periodic_plan_with_phase(
                1.0,
                |context| {
                    println!(
                        "Periodic plan at time {} with data {}",
                        context.get_current_time(),
                        context.get_my_data()
                    );
                },
                crate::ExecutionPhase::Normal,
            );
            self.queue_callback(|context| {
                let data = context.get_data(MyData);
                assert_eq!(*data, 42);
            });
        }
        fn setup(&mut self) {
            let data = self.get_data_mut(MyData);
            *data = 42;
            do_stuff_with_context(self);
        }
        fn get_my_data(&self) -> i32 {
            *self.get_data(MyData)
        }
        fn set_my_data(&mut self, value: i32) {
            let data = self.get_data_mut(MyData);
            *data = value;
        }
        fn test_external_function(&mut self) {
            self.setup();
            do_stuff_with_context(self);
        }
    }
    impl MyDataExt for Context {}

    #[test]
    fn test_all_methods() {
        let mut context = Context::new();
        context.all_methods_mut();
        context.all_methods();
        context.execute();
    }

    #[test]
    fn test_plugin_context() {
        let mut context = Context::new();
        context.setup();
        assert_eq!(context.get_my_data(), 42);
    }

    #[test]
    fn test_external_function() {
        let mut context = Context::new();
        context.test_external_function();
        assert_eq!(context.get_my_data(), 42);
    }
}