open_pql/base/board/
mod.rs

1use super::{mem, Card, Card64, From, Into, PQLCardCount, Rank, Rank16, *};
2
3mod flop;
4mod river;
5mod turn;
6
7pub use flop::Flop;
8pub use river::River;
9pub use turn::Turn;
10
11#[derive(Clone, Copy, Into, From, Default, Eq, PartialEq)]
12pub struct Board {
13    pub flop: Flop,
14    pub turn: Turn,
15    pub river: River,
16}
17
18impl Board {
19    #[must_use]
20    pub fn swap_turn(self, c: Card) -> Self {
21        Self {
22            flop: self.flop,
23            turn: c.into(),
24            river: self.river,
25        }
26    }
27
28    #[must_use]
29    pub fn swap_river(self, c: Card) -> Self {
30        Self {
31            flop: self.flop,
32            turn: self.turn,
33            river: c.into(),
34        }
35    }
36
37    pub fn contains_card(self, c: Card) -> bool {
38        self.flop.0 == c
39            || self.flop.1 == c
40            || self.flop.2 == c
41            || self.turn.0 == c
42            || self.river.0 == c
43    }
44}
45
46impl fmt::Debug for Board {
47    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
48        f.write_str(&format!(
49            "<{:?}{:?}{:?} {:?} {:?}>",
50            self.flop.0, self.flop.1, self.flop.2, self.turn.0, self.river.0,
51        ))
52    }
53}
54
55impl From<Board> for Flop {
56    fn from(board: Board) -> Self {
57        board.flop
58    }
59}
60
61impl From<Board> for Turn {
62    fn from(board: Board) -> Self {
63        board.turn
64    }
65}
66
67impl From<Board> for River {
68    fn from(board: Board) -> Self {
69        board.river
70    }
71}
72
73impl From<(Card, Card, Card, Card, Card)> for Board {
74    fn from(c: (Card, Card, Card, Card, Card)) -> Self {
75        Self {
76            flop: (c.0, c.1, c.2).into(),
77            turn: c.3.into(),
78            river: c.4.into(),
79        }
80    }
81}
82
83impl From<Board> for [Card; 5] {
84    fn from(b: Board) -> Self {
85        [b.flop.0, b.flop.1, b.flop.2, b.turn.into(), b.river.into()]
86    }
87}
88
89impl From<Board> for Rank16 {
90    fn from(b: Board) -> Self {
91        let mut r: Self = b.flop.into();
92
93        r.set(b.turn.into());
94        r.set(b.river.into());
95
96        r
97    }
98}
99
100#[cfg(any(test, feature = "benchmark"))]
101impl From<&[Card]> for Board {
102    fn from(cs: &[Card]) -> Self {
103        Self {
104            flop: cs[0..3].into(),
105            turn: cs[3].into(),
106            river: cs[4].into(),
107        }
108    }
109}
110
111#[cfg(test)]
112pub mod tests {
113    use super::*;
114    use crate::*;
115
116    impl Arbitrary for Board {
117        fn arbitrary(g: &mut quickcheck::Gen) -> Self {
118            CardN::<5>::arbitrary(g).as_ref().into()
119        }
120    }
121
122    impl Board {
123        pub fn to_vec(self) -> Vec<Card> {
124            vec![
125                self.flop.0,
126                self.flop.1,
127                self.flop.2,
128                self.turn.0,
129                self.river.0,
130            ]
131        }
132    }
133
134    #[quickcheck]
135    fn test_into_rank16_and_array(board: Board) {
136        let r: Rank16 = board.into();
137        let arr: [_; 5] = board.into();
138
139        assert!(r.contains_rank(board.flop.0.r));
140        assert!(r.contains_rank(board.flop.1.r));
141        assert!(r.contains_rank(board.flop.2.r));
142        assert!(r.contains_rank(board.turn.0.r));
143        assert!(r.contains_rank(board.river.0.r));
144
145        assert_eq!(arr[0], board.flop.0);
146        assert_eq!(arr[1], board.flop.1);
147        assert_eq!(arr[2], board.flop.2);
148        assert_eq!(arr[3], board.turn.0);
149        assert_eq!(arr[4], board.river.0);
150    }
151}
open_pql/base/board/mod.rs

open_pql/base/board/
mod.rs
