WIP: parse points without heap allocation

Cargo.toml

@@ -19,10 +19,12 @@ serde_json = "~1.0"
 geo-types = { version = "0.7", features = ["serde"], optional = true }
 thiserror = "1.0.20"
 log = "0.4.17"
+tinyvec = { version = "1.6.0", features = ["serde", "alloc"] }
 
 [dev-dependencies]
 num-traits = "0.2"
 criterion = "0.4.0"
+pretty_env_logger = "0.4.0"
 
 [[bench]]
 name = "parse"

README.md

@@ -37,7 +37,7 @@ let geojson = geojson_str.parse::<GeoJson>().unwrap();
 use geojson::{Feature, GeoJson, Geometry, Value, JsonObject, JsonValue};
 
 let geometry = Geometry::new(
-    Value::Point(vec![-120.66029,35.2812])
+    Value::Point(Position::from([-120.66029,35.2812]))
 );
 
 let mut properties = JsonObject::new();

benches/parse.rs

@@ -9,12 +9,10 @@ fn parse_feature_collection_benchmark(c: &mut Criterion) {
     let geojson_str = include_str!("../tests/fixtures/countries.geojson");
 
     c.bench_function("parse (countries.geojson)", |b| {
-        b.iter(|| match geojson_str.parse::<geojson::GeoJson>() {
-            Ok(GeoJson::FeatureCollection(fc)) => {
-                assert_eq!(fc.features.len(), 180);
-                black_box(fc)
-            }
-            _ => panic!("unexpected result"),
+        b.iter(|| {
+            let fc = geojson_str.parse::<geojson::FeatureCollection>().unwrap();
+            assert_eq!(fc.features.len(), 180);
+            black_box(fc);
         })
     });
 
@@ -32,52 +30,52 @@ fn parse_feature_collection_benchmark(c: &mut Criterion) {
         });
     });
 
-    c.bench_function("FeatureReader::deserialize (countries.geojson)", |b| {
-        b.iter(|| {
-            #[allow(unused)]
-            #[derive(serde::Deserialize)]
-            struct Country {
-                geometry: geojson::Geometry,
-                name: String,
-            }
-            let feature_reader =
-                geojson::FeatureReader::from_reader(BufReader::new(geojson_str.as_bytes()));
-
-            let mut count = 0;
-            for feature in feature_reader.deserialize::<Country>().unwrap() {
-                let feature = feature.unwrap();
-                black_box(feature);
-                count += 1;
-            }
-            assert_eq!(count, 180);
-        });
-    });
-
-    #[cfg(feature = "geo-types")]
-    c.bench_function(
-        "FeatureReader::deserialize to geo-types (countries.geojson)",
-        |b| {
-            b.iter(|| {
-                #[allow(unused)]
-                #[derive(serde::Deserialize)]
-                struct Country {
-                    #[serde(deserialize_with = "deserialize_geometry")]
-                    geometry: geo_types::Geometry,
-                    name: String,
-                }
-                let feature_reader =
-                    geojson::FeatureReader::from_reader(BufReader::new(geojson_str.as_bytes()));
+    // c.bench_function("FeatureReader::deserialize (countries.geojson)", |b| {
+    //     b.iter(|| {
+    //         #[allow(unused)]
+    //         #[derive(serde::Deserialize)]
+    //         struct Country {
+    //             geometry: geojson::Geometry,
+    //             name: String,
+    //         }
+    //         let feature_reader =
+    //             geojson::FeatureReader::from_reader(BufReader::new(geojson_str.as_bytes()));
+    //
+    //         let mut count = 0;
+    //         for feature in feature_reader.deserialize::<Country>().unwrap() {
+    //             let feature = feature.unwrap();
+    //             black_box(feature);
+    //             count += 1;
+    //         }
+    //         assert_eq!(count, 180);
+    //     });
+    // });
 
-                let mut count = 0;
-                for feature in feature_reader.deserialize::<Country>().unwrap() {
-                    let feature = feature.unwrap();
-                    black_box(feature);
-                    count += 1;
-                }
-                assert_eq!(count, 180);
-            });
-        },
-    );
+    // #[cfg(feature = "geo-types")]
+    // c.bench_function(
+    //     "FeatureReader::deserialize to geo-types (countries.geojson)",
+    //     |b| {
+    //         b.iter(|| {
+    //             #[allow(unused)]
+    //             #[derive(serde::Deserialize)]
+    //             struct Country {
+    //                 #[serde(deserialize_with = "deserialize_geometry")]
+    //                 geometry: geo_types::Geometry,
+    //                 name: String,
+    //             }
+    //             let feature_reader =
+    //                 geojson::FeatureReader::from_reader(BufReader::new(geojson_str.as_bytes()));
+    //
+    //             let mut count = 0;
+    //             for feature in feature_reader.deserialize::<Country>().unwrap() {
+    //                 let feature = feature.unwrap();
+    //                 black_box(feature);
+    //                 count += 1;
+    //             }
+    //             assert_eq!(count, 180);
+    //         });
+    //     },
+    // );
 }
 
 fn parse_geometry_collection_benchmark(c: &mut Criterion) {

benches/serialize.rs

@@ -18,56 +18,56 @@ fn serialize_feature_collection_benchmark(c: &mut Criterion) {
         },
     );
 
-    c.bench_function("serialize custom struct (countries.geojson)", |b| {
-        #[derive(serde::Serialize, serde::Deserialize)]
-        struct Country {
-            geometry: geojson::Geometry,
-            name: String,
-        }
-        let features =
-            geojson::de::deserialize_feature_collection_str_to_vec::<Country>(geojson_str).unwrap();
-        assert_eq!(features.len(), 180);
+    // c.bench_function("serialize custom struct (countries.geojson)", |b| {
+    //     #[derive(serde::Serialize, serde::Deserialize)]
+    //     struct Country {
+    //         geometry: geojson::Geometry,
+    //         name: String,
+    //     }
+    //     let features =
+    //         geojson::de::deserialize_feature_collection_str_to_vec::<Country>(geojson_str).unwrap();
+    //     assert_eq!(features.len(), 180);
+    //
+    //     b.iter(|| {
+    //         let geojson_string = geojson::ser::to_feature_collection_string(&features).unwrap();
+    //         // Sanity check that we serialized a long string of some kind.
+    //         //
+    //         // Note this is slightly shorter than the GeoJson round-trip above because we drop
+    //         // some fields, like foreign members
+    //         assert_eq!(geojson_string.len(), 254908);
+    //         black_box(geojson_string);
+    //     });
+    // });
 
-        b.iter(|| {
-            let geojson_string = geojson::ser::to_feature_collection_string(&features).unwrap();
-            // Sanity check that we serialized a long string of some kind.
-            //
-            // Note this is slightly shorter than the GeoJson round-trip above because we drop
-            // some fields, like foreign members
-            assert_eq!(geojson_string.len(), 254908);
-            black_box(geojson_string);
-        });
-    });
-
-    #[cfg(feature = "geo-types")]
-    c.bench_function(
-        "serialize custom struct to geo-types (countries.geojson)",
-        |b| {
-            #[derive(serde::Serialize, serde::Deserialize)]
-            struct Country {
-                #[serde(
-                    serialize_with = "serialize_geometry",
-                    deserialize_with = "deserialize_geometry"
-                )]
-                geometry: geo_types::Geometry,
-                name: String,
-            }
-            let features =
-                geojson::de::deserialize_feature_collection_str_to_vec::<Country>(geojson_str)
-                    .unwrap();
-            assert_eq!(features.len(), 180);
-
-            b.iter(|| {
-                let geojson_string = geojson::ser::to_feature_collection_string(&features).unwrap();
-                // Sanity check that we serialized a long string of some kind.
-                //
-                // Note this is slightly shorter than the GeoJson round-trip above because we drop
-                // some fields, like foreign members
-                assert_eq!(geojson_string.len(), 254908);
-                black_box(geojson_string);
-            });
-        },
-    );
+    // #[cfg(feature = "geo-types")]
+    // c.bench_function(
+    //     "serialize custom struct to geo-types (countries.geojson)",
+    //     |b| {
+    //         #[derive(serde::Serialize, serde::Deserialize)]
+    //         struct Country {
+    //             #[serde(
+    //                 serialize_with = "serialize_geometry",
+    //                 deserialize_with = "deserialize_geometry"
+    //             )]
+    //             geometry: geo_types::Geometry,
+    //             name: String,
+    //         }
+    //         let features =
+    //             geojson::de::deserialize_feature_collection_str_to_vec::<Country>(geojson_str)
+    //                 .unwrap();
+    //         assert_eq!(features.len(), 180);
+    //
+    //         b.iter(|| {
+    //             let geojson_string = geojson::ser::to_feature_collection_string(&features).unwrap();
+    //             // Sanity check that we serialized a long string of some kind.
+    //             //
+    //             // Note this is slightly shorter than the GeoJson round-trip above because we drop
+    //             // some fields, like foreign members
+    //             assert_eq!(geojson_string.len(), 254908);
+    //             black_box(geojson_string);
+    //         });
+    //     },
+    // );
 }
 
 criterion_group!(benches, serialize_feature_collection_benchmark);

src/conversion/from_geo_types.rs

@@ -185,16 +185,15 @@ where
 {
     let x: f64 = point.x().to_f64().unwrap();
     let y: f64 = point.y().to_f64().unwrap();
-
-    vec![x, y]
+    crate::Position::from([x, y])
 }
 
 fn create_line_string_type<T>(line_string: &geo_types::LineString<T>) -> LineStringType
 where
     T: CoordFloat,
 {
     line_string
-        .points_iter()
+        .points()
         .map(|point| create_point_type(&point))
         .collect()
 }
@@ -242,7 +241,7 @@ where
 {
     let mut coords = vec![polygon
         .exterior()
-        .points_iter()
+        .points()
         .map(|point| create_point_type(&point))
         .collect()];
 
@@ -271,8 +270,8 @@ where
 mod tests {
     use crate::{GeoJson, Geometry, Value};
     use geo_types::{
-        Coordinate, GeometryCollection, Line, LineString, MultiLineString, MultiPoint,
-        MultiPolygon, Point, Polygon, Rect, Triangle,
+        Coord, GeometryCollection, Line, LineString, MultiLineString, MultiPoint, MultiPolygon,
+        Point, Polygon, Rect, Triangle,
     };
 
     #[test]
@@ -356,9 +355,9 @@ mod tests {
 
     #[test]
     fn geo_triangle_conversion_test() {
-        let c1 = Coordinate { x: 0., y: 0. };
-        let c2 = Coordinate { x: 10., y: 20. };
-        let c3 = Coordinate { x: 20., y: -10. };
+        let c1 = Coord { x: 0., y: 0. };
+        let c2 = Coord { x: 10., y: 20. };
+        let c3 = Coord { x: 20., y: -10. };
 
         let triangle = Triangle(c1, c2, c3);
 
@@ -381,8 +380,8 @@ mod tests {
 
     #[test]
     fn geo_rect_conversion_test() {
-        let c1 = Coordinate { x: 0., y: 0. };
-        let c2 = Coordinate { x: 10., y: 20. };
+        let c1 = Coord { x: 0., y: 0. };
+        let c2 = Coord { x: 10., y: 20. };
 
         let rect = Rect::new(c1, c2);