1use std::ops::Deref;
2
3use cfg_if::cfg_if;
4
5cfg_if! {
6 if #[cfg(feature = "parse")] {
7 #[macro_use]
8 extern crate log;
9
10 mod parse;
11
12 pub use parse::parse;
13 }
14}
15
16#[cfg(feature = "display")]
17mod display;
18
19cfg_if! {
20 if #[cfg(feature = "to_json")] {
21 use serde::Serialize;
22
23 mod ser;
24 }
25}
26
27#[cfg_attr(feature = "to_json", derive(Serialize))]
28#[derive(Clone, Debug, Default, PartialEq, Eq)]
29pub struct Description<'a>(Vec<&'a str>);
30
31impl<'a> Deref for Description<'a> {
32 type Target = [&'a str];
33
34 fn deref(&self) -> &Self::Target {
35 self.0.as_slice()
36 }
37}
38
39impl<'a> From<Vec<&'a str>> for Description<'a> {
40 fn from(comments: Vec<&'a str>) -> Description<'a> {
41 Description(comments)
42 }
43}
44
45impl<'a> From<&'a str> for Description<'a> {
46 fn from(comment: &'a str) -> Description<'a> {
47 Description(vec![comment])
48 }
49}
50
51impl Description<'_> {
52 pub fn is_empty(&self) -> bool {
53 self.0.is_empty()
54 }
55}
56
57#[cfg_attr(feature = "to_json", derive(Serialize))]
58#[derive(Clone, Debug, PartialEq, Eq)]
59pub struct Protocol<'a> {
60 #[cfg_attr(feature = "to_json", serde(skip_serializing))]
61 pub description: Description<'a>,
62 pub version: Version,
63 #[cfg_attr(feature = "to_json", serde(skip_serializing_if = "Vec::is_empty"))]
64 pub domains: Vec<Domain<'a>>,
65}
66
67#[cfg_attr(feature = "to_json", derive(Serialize))]
68#[derive(Clone, Debug, PartialEq, Eq)]
69pub struct Version {
70 #[cfg_attr(feature = "to_json", serde(serialize_with = "ser::serialize_usize"))]
71 pub major: usize,
72 #[cfg_attr(feature = "to_json", serde(serialize_with = "ser::serialize_usize"))]
73 pub minor: usize,
74}
75
76#[cfg_attr(feature = "to_json", derive(Serialize))]
77#[derive(Clone, Debug, PartialEq, Eq)]
78pub struct Domain<'a> {
79 #[cfg_attr(
80 feature = "to_json",
81 serde(skip_serializing_if = "Description::is_empty")
82 )]
83 #[cfg_attr(
84 feature = "to_json",
85 serde(serialize_with = "ser::serialize_description")
86 )]
87 pub description: Description<'a>,
88 #[cfg_attr(feature = "to_json", serde(skip_serializing_if = "ser::is_false"))]
89 pub experimental: bool,
90 #[cfg_attr(feature = "to_json", serde(skip_serializing_if = "ser::is_false"))]
91 pub deprecated: bool,
92 #[cfg_attr(feature = "to_json", serde(rename = "domain"))]
93 pub name: &'a str,
94 #[cfg_attr(feature = "to_json", serde(skip_serializing_if = "Vec::is_empty"))]
95 pub dependencies: Vec<&'a str>,
96 #[cfg_attr(feature = "to_json", serde(skip_serializing_if = "Vec::is_empty"))]
97 pub types: Vec<TypeDef<'a>>,
98 #[cfg_attr(feature = "to_json", serde(skip_serializing_if = "Vec::is_empty"))]
99 pub commands: Vec<Command<'a>>,
100 #[cfg_attr(feature = "to_json", serde(skip_serializing_if = "Vec::is_empty"))]
101 pub events: Vec<Event<'a>>,
102}
103
104#[cfg_attr(feature = "to_json", derive(Serialize))]
105#[derive(Clone, Debug, PartialEq, Eq)]
106pub struct TypeDef<'a> {
107 #[cfg_attr(
108 feature = "to_json",
109 serde(skip_serializing_if = "Description::is_empty")
110 )]
111 #[cfg_attr(
112 feature = "to_json",
113 serde(serialize_with = "ser::serialize_description")
114 )]
115 pub description: Description<'a>,
116 #[cfg_attr(feature = "to_json", serde(skip_serializing_if = "ser::is_false"))]
117 pub experimental: bool,
118 #[cfg_attr(feature = "to_json", serde(skip_serializing_if = "ser::is_false"))]
119 pub deprecated: bool,
120 pub id: &'a str,
121 #[cfg_attr(feature = "to_json", serde(flatten))]
122 pub extends: Type<'a>,
123 #[cfg_attr(feature = "to_json", serde(flatten))]
124 pub item: Option<Item<'a>>,
125}
126
127#[derive(Clone, Debug, PartialEq, Eq)]
128pub enum Type<'a> {
129 Integer,
130 Number,
131 Boolean,
132 String,
133 Object,
134 Any,
135 Binary,
136 Enum(Vec<Variant<'a>>),
137 ArrayOf(Box<Type<'a>>),
138 Ref(&'a str),
139}
140
141#[cfg_attr(feature = "to_json", derive(Serialize))]
142#[cfg_attr(feature = "to_json", serde(rename_all = "lowercase"))]
143#[derive(Clone, Debug, PartialEq, Eq)]
144pub enum Item<'a> {
145 #[cfg_attr(feature = "to_json", serde(serialize_with = "ser::serialize_enum"))]
146 Enum(Vec<Variant<'a>>),
147 Properties(Vec<Param<'a>>),
148}
149
150#[cfg_attr(feature = "to_json", derive(Serialize))]
151#[derive(Clone, Debug, PartialEq, Eq)]
152pub struct Variant<'a> {
153 #[cfg_attr(
154 feature = "to_json",
155 serde(skip_serializing_if = "Description::is_empty")
156 )]
157 #[cfg_attr(
158 feature = "to_json",
159 serde(serialize_with = "ser::serialize_description")
160 )]
161 pub description: Description<'a>,
162 pub name: &'a str,
163}
164
165impl<'a> Variant<'a> {
166 pub fn new(name: &str) -> Variant {
167 Variant {
168 description: Default::default(),
169 name,
170 }
171 }
172}
173
174#[cfg_attr(feature = "to_json", derive(Serialize))]
175#[derive(Clone, Debug, PartialEq, Eq)]
176pub struct Param<'a> {
177 #[cfg_attr(
178 feature = "to_json",
179 serde(skip_serializing_if = "Description::is_empty")
180 )]
181 #[cfg_attr(
182 feature = "to_json",
183 serde(serialize_with = "ser::serialize_description")
184 )]
185 pub description: Description<'a>,
186 #[cfg_attr(feature = "to_json", serde(skip_serializing_if = "ser::is_false"))]
187 pub experimental: bool,
188 #[cfg_attr(feature = "to_json", serde(skip_serializing_if = "ser::is_false"))]
189 pub deprecated: bool,
190 #[cfg_attr(feature = "to_json", serde(skip_serializing_if = "ser::is_false"))]
191 pub optional: bool,
192 #[cfg_attr(feature = "to_json", serde(flatten))]
193 pub ty: Type<'a>,
194 pub name: &'a str,
195}
196
197#[cfg_attr(feature = "to_json", derive(Serialize))]
198#[derive(Clone, Debug, PartialEq, Eq)]
199pub struct Command<'a> {
200 #[cfg_attr(
201 feature = "to_json",
202 serde(skip_serializing_if = "Description::is_empty")
203 )]
204 #[cfg_attr(
205 feature = "to_json",
206 serde(serialize_with = "ser::serialize_description")
207 )]
208 pub description: Description<'a>,
209 #[cfg_attr(feature = "to_json", serde(skip_serializing_if = "ser::is_false"))]
210 pub experimental: bool,
211 #[cfg_attr(feature = "to_json", serde(skip_serializing_if = "ser::is_false"))]
212 pub deprecated: bool,
213 pub name: &'a str,
214 #[cfg_attr(feature = "to_json", serde(skip_serializing_if = "Option::is_none"))]
215 #[cfg_attr(feature = "to_json", serde(serialize_with = "ser::serialize_redirect"))]
216 pub redirect: Option<Redirect<'a>>,
217 #[cfg_attr(feature = "to_json", serde(skip_serializing_if = "Vec::is_empty"))]
218 pub parameters: Vec<Param<'a>>,
219 #[cfg_attr(feature = "to_json", serde(skip_serializing_if = "Vec::is_empty"))]
220 pub returns: Vec<Param<'a>>,
221}
222
223#[cfg_attr(feature = "to_json", derive(Serialize))]
224#[derive(Clone, Debug, PartialEq, Eq)]
225pub struct Event<'a> {
226 #[cfg_attr(
227 feature = "to_json",
228 serde(skip_serializing_if = "Description::is_empty")
229 )]
230 #[cfg_attr(
231 feature = "to_json",
232 serde(serialize_with = "ser::serialize_description")
233 )]
234 pub description: Description<'a>,
235 #[cfg_attr(feature = "to_json", serde(skip_serializing_if = "ser::is_false"))]
236 pub experimental: bool,
237 #[cfg_attr(feature = "to_json", serde(skip_serializing_if = "ser::is_false"))]
238 pub deprecated: bool,
239 pub name: &'a str,
240 #[cfg_attr(feature = "to_json", serde(skip_serializing_if = "Vec::is_empty"))]
241 pub parameters: Vec<Param<'a>>,
242}
243
244#[derive(Clone, Debug, PartialEq, Eq)]
245pub struct Redirect<'a> {
246 pub description: Description<'a>,
247 pub to: &'a str,
248}