espada 0.3.1

Texas Hold'em poker odds evaluator
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

use crate::card::Card;
use std::fmt::{Debug, Display, Formatter};
use std::ops::Index;
use std::str::FromStr;

#[derive(PartialEq, Eq, Hash, Clone, Copy)]
pub struct CardPair(Card, Card);

impl CardPair {
    pub fn new(left: Card, right: Card) -> CardPair {
        if left > right {
            CardPair(right, left)
        } else {
            CardPair(left, right)
        }
    }
}

impl Index<usize> for CardPair {
    type Output = Card;

    fn index(&self, index: usize) -> &Self::Output {
        match index {
            0 => &self.0,
            1 => &self.1,
            _ => panic!("index out of range."),
        }
    }
}

impl Display for CardPair {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}{}", self.0, self.1)
    }
}

impl Debug for CardPair {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "CardPair({}{})", self.0, self.1)
    }
}

impl FromStr for CardPair {
    type Err = ParseCardPairError;

    fn from_str(value: &str) -> Result<Self, Self::Err> {
        if value.len() != 4 {
            return Err(Self::Err::InvalidLength(value.len()));
        }

        match (Card::from_str(&value[0..2]), Card::from_str(&value[2..4])) {
            (Ok(l), Ok(r)) => Ok(CardPair::new(l, r)),
            (Err(_), _) => Err(Self::Err::InvalidCardStr((&value[0..2]).to_string())),
            (Ok(_), Err(_)) => Err(Self::Err::InvalidCardStr((&value[2..4]).to_string())),
        }
    }
}

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

    mod tests_from_str {
        use super::*;
        use crate::card::{Rank, Suit};

        #[test]
        fn it_parses_str_into_card_set_askc() {
            assert_eq!(
                CardPair::from_str("AsKc").unwrap(),
                CardPair::new(
                    Card::new(Rank::Ace, Suit::Spade),
                    Card::new(Rank::King, Suit::Club),
                )
            );
        }

        #[test]
        fn it_returns_error_when_invalid_length() {
            assert_eq!(
                CardPair::from_str("As Kc").unwrap_err(),
                ParseCardPairError::InvalidLength(5),
            );
        }

        #[test]
        fn it_returns_error_when_invalid_string() {
            assert_eq!(
                CardPair::from_str("AsKj").unwrap_err(),
                ParseCardPairError::InvalidCardStr("Kj".to_string()),
            );
        }
    }
}

#[derive(Debug, PartialEq, Eq)]
pub enum ParseCardPairError {
    InvalidLength(usize),
    InvalidCardStr(String),
}