electosim 0.3.0

Library to compute electoral methods (as D'Hondt) and simulate elections
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

/// Trait representing an entity that has votes.
pub trait WithVotes {
    /// Returns the number of votes.
    fn get_votes(&self) -> u32;

    /// Sets the number of votes.
    fn set_votes(&mut self, votes: u32);

    /// Increases the number of votes by a given amount.
    fn increase_votes(&mut self, n: i32) {
        let current_votes = self.get_votes();
        if n < 0 {
            self.set_votes(current_votes.saturating_sub(n.abs() as u32));
        } else {
            self.set_votes(current_votes + n as u32);
        }
    }
}

/// A trait for objects that have seats.
pub trait WithSeats {
    /// Returns the number of seats.
    fn get_seats(&self) -> u16;

    /// Sets the number of seats.
    fn set_seats(&mut self, seats: u16);

    /// Increases the number of seats by a given amount.
    fn increase_seats(&mut self, n: i16) {
        let current_seats = self.get_seats();
        if n < 0 {
            self.set_seats(current_seats.saturating_sub(n.abs() as u16));
        } else {
            self.set_seats(current_seats + n as u16);
        }
    }
}

impl<T> WithVotes for Box<&mut T>
where
    T: WithVotes,
{
    fn get_votes(&self) -> u32 {
        (**self).get_votes()
    }

    fn set_votes(&mut self, votes: u32) {
        (**self).set_votes(votes);
    }
}

impl<T> WithSeats for Box<&mut T>
where
    T: WithSeats,
{
    fn get_seats(&self) -> u16 {
        (**self).get_seats()
    }

    fn set_seats(&mut self, seats: u16) {
        (**self).set_seats(seats);
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    struct Candidate {
        votes: u32,
        seats: u16,
    }

    impl WithVotes for Candidate {
        fn get_votes(&self) -> u32 {
            self.votes
        }

        fn set_votes(&mut self, votes: u32) {
            self.votes = votes;
        }
    }

    impl WithSeats for Candidate {
        fn get_seats(&self) -> u16 {
            self.seats
        }

        fn set_seats(&mut self, seats: u16) {
            self.seats = seats;
        }
    }

    #[test]
    fn test_with_votes() {
        let mut candidate = Candidate {
            votes: 1000,
            seats: 0,
        };

        assert_eq!(candidate.get_votes(), 1000);
        candidate.set_votes(2000);
        assert_eq!(candidate.get_votes(), 2000);

        candidate.increase_votes(100);
        assert_eq!(candidate.get_votes(), 2100);

        candidate.increase_votes(-200);
        assert_eq!(candidate.get_votes(), 1900);
    }

    #[test]
    fn test_with_seats() {
        let mut candidate = Candidate {
            votes: 1000,
            seats: 50,
        };

        assert_eq!(candidate.get_seats(), 50);
        candidate.set_seats(100);
        assert_eq!(candidate.get_seats(), 100);

        candidate.increase_seats(10);
        assert_eq!(candidate.get_seats(), 110);

        candidate.increase_seats(-20);
        assert_eq!(candidate.get_seats(), 90);
    }

    #[test]
    fn test_with_box() {
        let mut candidate = Candidate {
            votes: 1000,
            seats: 50,
        };

        let mut boxed_candidate = Box::new(&mut candidate);

        assert_eq!(boxed_candidate.get_votes(), 1000);
        boxed_candidate.set_votes(2000);
        assert_eq!(boxed_candidate.get_votes(), 2000);

        boxed_candidate.set_seats(100);
        assert_eq!(boxed_candidate.get_seats(), 100);
    }
}