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


use DataHelper;
use EntityData;
use {Process, System};

/// System which operates every certain number of updates.
pub struct LazySystem<T: Process>
{
    pub inner: Option<T>,
}

impl<T: Process> LazySystem<T>
{
    /// Create a new lazy system
    pub fn new() -> LazySystem<T>
    {
        LazySystem {
            inner: None,
        }
    }

    /// Initialise the lazy system.
    ///
    /// Returns whether the system was already initialised.
    pub fn init(&mut self, sys: T) -> bool
    {
        match self.inner {
            Some(_) => true,
            None => {
                self.inner = Some(sys);
                false
            },
        }
    }

    /// Initialise the lazy system, overriding an already existing initialisation
    ///
    /// Returns whether the system was already initialised.
    pub fn init_override(&mut self, sys: T) -> bool
    {
        let ret = self.is_initialised();
        self.inner = Some(sys);
        ret
    }

    #[inline]
    pub fn is_initialised(&self) -> bool
    {
        self.inner.is_some()
    }
}

impl<T: Process> Process for LazySystem<T>
{
    fn process(&mut self, c: &mut DataHelper<T::Components, T::Services>)
    {
        if let Some(ref mut sys) = self.inner {
            sys.process(c);
        }
    }
}

impl<T: Process> System for LazySystem<T>
{
    type Components = T::Components;
    type Services = T::Services;
    fn activated(&mut self, e: &EntityData<T::Components>, c: &T::Components, s: &mut T::Services)
    {
        self.inner.as_mut().map(|sys| sys.activated(e, c, s));
    }

    fn reactivated(&mut self, e: &EntityData<T::Components>, c: &T::Components, s: &mut T::Services)
    {
        self.inner.as_mut().map(|sys| sys.reactivated(e, c, s));
    }

    fn deactivated(&mut self, e: &EntityData<T::Components>, c: &T::Components, s: &mut T::Services)
    {
        self.inner.as_mut().map(|sys| sys.deactivated(e, c, s));
    }
}