tennis 0.0.1-alpha

Tennis data structures
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

use std::fmt;

/// The numeric value corresponds to the number of points won.
#[derive(Debug)]
pub enum ScoreValue {
	Love = 0,
	Fifteen = 1,
	Thirty = 2,
	Forty = 3,
	Ad = 4,
}

impl fmt::Display for ScoreValue {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		let s = match *self {
			Self::Love => "0",
			Self::Fifteen => "15",
			Self::Thirty => "30",
			Self::Forty => "40",
			Self::Ad => "Ad",
		};
		write!(f, "{}", s)
	}
}

#[derive(Debug)]
pub enum Score {
	Love,
	LoveFifteen,
	LoveThirty,
	LoveForty,
	FifteenLove,
	FifteenAll,
	FifteenThirty,
	FifteenForty,
	ThirtyLove,
	ThirtyFifteen,
	ThirtyAll,
	ThirtyForty,
	FortyLove,
	FortyFifteen,
	FortyThirty,
	Deuce,
	AdIn,
	AdOut,
}

impl Score {
	pub fn to_score_values(&self) -> (ScoreValue, ScoreValue) {
		match &self {
			Self::Love => (ScoreValue::Love, ScoreValue::Love),
			Self::LoveFifteen => (ScoreValue::Love, ScoreValue::Fifteen),
			Self::LoveThirty => (ScoreValue::Love, ScoreValue::Thirty),
			Self::LoveForty => (ScoreValue::Love, ScoreValue::Forty),
			Self::FifteenLove => (ScoreValue::Fifteen, ScoreValue::Love),
			Self::FifteenAll => (ScoreValue::Fifteen, ScoreValue::Fifteen),
			Self::FifteenThirty => (ScoreValue::Fifteen, ScoreValue::Thirty),
			Self::FifteenForty => (ScoreValue::Fifteen, ScoreValue::Forty),
			Self::ThirtyLove => (ScoreValue::Thirty, ScoreValue::Love),
			Self::ThirtyFifteen => (ScoreValue::Thirty, ScoreValue::Fifteen),
			Self::ThirtyAll => (ScoreValue::Thirty, ScoreValue::Thirty),
			Self::ThirtyForty => (ScoreValue::Thirty, ScoreValue::Forty),
			Self::FortyLove => (ScoreValue::Forty, ScoreValue::Love),
			Self::FortyFifteen => (ScoreValue::Forty, ScoreValue::Fifteen),
			Self::FortyThirty => (ScoreValue::Forty, ScoreValue::Thirty),
			Self::Deuce => (ScoreValue::Forty, ScoreValue::Forty),
			Self::AdIn => (ScoreValue::Ad, ScoreValue::Forty),
			Self::AdOut => (ScoreValue::Forty, ScoreValue::Ad),
		}
	}
}

impl fmt::Display for Score {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		let val_s;
		let s = match &*self {
			Self::AdIn => "Ad In",
			Self::AdOut => "Ad Out",
			_ => {
				let v = self.to_score_values();
				val_s = format!("{}\u{2013}{}", v.0, v.1);
				&val_s
			}
		};
		write!(f, "{}", s)
	}
}

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

	#[test]
	fn display_love() {
		assert_eq!(format!("{}", Score::Love), "0\u{2013}0".to_string());
	}

	#[test]
	fn display_fifteen_love() {
		assert_eq!(format!("{}", Score::FifteenLove), "15\u{2013}0".to_string());
	}

	#[test]
	fn display_deuce() {
		assert_eq!(format!("{}", Score::Deuce), "40\u{2013}40".to_string());
	}

	#[test]
	fn display_ad_in() {
		assert_eq!(format!("{}", Score::AdIn), "Ad In".to_string());
	}

	#[test]
	fn display_ad_out() {
		assert_eq!(format!("{}", Score::AdOut), "Ad Out".to_string());
	}
}