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
#![allow(dead_code)]
#![allow(unused_imports)]
#![allow(unused_variables)]
#![allow(unused_mut)]
use std::cell::Cell;
use std::cell::RefCell;
use std::cmp::Ordering;
use std::collections::BinaryHeap;
use std::ops::Deref;
use std::ops::DerefMut;
use std::rc::{Rc, Weak};
use std::usize;
use super::*;
use super::base::*;
use super::simulator::*;
pub trait AbstractEvent : Clocked{
fn execute(&mut self, ctx: &mut Context);
}
type EventId = u64;
#[derive(Debug,Clone,Copy )]
pub enum EventType {
ServerEvent,
GeneratorEvent
}
#[derive(Debug,Clone,Copy )]
pub struct Event {
id: EventId,
clock: Clock,
etype: EventType
}
impl Ord for Event {
fn cmp(&self, other: &Self) -> Ordering {
other.clock.cmp(&self.clock)
}
}
impl PartialOrd for Event {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(other.get_clock().cmp(&self.get_clock()))
}
}
impl PartialEq for Event {
fn eq(&self, other: &Self) -> bool {
self.get_clock() == other.get_clock()
}
}
impl Eq for Event {
}
impl AbstractEvent for Event {
fn execute(&mut self, ctx : &mut Context) {
match self.etype {
EventType::ServerEvent => {
let mut server = ctx.get_servers();
server.execute(ctx);
},
EventType::GeneratorEvent =>{
let mut generator = ctx.get_generator();
generator.execute(ctx);
}
}
}
}
impl Clocked for Event{
fn get_clock(&self) -> Clock {
self.clock
}
fn set_clock(&mut self, t: Clock) {
self.clock = t;
}
}
impl Event{
pub fn new( etype: EventType, clock: Clock) -> Self{
let id = 0;
Event {id, clock, etype}
}
}
#[derive(Debug)]
pub struct EventQueue {
pub elements: BinaryHeap<Event>
}
impl EventQueue {
pub fn insert(&mut self, t: Event) {
self.elements.push(t);
}
pub fn size(&self) -> usize {
self.elements.len()
}
pub fn remove_first(&mut self) -> Option<Event> {
self.elements.pop()
}
pub fn new() -> Self {
EventQueue { elements: Default::default() }
}
}
#[test]
fn test_event() {
}
#[test]
fn test_event_queue() {
}