ggq 0.1.1

A simulation framework for multi-server queues.
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

use crate::customer::Customer;
use std::cmp::Ordering;

#[derive(Debug)]
pub(crate) enum EventType {
    Arrival,
    StartService,
    Departure,
}

impl std::fmt::Display for EventType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            EventType::Arrival => write!(f, "Arrival"),
            EventType::StartService => write!(f, "StartService"),
            EventType::Departure => write!(f, "Departure"),
        }
    }
}

impl PartialOrd for EventType {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

impl Ord for EventType {
    fn cmp(&self, other: &Self) -> Ordering {
        use EventType::*;
        match (self, other) {
            (Departure, Departure) | (StartService, StartService) | (Arrival, Arrival) => {
                Ordering::Equal
            }
            (Departure, _) => Ordering::Greater,
            (_, Departure) => Ordering::Less,
            (StartService, _) => Ordering::Greater,
            (_, StartService) => Ordering::Less,
        }
    }
}

impl PartialEq for EventType {
    fn eq(&self, other: &Self) -> bool {
        self == other
    }
}

impl Eq for EventType {}

#[derive(Debug)]
pub(crate) struct Event {
    pub(crate) event_type: EventType,
    customer: Customer,
    pub(crate) t: f64,
}

impl Event {
    pub fn new(event_type: EventType, customer: Customer, t: f64) -> Self {
        Self {
            event_type,
            customer,
            t,
        }
    }

    pub fn get_customer(&self) -> Customer {
        self.customer
    }

    pub fn get_customer_mut(&mut self) -> &mut Customer {
        &mut self.customer
    }
}

impl std::fmt::Display for Event {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "Event({:15}, {:.4}, {})",
            self.event_type,
            self.t,
            self.get_customer()
        )
    }
}

impl PartialEq for Event {
    fn eq(&self, other: &Self) -> bool {
        other.t.eq(&self.t) && self.event_type == other.event_type
    }
}

impl Eq for Event {}

impl PartialOrd for Event {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        if self.t == other.t {
            return self.event_type.partial_cmp(&other.event_type);
        }
        other.t.partial_cmp(&self.t)
    }
}

impl Ord for Event {
    fn cmp(&self, other: &Self) -> Ordering {
        self.partial_cmp(&other).unwrap()
    }
}