apply empty to other crates

Author: michaelkirk

geo-traits/src/to_geo.rs

@@ -81,7 +81,7 @@ impl<T: CoordNum, G: PolygonTrait<T = T>> ToGeoPolygon<T> for G {
         let exterior = if let Some(exterior) = self.exterior() {
             exterior.to_line_string()
         } else {
-            LineString::new(vec![])
+            LineString::empty()
         };
         let interiors = self
             .interiors()

geo/src/algorithm/bool_ops/i_overlay_integration.rs

@@ -54,7 +54,7 @@ pub(super) mod convert {
             line_string.0.reverse();
             line_string
         });
-        let exterior = rings.next().unwrap_or(LineString::new(vec![]));
+        let exterior = rings.next().unwrap_or(LineString::empty());
 
         Polygon::new(exterior, rings.collect())
     }

geo/src/algorithm/bool_ops/tests.rs

@@ -31,7 +31,7 @@ fn test_unary_union_errors() {
 
     let naive_union = {
         let start = Instant::now();
-        let mut output = MultiPolygon::new(Vec::new());
+        let mut output = MultiPolygon::empty();
         for poly in input.iter() {
             output = output.union(poly);
         }
@@ -279,7 +279,7 @@ mod gh_issues {
             wkt!(POLYGON((3.3493652 -55.80127,171.22443 -300.,195.83728 -300.,-46.650635 30.80127,3.3493652 -55.80127))),
         ];
 
-        let mut multi: MultiPolygon<f32> = MultiPolygon::new(Vec::new());
+        let mut multi: MultiPolygon<f32> = MultiPolygon::empty();
         for poly in polygons {
             multi = multi.union(&MultiPolygon::new(vec![poly]));
         }

geo/src/algorithm/centroid.rs

@@ -745,7 +745,7 @@ mod test {
     // Tests: Centroid of MultiLineString
     #[test]
     fn empty_multilinestring_test() {
-        let mls: MultiLineString = MultiLineString::new(vec![]);
+        let mls: MultiLineString = MultiLineString::empty();
         let centroid = mls.centroid();
         assert!(centroid.is_none());
     }
@@ -924,7 +924,7 @@ mod test {
     fn empty_interior_polygon_test() {
         let poly = Polygon::new(
             LineString::from(vec![p(0., 0.), p(0., 1.), p(1., 1.), p(1., 0.), p(0., 0.)]),
-            vec![LineString::new(vec![])],
+            vec![LineString::empty()],
         );
         assert_eq!(poly.centroid(), Some(p(0.5, 0.5)));
     }
@@ -947,7 +947,7 @@ mod test {
     // Tests: Centroid of MultiPolygon
     #[test]
     fn empty_multipolygon_polygon_test() {
-        assert!(MultiPolygon::<f64>::new(Vec::new()).centroid().is_none());
+        assert!(MultiPolygon::<f64>::empty().centroid().is_none());
     }
 
     #[test]

geo/src/algorithm/closest_point.rs

@@ -260,7 +260,7 @@ mod tests {
 
     #[test]
     fn empty_line_string_is_indeterminate() {
-        let ls = LineString::new(Vec::new());
+        let ls = LineString::empty();
         let p = Point::new(0.0, 0.0);
 
         let got = ls.closest_point(&p);

geo/src/algorithm/contains/mod.rs

@@ -176,7 +176,7 @@ mod test {
     /// Tests: Point in LineString
     #[test]
     fn empty_linestring_test() {
-        let linestring = LineString::new(Vec::new());
+        let linestring = LineString::empty();
         assert!(!linestring.contains(&Point::new(2., 1.)));
     }
     #[test]
@@ -196,8 +196,7 @@ mod test {
     /// Tests: Point in Polygon
     #[test]
     fn empty_polygon_test() {
-        let linestring = LineString::new(Vec::new());
-        let poly = Polygon::new(linestring, Vec::new());
+        let poly = Polygon::empty();
         assert!(!poly.contains(&Point::new(2., 1.)));
     }
     #[test]
@@ -275,7 +274,7 @@ mod test {
     /// Tests: Point in MultiPolygon
     #[test]
     fn empty_multipolygon_test() {
-        let multipoly = MultiPolygon::new(Vec::new());
+        let multipoly = MultiPolygon::empty();
         assert!(!multipoly.contains(&Point::new(2., 1.)));
     }
     #[test]
@@ -605,7 +604,7 @@ mod test {
     #[test]
     fn rect_contains_empty_polygon() {
         let rect = Rect::new(coord! { x: 90., y: 150. }, coord! { x: 300., y: 360. });
-        let empty_poly = Polygon::new(line_string![], vec![]);
+        let empty_poly = Polygon::empty();
         assert_eq!(
             rect.contains(&empty_poly),
             rect.relate(&empty_poly).is_contains()

geo/src/algorithm/coordinate_position.rs

@@ -452,7 +452,7 @@ mod test {
 
     #[test]
     fn test_empty_poly() {
-        let square_poly: Polygon<f64> = Polygon::new(LineString::new(vec![]), vec![]);
+        let square_poly: Polygon<f64> = Polygon::empty();
         assert_eq!(
             square_poly.coordinate_position(&Coord::zero()),
             CoordPos::Outside

geo/src/algorithm/densify_haversine.rs

@@ -221,7 +221,7 @@ mod tests {
 
     #[test]
     fn test_empty_linestring() {
-        let linestring: LineString<f64> = LineString::new(vec![]);
+        let linestring: LineString<f64> = LineString::empty();
         #[allow(deprecated)]
         let dense = linestring.densify_haversine(10.0);
         assert_eq!(0, dense.coords_count());

geo/src/algorithm/dimensions.rs

@@ -50,7 +50,7 @@ pub trait HasDimensions {
     /// ]);
     /// assert!(!line_string.is_empty());
     ///
-    /// let empty_line_string: LineString = LineString::new(vec![]);
+    /// let empty_line_string: LineString = LineString::empty();
     /// assert!(empty_line_string.is_empty());
     ///
     /// let point = Point::new(0.0, 0.0);
@@ -89,7 +89,7 @@ pub trait HasDimensions {
     /// assert_eq!(Dimensions::ZeroDimensional, point.dimensions());
     ///
     /// // An `Empty` dimensionality is distinct from, and less than, being 0-dimensional
-    /// let empty_collection = GeometryCollection::<f32>::new_from(vec![]);
+    /// let empty_collection = GeometryCollection::<f32>::empty();
     /// assert_eq!(Dimensions::Empty, empty_collection.dimensions());
     /// assert!(empty_collection.dimensions() < point.dimensions());
     /// ```

geo/src/algorithm/euclidean_distance.rs

@@ -769,8 +769,7 @@ mod test {
     #[test]
     // Point to LineString, empty LineString
     fn point_linestring_empty_test() {
-        let points = vec![];
-        let ls = LineString::new(points);
+        let ls = LineString::empty();
         let p = Point::new(5.0, 4.0);
         let dist = p.euclidean_distance(&ls);
         assert_relative_eq!(dist, 0.0);