serde_esri 0.5.0

A library for serializing and deserializing JSON from Esri Location Services.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

//! Optional feature for converting Esri JSON objects into `geo-types` geometries.
//!
//! This feature enables conversion between `EsriGeometry` objects and geo_types obejcts.
//! Since geo_types presently only supports 2 dimensional coordinatees,
//! Z and M dimensions are dropped if present.
//!
//! Provides conversions for:
//!
//! - `EsriCoord` -> `Coord`
//! - `EsriPoint` -> `Point`
//! - `EsriMultiPoint` -> `MultiPoint`
//! - `EsriPolyline` -> `MultiLineString`
//! - `EsriPolygon` -> `Polygon`
use crate::geometry::*;
use geo_types::{Coord, LineString, MultiLineString, MultiPoint, Point, Polygon};

/// Note that only x and y dimensions are captured
impl<const N: usize> From<EsriCoord<N>> for Coord {
    fn from(value: EsriCoord<N>) -> Self {
        Coord {
            x: value.0[0],
            y: value.0[1],
        }
    }
}

impl From<EsriPoint> for Point {
    fn from(value: EsriPoint) -> Self {
        Point::new(value.x, value.y)
    }
}

impl<const N: usize> From<EsriMultiPoint<N>> for MultiPoint {
    fn from(value: EsriMultiPoint<N>) -> Self {
        let pnts = value
            .points
            .into_iter()
            .map(|xi| Point::from(Coord::from(xi)))
            .collect::<Vec<Point>>();

        MultiPoint::new(pnts)
    }
}

impl<const N: usize> From<EsriPolyline<N>> for MultiLineString {
    fn from(value: EsriPolyline<N>) -> Self {
        let lns = value
            .paths
            .into_iter()
            .map(|mli| {
                let li_coords = mli
                    .into_iter()
                    .map(|ci| Coord::from(ci))
                    .collect::<Vec<Coord>>();

                LineString::new(li_coords)
            })
            .collect::<Vec<LineString>>();

        MultiLineString::new(lns)
    }
}

impl<const N: usize> From<EsriPolygon<N>> for Polygon {
    fn from(value: EsriPolygon<N>) -> Self {
        let lns = value
            .rings
            .into_iter()
            .map(|mli| {
                let li_coords = mli
                    .into_iter()
                    .map(|ci| Coord::from(ci))
                    .collect::<Vec<Coord>>();

                LineString::new(li_coords)
            })
            .collect::<Vec<LineString>>();

        let mut lns_iter = lns.into_iter();
        let ext = lns_iter.next().unwrap();
        let ints = lns_iter.collect::<Vec<_>>();
        Polygon::new(ext, ints)
    }
}