wkb 0.9.2

Fast, pure-Rust reader and writer for Well-Known Binary geometries
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

use std::io::Cursor;

use crate::common::Dimension;
use crate::reader::util::ReadBytesExt;
use crate::Endianness;
use geo_traits::{CoordTrait, Dimensions};

const F64_WIDTH: u64 = 8;

/// A coordinate in a WKB buffer.
///
/// Note that according to the WKB specification this is called `"Point"`, which is **not** the
/// same as a WKB "framed" `Point`. In particular, a "framed" `Point` has framing that includes the
/// byte order and geometry type of the WKB buffer. In contrast, this `Coord` is the building block
/// of two to four f64 numbers that can occur within any geometry type.
///
/// See page 65 of <https://portal.ogc.org/files/?artifact_id=25355>.
#[derive(Debug, Clone, Copy)]
pub struct Coord<'a> {
    /// The underlying WKB buffer. This should only contain the bytes for one coordinate.
    buf: &'a [u8],

    /// The byte order of this WKB buffer
    byte_order: Endianness,

    dim: Dimension,
}

impl<'a> Coord<'a> {
    pub(crate) fn new(buf: &'a [u8], byte_order: Endianness, dim: Dimension) -> Self {
        Self {
            buf: &buf[..dim.size() * F64_WIDTH as usize],
            byte_order,
            dim,
        }
    }

    #[inline]
    fn get_x(&self) -> f64 {
        let mut reader = Cursor::new(self.buf);
        reader.read_f64(self.byte_order).unwrap()
    }

    #[inline]
    fn get_y(&self) -> f64 {
        let mut reader = Cursor::new(self.buf);
        reader.set_position(F64_WIDTH);
        reader.read_f64(self.byte_order).unwrap()
    }

    #[inline]
    fn get_nth_unchecked(&self, n: usize) -> f64 {
        debug_assert!(n < self.dim.size());
        let mut reader = Cursor::new(self.buf);
        reader.set_position(n as u64 * F64_WIDTH);
        reader.read_f64(self.byte_order).unwrap()
    }

    /// Get the byte order of WKB coordinate
    #[inline]
    pub fn byte_order(&self) -> Endianness {
        self.byte_order
    }

    /// Get the slice of bytes containing the coordinate. The byte order
    /// of coordinate can be obtained by calling [Coord::byte_order].
    #[inline]
    pub fn coord_slice(&self) -> &'a [u8] {
        let end = self.size() as usize;
        &self.buf[0..end]
    }

    /// Get the dimension of this coordinate
    #[inline]
    pub fn dimension(&self) -> Dimension {
        self.dim
    }

    /// The number of bytes in this object
    #[inline]
    pub fn size(&self) -> u64 {
        self.buf.len() as u64
    }
}

impl CoordTrait for Coord<'_> {
    type T = f64;

    fn dim(&self) -> Dimensions {
        self.dim.into()
    }

    #[inline]
    fn nth_or_panic(&self, n: usize) -> Self::T {
        self.get_nth_unchecked(n)
    }

    #[inline]
    fn x(&self) -> Self::T {
        self.get_x()
    }

    #[inline]
    fn y(&self) -> Self::T {
        self.get_y()
    }
}