emergent 1.8.2

Toolset for producing emergent gameplay for games written in Rust
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

use std::collections::HashMap;

/// DataTable holds set of rows of given type assigned to keys/names.
///
/// # Example
/// ```
/// use emergent::prelude::*;
///
/// #[derive(Debug, Copy, Clone, PartialEq)]
/// enum Row {
///     Bool(bool),
///     Float(f32),
///     Tuple(usize, usize),
/// }
///
/// let mut memory = DataTable::<Row>::default();
///
/// memory.set("bool".to_owned(), Row::Bool(true));
/// memory.set("float".to_owned(), Row::Float(42.0));
/// memory.set("tuple".to_owned(), Row::Tuple(4, 2));
/// assert_eq!(memory.len(), 3);
/// assert_eq!(memory.has_row("bool"), true);
/// assert_eq!(memory.has_row("int"), false);
/// assert_eq!(memory.get("bool"), Some(&Row::Bool(true)));
/// assert_eq!(memory.get("float"), Some(&Row::Float(42.0)));
/// assert_eq!(memory.get("tuple"), Some(&Row::Tuple(4, 2)));
/// assert_eq!(
///     memory
///         .with("bool", |v| std::mem::replace(v, Row::Bool(false)))
///         .unwrap(),
///     Row::Bool(true),
/// );
/// assert_eq!(memory.get("bool"), Some(&Row::Bool(false)));
/// assert!(memory.remove("bool"));
/// assert!(memory.remove("float"));
/// assert!(memory.remove("tuple"));
/// assert_eq!(memory.len(), 0);
/// ```
pub struct DataTable<T>
where
    T: Send + Sync,
{
    rows: HashMap<String, T>,
}

impl<T> Default for DataTable<T>
where
    T: Send + Sync,
{
    fn default() -> Self {
        Self {
            rows: Default::default(),
        }
    }
}

impl<T> std::fmt::Debug for DataTable<T>
where
    T: std::fmt::Debug + Send + Sync,
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("DataTable")
            .field("rows", &self.rows)
            .finish()
    }
}

impl<T> Clone for DataTable<T>
where
    T: Clone + Send + Sync,
{
    fn clone(&self) -> Self {
        Self {
            rows: self.rows.clone(),
        }
    }
}

impl<T> DataTable<T>
where
    T: Send + Sync,
{
    /// Returns number of rows stored in datatable.
    pub fn len(&self) -> usize {
        self.rows.len()
    }

    /// Tells if there are no rows stored in datatable.
    pub fn is_empty(&self) -> bool {
        self.rows.is_empty()
    }

    /// Tells if there is a row under given name stored in datatable.
    pub fn has_row(&self, name: &str) -> bool {
        self.rows.contains_key(name)
    }

    /// Returns reference to row data.
    pub fn get(&self, name: &str) -> Option<&T> {
        self.rows.get(name)
    }

    /// Returns mutable reference to row data.
    pub fn get_mut(&mut self, name: &str) -> Option<&mut T> {
        self.rows.get_mut(name)
    }

    /// Put value to row under given name.
    pub fn set(&mut self, name: String, value: T) {
        self.rows.insert(name, value);
    }

    /// Mutate row data in-place with closure.
    pub fn with<R, F>(&mut self, name: &str, mut f: F) -> Option<R>
    where
        F: FnMut(&mut T) -> R,
    {
        if let Some(value) = self.rows.get_mut(name) {
            return Some(f(value));
        }
        None
    }

    /// Remove row under given name.
    pub fn remove(&mut self, name: &str) -> bool {
        self.rows.remove(name).is_some()
    }

    /// Remove all rows in datatable.
    pub fn clear(&mut self) {
        self.rows.clear();
    }

    /// Return iterator over rows keys.
    pub fn keys(&self) -> impl Iterator<Item = &str> {
        self.rows.keys().map(|k| k.as_str())
    }

    /// Return iterator over rows values.
    pub fn values(&self) -> impl Iterator<Item = &T> {
        self.rows.values()
    }

    /// Return iterator over rows keys and their values.
    pub fn iter(&self) -> impl Iterator<Item = (&str, &T)> {
        self.rows.iter().map(|(k, v)| (k.as_str(), v))
    }
}