better Pos

src/common/area.rs

@@ -3,25 +3,25 @@ use std::fmt::Display;
 
 use num_traits::{Num, NumAssignOps};
 
-use super::pos::Pos;
+use super::pos::Pos2D;
 
 #[derive(Debug, Clone, Copy, Default)]
 pub struct Area<T>
 where
     T: Num,
 {
-    lower_left: Pos<T>,
-    upper_right: Pos<T>,
+    lower_left: Pos2D<T>,
+    upper_right: Pos2D<T>,
 }
 
 impl<T> Area<T>
 where
     T: Num + Ord + Copy,
 {
-    pub fn new(p1: Pos<T>, p2: Pos<T>) -> Area<T> {
+    pub fn new(p1: Pos2D<T>, p2: Pos2D<T>) -> Area<T> {
         Area {
-            lower_left: p1.min_components(&p2),
-            upper_right: p1.max_components(&p2),
+            lower_left: p1.min_components(p2),
+            upper_right: p1.max_components(p2),
         }
     }
 }
@@ -30,25 +30,25 @@ impl<T> Area<T>
 where
     T: Num + Ord + Copy,
 {
-    pub fn extend(&self, pos: Pos<T>) -> Area<T> {
+    pub fn extend(&self, pos: Pos2D<T>) -> Area<T> {
         if self.contains(pos) {
             return *self;
         }
 
         Area {
-            lower_left: self.lower_left.min_components(&pos),
-            upper_right: self.upper_right.max_components(&pos),
+            lower_left: self.lower_left.min_components(pos),
+            upper_right: self.upper_right.max_components(pos),
         }
     }
-    pub fn get_lower_left(&self) -> Pos<T> {
+    pub fn get_lower_left(&self) -> Pos2D<T> {
         self.lower_left
     }
 
-    pub fn get_upper_right(&self) -> Pos<T> {
+    pub fn get_upper_right(&self) -> Pos2D<T> {
         self.upper_right
     }
 
-    pub fn contains(&self, pos: Pos<T>) -> bool {
+    pub fn contains(&self, pos: Pos2D<T>) -> bool {
         self.lower_left.x() >= pos.x()
             && pos.x() >= self.upper_right.x()
             && self.lower_left.y() >= pos.y()
@@ -62,11 +62,11 @@ where
 {
     pub fn from_iterator<I>(mut iter: I) -> Option<Self>
     where
-        I: Iterator<Item = &'a Pos<T>>,
+        I: Iterator<Item = &'a Pos2D<T>>,
     {
         let first = *iter.next()?;
         let (upper, lower) = iter.fold((first, first), |(mx, mn), p| {
-            (mx.max_components(p), mn.min_components(p))
+            (mx.max_components(*p), mn.min_components(*p))
         });
 
         Some(Area::new(lower, upper))
@@ -214,12 +214,12 @@ impl<'a, T> Iterator for ColIterator<'a, T>
 where
     T: Num + Ord + NumAssignOps + Copy,
 {
-    type Item = Pos<T>;
+    type Item = Pos2D<T>;
     fn next(&mut self) -> Option<Self::Item> {
         if (self.ascending && self.col <= self.area.upper_right.x())
             || (!self.ascending && self.col >= self.area.lower_left.x())
         {
-            let pos = Pos::new(self.col, self.row);
+            let pos = Pos2D::new(self.col, self.row);
             if self.ascending {
                 self.col += T::one();
             } else {
@@ -266,13 +266,13 @@ impl<'a, T> Iterator for CellIterator<'a, T>
 where
     T: Num + Ord + NumAssignOps + Copy,
 {
-    type Item = Pos<T>;
+    type Item = Pos2D<T>;
 
     fn next(&mut self) -> Option<Self::Item> {
         if (self.ascending && self.row <= self.area.upper_right.y())
             || (!self.ascending && self.row >= self.area.lower_left.y())
         {
-            let pos = Pos::new(self.col, self.row);
+            let pos = Pos2D::new(self.col, self.row);
             if self.ascending {
                 self.col += T::one();
                 if self.col > self.area.upper_right.x() {
@@ -300,18 +300,18 @@ mod test {
 
     #[test]
     fn test_cell_iterator() {
-        let area = Area::new(Pos::new(-1, -1), Pos::new(1, 1));
+        let area = Area::new(Pos2D::new(-1, -1), Pos2D::new(1, 1));
         let result = area.cells(true).collect::<Vec<_>>();
         let expected = vec![
-            Pos::new(-1, -1),
-            Pos::new(0, -1),
-            Pos::new(1, -1),
-            Pos::new(-1, 0),
-            Pos::new(0, 0),
-            Pos::new(1, 0),
-            Pos::new(-1, 1),
-            Pos::new(0, 1),
-            Pos::new(1, 1),
+            Pos2D::new(-1, -1),
+            Pos2D::new(0, -1),
+            Pos2D::new(1, -1),
+            Pos2D::new(-1, 0),
+            Pos2D::new(0, 0),
+            Pos2D::new(1, 0),
+            Pos2D::new(-1, 1),
+            Pos2D::new(0, 1),
+            Pos2D::new(1, 1),
         ];
         assert_eq!(result, expected);
     }