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

use std::slice::Iter as SliceIter;
use std::mem::transmute;

use vec_map::VecMap;

use super::family::{Family, FamilyMember, FamilyStore};

trait AnyEventQueue: FamilyStore {
    fn flush(&mut self);
    fn merge(&mut self, any_emitter: &mut Box<AnyEventEmitter>);
}

trait AnyEventEmitter: FamilyStore { }

struct InnerEventQueue<T> {
    events: Vec<T>,
}

impl<T> InnerEventQueue<T> {
    fn new() -> InnerEventQueue<T> {
        InnerEventQueue {
            events: Vec::new(),
        }
    }

    fn receive(&self) -> Iter<T> {
        Iter::new(self.events.iter())
    }
}

impl<T: FamilyMember> FamilyStore for InnerEventQueue<T> {
    fn family(&self) -> Family {
        T::family()
    }
}

impl<T: FamilyMember> AnyEventQueue for InnerEventQueue<T> {
    fn flush(&mut self) {
        self.events.clear();
    }

    fn merge(&mut self, any_emitter: &mut Box<AnyEventEmitter>) {
        assert_eq!(self.family(), any_emitter.family());
        let emitter: &mut Box<InnerEventEmitter<T>> = unsafe { transmute(any_emitter) };
        self.events.append(&mut emitter.events);
    }
}

pub struct Iter<'a, T: 'a> {
    iter: SliceIter<'a, T>,
}

impl<'a, T: 'a> Iter<'a, T> {
    fn new(iter: SliceIter<'a, T>) -> Iter<'a, T> {
        Iter {
            iter: iter,
        }
    }
}

impl<'a, T: 'a> Iterator for Iter<'a, T> {
    type Item = &'a T;

    fn next(&mut self) -> Option<&'a T> {
        self.iter.next()
    }
}

struct InnerEventEmitter<T> {
    events: Vec<T>,
}

impl<T> InnerEventEmitter<T> {
    fn new() -> InnerEventEmitter<T> {
        InnerEventEmitter {
            events: Vec::new(),
        }
    }

    fn emit(&mut self, event: T) {
        self.events.push(event);
    }
}

impl<T: FamilyMember> FamilyStore for InnerEventEmitter<T> {
    fn family(&self) -> Family {
        T::family()
    }
}

impl<T: FamilyMember> AnyEventEmitter for InnerEventEmitter<T> {

}

/// Used to receive registered events.
pub struct EventQueue {
    queues: VecMap<Box<AnyEventQueue>>,
}

impl EventQueue {
    /// Create a new, empty `EventQueue`.
    pub fn new() -> EventQueue {
        EventQueue {
            queues: VecMap::new(),
        }
    }

    /// Register a new event type.
    pub fn register<T: 'static + FamilyMember>(&mut self) {
        self.queues.insert(T::family(), Box::new(InnerEventQueue::<T>::new()));
    }

    /// Iterate over all events of the given type that have been emitted during
    /// the current simulation step.
    pub fn receive<T: FamilyMember>(&self) -> Iter<T> {
        let any_queue = self.queues.get(T::family()).unwrap();
        let queue: &Box<InnerEventQueue<T>> = unsafe { transmute(any_queue) };
        queue.receive()
    }

    /// Clear all events from the queue.
    pub fn flush(&mut self) {
        for (_, any_queue) in self.queues.iter_mut() {
            any_queue.flush();
        }
    }

    /// Merge events that were emitted into the queue.
    pub fn merge(&mut self, emitter: &mut EventEmitter) {
        for (family, any_emitter) in emitter.emitters.iter_mut() {
            let any_queue = self.queues.get_mut(family).unwrap();
            any_queue.merge(any_emitter);
        }
    }
}

/// Used to emit registered events.
pub struct EventEmitter {
    emitters: VecMap<Box<AnyEventEmitter>>,
}

impl EventEmitter {
    /// Create a new, empty `EventEmitter`.
    pub fn new() -> EventEmitter {
        EventEmitter {
            emitters: VecMap::new(),
        }
    }

    /// Register a new event type.
    pub fn register<T: 'static + FamilyMember>(&mut self) {
        self.emitters.insert(T::family(), Box::new(InnerEventEmitter::<T>::new()));
    }

    /// Emit a registered event type.
    pub fn emit<T: FamilyMember>(&mut self, event: T) {
        let any_emitter = self.emitters.get_mut(T::family()).unwrap();
        let emitter: &mut Box<InnerEventEmitter<T>> = unsafe { transmute(any_emitter) };
        emitter.emit(event);
    }
}