slidy 0.3.2

Utilities for working with sliding puzzles
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

//! Defines ways in which an [`Algorithm`] can be displayed.
//!
//! [`Algorithm`]: ../../algorithm.html

use std::{
    fmt::{Display, Write as _},
    marker::PhantomData,
};

use crate::algorithm::{
    as_slice::AsAlgorithmSlice, display::r#move::MoveDisplay, slice::AlgorithmSlice,
};

/// Marker trait for structs that are used to display algorithms
pub trait AlgorithmDisplay<'a> {
    /// Create a new [`AlgorithmDisplay`] for displaying `algorithm`.
    #[must_use]
    fn new<Alg: AsAlgorithmSlice<'a>>(algorithm: &'a Alg) -> Self;
}

macro_rules! define_display {
    ($(#[$annot:meta] $name:ident),* $(,)?) => {
        $(
            #[$annot]
            #[derive(Clone, Debug)]
            pub struct $name<'a, T: MoveDisplay + Display> {
                algorithm: AlgorithmSlice<'a>,
                phantom_t: PhantomData<T>,
            }

            impl<'a, T: MoveDisplay + Display> AlgorithmDisplay<'a> for $name<'a, T> {
                fn new<Alg: AsAlgorithmSlice<'a>>(algorithm: &'a Alg) -> Self {
                    Self {
                        algorithm: algorithm.as_slice(),
                        phantom_t: PhantomData,
                    }
                }
            }
        )*
    };
}

define_display!(
    /// Formats each move of the algorithm using `T` and adds a space between moves.
    DisplaySpaced,
    /// Formats each move of the algorithm using `T`.
    DisplayUnspaced
);

impl<T: MoveDisplay + Display> Display for DisplaySpaced<'_, T> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut moves = self.algorithm.moves();

        if let Some(first) = moves.next() {
            f.write_str(&T::new(first).to_string())?;
        }

        for m in moves {
            f.write_char(' ')?;
            f.write_str(&T::new(m).to_string())?;
        }

        Ok(())
    }
}

impl<T: MoveDisplay + Display> Display for DisplayUnspaced<'_, T> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        for m in self.algorithm.moves() {
            T::new(m).fmt(f)?;
        }
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use std::str::FromStr as _;

    use crate::algorithm::{
        algorithm::Algorithm,
        display::{
            algorithm::{AlgorithmDisplay as _, DisplaySpaced, DisplayUnspaced},
            r#move::{DisplayLongSpaced, DisplayLongUnspaced, DisplayShort},
        },
    };

    #[test]
    fn test_display() {
        let a = Algorithm::from_str("U2RDL3").unwrap();
        let d1 = DisplaySpaced::<DisplayLongSpaced>::new(&a).to_string();
        let d2 = DisplaySpaced::<DisplayLongUnspaced>::new(&a).to_string();
        let d3 = DisplaySpaced::<DisplayShort>::new(&a).to_string();
        let d4 = DisplayUnspaced::<DisplayLongSpaced>::new(&a).to_string();
        let d5 = DisplayUnspaced::<DisplayLongUnspaced>::new(&a).to_string();
        let d6 = DisplayUnspaced::<DisplayShort>::new(&a).to_string();
        assert_eq!(d1, "U U R D L L L");
        assert_eq!(d2, "UU R D LLL");
        assert_eq!(d3, "U2 R D L3");
        assert_eq!(d4, "U URDL L L");
        assert_eq!(d5, "UURDLLL");
        assert_eq!(d6, "U2RDL3");

        assert_eq!(a.display_long_spaced().to_string(), d1);
        assert_eq!(a.display_long_unspaced().to_string(), d5);
        assert_eq!(a.display_short_spaced().to_string(), d3);
        assert_eq!(a.display_short_unspaced().to_string(), d6);
    }
}

#[cfg(all(feature = "nightly", test))]
mod benchmarks {
    extern crate test;

    use std::str::FromStr as _;

    use test::Bencher;

    use crate::algorithm::{algorithm::Algorithm, display::r#move::DisplayShort};

    use super::*;

    #[bench]
    fn bench_display_spaced_display_short(b: &mut Bencher) {
        let a = Algorithm::from_str(
            "DR2D2LULURUR2DL2DRU2RD2LDRULULDRDL2URDLU3RDLUR3DLDLU2RD3LU3R2DLD2LULU2R3D3",
        )
        .unwrap();

        b.iter(|| DisplaySpaced::<DisplayShort>::new(&a).to_string());
    }

    #[bench]
    fn bench_display_unspaced_display_short(b: &mut Bencher) {
        let a = Algorithm::from_str(
            "DR2D2LULURUR2DL2DRU2RD2LDRULULDRDL2URDLU3RDLUR3DLDLU2RD3LU3R2DLD2LULU2R3D3",
        )
        .unwrap();

        b.iter(|| DisplayUnspaced::<DisplayShort>::new(&a).to_string());
    }
}