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

use super::{CoordIndex, Validation, utils};
use crate::{GeoFloat, Line};

use std::fmt;

#[derive(Debug, Clone, PartialEq)]
pub enum InvalidLine {
    /// A valid [`Line`] must have at least 2 distinct points to be valid - it must have a non-zero length.
    IdenticalCoords,

    /// A valid [`Line`] must have finite coordinates.
    NonFiniteCoord(CoordIndex),
}

impl fmt::Display for InvalidLine {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            InvalidLine::IdenticalCoords => write!(f, "line has identical coordinates"),
            InvalidLine::NonFiniteCoord(idx) => write!(
                f,
                "{} coordinate is non-finite",
                if idx.0 == 0 { "start" } else { "end" }
            ),
        }
    }
}

impl std::error::Error for InvalidLine {}

impl<F: GeoFloat> Validation for Line<F> {
    type Error = InvalidLine;

    fn visit_validation<T>(
        &self,
        mut handle_validation_error: Box<dyn FnMut(Self::Error) -> Result<(), T> + '_>,
    ) -> Result<(), T> {
        if utils::check_coord_is_not_finite(&self.start) {
            handle_validation_error(InvalidLine::NonFiniteCoord(CoordIndex(0)))?;
        }
        if utils::check_coord_is_not_finite(&self.end) {
            handle_validation_error(InvalidLine::NonFiniteCoord(CoordIndex(1)))?;
        }
        if self.start == self.end {
            handle_validation_error(InvalidLine::IdenticalCoords)?
        }
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::algorithm::validation::{assert_valid, assert_validation_errors};

    #[test]
    fn test_line_valid() {
        let l = Line::new((0., 0.), (1., 1.));
        assert_valid!(l);
    }

    #[test]
    fn test_line_invalid_not_finite_coords() {
        let l = Line::new((0., 0.), (f64::NEG_INFINITY, 0.));
        assert_validation_errors!(l, vec![InvalidLine::NonFiniteCoord(CoordIndex(1))]);
    }

    #[test]
    fn test_line_invalid_same_points() {
        let l = Line::new((0., 0.), (0., 0.));
        assert_validation_errors!(l, vec![InvalidLine::IdenticalCoords]);
    }
}