/rust/registry/src/index.crates.io-1949cf8c6b5b557f/revision-0.17.0/src/implementations/geo.rs

Source
#![cfg(feature = "geo")]

use super::super::Error;
use super::super::{DeserializeRevisioned, Revisioned, SerializeRevisioned};
use geo::{Coord, LineString, MultiLineString, MultiPoint, MultiPolygon, Point, Polygon};

impl SerializeRevisioned for Coord {
  #[inline]
  fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {
    self.x.serialize_revisioned(writer)?;
    self.y.serialize_revisioned(writer)
  }
}

impl DeserializeRevisioned for Coord {
  #[inline]
  fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {
    let x = f64::deserialize_revisioned(reader)?;
    let y = f64::deserialize_revisioned(reader)?;
    Ok(Self {
      x,
      y,
    })
  }
}

impl Revisioned for Coord {
  #[inline]
  fn revision() -> u16 {
    1
  }
}

impl SerializeRevisioned for Point {
  #[inline]
  fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {
    self.0.serialize_revisioned(writer)
  }
}

impl DeserializeRevisioned for Point {
  #[inline]
  fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {
    Ok(Self(DeserializeRevisioned::deserialize_revisioned(reader)?))
  }
}

impl Revisioned for Point {
  #[inline]
  fn revision() -> u16 {
    1
  }
}

impl SerializeRevisioned for LineString {
  #[inline]
  fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {
    self.0.serialize_revisioned(writer)
  }
}

impl DeserializeRevisioned for LineString {
  #[inline]
  fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {
    Ok(Self(DeserializeRevisioned::deserialize_revisioned(reader)?))
  }
}

impl Revisioned for LineString {
  #[inline]
  fn revision() -> u16 {
    1
  }
}

impl SerializeRevisioned for Polygon {
  #[inline]
  fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {
    self.exterior().serialize_revisioned(writer)?;
    self.interiors().len().serialize_revisioned(writer)?;
    for interior in self.interiors() {
      interior.serialize_revisioned(writer)?;
    }
    Ok(())
  }
}

impl DeserializeRevisioned for Polygon {
  #[inline]
  fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {
    Ok(Self::new(
      DeserializeRevisioned::deserialize_revisioned(reader)?,
      DeserializeRevisioned::deserialize_revisioned(reader)?,
    ))
  }
}

impl Revisioned for Polygon {
  #[inline]
  fn revision() -> u16 {
    1
  }
}

impl SerializeRevisioned for MultiPoint {
  #[inline]
  fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {
    self.0.serialize_revisioned(writer)
  }
}

impl DeserializeRevisioned for MultiPoint {
  #[inline]
  fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {
    Ok(Self(DeserializeRevisioned::deserialize_revisioned(reader)?))
  }
}

impl Revisioned for MultiPoint {
  #[inline]
  fn revision() -> u16 {
    1
  }
}

impl SerializeRevisioned for MultiLineString {
  #[inline]
  fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {
    self.0.serialize_revisioned(writer)
  }
}

impl DeserializeRevisioned for MultiLineString {
  #[inline]
  fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {
    Ok(Self(DeserializeRevisioned::deserialize_revisioned(reader)?))
  }
}

impl Revisioned for MultiLineString {
  #[inline]
  fn revision() -> u16 {
    1
  }
}

impl SerializeRevisioned for MultiPolygon {
  #[inline]
  fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {
    self.0.serialize_revisioned(writer)
  }
}

impl DeserializeRevisioned for MultiPolygon {
  #[inline]
  fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {
    Ok(Self(DeserializeRevisioned::deserialize_revisioned(reader)?))
  }
}

impl Revisioned for MultiPolygon {
  #[inline]
  fn revision() -> u16 {
    1
  }
}

#[cfg(test)]
mod test {
  use std::cell::Cell;

  use super::*;

  use crate::implementations::assert_bincode_compat;

  pub struct Rng(pub Cell<u64>);

  impl Rng {
    pub fn next(&self) -> u64 {
      let mut x = self.0.get();
      x ^= x << 13;
      x ^= x >> 7;
      x ^= x << 17;
      self.0.set(x);
      x
    }

    pub fn next_f64(&self) -> f64 {
      f64::from_bits(self.next())
    }

    pub fn next_point(&self) -> Point {
      Point::new(self.next_f64(), self.next_f64())
    }

    pub fn next_points(&self, len: usize) -> Vec<Point> {
      (0..len).map(|_| self.next_point()).collect()
    }

    pub fn next_coords(&self, len: usize) -> Vec<Coord> {
      (0..len).map(|_| self.next_point().0).collect()
    }
  }

  #[test]
  fn compat() {
    let rng = Rng(Cell::new(0x1fb931de31));

    let point_a = rng.next_point();
    let point_b = rng.next_point();
    assert_bincode_compat(&point_a);
    assert_bincode_compat(&point_b);

    let line_string = LineString(rng.next_coords(10));
    assert_bincode_compat(&line_string);

    let create_multi_line =
      || (0..10).map(|_| LineString(rng.next_coords(10))).collect::<Vec<_>>();

    let create_polygon = || Polygon::new(LineString(rng.next_coords(10)), create_multi_line());

    let polygon = create_polygon();
    assert_bincode_compat(&polygon);

    let multi_point = MultiPoint(rng.next_points(10));
    assert_bincode_compat(&multi_point);

    let multi_line = MultiLineString(create_multi_line());
    assert_bincode_compat(&multi_line);

    let multi_polygon = MultiPolygon((0..10).map(|_| create_polygon()).collect());
    assert_bincode_compat(&multi_polygon);
  }
}

Coverage Report

Created: 2026-03-31 07:09

Line	Count	Source
1		#![cfg(feature = "geo")]
2
3		use super::super::Error;
4		use super::super::{DeserializeRevisioned, Revisioned, SerializeRevisioned};
5		use geo::{Coord, LineString, MultiLineString, MultiPoint, MultiPolygon, Point, Polygon};
6
7		impl SerializeRevisioned for Coord {
8		#[inline]
9	0	fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {
10	0	self.x.serialize_revisioned(writer)?;
11	0	self.y.serialize_revisioned(writer)
12	0	} Unexecuted instantiation: <geo_types::geometry::coord::Coord as revision::SerializeRevisioned>::serialize_revisioned::<alloc::vec::Vec<u8>> Unexecuted instantiation: <geo_types::geometry::coord::Coord as revision::SerializeRevisioned>::serialize_revisioned::<_>
13		}
14
15		impl DeserializeRevisioned for Coord {
16		#[inline]
17	0	fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {
18	0	let x = f64::deserialize_revisioned(reader)?;
19	0	let y = f64::deserialize_revisioned(reader)?;
20	0	Ok(Self {
21	0	x,
22	0	y,
23	0	})
24	0	} Unexecuted instantiation: <geo_types::geometry::coord::Coord as revision::DeserializeRevisioned>::deserialize_revisioned::<&[u8]> Unexecuted instantiation: <geo_types::geometry::coord::Coord as revision::DeserializeRevisioned>::deserialize_revisioned::<_>
25		}
26
27		impl Revisioned for Coord {
28		#[inline]
29	0	fn revision() -> u16 {
30	0	1
31	0	}
32		}
33
34		impl SerializeRevisioned for Point {
35		#[inline]
36	0	fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {
37	0	self.0.serialize_revisioned(writer)
38	0	} Unexecuted instantiation: <geo_types::geometry::point::Point as revision::SerializeRevisioned>::serialize_revisioned::<alloc::vec::Vec<u8>> Unexecuted instantiation: <geo_types::geometry::point::Point as revision::SerializeRevisioned>::serialize_revisioned::<_>
39		}
40
41		impl DeserializeRevisioned for Point {
42		#[inline]
43	0	fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {
44	0	Ok(Self(DeserializeRevisioned::deserialize_revisioned(reader)?))
45	0	} Unexecuted instantiation: <geo_types::geometry::point::Point as revision::DeserializeRevisioned>::deserialize_revisioned::<&[u8]> Unexecuted instantiation: <geo_types::geometry::point::Point as revision::DeserializeRevisioned>::deserialize_revisioned::<_>
46		}
47
48		impl Revisioned for Point {
49		#[inline]
50	0	fn revision() -> u16 {
51	0	1
52	0	}
53		}
54
55		impl SerializeRevisioned for LineString {
56		#[inline]
57	0	fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {
58	0	self.0.serialize_revisioned(writer)
59	0	} Unexecuted instantiation: <geo_types::geometry::line_string::LineString as revision::SerializeRevisioned>::serialize_revisioned::<alloc::vec::Vec<u8>> Unexecuted instantiation: <geo_types::geometry::line_string::LineString as revision::SerializeRevisioned>::serialize_revisioned::<_>
60		}
61
62		impl DeserializeRevisioned for LineString {
63		#[inline]
64	0	fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {
65	0	Ok(Self(DeserializeRevisioned::deserialize_revisioned(reader)?))
66	0	} Unexecuted instantiation: <geo_types::geometry::line_string::LineString as revision::DeserializeRevisioned>::deserialize_revisioned::<&[u8]> Unexecuted instantiation: <geo_types::geometry::line_string::LineString as revision::DeserializeRevisioned>::deserialize_revisioned::<_>
67		}
68
69		impl Revisioned for LineString {
70		#[inline]
71	0	fn revision() -> u16 {
72	0	1
73	0	}
74		}
75
76		impl SerializeRevisioned for Polygon {
77		#[inline]
78	0	fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {
79	0	self.exterior().serialize_revisioned(writer)?;
80	0	self.interiors().len().serialize_revisioned(writer)?;
81	0	for interior in self.interiors() {
82	0	interior.serialize_revisioned(writer)?;
83		}
84	0	Ok(())
85	0	} Unexecuted instantiation: <geo_types::geometry::polygon::Polygon as revision::SerializeRevisioned>::serialize_revisioned::<alloc::vec::Vec<u8>> Unexecuted instantiation: <geo_types::geometry::polygon::Polygon as revision::SerializeRevisioned>::serialize_revisioned::<_>
86		}
87
88		impl DeserializeRevisioned for Polygon {
89		#[inline]
90	0	fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {
91	0	Ok(Self::new(
92	0	DeserializeRevisioned::deserialize_revisioned(reader)?,
93	0	DeserializeRevisioned::deserialize_revisioned(reader)?,
94		))
95	0	} Unexecuted instantiation: <geo_types::geometry::polygon::Polygon as revision::DeserializeRevisioned>::deserialize_revisioned::<&[u8]> Unexecuted instantiation: <geo_types::geometry::polygon::Polygon as revision::DeserializeRevisioned>::deserialize_revisioned::<_>
96		}
97
98		impl Revisioned for Polygon {
99		#[inline]
100	0	fn revision() -> u16 {
101	0	1
102	0	}
103		}
104
105		impl SerializeRevisioned for MultiPoint {
106		#[inline]
107	0	fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {
108	0	self.0.serialize_revisioned(writer)
109	0	} Unexecuted instantiation: <geo_types::geometry::multi_point::MultiPoint as revision::SerializeRevisioned>::serialize_revisioned::<alloc::vec::Vec<u8>> Unexecuted instantiation: <geo_types::geometry::multi_point::MultiPoint as revision::SerializeRevisioned>::serialize_revisioned::<_>
110		}
111
112		impl DeserializeRevisioned for MultiPoint {
113		#[inline]
114	0	fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {
115	0	Ok(Self(DeserializeRevisioned::deserialize_revisioned(reader)?))
116	0	} Unexecuted instantiation: <geo_types::geometry::multi_point::MultiPoint as revision::DeserializeRevisioned>::deserialize_revisioned::<&[u8]> Unexecuted instantiation: <geo_types::geometry::multi_point::MultiPoint as revision::DeserializeRevisioned>::deserialize_revisioned::<_>
117		}
118
119		impl Revisioned for MultiPoint {
120		#[inline]
121	0	fn revision() -> u16 {
122	0	1
123	0	}
124		}
125
126		impl SerializeRevisioned for MultiLineString {
127		#[inline]
128	0	fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {
129	0	self.0.serialize_revisioned(writer)
130	0	} Unexecuted instantiation: <geo_types::geometry::multi_line_string::MultiLineString as revision::SerializeRevisioned>::serialize_revisioned::<alloc::vec::Vec<u8>> Unexecuted instantiation: <geo_types::geometry::multi_line_string::MultiLineString as revision::SerializeRevisioned>::serialize_revisioned::<_>
131		}
132
133		impl DeserializeRevisioned for MultiLineString {
134		#[inline]
135	0	fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {
136	0	Ok(Self(DeserializeRevisioned::deserialize_revisioned(reader)?))
137	0	} Unexecuted instantiation: <geo_types::geometry::multi_line_string::MultiLineString as revision::DeserializeRevisioned>::deserialize_revisioned::<&[u8]> Unexecuted instantiation: <geo_types::geometry::multi_line_string::MultiLineString as revision::DeserializeRevisioned>::deserialize_revisioned::<_>
138		}
139
140		impl Revisioned for MultiLineString {
141		#[inline]
142	0	fn revision() -> u16 {
143	0	1
144	0	}
145		}
146
147		impl SerializeRevisioned for MultiPolygon {
148		#[inline]
149	0	fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {
150	0	self.0.serialize_revisioned(writer)
151	0	} Unexecuted instantiation: <geo_types::geometry::multi_polygon::MultiPolygon as revision::SerializeRevisioned>::serialize_revisioned::<alloc::vec::Vec<u8>> Unexecuted instantiation: <geo_types::geometry::multi_polygon::MultiPolygon as revision::SerializeRevisioned>::serialize_revisioned::<_>
152		}
153
154		impl DeserializeRevisioned for MultiPolygon {
155		#[inline]
156	0	fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {
157	0	Ok(Self(DeserializeRevisioned::deserialize_revisioned(reader)?))
158	0	} Unexecuted instantiation: <geo_types::geometry::multi_polygon::MultiPolygon as revision::DeserializeRevisioned>::deserialize_revisioned::<&[u8]> Unexecuted instantiation: <geo_types::geometry::multi_polygon::MultiPolygon as revision::DeserializeRevisioned>::deserialize_revisioned::<_>
159		}
160
161		impl Revisioned for MultiPolygon {
162		#[inline]
163	0	fn revision() -> u16 {
164	0	1
165	0	}
166		}
167
168		#[cfg(test)]
169		mod test {
170		use std::cell::Cell;
171
172		use super::*;
173
174		use crate::implementations::assert_bincode_compat;
175
176		pub struct Rng(pub Cell<u64>);
177
178		impl Rng {
179		pub fn next(&self) -> u64 {
180		let mut x = self.0.get();
181		x ^= x << 13;
182		x ^= x >> 7;
183		x ^= x << 17;
184		self.0.set(x);
185		x
186		}
187
188		pub fn next_f64(&self) -> f64 {
189		f64::from_bits(self.next())
190		}
191
192		pub fn next_point(&self) -> Point {
193		Point::new(self.next_f64(), self.next_f64())
194		}
195
196		pub fn next_points(&self, len: usize) -> Vec<Point> {
197		(0..len).map(\|_\| self.next_point()).collect()
198		}
199
200		pub fn next_coords(&self, len: usize) -> Vec<Coord> {
201		(0..len).map(\|_\| self.next_point().0).collect()
202		}
203		}
204
205		#[test]
206		fn compat() {
207		let rng = Rng(Cell::new(0x1fb931de31));
208
209		let point_a = rng.next_point();
210		let point_b = rng.next_point();
211		assert_bincode_compat(&point_a);
212		assert_bincode_compat(&point_b);
213
214		let line_string = LineString(rng.next_coords(10));
215		assert_bincode_compat(&line_string);
216
217		let create_multi_line =
218		\|\| (0..10).map(\|_\| LineString(rng.next_coords(10))).collect::<Vec<_>>();
219
220		let create_polygon = \|\| Polygon::new(LineString(rng.next_coords(10)), create_multi_line());
221
222		let polygon = create_polygon();
223		assert_bincode_compat(&polygon);
224
225		let multi_point = MultiPoint(rng.next_points(10));
226		assert_bincode_compat(&multi_point);
227
228		let multi_line = MultiLineString(create_multi_line());
229		assert_bincode_compat(&multi_line);
230
231		let multi_polygon = MultiPolygon((0..10).map(\|_\| create_polygon()).collect());
232		assert_bincode_compat(&multi_polygon);
233		}
234		}