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
use json::{Deserialize, Deserializer, JsonObject, Serialize, Serializer};
use serde_json;
use {util, Bbox, Error, Feature};
#[derive(Clone, Debug, PartialEq)]
pub struct FeatureCollection {
pub bbox: Option<Bbox>,
pub features: Vec<Feature>,
pub foreign_members: Option<JsonObject>,
}
impl<'a> From<&'a FeatureCollection> for JsonObject {
fn from(fc: &'a FeatureCollection) -> JsonObject {
let mut map = JsonObject::new();
map.insert(String::from("type"), json!("FeatureCollection"));
map.insert(
String::from("features"),
serde_json::to_value(&fc.features).unwrap(),
);
if let Some(ref bbox) = fc.bbox {
map.insert(String::from("bbox"), serde_json::to_value(bbox).unwrap());
}
if let Some(ref foreign_members) = fc.foreign_members {
for (key, value) in foreign_members {
map.insert(key.to_owned(), value.to_owned());
}
}
map
}
}
impl FeatureCollection {
pub fn from_json_object(mut object: JsonObject) -> Result<Self, Error> {
match util::expect_type(&mut object)? {
ref type_ if type_ == "FeatureCollection" => Ok(FeatureCollection {
bbox: util::get_bbox(&mut object)?,
features: util::get_features(&mut object)?,
foreign_members: util::get_foreign_members(object)?,
}),
type_ => Err(Error::ExpectedType {
expected: "FeatureCollection".to_owned(),
actual: type_,
}),
}
}
}
impl Serialize for FeatureCollection {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
JsonObject::from(self).serialize(serializer)
}
}
impl<'de> Deserialize<'de> for FeatureCollection {
fn deserialize<D>(deserializer: D) -> Result<FeatureCollection, D::Error>
where
D: Deserializer<'de>,
{
use serde::de::Error as SerdeError;
use std::error::Error as StdError;
let val = JsonObject::deserialize(deserializer)?;
FeatureCollection::from_json_object(val).map_err(|e| D::Error::custom(e.description()))
}
}