Expose more APIs for accessing the WKB coordinate buffer

Author: Kontinuation

CHANGELOG.md

@@ -2,6 +2,9 @@
 
 ## Unreleased
 
+- Expose APIs for accessing the underlying WKB buffer. (#85)
+- Making structs for individual geometry types public. (#85)
+
 ## 0.9.1 - 2025-09-24
 
 - Don't panic when parsing invalid WKB (#74).

src/common.rs

@@ -200,7 +200,7 @@ impl From<WkbType> for u32 {
 }
 
 /// Endianness
-#[derive(Debug, Clone, Copy, Default, TryFromPrimitive, IntoPrimitive)]
+#[derive(Debug, Clone, Copy, Default, TryFromPrimitive, IntoPrimitive, PartialEq)]
 #[repr(u8)]
 pub enum Endianness {
     /// Big endian

src/reader/coord.rs

@@ -66,6 +66,27 @@ impl<'a> Coord<'a> {
         reader.read_f64(self.byte_order).unwrap()
     }
 
+    /// Get the byte order of WKB coordinate
+    #[inline]
+    pub fn byte_order(&self) -> Endianness {
+        self.byte_order
+    }
+
+    /// Get the slice of bytes containing the coordinate. The byte order
+    /// of coordinate can be obtained by calling [Coord::byte_order].
+    #[inline]
+    pub fn coord_slice(&self) -> &'a [u8] {
+        let start = self.offset as usize;
+        let end = start + self.size() as usize;
+        &self.buf[start..end]
+    }
+
+    /// Get the dimension of this coordinate
+    #[inline]
+    pub fn dimension(&self) -> Dimension {
+        self.dim
+    }
+
     /// The number of bytes in this object
     ///
     /// Note that this is not the same as the length of the underlying buffer

src/reader/geometry.rs

@@ -20,7 +20,10 @@ use geo_traits::{
 ///
 /// The contained [dimension][geo_traits::Dimensions] will never be `Unknown`.
 #[derive(Debug, Clone)]
-pub struct Wkb<'a>(WkbInner<'a>);
+pub struct Wkb<'a> {
+    buf: &'a [u8],
+    inner: WkbInner<'a>,
+}
 
 impl<'a> Wkb<'a> {
     /// Parse a WKB byte slice into a geometry.
@@ -38,13 +41,13 @@ impl<'a> Wkb<'a> {
     /// newly-allocated `f64`.
     pub fn try_new(buf: &'a [u8]) -> WkbResult<Self> {
         let inner = WkbInner::try_new(buf)?;
-        Ok(Self(inner))
+        Ok(Self { buf, inner })
     }
 
     /// Return the [Dimension] of this geometry.
     pub fn dimension(&self) -> Dimension {
         use WkbInner::*;
-        match &self.0 {
+        match &self.inner {
             Point(g) => g.dimension(),
             LineString(g) => g.dimension(),
             Polygon(g) => g.dimension(),
@@ -58,7 +61,7 @@ impl<'a> Wkb<'a> {
     /// Return the [GeometryType] of this geometry.
     pub fn geometry_type(&self) -> GeometryType {
         use WkbInner::*;
-        match &self.0 {
+        match &self.inner {
             Point(_) => GeometryType::Point,
             LineString(_) => GeometryType::LineString,
             Polygon(_) => GeometryType::Polygon,
@@ -69,9 +72,15 @@ impl<'a> Wkb<'a> {
         }
     }
 
+    /// Return the underlying buffer of this WKB geometry.
+    #[inline]
+    pub fn buf(&self) -> &'a [u8] {
+        self.buf
+    }
+
     pub(crate) fn size(&self) -> u64 {
         use WkbInner::*;
-        match &self.0 {
+        match &self.inner {
             Point(g) => g.size(),
             LineString(g) => g.size(),
             Polygon(g) => g.size(),
@@ -189,7 +198,7 @@ impl<'a> GeometryTrait for Wkb<'a> {
     > {
         use geo_traits::GeometryType as B;
         use WkbInner as A;
-        match &self.0 {
+        match &self.inner {
             A::Point(p) => B::Point(p),
             A::LineString(ls) => B::LineString(ls),
             A::Polygon(ls) => B::Polygon(ls),
@@ -265,7 +274,7 @@ impl<'a> GeometryTrait for &Wkb<'a> {
     > {
         use geo_traits::GeometryType as B;
         use WkbInner as A;
-        match &self.0 {
+        match &self.inner {
             A::Point(p) => B::Point(p),
             A::LineString(ls) => B::LineString(ls),
             A::Polygon(ls) => B::Polygon(ls),

src/reader/geometry_collection.rs

@@ -20,6 +20,9 @@ pub struct GeometryCollection<'a> {
 }
 
 impl<'a> GeometryCollection<'a> {
+    /// Construct a new GeometryCollection from a WKB buffer.
+    ///
+    /// This will parse the WKB header and extract all contained geometries.
     pub fn try_new(buf: &'a [u8], byte_order: Endianness, dim: Dimension) -> WkbResult<Self> {
         let mut offset = 0;
         let has_srid = has_srid(buf, byte_order, offset)?;
@@ -56,10 +59,14 @@ impl<'a> GeometryCollection<'a> {
         })
     }
 
+    /// The dimension of this GeometryCollection
     pub fn dimension(&self) -> Dimension {
         self.dim
     }
 
+    /// The number of bytes in this object, including any header
+    ///
+    /// Note that this is not the same as the length of the underlying buffer
     pub fn size(&self) -> u64 {
         // - 1: byteOrder
         // - 4: wkbType

src/reader/linearring.rs

@@ -40,10 +40,19 @@ pub struct LinearRing<'a> {
 }
 
 impl<'a> LinearRing<'a> {
+    /// Construct a new LinearRing from a WKB buffer.
+    ///
+    /// # Panics
+    ///
+    /// This will panic if the WKB buffer is invalid. For fallible parsing, use
+    /// [`try_new`](Self::try_new) instead.
     pub fn new(buf: &'a [u8], byte_order: Endianness, offset: u64, dim: Dimension) -> Self {
         Self::try_new(buf, byte_order, offset, dim).unwrap()
     }
 
+    /// Construct a new LinearRing from a WKB buffer.
+    ///
+    /// This will parse the number of points and validate the buffer length.
     pub fn try_new(
         buf: &'a [u8],
         byte_order: Endianness,
@@ -101,9 +110,26 @@ impl<'a> LinearRing<'a> {
         self.offset + 4 + (self.dim.size() as u64 * 8 * i)
     }
 
-    pub(crate) fn dimension(&self) -> Dimension {
+    /// The dimension of this LinearRing
+    #[inline]
+    pub fn dimension(&self) -> Dimension {
         self.dim
     }
+
+    /// The slice of bytes containing the coordinates of this LinearRing. The byte order
+    /// of LinearRing can be obtained by calling [LinearRing::byte_order].
+    #[inline]
+    pub fn coords_slice(&self) -> &'a [u8] {
+        let start = self.coord_offset(0) as usize;
+        let end = start + self.dim.size() * 8 * self.num_points;
+        &self.buf[start..end]
+    }
+
+    /// Get the byte order of WKB LinearRing
+    #[inline]
+    pub fn byte_order(&self) -> Endianness {
+        self.byte_order
+    }
 }
 
 impl<'a> LineStringTrait for LinearRing<'a> {

src/reader/linestring.rs

@@ -28,10 +28,19 @@ pub struct LineString<'a> {
 }
 
 impl<'a> LineString<'a> {
+    /// Construct a new LineString from a WKB buffer.
+    ///
+    /// # Panics
+    ///
+    /// This will panic if the WKB buffer is invalid. For fallible parsing, use
+    /// [`try_new`](Self::try_new) instead.
     pub fn new(buf: &'a [u8], byte_order: Endianness, offset: u64, dim: Dimension) -> Self {
         Self::try_new(buf, byte_order, offset, dim).unwrap()
     }
 
+    /// Construct a new LineString from a WKB buffer.
+    ///
+    /// This will parse the WKB header and validate the buffer length.
     pub fn try_new(
         buf: &'a [u8],
         byte_order: Endianness,
@@ -103,9 +112,26 @@ impl<'a> LineString<'a> {
         self.offset + 1 + 4 + 4 + (self.dim.size() as u64 * 8 * i)
     }
 
+    /// The dimension of this LineString
+    #[inline]
     pub fn dimension(&self) -> Dimension {
         self.dim
     }
+
+    /// The slice of bytes containing the coordinates of this LineString. The byte order
+    /// of LineString can be obtained by calling [LineString::byte_order].
+    #[inline]
+    pub fn coords_slice(&self) -> &'a [u8] {
+        let start = self.coord_offset(0) as usize;
+        let end = start + self.dim.size() * 8 * self.num_points;
+        &self.buf[start..end]
+    }
+
+    /// Get the byte order of WKB LineString
+    #[inline]
+    pub fn byte_order(&self) -> Endianness {
+        self.byte_order
+    }
 }
 
 impl<'a> LineStringTrait for LineString<'a> {
@@ -114,10 +140,12 @@ impl<'a> LineStringTrait for LineString<'a> {
     where
         Self: 'b;
 
+    #[inline]
     fn num_coords(&self) -> usize {
         self.num_points
     }
 
+    #[inline]
     unsafe fn coord_unchecked(&self, i: usize) -> Self::CoordType<'_> {
         Coord::new(
             self.buf,
@@ -134,10 +162,12 @@ impl<'a> LineStringTrait for &LineString<'a> {
     where
         Self: 'b;
 
+    #[inline]
     fn num_coords(&self) -> usize {
         self.num_points
     }
 
+    #[inline]
     unsafe fn coord_unchecked(&self, i: usize) -> Self::CoordType<'_> {
         Coord::new(
             self.buf,

src/reader/mod.rs

@@ -16,14 +16,16 @@ mod polygon;
 mod util;
 
 pub use crate::common::Dimension;
+pub use coord::Coord;
 pub use geometry::Wkb;
-use geometry_collection::GeometryCollection;
-use linestring::LineString;
-use multilinestring::MultiLineString;
-use multipoint::MultiPoint;
-use multipolygon::MultiPolygon;
-use point::Point;
-use polygon::Polygon;
+pub use geometry_collection::GeometryCollection;
+pub use linearring::LinearRing;
+pub use linestring::LineString;
+pub use multilinestring::MultiLineString;
+pub use multipoint::MultiPoint;
+pub use multipolygon::MultiPolygon;
+pub use point::Point;
+pub use polygon::Polygon;
 
 use crate::error::WkbResult;
 

src/reader/multilinestring.rs

@@ -83,6 +83,7 @@ impl<'a> MultiLineString<'a> {
             .fold(header, |acc, ls| acc + ls.size())
     }
 
+    /// The dimension of this MultiLineString
     pub fn dimension(&self) -> Dimension {
         self.dim
     }

src/reader/multipoint.rs

@@ -97,6 +97,7 @@ impl<'a> MultiPoint<'a> {
         header + ((1 + 4 + (self.dim.size() as u64 * 8)) * i)
     }
 
+    /// The dimension of this MultiPoint
     pub fn dimension(&self) -> Dimension {
         self.dim
     }