geoarrow-array API cleanup (#1131)

- Remove `into_inner` that was only implemented on a few geometry array
types
- Remove `from_geometries` in favor of `from_nullable_geometries` on
geometry builders
- Remove `reserve_from_iter`. Use `reserve` instead with a capacity
counter
- Remove `with_capacity_from_iter` in favor of the user calling
`with_capacity` manually
- Slim down API for adding geometries into Geometry and WKB capacity
counters
- Use GAT types in `GeometryType::as_type`

Author: kylebarron

rust/geoarrow-array/src/array/geometry.rs

@@ -1053,9 +1053,9 @@ mod test {
     }
 
     fn geom_array(coord_type: CoordType) -> GeometryArray {
-        let geoms = geoms();
+        let geoms = geoms().into_iter().map(Some).collect::<Vec<_>>();
         let typ = GeometryType::new(coord_type, Default::default());
-        GeometryBuilder::from_geometries(&geoms, typ)
+        GeometryBuilder::from_nullable_geometries(&geoms, typ)
             .unwrap()
             .finish()
     }

rust/geoarrow-array/src/array/point.rs

@@ -81,11 +81,6 @@ impl PointArray {
         &self.coords
     }
 
-    /// Access the
-    pub fn into_inner(self) -> (CoordBuffer, Option<NullBuffer>) {
-        (self.coords, self.nulls)
-    }
-
     /// The lengths of each buffer contained in this array.
     pub fn buffer_lengths(&self) -> usize {
         self.len()

rust/geoarrow-array/src/array/wkt.rs

@@ -50,11 +50,6 @@ impl<O: OffsetSizeTrait> GenericWktArray<O> {
         &self.array
     }
 
-    /// Consume self and access the underlying data.
-    pub fn into_inner(self) -> GenericStringArray<O> {
-        self.array
-    }
-
     /// Slices this [`GenericWkbArray`] in place.
     /// # Panic
     /// This function panics iff `offset + length > self.len()`.

rust/geoarrow-array/src/builder/geometry.rs

@@ -6,7 +6,6 @@ use geoarrow_schema::{
     Dimension, GeometryCollectionType, GeometryType, LineStringType, Metadata, MultiLineStringType,
     MultiPointType, MultiPolygonType, PointType, PolygonType,
 };
-use wkt::WktNum;
 
 use crate::GeoArrowArray;
 use crate::array::{DimensionIndex, GenericWkbArray, GeometryArray};
@@ -296,37 +295,6 @@ impl<'a> GeometryBuilder {
         )
     }
 
-    /// Creates a new builder with a capacity inferred by the provided iterator.
-    pub fn with_capacity_from_iter<T: WktNum>(
-        geoms: impl Iterator<Item = Option<&'a (impl GeometryTrait<T = T> + 'a)>>,
-        typ: GeometryType,
-    ) -> Result<Self> {
-        let counter = GeometryCapacity::from_geometries(geoms)?;
-        Ok(Self::with_capacity(typ, counter))
-    }
-
-    /// Reserve more space in the underlying buffers with the capacity inferred from the provided
-    /// geometries.
-    pub fn reserve_from_iter<T: WktNum>(
-        &mut self,
-        geoms: impl Iterator<Item = Option<&'a (impl GeometryTrait<T = T> + 'a)>>,
-    ) -> Result<()> {
-        let counter = GeometryCapacity::from_geometries(geoms)?;
-        self.reserve(counter);
-        Ok(())
-    }
-
-    /// Reserve more space in the underlying buffers with the capacity inferred from the provided
-    /// geometries.
-    pub fn reserve_exact_from_iter<T: WktNum>(
-        &mut self,
-        geoms: impl Iterator<Item = Option<&'a (impl GeometryTrait<T = T> + 'a)>>,
-    ) -> Result<()> {
-        let counter = GeometryCapacity::from_geometries(geoms)?;
-        self.reserve_exact(counter);
-        Ok(())
-    }
-
     /// Add a new Point to the end of this array.
     ///
     /// If `self.prefer_multi` is `true`, it will be stored in the `MultiPointBuilder` child
@@ -788,22 +756,13 @@ impl<'a> GeometryBuilder {
             .unwrap();
     }
 
-    /// Create this builder from a slice of Geometries.
-    pub fn from_geometries(
-        geoms: &[impl GeometryTrait<T = f64>],
-        typ: GeometryType,
-    ) -> Result<Self> {
-        let mut array = Self::with_capacity_from_iter(geoms.iter().map(Some), typ)?;
-        array.extend_from_iter(geoms.iter().map(Some));
-        Ok(array)
-    }
-
     /// Create this builder from a slice of nullable Geometries.
     pub fn from_nullable_geometries(
         geoms: &[Option<impl GeometryTrait<T = f64>>],
         typ: GeometryType,
     ) -> Result<Self> {
-        let mut array = Self::with_capacity_from_iter(geoms.iter().map(|x| x.as_ref()), typ)?;
+        let capacity = GeometryCapacity::from_geometries(geoms.iter().map(|x| x.as_ref()))?;
+        let mut array = Self::with_capacity(typ, capacity);
         array.extend_from_iter(geoms.iter().map(|x| x.as_ref()));
         Ok(array)
     }

rust/geoarrow-array/src/builder/geometrycollection.rs

@@ -7,7 +7,6 @@ use geo_traits::{
     MultiPolygonTrait, PointTrait, PolygonTrait,
 };
 use geoarrow_schema::GeometryCollectionType;
-use wkt::WktNum;
 
 use crate::GeoArrowArray;
 use crate::array::{GenericWkbArray, GeometryCollectionArray};
@@ -38,7 +37,8 @@ impl<'a> GeometryCollectionBuilder {
         Self::with_capacity(typ, Default::default())
     }
 
-    /// Creates a new empty [`GeometryCollectionBuilder`] with the provided capacity.
+    /// Creates a new empty [`GeometryCollectionBuilder`] with the provided
+    /// [capacity][GeometryCollectionCapacity].
     pub fn with_capacity(
         typ: GeometryCollectionType,
         capacity: GeometryCollectionCapacity,
@@ -110,38 +110,6 @@ impl<'a> GeometryCollectionBuilder {
         )
     }
 
-    /// Creates a new [`GeometryCollectionBuilder`] with a capacity inferred by the provided
-    /// iterator.
-    pub fn with_capacity_from_iter<T: WktNum>(
-        geoms: impl Iterator<Item = Option<&'a (impl GeometryCollectionTrait<T = T> + 'a)>>,
-        typ: GeometryCollectionType,
-    ) -> Result<Self> {
-        let counter = GeometryCollectionCapacity::from_geometry_collections(geoms)?;
-        Ok(Self::with_capacity(typ, counter))
-    }
-
-    /// Reserve more space in the underlying buffers with the capacity inferred from the provided
-    /// geometries.
-    pub fn reserve_from_iter<T: WktNum>(
-        &mut self,
-        geoms: impl Iterator<Item = Option<&'a (impl GeometryCollectionTrait<T = T> + 'a)>>,
-    ) -> Result<()> {
-        let counter = GeometryCollectionCapacity::from_geometry_collections(geoms)?;
-        self.reserve(counter);
-        Ok(())
-    }
-
-    /// Reserve more space in the underlying buffers with the capacity inferred from the provided
-    /// geometries.
-    pub fn reserve_exact_from_iter<T: WktNum>(
-        &mut self,
-        geoms: impl Iterator<Item = Option<&'a (impl GeometryCollectionTrait<T = T> + 'a)>>,
-    ) -> Result<()> {
-        let counter = GeometryCollectionCapacity::from_geometry_collections(geoms)?;
-        self.reserve_exact(counter);
-        Ok(())
-    }
-
     /// Push a Point onto the end of this builder
     #[inline]
     fn push_point(&mut self, value: Option<&impl PointTrait<T = f64>>) -> Result<()> {
@@ -299,7 +267,9 @@ impl<'a> GeometryCollectionBuilder {
         geoms: &[impl GeometryCollectionTrait<T = f64>],
         typ: GeometryCollectionType,
     ) -> Result<Self> {
-        let mut array = Self::with_capacity_from_iter(geoms.iter().map(Some), typ)?;
+        let capacity =
+            GeometryCollectionCapacity::from_geometry_collections(geoms.iter().map(Some))?;
+        let mut array = Self::with_capacity(typ, capacity);
         array.extend_from_iter(geoms.iter().map(Some));
         Ok(array)
     }
@@ -309,21 +279,11 @@ impl<'a> GeometryCollectionBuilder {
         geoms: &[Option<impl GeometryCollectionTrait<T = f64>>],
         typ: GeometryCollectionType,
     ) -> Result<Self> {
-        let mut array = Self::with_capacity_from_iter(geoms.iter().map(|x| x.as_ref()), typ)?;
-        array.extend_from_iter(geoms.iter().map(|x| x.as_ref()));
-        Ok(array)
-    }
-
-    /// Construct a new builder, pre-filling it with the provided geometries
-    pub fn from_geometries(
-        geoms: &[impl GeometryTrait<T = f64>],
-        typ: GeometryCollectionType,
-    ) -> Result<Self> {
-        let capacity = GeometryCollectionCapacity::from_geometries(geoms.iter().map(Some))?;
+        let capacity = GeometryCollectionCapacity::from_geometry_collections(
+            geoms.iter().map(|x| x.as_ref()),
+        )?;
         let mut array = Self::with_capacity(typ, capacity);
-        for geom in geoms {
-            array.push_geometry(Some(geom))?;
-        }
+        array.extend_from_iter(geoms.iter().map(|x| x.as_ref()));
         Ok(array)
     }
 

rust/geoarrow-array/src/builder/linestring.rs

@@ -121,38 +121,10 @@ impl LineStringBuilder {
         )
     }
 
-    /// Creates a new builder with a capacity inferred by the provided iterator.
-    pub fn with_capacity_from_iter<'a>(
-        typ: LineStringType,
-        geoms: impl Iterator<Item = Option<&'a (impl LineStringTrait + 'a)>>,
-    ) -> Self {
-        let counter = LineStringCapacity::from_line_strings(geoms);
-        Self::with_capacity(typ, counter)
-    }
-
-    /// Reserve more space in the underlying buffers with the capacity inferred from the provided
-    /// geometries.
-    pub fn reserve_from_iter<'a>(
-        &mut self,
-        geoms: impl Iterator<Item = Option<&'a (impl LineStringTrait + 'a)>>,
-    ) {
-        let counter = LineStringCapacity::from_line_strings(geoms);
-        self.reserve(counter)
-    }
-
-    /// Reserve more space in the underlying buffers with the capacity inferred from the provided
-    /// geometries.
-    pub fn reserve_exact_from_iter<'a>(
-        &mut self,
-        geoms: impl Iterator<Item = Option<&'a (impl LineStringTrait + 'a)>>,
-    ) {
-        let counter = LineStringCapacity::from_line_strings(geoms);
-        self.reserve_exact(counter)
-    }
-
     /// Construct a new builder, pre-filling it with the provided geometries
     pub fn from_line_strings(geoms: &[impl LineStringTrait<T = f64>], typ: LineStringType) -> Self {
-        let mut array = Self::with_capacity_from_iter(typ, geoms.iter().map(Some));
+        let capacity = LineStringCapacity::from_line_strings(geoms.iter().map(Some));
+        let mut array = Self::with_capacity(typ, capacity);
         array.extend_from_iter(geoms.iter().map(Some));
         array
     }
@@ -162,7 +134,8 @@ impl LineStringBuilder {
         geoms: &[Option<impl LineStringTrait<T = f64>>],
         typ: LineStringType,
     ) -> Self {
-        let mut array = Self::with_capacity_from_iter(typ, geoms.iter().map(|x| x.as_ref()));
+        let capacity = LineStringCapacity::from_line_strings(geoms.iter().map(|x| x.as_ref()));
+        let mut array = Self::with_capacity(typ, capacity);
         array.extend_from_iter(geoms.iter().map(|x| x.as_ref()));
         array
     }

rust/geoarrow-array/src/builder/multilinestring.rs

@@ -166,35 +166,6 @@ impl MultiLineStringBuilder {
         )
     }
 
-    /// Creates a new builder with a capacity inferred by the provided iterator.
-    pub fn with_capacity_from_iter<'a>(
-        geoms: impl Iterator<Item = Option<&'a (impl MultiLineStringTrait + 'a)>>,
-        typ: MultiLineStringType,
-    ) -> Self {
-        let counter = MultiLineStringCapacity::from_multi_line_strings(geoms);
-        Self::with_capacity(typ, counter)
-    }
-
-    /// Reserve more space in the underlying buffers with the capacity inferred from the provided
-    /// geometries.
-    pub fn reserve_from_iter<'a>(
-        &mut self,
-        geoms: impl Iterator<Item = Option<&'a (impl MultiLineStringTrait + 'a)>>,
-    ) {
-        let counter = MultiLineStringCapacity::from_multi_line_strings(geoms);
-        self.reserve(counter)
-    }
-
-    /// Reserve more space in the underlying buffers with the capacity inferred from the provided
-    /// geometries.
-    pub fn reserve_exact_from_iter<'a>(
-        &mut self,
-        geoms: impl Iterator<Item = Option<&'a (impl MultiLineStringTrait + 'a)>>,
-    ) {
-        let counter = MultiLineStringCapacity::from_multi_line_strings(geoms);
-        self.reserve_exact(counter)
-    }
-
     /// Add a new LineString to the end of this array.
     ///
     /// # Errors
@@ -330,7 +301,8 @@ impl MultiLineStringBuilder {
         geoms: &[impl MultiLineStringTrait<T = f64>],
         typ: MultiLineStringType,
     ) -> Self {
-        let mut array = Self::with_capacity_from_iter(geoms.iter().map(Some), typ);
+        let capacity = MultiLineStringCapacity::from_multi_line_strings(geoms.iter().map(Some));
+        let mut array = Self::with_capacity(typ, capacity);
         array.extend_from_iter(geoms.iter().map(Some));
         array
     }
@@ -340,7 +312,9 @@ impl MultiLineStringBuilder {
         geoms: &[Option<impl MultiLineStringTrait<T = f64>>],
         typ: MultiLineStringType,
     ) -> Self {
-        let mut array = Self::with_capacity_from_iter(geoms.iter().map(|x| x.as_ref()), typ);
+        let capacity =
+            MultiLineStringCapacity::from_multi_line_strings(geoms.iter().map(|x| x.as_ref()));
+        let mut array = Self::with_capacity(typ, capacity);
         array.extend_from_iter(geoms.iter().map(|x| x.as_ref()));
         array
     }

rust/geoarrow-array/src/builder/multipoint.rs

@@ -102,35 +102,6 @@ impl MultiPointBuilder {
         )
     }
 
-    /// Creates a new builder with a capacity inferred by the provided iterator.
-    pub fn with_capacity_from_iter<'a>(
-        geoms: impl Iterator<Item = Option<&'a (impl MultiPointTrait + 'a)>>,
-        typ: MultiPointType,
-    ) -> Self {
-        let counter = MultiPointCapacity::from_multi_points(geoms);
-        Self::with_capacity(typ, counter)
-    }
-
-    /// Reserve more space in the underlying buffers with the capacity inferred from the provided
-    /// geometries.
-    pub fn reserve_from_iter<'a>(
-        &mut self,
-        geoms: impl Iterator<Item = Option<&'a (impl MultiPointTrait + 'a)>>,
-    ) {
-        let counter = MultiPointCapacity::from_multi_points(geoms);
-        self.reserve(counter)
-    }
-
-    /// Reserve more space in the underlying buffers with the capacity inferred from the provided
-    /// geometries.
-    pub fn reserve_exact_from_iter<'a>(
-        &mut self,
-        geoms: impl Iterator<Item = Option<&'a (impl MultiPointTrait + 'a)>>,
-    ) {
-        let counter = MultiPointCapacity::from_multi_points(geoms);
-        self.reserve_exact(counter)
-    }
-
     /// Extend this builder with the given geometries
     pub fn extend_from_iter<'a>(
         &mut self,
@@ -235,7 +206,8 @@ impl MultiPointBuilder {
 
     /// Construct a new builder, pre-filling it with the provided geometries
     pub fn from_multi_points(geoms: &[impl MultiPointTrait<T = f64>], typ: MultiPointType) -> Self {
-        let mut array = Self::with_capacity_from_iter(geoms.iter().map(Some), typ);
+        let capacity = MultiPointCapacity::from_multi_points(geoms.iter().map(Some));
+        let mut array = Self::with_capacity(typ, capacity);
         array.extend_from_iter(geoms.iter().map(Some));
         array
     }
@@ -245,7 +217,8 @@ impl MultiPointBuilder {
         geoms: &[Option<impl MultiPointTrait<T = f64>>],
         typ: MultiPointType,
     ) -> Self {
-        let mut array = Self::with_capacity_from_iter(geoms.iter().map(|x| x.as_ref()), typ);
+        let capacity = MultiPointCapacity::from_multi_points(geoms.iter().map(|x| x.as_ref()));
+        let mut array = Self::with_capacity(typ, capacity);
         array.extend_from_iter(geoms.iter().map(|x| x.as_ref()));
         array
     }