No alloc support for geo-types

Author: wetheredge

geo-types/Cargo.toml

@@ -11,7 +11,8 @@ edition = "2021"
 
 [features]
 default = ["std"]
-std = []
+alloc = []
+std = ["alloc"]
 # Prefer `use-rstar` feature rather than enabling rstar directly.
 # rstar integration relies on the optional approx crate, but implicit features cannot yet enable other features.
 # See: https://doc.rust-lang.org/nightly/cargo/reference/unstable.html#namespaced-features

geo-types/src/error.rs

@@ -21,7 +21,8 @@ impl fmt::Display for Error {
     }
 }
 
-#[cfg(test)]
+// NOTE: Move feature = alloc to error_output if/when other tests that do not need alloc get added
+#[cfg(all(test, feature = "alloc"))]
 mod test {
     use crate::{Geometry, Point, Rect};
     use alloc::string::ToString;

geo-types/src/geometry/mod.rs

@@ -1,30 +1,45 @@
 pub(crate) mod coord;
-pub(crate) mod geometry_collection;
 pub(crate) mod line;
+pub(crate) mod point;
+pub(crate) mod rect;
+pub(crate) mod triangle;
+
+#[cfg(feature = "alloc")]
+pub(crate) mod geometry_collection;
+#[cfg(feature = "alloc")]
 pub(crate) mod line_string;
+#[cfg(feature = "alloc")]
 pub(crate) mod multi_line_string;
+#[cfg(feature = "alloc")]
 pub(crate) mod multi_point;
+#[cfg(feature = "alloc")]
 pub(crate) mod multi_polygon;
-pub(crate) mod point;
+#[cfg(feature = "alloc")]
 pub(crate) mod polygon;
-pub(crate) mod rect;
-pub(crate) mod triangle;
 
 // re-export all the geometry variants:
 #[allow(deprecated)]
 pub use coord::{Coord, Coordinate};
-pub use geometry_collection::GeometryCollection;
 pub use line::Line;
+pub use point::Point;
+pub use rect::Rect;
+pub use triangle::Triangle;
+
+#[cfg(feature = "alloc")]
+pub use geometry_collection::GeometryCollection;
+#[cfg(feature = "alloc")]
 pub use line_string::LineString;
+#[cfg(feature = "alloc")]
 pub use multi_line_string::MultiLineString;
+#[cfg(feature = "alloc")]
 pub use multi_point::MultiPoint;
+#[cfg(feature = "alloc")]
 pub use multi_polygon::MultiPolygon;
-pub use point::Point;
+#[cfg(feature = "alloc")]
 pub use polygon::Polygon;
-pub use rect::Rect;
-pub use triangle::Triangle;
 
-use crate::{CoordNum, Error};
+use crate::CoordNum;
+use crate::Error;
 
 #[cfg(any(feature = "approx", test))]
 use approx::{AbsDiffEq, RelativeEq};
@@ -41,7 +56,7 @@ use core::convert::TryFrom;
 ///
 /// ```
 /// use std::convert::TryFrom;
-/// use geo_types::{Point, point, Geometry, GeometryCollection};
+/// use geo_types::{Point, point, Geometry};
 /// let p = point!(x: 1.0, y: 1.0);
 /// let pe: Geometry = p.into();
 /// let pn = Point::try_from(pe).unwrap();
@@ -52,11 +67,17 @@ use core::convert::TryFrom;
 pub enum Geometry<T: CoordNum = f64> {
     Point(Point<T>),
     Line(Line<T>),
+    #[cfg(feature = "alloc")]
     LineString(LineString<T>),
+    #[cfg(feature = "alloc")]
     Polygon(Polygon<T>),
+    #[cfg(feature = "alloc")]
     MultiPoint(MultiPoint<T>),
+    #[cfg(feature = "alloc")]
     MultiLineString(MultiLineString<T>),
+    #[cfg(feature = "alloc")]
     MultiPolygon(MultiPolygon<T>),
+    #[cfg(feature = "alloc")]
     GeometryCollection(GeometryCollection<T>),
     Rect(Rect<T>),
     Triangle(Triangle<T>),
@@ -72,26 +93,31 @@ impl<T: CoordNum> From<Line<T>> for Geometry<T> {
         Self::Line(x)
     }
 }
+#[cfg(feature = "alloc")]
 impl<T: CoordNum> From<LineString<T>> for Geometry<T> {
     fn from(x: LineString<T>) -> Self {
         Self::LineString(x)
     }
 }
+#[cfg(feature = "alloc")]
 impl<T: CoordNum> From<Polygon<T>> for Geometry<T> {
     fn from(x: Polygon<T>) -> Self {
         Self::Polygon(x)
     }
 }
+#[cfg(feature = "alloc")]
 impl<T: CoordNum> From<MultiPoint<T>> for Geometry<T> {
     fn from(x: MultiPoint<T>) -> Self {
         Self::MultiPoint(x)
     }
 }
+#[cfg(feature = "alloc")]
 impl<T: CoordNum> From<MultiLineString<T>> for Geometry<T> {
     fn from(x: MultiLineString<T>) -> Self {
         Self::MultiLineString(x)
     }
 }
+#[cfg(feature = "alloc")]
 impl<T: CoordNum> From<MultiPolygon<T>> for Geometry<T> {
     fn from(x: MultiPolygon<T>) -> Self {
         Self::MultiPolygon(x)
@@ -145,6 +171,7 @@ impl<T: CoordNum> Geometry<T> {
     #[deprecated(
         note = "Will be removed in an upcoming version. Switch to std::convert::TryInto<LineString>"
     )]
+    #[cfg(feature = "alloc")]
     pub fn into_line_string(self) -> Option<LineString<T>> {
         if let Geometry::LineString(x) = self {
             Some(x)
@@ -169,6 +196,7 @@ impl<T: CoordNum> Geometry<T> {
     #[deprecated(
         note = "Will be removed in an upcoming version. Switch to std::convert::TryInto<Polygon>"
     )]
+    #[cfg(feature = "alloc")]
     pub fn into_polygon(self) -> Option<Polygon<T>> {
         if let Geometry::Polygon(x) = self {
             Some(x)
@@ -181,6 +209,7 @@ impl<T: CoordNum> Geometry<T> {
     #[deprecated(
         note = "Will be removed in an upcoming version. Switch to std::convert::TryInto<MultiPoint>"
     )]
+    #[cfg(feature = "alloc")]
     pub fn into_multi_point(self) -> Option<MultiPoint<T>> {
         if let Geometry::MultiPoint(x) = self {
             Some(x)
@@ -193,6 +222,7 @@ impl<T: CoordNum> Geometry<T> {
     #[deprecated(
         note = "Will be removed in an upcoming version. Switch to std::convert::TryInto<MultiLineString>"
     )]
+    #[cfg(feature = "alloc")]
     pub fn into_multi_line_string(self) -> Option<MultiLineString<T>> {
         if let Geometry::MultiLineString(x) = self {
             Some(x)
@@ -205,6 +235,7 @@ impl<T: CoordNum> Geometry<T> {
     #[deprecated(
         note = "Will be removed in an upcoming version. Switch to std::convert::TryInto<MultiPolygon>"
     )]
+    #[cfg(feature = "alloc")]
     pub fn into_multi_polygon(self) -> Option<MultiPolygon<T>> {
         if let Geometry::MultiPolygon(x) = self {
             Some(x)
@@ -215,11 +246,12 @@ impl<T: CoordNum> Geometry<T> {
 }
 
 macro_rules! try_from_geometry_impl {
-    ($($type: ident),+) => {
+    ($($(#[$attr:meta])* $type: ident),+) => {
         $(
         /// Convert a Geometry enum into its inner type.
         ///
         /// Fails if the enum case does not match the type you are trying to convert it to.
+        $(#[$attr])*
         impl <T: CoordNum> TryFrom<Geometry<T>> for $type<T> {
             type Error = Error;
 
@@ -240,10 +272,15 @@ macro_rules! try_from_geometry_impl {
 try_from_geometry_impl!(
     Point,
     Line,
+    #[cfg(feature = "alloc")]
     LineString,
+    #[cfg(feature = "alloc")]
     Polygon,
+    #[cfg(feature = "alloc")]
     MultiPoint,
+    #[cfg(feature = "alloc")]
     MultiLineString,
+    #[cfg(feature = "alloc")]
     MultiPolygon,
     // Disabled until we remove the deprecated GeometryCollection::from(single_geom) impl.
     // GeometryCollection,
@@ -258,11 +295,17 @@ where
     match geometry {
         Geometry::Point(_) => type_name::<Point<T>>(),
         Geometry::Line(_) => type_name::<Line<T>>(),
+        #[cfg(feature = "alloc")]
         Geometry::LineString(_) => type_name::<LineString<T>>(),
+        #[cfg(feature = "alloc")]
         Geometry::Polygon(_) => type_name::<Polygon<T>>(),
+        #[cfg(feature = "alloc")]
         Geometry::MultiPoint(_) => type_name::<MultiPoint<T>>(),
+        #[cfg(feature = "alloc")]
         Geometry::MultiLineString(_) => type_name::<MultiLineString<T>>(),
+        #[cfg(feature = "alloc")]
         Geometry::MultiPolygon(_) => type_name::<MultiPolygon<T>>(),
+        #[cfg(feature = "alloc")]
         Geometry::GeometryCollection(_) => type_name::<GeometryCollection<T>>(),
         Geometry::Rect(_) => type_name::<Rect<T>>(),
         Geometry::Triangle(_) => type_name::<Triangle<T>>(),
@@ -284,10 +327,10 @@ where
     /// # Examples
     ///
     /// ```
-    /// use geo_types::{Geometry, polygon};
+    /// use geo_types::{Geometry, Line, point};
     ///
-    /// let a: Geometry<f32> = polygon![(x: 0., y: 0.), (x: 5., y: 0.), (x: 7., y: 9.), (x: 0., y: 0.)].into();
-    /// let b: Geometry<f32> = polygon![(x: 0., y: 0.), (x: 5., y: 0.), (x: 7.01, y: 9.), (x: 0., y: 0.)].into();
+    /// let a: Geometry<f32> = Line::new(point!(x: 0., y: 0.), point!(x: 7., y: 9.)).into();
+    /// let b: Geometry<f32> = Line::new(point!(x: 0., y: 0.), point!(x: 7.01, y: 9.)).into();
     ///
     /// approx::assert_relative_eq!(a, b, max_relative=0.1);
     /// approx::assert_relative_ne!(a, b, max_relative=0.001);
@@ -302,21 +345,27 @@ where
         match (self, other) {
             (Geometry::Point(g1), Geometry::Point(g2)) => g1.relative_eq(g2, epsilon, max_relative),
             (Geometry::Line(g1), Geometry::Line(g2)) => g1.relative_eq(g2, epsilon, max_relative),
+            #[cfg(feature = "alloc")]
             (Geometry::LineString(g1), Geometry::LineString(g2)) => {
                 g1.relative_eq(g2, epsilon, max_relative)
             }
+            #[cfg(feature = "alloc")]
             (Geometry::Polygon(g1), Geometry::Polygon(g2)) => {
                 g1.relative_eq(g2, epsilon, max_relative)
             }
+            #[cfg(feature = "alloc")]
             (Geometry::MultiPoint(g1), Geometry::MultiPoint(g2)) => {
                 g1.relative_eq(g2, epsilon, max_relative)
             }
+            #[cfg(feature = "alloc")]
             (Geometry::MultiLineString(g1), Geometry::MultiLineString(g2)) => {
                 g1.relative_eq(g2, epsilon, max_relative)
             }
+            #[cfg(feature = "alloc")]
             (Geometry::MultiPolygon(g1), Geometry::MultiPolygon(g2)) => {
                 g1.relative_eq(g2, epsilon, max_relative)
             }
+            #[cfg(feature = "alloc")]
             (Geometry::GeometryCollection(g1), Geometry::GeometryCollection(g2)) => {
                 g1.relative_eq(g2, epsilon, max_relative)
             }
@@ -343,10 +392,10 @@ impl<T: AbsDiffEq<Epsilon = T> + CoordNum> AbsDiffEq for Geometry<T> {
     /// # Examples
     ///
     /// ```
-    /// use geo_types::{Geometry, polygon};
+    /// use geo_types::{Geometry, Line, point};
     ///
-    /// let a: Geometry<f32> = polygon![(x: 0., y: 0.), (x: 5., y: 0.), (x: 7., y: 9.), (x: 0., y: 0.)].into();
-    /// let b: Geometry<f32> = polygon![(x: 0., y: 0.), (x: 5., y: 0.), (x: 7.01, y: 9.), (x: 0., y: 0.)].into();
+    /// let a: Geometry<f32> = Line::new(point!(x: 0., y: 0.), point!(x: 7., y: 9.)).into();
+    /// let b: Geometry<f32> = Line::new(point!(x: 0., y: 0.), point!(x: 7.01, y: 9.)).into();
     ///
     /// approx::assert_abs_diff_eq!(a, b, epsilon=0.1);
     /// approx::assert_abs_diff_ne!(a, b, epsilon=0.001);
@@ -355,13 +404,19 @@ impl<T: AbsDiffEq<Epsilon = T> + CoordNum> AbsDiffEq for Geometry<T> {
         match (self, other) {
             (Geometry::Point(g1), Geometry::Point(g2)) => g1.abs_diff_eq(g2, epsilon),
             (Geometry::Line(g1), Geometry::Line(g2)) => g1.abs_diff_eq(g2, epsilon),
+            #[cfg(feature = "alloc")]
             (Geometry::LineString(g1), Geometry::LineString(g2)) => g1.abs_diff_eq(g2, epsilon),
+            #[cfg(feature = "alloc")]
             (Geometry::Polygon(g1), Geometry::Polygon(g2)) => g1.abs_diff_eq(g2, epsilon),
+            #[cfg(feature = "alloc")]
             (Geometry::MultiPoint(g1), Geometry::MultiPoint(g2)) => g1.abs_diff_eq(g2, epsilon),
+            #[cfg(feature = "alloc")]
             (Geometry::MultiLineString(g1), Geometry::MultiLineString(g2)) => {
                 g1.abs_diff_eq(g2, epsilon)
             }
+            #[cfg(feature = "alloc")]
             (Geometry::MultiPolygon(g1), Geometry::MultiPolygon(g2)) => g1.abs_diff_eq(g2, epsilon),
+            #[cfg(feature = "alloc")]
             (Geometry::GeometryCollection(g1), Geometry::GeometryCollection(g2)) => {
                 g1.abs_diff_eq(g2, epsilon)
             }

geo-types/src/geometry/rect.rs

@@ -1,4 +1,6 @@
-use crate::{coord, polygon, Coord, CoordFloat, CoordNum, Line, Polygon};
+use crate::{coord, Coord, CoordFloat, CoordNum, Line};
+#[cfg(feature = "alloc")]
+use crate::{polygon, Polygon};
 
 #[cfg(any(feature = "approx", test))]
 use approx::{AbsDiffEq, RelativeEq};
@@ -214,6 +216,7 @@ impl<T: CoordNum> Rect<T> {
     ///     ],
     /// );
     /// ```
+    #[cfg(feature = "alloc")]
     pub fn to_polygon(self) -> Polygon<T> {
         polygon![
             (x: self.min.x, y: self.min.y),

geo-types/src/geometry/triangle.rs

@@ -1,4 +1,6 @@
-use crate::{polygon, Coord, CoordNum, Line, Polygon};
+#[cfg(feature = "alloc")]
+use crate::{polygon, Polygon};
+use crate::{Coord, CoordNum, Line};
 
 #[cfg(any(feature = "approx", test))]
 use approx::{AbsDiffEq, RelativeEq};
@@ -52,6 +54,7 @@ impl<T: CoordNum> Triangle<T> {
     ///     ],
     /// );
     /// ```
+    #[cfg(feature = "alloc")]
     pub fn to_polygon(self) -> Polygon<T> {
         polygon![self.0, self.1, self.2, self.0]
     }

geo-types/src/lib.rs

@@ -76,6 +76,7 @@
 //! [OGC-SFA]: https://www.ogc.org/standards/sfa
 //! [rstar]: https://github.com/Stoeoef/rstar
 //! [Serde]: https://serde.rs/
+#[cfg(feature = "alloc")]
 extern crate alloc;
 extern crate num_traits;
 
@@ -116,6 +117,7 @@ impl<T: CoordNum + Float> CoordFloat for T {}
 pub mod geometry;
 pub use geometry::*;
 
+#[cfg(feature = "alloc")]
 pub use geometry::line_string::PointsIter;
 
 #[allow(deprecated)]
@@ -135,6 +137,7 @@ mod arbitrary;
 pub mod private_utils;
 
 #[doc(hidden)]
+#[cfg(feature = "alloc")]
 pub mod _alloc {
     //! Needed to access these types from `alloc` in macros when the std feature is
     //! disabled and the calling context is missing `extern crate alloc`. These are
@@ -146,6 +149,7 @@ pub mod _alloc {
 
 #[cfg(test)]
 mod tests {
+    #[cfg(feature = "alloc")]
     use alloc::vec;
 
     use super::*;
@@ -180,6 +184,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg(feature = "alloc")]
     fn polygon_new_test() {
         let exterior = LineString::new(vec![
             coord! { x: 0., y: 0. },
@@ -200,6 +205,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg(feature = "alloc")]
     fn iters() {
         let _: MultiPoint<_> = vec![(0., 0.), (1., 2.)].into();
         let _: MultiPoint<_> = vec![(0., 0.), (1., 2.)].into_iter().collect();
@@ -253,6 +259,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg(feature = "alloc")]
     fn test_rects() {
         let r = Rect::new(coord! { x: -1., y: -1. }, coord! { x: 1., y: 1. });
         let p: Polygon<_> = r.into();