geo 0.33.0

Geospatial primitives and algorithms
Documentation 
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use super::Validation;
use super::{
    InvalidGeometryCollection, InvalidLine, InvalidLineString, InvalidMultiLineString,
    InvalidMultiPoint, InvalidMultiPolygon, InvalidPoint, InvalidPolygon, InvalidRect,
    InvalidTriangle,
};
use crate::{GeoFloat, Geometry};

use crate::geometry_cow::GeometryCow;
use std::fmt;

/// A [`Geometry`] is valid if its inner variant is valid.
/// e.g. `Geometry::Polygon(polygon)` is valid if and only if `polygon` is valid.
#[derive(Debug, Clone, PartialEq)]
pub enum InvalidGeometry {
    InvalidPoint(InvalidPoint),
    InvalidLine(InvalidLine),
    InvalidLineString(InvalidLineString),
    InvalidPolygon(InvalidPolygon),
    InvalidMultiPoint(InvalidMultiPoint),
    InvalidMultiLineString(InvalidMultiLineString),
    InvalidMultiPolygon(InvalidMultiPolygon),
    InvalidGeometryCollection(InvalidGeometryCollection),
    InvalidRect(InvalidRect),
    InvalidTriangle(InvalidTriangle),
}

impl fmt::Display for InvalidGeometry {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            InvalidGeometry::InvalidPoint(err) => write!(f, "{err}"),
            InvalidGeometry::InvalidLine(err) => write!(f, "{err}"),
            InvalidGeometry::InvalidLineString(err) => write!(f, "{err}"),
            InvalidGeometry::InvalidPolygon(err) => write!(f, "{err}"),
            InvalidGeometry::InvalidMultiPoint(err) => write!(f, "{err}"),
            InvalidGeometry::InvalidMultiLineString(err) => write!(f, "{err}"),
            InvalidGeometry::InvalidMultiPolygon(err) => write!(f, "{err}"),
            InvalidGeometry::InvalidGeometryCollection(err) => write!(f, "{err}"),
            InvalidGeometry::InvalidRect(err) => write!(f, "{err}"),
            InvalidGeometry::InvalidTriangle(err) => write!(f, "{err}"),
        }
    }
}

impl std::error::Error for InvalidGeometry {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            InvalidGeometry::InvalidPoint(err) => Some(err),
            InvalidGeometry::InvalidLine(err) => Some(err),
            InvalidGeometry::InvalidLineString(err) => Some(err),
            InvalidGeometry::InvalidPolygon(err) => Some(err),
            InvalidGeometry::InvalidMultiPoint(err) => Some(err),
            InvalidGeometry::InvalidMultiLineString(err) => Some(err),
            InvalidGeometry::InvalidMultiPolygon(err) => Some(err),
            InvalidGeometry::InvalidGeometryCollection(err) => Some(err),
            InvalidGeometry::InvalidRect(err) => Some(err),
            InvalidGeometry::InvalidTriangle(err) => Some(err),
        }
    }
}

impl<F: GeoFloat> Validation for Geometry<F> {
    type Error = InvalidGeometry;

    fn visit_validation<T>(
        &self,
        mut handle_validation_error: Box<dyn FnMut(Self::Error) -> Result<(), T> + '_>,
    ) -> Result<(), T> {
        match self {
            Geometry::Point(g) => g.visit_validation(Box::new(|err| {
                handle_validation_error(InvalidGeometry::InvalidPoint(err))
            }))?,
            Geometry::Line(g) => g.visit_validation(Box::new(|err| {
                handle_validation_error(InvalidGeometry::InvalidLine(err))
            }))?,
            Geometry::LineString(g) => g.visit_validation(Box::new(|err| {
                handle_validation_error(InvalidGeometry::InvalidLineString(err))
            }))?,
            Geometry::Polygon(g) => g.visit_validation(Box::new(|err| {
                handle_validation_error(InvalidGeometry::InvalidPolygon(err))
            }))?,
            Geometry::MultiPoint(g) => g.visit_validation(Box::new(|err| {
                handle_validation_error(InvalidGeometry::InvalidMultiPoint(err))
            }))?,
            Geometry::MultiLineString(g) => g.visit_validation(Box::new(|err| {
                handle_validation_error(InvalidGeometry::InvalidMultiLineString(err))
            }))?,
            Geometry::MultiPolygon(g) => g.visit_validation(Box::new(|err| {
                handle_validation_error(InvalidGeometry::InvalidMultiPolygon(err))
            }))?,
            Geometry::GeometryCollection(g) => g.visit_validation(Box::new(|err| {
                handle_validation_error(InvalidGeometry::InvalidGeometryCollection(err))
            }))?,
            Geometry::Rect(g) => g.visit_validation(Box::new(|err| {
                handle_validation_error(InvalidGeometry::InvalidRect(err))
            }))?,
            Geometry::Triangle(g) => g.visit_validation(Box::new(|err| {
                handle_validation_error(InvalidGeometry::InvalidTriangle(err))
            }))?,
        }
        Ok(())
    }
}

impl<F: GeoFloat> Validation for GeometryCow<'_, F> {
    type Error = InvalidGeometry;

    fn visit_validation<T>(
        &self,
        mut handle_validation_error: Box<dyn FnMut(Self::Error) -> Result<(), T> + '_>,
    ) -> Result<(), T> {
        match self {
            GeometryCow::Point(g) => g.visit_validation(Box::new(|err| {
                handle_validation_error(InvalidGeometry::InvalidPoint(err))
            }))?,
            GeometryCow::Line(g) => g.visit_validation(Box::new(|err| {
                handle_validation_error(InvalidGeometry::InvalidLine(err))
            }))?,
            GeometryCow::LineString(g) => g.visit_validation(Box::new(|err| {
                handle_validation_error(InvalidGeometry::InvalidLineString(err))
            }))?,
            GeometryCow::Polygon(g) => g.visit_validation(Box::new(|err| {
                handle_validation_error(InvalidGeometry::InvalidPolygon(err))
            }))?,
            GeometryCow::MultiPoint(g) => g.visit_validation(Box::new(|err| {
                handle_validation_error(InvalidGeometry::InvalidMultiPoint(err))
            }))?,
            GeometryCow::MultiLineString(g) => g.visit_validation(Box::new(|err| {
                handle_validation_error(InvalidGeometry::InvalidMultiLineString(err))
            }))?,
            GeometryCow::MultiPolygon(g) => g.visit_validation(Box::new(|err| {
                handle_validation_error(InvalidGeometry::InvalidMultiPolygon(err))
            }))?,
            GeometryCow::GeometryCollection(g) => g.visit_validation(Box::new(|err| {
                handle_validation_error(InvalidGeometry::InvalidGeometryCollection(err))
            }))?,
            GeometryCow::Rect(g) => g.visit_validation(Box::new(|err| {
                handle_validation_error(InvalidGeometry::InvalidRect(err))
            }))?,
            GeometryCow::Triangle(g) => g.visit_validation(Box::new(|err| {
                handle_validation_error(InvalidGeometry::InvalidTriangle(err))
            }))?,
        }
        Ok(())
    }
}