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
150
151
152
153
154
155
156
157

//! Entities that get packed

use std::fmt::{Formatter, Display, Error};

use super::super::vector::VectorAdd;
use super::{Position, MinimumPosition, Translatable, Translation, Transformable, CubeSymmetry};

/// A piece that get packed.
#[derive(Debug, PartialEq, Eq, Hash, Clone)]
pub struct Piece<T> {
    positions: Vec<Position<T>>,
    name: Option<String>
}

impl<T> Piece<T> where T: PartialOrd + Ord + Clone {
    /// Create a new `Piece` from a collection of `Position`s.
    pub fn new(mut positions: Vec<Position<T>>) -> Piece<T> {
        positions.sort();
        Piece { positions, name: None }
    }

    /// Create a named `Piece` from a collection of `Position`s.
    pub fn named<S>(mut positions: Vec<Position<T>>, name: S) -> Piece<T> where S: Into<String> {
        positions.sort();
        Piece { positions, name: Some(name.into()) }
    }

    /// Determine if a `Position` is contained in this `Piece`.
    pub fn contains(&self, position: &Position<T>) -> bool {
        self.positions.contains(position)
    }

    /// Create an `Iterator` that iterates over all `Position`s.
    pub fn iter(&self) -> PositionIterator<T> {
        let positions: Vec<Position<T>> = self.positions.to_vec();
        PositionIterator::new(positions)
    }
}

impl Display for Piece<(i8,i8,i8)> {
    fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
        write!(f, "[")?;
        let name = self.name.clone().unwrap_or_else(|| String::from(""));
        write!(f, "{}", name)?;
        for position in &self.positions {
            write!(f, "{}", position)?
        }
        write!(f, "]")
    }
}


impl Display for Piece<(i8, i8)> {
    fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
        write!(f, "[")?;
        let name = self.name.clone().unwrap_or_else(|| String::from(""));
        write!(f, "{}", name)?;
        for position in &self.positions {
            write!(f, "{}", position)?
        }
        write!(f, "]")
    }
}

impl<T> Transformable for Piece<T> where T: Transformable + PartialOrd + Ord {
    fn transform(&mut self, symmetry: &CubeSymmetry) {
        for position in &mut self.positions {
            position.transform(symmetry);
        }
        self.positions.sort()
    }
}

impl<T> Translatable<T> for Piece<T> where T: VectorAdd<T>  {
    fn translate(&mut self, translation: &Translation<T>) {
        for position in &mut self.positions {
            position.translate(translation);
        }
    }
}

impl<T> MinimumPosition<T> for Piece<T> where T: PartialOrd + Ord + Clone {
    fn minimum_position(&self) -> Option<Position<T>> {
        self.positions.iter().min().cloned()
    }
}

/// Iterate over the `Position`s of entities.
pub struct PositionIterator<T> {
    index: usize,
    positions: Vec<Position<T>>,
}

impl<T> PositionIterator<T> {
    /// Create a `PositionIterator` that iterates over the provided positions.
    pub fn new(positions: Vec<Position<T>>) -> PositionIterator<T> {
        PositionIterator { index: 0, positions }
    }
}

impl<T> Iterator for PositionIterator<T> where T: Clone {
    type Item = Position<T>;

    fn next(&mut self) -> Option<Self::Item> {
        if self.index < self.positions.len() {
            let position = self.positions[self.index].clone();
            self.index += 1;
            Some(position)
        } else {
            None
        }
    }
}

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

    #[test]
    fn piece_should_translate() {
        let mut piece = Piece::new(vec!(
            Position::new(0, 0, 0),
            Position::new(1, 0, 0),
            Position::new(1, 1, 0),
            Position::new(1, 1, 1),
        ));
        let translation = Translation::new(5, -3, 0);

        piece.translate(&translation);

        assert_eq!(piece, Piece::new(vec!(
            Position::new(5, -3, 0),
            Position::new(6, -3, 0),
            Position::new(6, -2, 0),
            Position::new(6, -2, 1),
        )));
    }

    #[test]
    fn piece_should_tranform() {
        let mut piece = Piece::new(vec!(
            Position::new(0, 0, 0),
            Position::new(1, 0, 0),
            Position::new(1, 1, 0),
            Position::new(1, 1, 1),
        ));

        piece.transform(&CubeSymmetry::E2103);

        assert_eq!(piece, Piece::new(vec!(
            Position::new(0, 0, 0),
            Position::new(0, 1, 0),
            Position::new(1, 1, 0),
            Position::new(1, 1, -1),
        )));
    }
}