pack 0.4.0

Solver for packing puzzle.
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
143
144
145
146
147
148
149

//! template is a container to hold orientations of pieces.

use std::convert::From;
use super::super::vector::VectorAdd;
use super::{Position, Normalizable, Piece, CubeSymmetryIterator, Translatable, Transformable, MinimumPosition};

/// A `Template` is a container to hold a representation of a `Piece`. By
/// Iterating over a one gets a piece in all the possible orientations.
#[derive(Debug, PartialEq, Eq, Hash, Clone)]
pub struct Template<T> {
    positions: Vec<Position<T>>,
    name: Option<String>
}

impl<T> Template<T> {
    /// Create a `Template` from a vector of `Position`s.
    pub fn new(positions: Vec<Position<T>>) -> Template<T> {
        Template { positions, name: None }
    }

    /// Create a named `Template` from this `Template`
    pub fn with_name<S>(self, name: S) -> Template<T> where S : Into<String> {
        let name = Some(name.into());

        Template { positions: self.positions, name }
    }
}

impl<T> IntoIterator for Template<T> where T: Clone + PartialOrd + Ord + Transformable + Normalizable<T> + VectorAdd<T> {
    type Item = Piece<T>;
    type IntoIter = PieceIterator<T>;

    fn into_iter(self) -> Self::IntoIter {
        PieceIterator::new(self)
    }
}


/// The `PieceIterator` will return `Piece`s  in all the orientations possible
/// from a `Template`
pub struct PieceIterator<T> {
    symmetry_iterator: CubeSymmetryIterator,
    seen_pieces: Vec<Piece<T>>,
    template: Template<T>,
}

impl<T> PieceIterator<T> {
    /// Creates a `PieceIterator` for the `Template` that is passed as an argument
    pub fn new(template: Template<T>) -> PieceIterator<T> {
        PieceIterator {
            symmetry_iterator: CubeSymmetryIterator::new(),
            seen_pieces: vec!(),
            template,
        }
    }
}

impl<T> Iterator for PieceIterator<T> where T: Clone + PartialEq + Eq + PartialOrd + Ord + Transformable + Normalizable<T> + VectorAdd<T> {
    type Item = Piece<T>;

    fn next(&mut self) -> Option<Self::Item> {
        let mut symmetry_option = self.symmetry_iterator.next();
        while symmetry_option.is_some() {
            let piece_option = symmetry_option.map(|symmetry|{
                let mut piece = Piece::from(self.template.clone());

                piece.transform(&symmetry);
                let minimum_position = piece.minimum_position();
                let translation = minimum_position.unwrap().to_reference();
                piece.translate(&translation);

                piece
            });

            if piece_option.is_some() {
                let piece = piece_option.unwrap();
                let clone = piece.clone();
                if !self.seen_pieces.contains(&clone) {
                    self.seen_pieces.push(clone);

                    return Some(piece)
                }
            }

            symmetry_option = self.symmetry_iterator.next();
        }
        None
    }
}

impl<T> From<Template<T>> for Piece<T> where T: Clone + PartialOrd + Ord + Transformable + Normalizable<T> + VectorAdd<T> {
    fn from(template: Template<T>) -> Self {
        if template.name.is_some() {
            Piece::named(template.positions, template.name.unwrap())
        } else {
            Piece::new(template.positions)
        }
    }
}

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

    #[test]
    fn templates_are_equal_on_values() {
        let a = Template::new(vec!(
            Position::new(0,0,0),
            Position::new(1,0,0),
        ));
        let b = Template::new(vec!(
            Position::new(0,0,0),
            Position::new(1,0,0),
        ));

        assert_eq!(a, b);
    }


    #[test]
    fn templates_should_return_24_pieces_unsymmetric_templates() {
        let template = Template::new(vec!(
            Position::new(0, 0, 0),
            Position::new(1, 0, 0),
            Position::new(1, 1, 0),
            Position::new(1, 1, 1),
            Position::new(1, 1, 2),
        ));

        let iterator: PieceIterator<(i8, i8, i8)> = template.into_iter();

        assert_eq!(iterator.count(), 24);
    }

    #[test]
    fn templates_should_return_less_than_24_pieces_for_symmetric_templates() {
        let template = Template::new(vec!(
            Position::new(0, 0, 0),
            Position::new(0, 1, 0),
            Position::new(1, 0, 0),
            Position::new(1, 1, 0),
        ));

        let iterator: PieceIterator<(i8, i8, i8)>= template.into_iter();

        assert_eq!(iterator.count(), 3);
    }
}