ewkt PR - a few suggestions

geozero-shp/tests/reader.rs

@@ -1,7 +1,7 @@
 use dbase::FieldValue;
 use geozero::geojson::GeoJsonWriter;
 use geozero::wkt::WktWriter;
-use geozero::{FeatureProperties, ProcessorSink};
+use geozero::{CoordDimensions, FeatureProperties, ProcessorSink};
 use std::fs::File;
 use std::io::BufReader;
 use std::str::from_utf8;
@@ -178,8 +178,7 @@ fn point() -> Result<(), geozero_shp::Error> {
 fn pointzm() -> Result<(), geozero_shp::Error> {
     let reader = geozero_shp::Reader::from_path("./tests/data/pointm.shp")?;
     let mut wkt_data: Vec<u8> = Vec::new();
-    let mut writer = WktWriter::new(&mut wkt_data);
-    writer.dims.m = true;
+    let mut writer = WktWriter::with_dims(&mut wkt_data, CoordDimensions::xym());
     reader.iter_geometries(&mut writer).next();
     assert_eq!(
         from_utf8(&wkt_data).unwrap(),
@@ -188,8 +187,7 @@ fn pointzm() -> Result<(), geozero_shp::Error> {
 
     let reader = geozero_shp::Reader::from_path("./tests/data/pointz.shp")?;
     let mut wkt_data: Vec<u8> = Vec::new();
-    let mut writer = WktWriter::new(&mut wkt_data);
-    writer.dims.z = true;
+    let mut writer = WktWriter::with_dims(&mut wkt_data, CoordDimensions::xyz());
     reader.iter_geometries(&mut writer).next();
     assert_eq!(
         from_utf8(&wkt_data).unwrap(),
@@ -213,8 +211,7 @@ fn multipoint() -> Result<(), geozero_shp::Error> {
 fn multipointzm() -> Result<(), geozero_shp::Error> {
     let reader = geozero_shp::Reader::from_path("./tests/data/multipointz.shp")?;
     let mut wkt_data: Vec<u8> = Vec::new();
-    let mut writer = WktWriter::new(&mut wkt_data);
-    writer.dims.z = true;
+    let mut writer = WktWriter::with_dims(&mut wkt_data, CoordDimensions::xyz());
     reader.iter_geometries(&mut writer).next();
     assert_eq!(
         from_utf8(&wkt_data).unwrap(),
@@ -241,9 +238,7 @@ fn line() -> Result<(), geozero_shp::Error> {
 fn linezm() -> Result<(), geozero_shp::Error> {
     let reader = geozero_shp::Reader::from_path("./tests/data/linez.shp")?;
     let mut wkt_data: Vec<u8> = Vec::new();
-    let mut writer = WktWriter::new(&mut wkt_data);
-    writer.dims.z = true;
-    writer.dims.m = true;
+    let mut writer = WktWriter::with_dims(&mut wkt_data, CoordDimensions::xyzm());
     reader.iter_geometries(&mut writer).next();
     assert_eq!(
         from_utf8(&wkt_data).unwrap(),
@@ -252,8 +247,7 @@ fn linezm() -> Result<(), geozero_shp::Error> {
 
     let reader = geozero_shp::Reader::from_path("./tests/data/linez.shp")?;
     let mut wkt_data: Vec<u8> = Vec::new();
-    let mut writer = WktWriter::new(&mut wkt_data);
-    writer.dims.z = true; // return XYZ only
+    let mut writer = WktWriter::with_dims(&mut wkt_data, CoordDimensions::xyz());
     reader.iter_geometries(&mut writer).next();
     assert_eq!(
         from_utf8(&wkt_data).unwrap(),
@@ -272,8 +266,7 @@ fn linezm() -> Result<(), geozero_shp::Error> {
 
     let reader = geozero_shp::Reader::from_path("./tests/data/linem.shp")?;
     let mut wkt_data: Vec<u8> = Vec::new();
-    let mut writer = WktWriter::new(&mut wkt_data);
-    writer.dims.m = true;
+    let mut writer = WktWriter::with_dims(&mut wkt_data, CoordDimensions::xym());
     reader.iter_geometries(&mut writer).next();
     assert_eq!(
         from_utf8(&wkt_data).unwrap(),
@@ -326,9 +319,7 @@ fn polygon() -> Result<(), geozero_shp::Error> {
 fn polygonzm() -> Result<(), geozero_shp::Error> {
     let reader = geozero_shp::Reader::from_path("./tests/data/polygonz.shp")?;
     let mut wkt_data: Vec<u8> = Vec::new();
-    let mut writer = WktWriter::new(&mut wkt_data);
-    writer.dims.z = true;
-    writer.dims.m = true;
+    let mut writer = WktWriter::with_dims(&mut wkt_data, CoordDimensions::xyzm());
     reader.iter_geometries(&mut writer).next();
     assert_eq!(
         from_utf8(&wkt_data).unwrap(),
@@ -337,8 +328,7 @@ fn polygonzm() -> Result<(), geozero_shp::Error> {
 
     let reader = geozero_shp::Reader::from_path("./tests/data/polygonm.shp")?;
     let mut wkt_data: Vec<u8> = Vec::new();
-    let mut writer = WktWriter::new(&mut wkt_data);
-    writer.dims.m = true;
+    let mut writer = WktWriter::with_dims(&mut wkt_data, CoordDimensions::xym());
     reader.iter_geometries(&mut writer).next();
     assert_eq!(
         from_utf8(&wkt_data).unwrap(),

geozero/src/geojson/geojson_reader.rs

@@ -282,7 +282,7 @@ mod test {
     use super::*;
     use crate::geojson::GeoJsonWriter;
     use crate::wkt::WktWriter;
-    use crate::{ProcessToSvg, ToJson, ToWkt};
+    use crate::{CoordDimensions, ProcessToSvg, ToJson, ToWkt};
     use std::fs::File;
 
     #[test]
@@ -306,16 +306,14 @@ mod test {
     fn geometries3d() -> Result<()> {
         let geojson = r#"{"type": "LineString", "coordinates": [[1,1,10],[2,2,20]]}"#;
         let mut wkt_data: Vec<u8> = Vec::new();
-        let mut out = WktWriter::new(&mut wkt_data);
-        out.dims.z = true;
+        let mut out = WktWriter::with_dims(&mut wkt_data, CoordDimensions::xyz());
         assert!(read_geojson_geom(&mut geojson.as_bytes(), &mut out).is_ok());
         let wkt = std::str::from_utf8(&wkt_data).unwrap();
         assert_eq!(wkt, "LINESTRING(1 1 10,2 2 20)");
 
         let geojson = r#"{"type": "LineString", "coordinates": [[1,1],[2,2]]}"#;
         let mut wkt_data: Vec<u8> = Vec::new();
-        let mut out = WktWriter::new(&mut wkt_data);
-        out.dims.z = true;
+        let mut out = WktWriter::with_dims(&mut wkt_data, CoordDimensions::xyz());
         assert!(read_geojson_geom(&mut geojson.as_bytes(), &mut out).is_ok());
         let wkt = std::str::from_utf8(&wkt_data).unwrap();
         assert_eq!(wkt, "LINESTRING(1 1,2 2)");

geozero/src/geos/geos_reader.rs

@@ -215,8 +215,7 @@ mod test {
         let ggeom = GGeometry::new_from_wkt(wkt).unwrap();
 
         let mut wkt_data: Vec<u8> = Vec::new();
-        let mut writer = WktWriter::new(&mut wkt_data);
-        writer.dims.z = true;
+        let mut writer = WktWriter::with_dims(&mut wkt_data, CoordDimensions::xyz());
         assert!(process_geom(&ggeom, &mut writer).is_ok());
 
         assert_eq!(std::str::from_utf8(&wkt_data).unwrap(), wkt);

geozero/src/wkb/wkb_reader.rs

@@ -444,7 +444,7 @@ fn process_curvepolygon<R: Read, P: GeomProcessor>(
 mod test {
     use super::*;
     use crate::wkt::WktWriter;
-    use crate::ToWkt;
+    use crate::{CoordDimensions, ToWkt};
 
     #[test]
     fn ewkb_format() {
@@ -468,9 +468,7 @@ mod test {
 
         // Process all dimensions
         let mut wkt_data: Vec<u8> = Vec::new();
-        let mut writer = WktWriter::new(&mut wkt_data);
-        writer.dims.z = true;
-        writer.dims.m = true;
+        let mut writer = WktWriter::with_dims(&mut wkt_data, CoordDimensions::xyzm());
         assert!(process_ewkb_geom(&mut ewkb.as_slice(), &mut writer).is_ok());
         assert_eq!(
             std::str::from_utf8(&wkt_data).unwrap(),
@@ -487,8 +485,7 @@ mod test {
         assert!(info.has_z);
 
         let mut wkt_data: Vec<u8> = Vec::new();
-        let mut writer = WktWriter::new(&mut wkt_data);
-        writer.dims.z = true;
+        let mut writer = WktWriter::with_dims(&mut wkt_data, CoordDimensions::xyz());
         assert!(process_ewkb_geom(&mut ewkb.as_slice(), &mut writer).is_ok());
         assert_eq!(
             std::str::from_utf8(&wkt_data).unwrap(),
@@ -598,8 +595,12 @@ mod test {
     fn ewkb_to_wkt(ewkb_str: &str, with_z: bool) -> String {
         let ewkb = hex::decode(ewkb_str).unwrap();
         let mut wkt_data: Vec<u8> = Vec::new();
-        let mut writer = WktWriter::new(&mut wkt_data);
-        writer.dims.z = with_z;
+        let dims = if with_z {
+            CoordDimensions::xyz()
+        } else {
+            CoordDimensions::xy()
+        };
+        let mut writer = WktWriter::with_dims(&mut wkt_data, dims);
         assert_eq!(
             process_ewkb_geom(&mut ewkb.as_slice(), &mut writer).map_err(|e| e.to_string()),
             Ok(())

geozero/src/wkt/mod.rs

@@ -21,7 +21,7 @@ pub(crate) mod conversion {
         /// Convert to WKT String with dimensions.
         fn to_wkt_ndim(&self, dims: CoordDimensions) -> Result<String>;
         /// Convert to WKT String with srid, dimensions and dialect.
-        fn to_wkt_dialect(
+        fn to_wkt_with_opts(
             &self,
             dialect: WktDialect,
             dims: CoordDimensions,
@@ -31,24 +31,25 @@ pub(crate) mod conversion {
 
     impl<T: GeozeroGeometry> ToWkt for T {
         fn to_wkt(&self) -> Result<String> {
-            self.to_wkt_dialect(WktDialect::Wkt, CoordDimensions::default(), None)
+            self.to_wkt_with_opts(WktDialect::Wkt, CoordDimensions::default(), None)
         }
+
         fn to_ewkt(&self, srid: Option<i32>) -> Result<String> {
-            self.to_wkt_dialect(WktDialect::Ewkt, CoordDimensions::xyzm(), srid)
+            self.to_wkt_with_opts(WktDialect::Ewkt, CoordDimensions::xyzm(), srid)
         }
+
         fn to_wkt_ndim(&self, dims: CoordDimensions) -> Result<String> {
-            self.to_wkt_dialect(WktDialect::Wkt, dims, None)
+            self.to_wkt_with_opts(WktDialect::Wkt, dims, None)
         }
-        fn to_wkt_dialect(
+
+        fn to_wkt_with_opts(
             &self,
             dialect: WktDialect,
             dims: CoordDimensions,
             srid: Option<i32>,
         ) -> Result<String> {
             let mut out: Vec<u8> = Vec::new();
-            let mut writer = WktWriter::with_dialect(&mut out, dialect);
-            writer.dims = dims;
-            writer.srid = srid;
+            let mut writer = WktWriter::with_opts(&mut out, dialect, dims, srid);
             self.process_geom(&mut writer)?;
             String::from_utf8(out).map_err(|_| {
                 crate::error::GeozeroError::Geometry("Invalid UTF-8 encoding".to_string())
@@ -80,8 +81,8 @@ mod wkb {
     impl FromWkb for EwktString {
         fn from_wkb<R: Read>(rdr: &mut R, dialect: WkbDialect) -> Result<Self> {
             let mut out: Vec<u8> = Vec::new();
-            let mut writer = WktWriter::with_dialect(&mut out, WktDialect::Ewkt);
-            writer.dims = CoordDimensions::xyzm();
+            let mut writer =
+                WktWriter::with_opts(&mut out, WktDialect::Ewkt, CoordDimensions::xyzm(), None);
             crate::wkb::process_wkb_type_geom(rdr, &mut writer, dialect)?;
             let wkt = String::from_utf8(out).map_err(|_| {
                 crate::error::GeozeroError::Geometry("Invalid UTF-8 encoding".to_string())

geozero/src/wkt/wkt_writer.rs

@@ -6,27 +6,31 @@ use super::WktDialect;
 
 /// WKT Writer.
 pub struct WktWriter<'a, W: Write> {
-    pub dims: CoordDimensions,
-    pub srid: Option<i32>,
+    dims: CoordDimensions,
+    srid: Option<i32>,
     dialect: WktDialect,
     first_header: bool,
     out: &'a mut W,
 }
 
 impl<'a, W: Write> WktWriter<'a, W> {
     pub fn new(out: &'a mut W) -> WktWriter<'a, W> {
-        WktWriter {
-            dims: CoordDimensions::default(),
-            srid: None,
-            dialect: WktDialect::Wkt,
-            first_header: true,
-            out,
-        }
+        Self::with_opts(out, WktDialect::Wkt, CoordDimensions::default(), None)
     }
-    pub fn with_dialect(out: &'a mut W, dialect: WktDialect) -> WktWriter<'a, W> {
+
+    pub fn with_dims(out: &'a mut W, dims: CoordDimensions) -> WktWriter<'a, W> {
+        Self::with_opts(out, WktDialect::Wkt, dims, None)
+    }
+
+    pub fn with_opts(
+        out: &'a mut W,
+        dialect: WktDialect,
+        dims: CoordDimensions,
+        srid: Option<i32>,
+    ) -> WktWriter<'a, W> {
         WktWriter {
-            dims: CoordDimensions::default(),
-            srid: None,
+            dims,
+            srid,
             dialect,
             first_header: true,
             out,
@@ -75,14 +79,14 @@ impl<W: Write> GeomProcessor for WktWriter<'_, W> {
         self.dims
     }
 
-    fn xy(&mut self, x: f64, y: f64, idx: usize) -> Result<()> {
-        self.comma(idx)?;
-        self.out.write_all(format!("{x} {y}").as_bytes())?;
+    fn srid(&mut self, srid: Option<i32>) -> Result<()> {
+        self.srid = self.srid.or(srid);
         Ok(())
     }
 
-    fn srid(&mut self, srid: Option<i32>) -> Result<()> {
-        self.srid = self.srid.or(srid);
+    fn xy(&mut self, x: f64, y: f64, idx: usize) -> Result<()> {
+        self.comma(idx)?;
+        self.out.write_all(format!("{x} {y}").as_bytes())?;
         Ok(())
     }