domino_lib/utils/
types.rs

1use std::{collections::vec_deque::{Iter}, ops::{Index, IndexMut}};
2use std::vec::IntoIter;
3
4use serde::{Deserialize, Serialize};
5
6#[derive(Debug, Clone, Copy, Hash, Eq)]
7pub struct Tile(pub i32, pub i32);
8
9impl std::fmt::Display for Tile {
10  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11    write!(f, "[{},{}]", self.0, self.1)
12  }
13}
14
15impl std::str::FromStr for Tile {
16  type Err = std::num::ParseIntError;
17  fn from_str(s: &str) -> Result<Self, Self::Err> {
18    let v: Vec<i32> = s
19      .trim_matches(|c| c == '[' || c == ']')
20      .split(',')
21      .map(|s| s.parse().unwrap())
22      .collect();
23    Ok(Tile(v[0], v[1]))
24  }
25}
26
27impl Serialize for Tile {
28  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
29  where
30    S: serde::Serializer,
31  {
32    serializer.serialize_str(&format!("[{},{}]", self.0, self.1))
33  }
34}
35
36impl<'de> Deserialize<'de> for Tile {
37  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
38  where
39    D: serde::Deserializer<'de>,
40  {
41    let s = String::deserialize(deserializer)?;
42    let v: Vec<i32> = s
43      .trim_matches(|c| c == '[' || c == ']')
44      .split(',')
45      .map(|s| s.parse().unwrap())
46      .collect();
47    Ok(Tile(v[0], v[1]))
48  }
49}
50
51impl PartialEq for Tile {
52    fn eq(&self, other: &Self) -> bool {
53        self.0 == other.0 && self.1 == other.1 || self.0 == other.1 && self.1 == other.0
54    }
55}
56
57impl From<(i32, i32)> for Tile {
58    fn from(value: (i32, i32)) -> Self {
59        Tile(value.0, value.1)
60    }
61}
62
63impl Tile {
64    pub fn flip(self) -> Self {
65        Tile(self.1, self.0)
66    }
67}
68
69pub type Solution = Vec<Tile>;
70
71#[derive(Debug, Clone, Eq, PartialEq, Hash)]
72pub struct Puzzle(pub Vec<Option<Tile>>);
73
74impl Puzzle {
75
76  pub fn len(&self) -> usize {
77    self.0.len()
78  }
79
80  pub fn into_iter(self) -> std::vec::IntoIter<Option<Tile>> {
81    self.0.into_iter()
82  }
83}
84
85impl Index<usize> for Puzzle {
86    type Output = Option<Tile>;
87    fn index(&self, index: usize) -> &Self::Output {
88        &self.0[index]
89    }
90}
91
92impl IndexMut<usize> for Puzzle {
93    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
94        &mut self.0[index]
95    }
96}
97
98impl std::fmt::Display for Puzzle {
99    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
100        write!(f, "{:?}", self.0)
101    }
102}
103
104impl Serialize for Puzzle {
105    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
106    where
107        S: serde::Serializer,
108    {
109        let mut s = vec![];
110        self.0.iter().for_each(|t| {
111          if let Some(t) = t {
112            s.push(t.to_string());
113          } else {
114            s.push("null".to_string());
115          }
116         });
117         let result = "[".to_string() + &s.join(",") + "]";
118        serializer.serialize_str(&result)
119    }
120}
121
122impl<'de> Deserialize<'de> for Puzzle {
123    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
124    where
125        D: serde::Deserializer<'de>,
126    {
127        let s = String::deserialize(deserializer)?;
128        let mut v: Vec<Option<Tile>> = vec![];
129        s
130            .trim_matches(|c| c == '[' || c == ']')
131            .split(',')
132            .for_each(|tile| {
133              if tile == "null" {
134                v.push(None);
135              } else {
136                let parsed_tile: Tile = tile.parse().unwrap();
137                v.push(Some(parsed_tile));
138              }
139            });
140
141        Ok(Puzzle(v))
142    }
143}
144
145impl From<Vec<Option<Tile>>> for Puzzle {
146    fn from(value: Vec<Option<Tile>>) -> Self {
147        Puzzle(value)
148    }
149}
domino_lib/utils/types.rs

domino_lib/utils/
types.rs
