1use std::marker::PhantomData;
2use futures::{Future, future, Stream, stream};
3use hyper;
4use hyper::{Request, Response, Error, StatusCode, Body, HeaderMap};
5use hyper::header::{HeaderName, HeaderValue, CONTENT_TYPE};
6use log::warn;
7use serde_json;
8#[allow(unused_imports)]
9use std::convert::{TryFrom, TryInto};
10use std::io;
11use url::form_urlencoded;
12#[allow(unused_imports)]
13use swagger;
14use swagger::{ApiError, XSpanIdString, Has, RequestParser};
15pub use swagger::auth::Authorization;
16use swagger::auth::Scopes;
17use swagger::context::ContextualPayload;
18
19#[allow(unused_imports)]
20use crate::models;
21use crate::header;
22
23pub use crate::context;
24
25use crate::{Api,
26 ClearErrorResponse,
27 GetAddrEnabledResponse,
28 GetAddrInfoResponse,
29 GetAddrValueResponse,
30 GetApiResponse,
31 GetConfigResponse,
32 GetCurrentResponse,
33 GetErrorResponse,
34 GetErrorsResponse,
35 GetFreqResponse,
36 GetGroupResponse,
37 GetLedCurrentResponse,
38 GetLedErrorResponse,
39 GetLedInfoResponse,
40 GetLedInfoAllResponse,
41 GetLedPwmResponse,
42 GetLedStateResponse,
43 GetOffsetResponse,
44 GetOutputChangeResponse,
45 GetOverTempResponse,
46 GetPwmResponse,
47 GetSleepResponse,
48 ResetResponse,
49 SetAddrEnabledResponse,
50 SetAddrValueResponse,
51 SetConfigResponse,
52 SetCurrentResponse,
53 SetFreqResponse,
54 SetGroupResponse,
55 SetLedCurrentResponse,
56 SetLedErrorResponse,
57 SetLedInfoResponse,
58 SetLedInfoAllResponse,
59 SetLedPwmResponse,
60 SetLedStateResponse,
61 SetOffsetResponse,
62 SetOutputChangeResponse,
63 SetPwmResponse,
64 SetSleepResponse
65};
66
67mod paths {
68 use lazy_static::lazy_static;
69
70 lazy_static! {
71 pub static ref GLOBAL_REGEX_SET: regex::RegexSet = regex::RegexSet::new(vec![
72 r"^/pca9956b/api$",
73 r"^/pca9956b/(?P<busId>[^/?#]*)/reset$",
74 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/addr/(?P<num>[^/?#]*)$",
75 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/addr/(?P<num>[^/?#]*)/addr$",
76 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/addr/(?P<num>[^/?#]*)/addr/(?P<addrVal>[^/?#]*)$",
77 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/addr/(?P<num>[^/?#]*)/enabled$",
78 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/addr/(?P<num>[^/?#]*)/enabled/(?P<enabled>[^/?#]*)$",
79 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/config$",
80 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/current$",
81 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/current/(?P<current>[^/?#]*)$",
82 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/error$",
83 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/error/clear$",
84 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/errors$",
85 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/freq$",
86 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/freq/(?P<freq>[^/?#]*)$",
87 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/group$",
88 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/group/(?P<group>[^/?#]*)$",
89 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/led$",
90 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/led/(?P<led>[^/?#]*)$",
91 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/led/(?P<led>[^/?#]*)/current$",
92 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/led/(?P<led>[^/?#]*)/current/(?P<current>[^/?#]*)$",
93 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/led/(?P<led>[^/?#]*)/error$",
94 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/led/(?P<led>[^/?#]*)/error/(?P<error>[^/?#]*)$",
95 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/led/(?P<led>[^/?#]*)/pwm$",
96 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/led/(?P<led>[^/?#]*)/pwm/(?P<pwm>[^/?#]*)$",
97 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/led/(?P<led>[^/?#]*)/state$",
98 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/led/(?P<led>[^/?#]*)/state/(?P<state>[^/?#]*)$",
99 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/offset$",
100 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/offset/(?P<offset>[^/?#]*)$",
101 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/outputChange$",
102 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/outputChange/(?P<outputChange>[^/?#]*)$",
103 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/overTemp$",
104 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/pwm$",
105 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/pwm/(?P<pwm>[^/?#]*)$",
106 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/sleep$",
107 r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/sleep/(?P<sleep>[^/?#]*)$"
108 ])
109 .expect("Unable to create global regex set");
110 }
111 pub(crate) static ID_PCA9956B_API: usize = 0;
112 pub(crate) static ID_PCA9956B_BUSID_RESET: usize = 1;
113 lazy_static! {
114 pub static ref REGEX_PCA9956B_BUSID_RESET: regex::Regex =
115 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/reset$")
116 .expect("Unable to create regex for PCA9956B_BUSID_RESET");
117 }
118 pub(crate) static ID_PCA9956B_BUSID_ADDR_ADDR_NUM: usize = 2;
119 lazy_static! {
120 pub static ref REGEX_PCA9956B_BUSID_ADDR_ADDR_NUM: regex::Regex =
121 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/addr/(?P<num>[^/?#]*)$")
122 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_ADDR_NUM");
123 }
124 pub(crate) static ID_PCA9956B_BUSID_ADDR_ADDR_NUM_ADDR: usize = 3;
125 lazy_static! {
126 pub static ref REGEX_PCA9956B_BUSID_ADDR_ADDR_NUM_ADDR: regex::Regex =
127 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/addr/(?P<num>[^/?#]*)/addr$")
128 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_ADDR_NUM_ADDR");
129 }
130 pub(crate) static ID_PCA9956B_BUSID_ADDR_ADDR_NUM_ADDR_ADDRVAL: usize = 4;
131 lazy_static! {
132 pub static ref REGEX_PCA9956B_BUSID_ADDR_ADDR_NUM_ADDR_ADDRVAL: regex::Regex =
133 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/addr/(?P<num>[^/?#]*)/addr/(?P<addrVal>[^/?#]*)$")
134 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_ADDR_NUM_ADDR_ADDRVAL");
135 }
136 pub(crate) static ID_PCA9956B_BUSID_ADDR_ADDR_NUM_ENABLED: usize = 5;
137 lazy_static! {
138 pub static ref REGEX_PCA9956B_BUSID_ADDR_ADDR_NUM_ENABLED: regex::Regex =
139 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/addr/(?P<num>[^/?#]*)/enabled$")
140 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_ADDR_NUM_ENABLED");
141 }
142 pub(crate) static ID_PCA9956B_BUSID_ADDR_ADDR_NUM_ENABLED_ENABLED: usize = 6;
143 lazy_static! {
144 pub static ref REGEX_PCA9956B_BUSID_ADDR_ADDR_NUM_ENABLED_ENABLED: regex::Regex =
145 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/addr/(?P<num>[^/?#]*)/enabled/(?P<enabled>[^/?#]*)$")
146 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_ADDR_NUM_ENABLED_ENABLED");
147 }
148 pub(crate) static ID_PCA9956B_BUSID_ADDR_CONFIG: usize = 7;
149 lazy_static! {
150 pub static ref REGEX_PCA9956B_BUSID_ADDR_CONFIG: regex::Regex =
151 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/config$")
152 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_CONFIG");
153 }
154 pub(crate) static ID_PCA9956B_BUSID_ADDR_CURRENT: usize = 8;
155 lazy_static! {
156 pub static ref REGEX_PCA9956B_BUSID_ADDR_CURRENT: regex::Regex =
157 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/current$")
158 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_CURRENT");
159 }
160 pub(crate) static ID_PCA9956B_BUSID_ADDR_CURRENT_CURRENT: usize = 9;
161 lazy_static! {
162 pub static ref REGEX_PCA9956B_BUSID_ADDR_CURRENT_CURRENT: regex::Regex =
163 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/current/(?P<current>[^/?#]*)$")
164 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_CURRENT_CURRENT");
165 }
166 pub(crate) static ID_PCA9956B_BUSID_ADDR_ERROR: usize = 10;
167 lazy_static! {
168 pub static ref REGEX_PCA9956B_BUSID_ADDR_ERROR: regex::Regex =
169 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/error$")
170 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_ERROR");
171 }
172 pub(crate) static ID_PCA9956B_BUSID_ADDR_ERROR_CLEAR: usize = 11;
173 lazy_static! {
174 pub static ref REGEX_PCA9956B_BUSID_ADDR_ERROR_CLEAR: regex::Regex =
175 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/error/clear$")
176 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_ERROR_CLEAR");
177 }
178 pub(crate) static ID_PCA9956B_BUSID_ADDR_ERRORS: usize = 12;
179 lazy_static! {
180 pub static ref REGEX_PCA9956B_BUSID_ADDR_ERRORS: regex::Regex =
181 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/errors$")
182 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_ERRORS");
183 }
184 pub(crate) static ID_PCA9956B_BUSID_ADDR_FREQ: usize = 13;
185 lazy_static! {
186 pub static ref REGEX_PCA9956B_BUSID_ADDR_FREQ: regex::Regex =
187 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/freq$")
188 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_FREQ");
189 }
190 pub(crate) static ID_PCA9956B_BUSID_ADDR_FREQ_FREQ: usize = 14;
191 lazy_static! {
192 pub static ref REGEX_PCA9956B_BUSID_ADDR_FREQ_FREQ: regex::Regex =
193 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/freq/(?P<freq>[^/?#]*)$")
194 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_FREQ_FREQ");
195 }
196 pub(crate) static ID_PCA9956B_BUSID_ADDR_GROUP: usize = 15;
197 lazy_static! {
198 pub static ref REGEX_PCA9956B_BUSID_ADDR_GROUP: regex::Regex =
199 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/group$")
200 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_GROUP");
201 }
202 pub(crate) static ID_PCA9956B_BUSID_ADDR_GROUP_GROUP: usize = 16;
203 lazy_static! {
204 pub static ref REGEX_PCA9956B_BUSID_ADDR_GROUP_GROUP: regex::Regex =
205 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/group/(?P<group>[^/?#]*)$")
206 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_GROUP_GROUP");
207 }
208 pub(crate) static ID_PCA9956B_BUSID_ADDR_LED: usize = 17;
209 lazy_static! {
210 pub static ref REGEX_PCA9956B_BUSID_ADDR_LED: regex::Regex =
211 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/led$")
212 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_LED");
213 }
214 pub(crate) static ID_PCA9956B_BUSID_ADDR_LED_LED: usize = 18;
215 lazy_static! {
216 pub static ref REGEX_PCA9956B_BUSID_ADDR_LED_LED: regex::Regex =
217 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/led/(?P<led>[^/?#]*)$")
218 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_LED_LED");
219 }
220 pub(crate) static ID_PCA9956B_BUSID_ADDR_LED_LED_CURRENT: usize = 19;
221 lazy_static! {
222 pub static ref REGEX_PCA9956B_BUSID_ADDR_LED_LED_CURRENT: regex::Regex =
223 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/led/(?P<led>[^/?#]*)/current$")
224 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_LED_LED_CURRENT");
225 }
226 pub(crate) static ID_PCA9956B_BUSID_ADDR_LED_LED_CURRENT_CURRENT: usize = 20;
227 lazy_static! {
228 pub static ref REGEX_PCA9956B_BUSID_ADDR_LED_LED_CURRENT_CURRENT: regex::Regex =
229 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/led/(?P<led>[^/?#]*)/current/(?P<current>[^/?#]*)$")
230 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_LED_LED_CURRENT_CURRENT");
231 }
232 pub(crate) static ID_PCA9956B_BUSID_ADDR_LED_LED_ERROR: usize = 21;
233 lazy_static! {
234 pub static ref REGEX_PCA9956B_BUSID_ADDR_LED_LED_ERROR: regex::Regex =
235 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/led/(?P<led>[^/?#]*)/error$")
236 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_LED_LED_ERROR");
237 }
238 pub(crate) static ID_PCA9956B_BUSID_ADDR_LED_LED_ERROR_ERROR: usize = 22;
239 lazy_static! {
240 pub static ref REGEX_PCA9956B_BUSID_ADDR_LED_LED_ERROR_ERROR: regex::Regex =
241 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/led/(?P<led>[^/?#]*)/error/(?P<error>[^/?#]*)$")
242 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_LED_LED_ERROR_ERROR");
243 }
244 pub(crate) static ID_PCA9956B_BUSID_ADDR_LED_LED_PWM: usize = 23;
245 lazy_static! {
246 pub static ref REGEX_PCA9956B_BUSID_ADDR_LED_LED_PWM: regex::Regex =
247 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/led/(?P<led>[^/?#]*)/pwm$")
248 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_LED_LED_PWM");
249 }
250 pub(crate) static ID_PCA9956B_BUSID_ADDR_LED_LED_PWM_PWM: usize = 24;
251 lazy_static! {
252 pub static ref REGEX_PCA9956B_BUSID_ADDR_LED_LED_PWM_PWM: regex::Regex =
253 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/led/(?P<led>[^/?#]*)/pwm/(?P<pwm>[^/?#]*)$")
254 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_LED_LED_PWM_PWM");
255 }
256 pub(crate) static ID_PCA9956B_BUSID_ADDR_LED_LED_STATE: usize = 25;
257 lazy_static! {
258 pub static ref REGEX_PCA9956B_BUSID_ADDR_LED_LED_STATE: regex::Regex =
259 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/led/(?P<led>[^/?#]*)/state$")
260 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_LED_LED_STATE");
261 }
262 pub(crate) static ID_PCA9956B_BUSID_ADDR_LED_LED_STATE_STATE: usize = 26;
263 lazy_static! {
264 pub static ref REGEX_PCA9956B_BUSID_ADDR_LED_LED_STATE_STATE: regex::Regex =
265 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/led/(?P<led>[^/?#]*)/state/(?P<state>[^/?#]*)$")
266 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_LED_LED_STATE_STATE");
267 }
268 pub(crate) static ID_PCA9956B_BUSID_ADDR_OFFSET: usize = 27;
269 lazy_static! {
270 pub static ref REGEX_PCA9956B_BUSID_ADDR_OFFSET: regex::Regex =
271 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/offset$")
272 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_OFFSET");
273 }
274 pub(crate) static ID_PCA9956B_BUSID_ADDR_OFFSET_OFFSET: usize = 28;
275 lazy_static! {
276 pub static ref REGEX_PCA9956B_BUSID_ADDR_OFFSET_OFFSET: regex::Regex =
277 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/offset/(?P<offset>[^/?#]*)$")
278 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_OFFSET_OFFSET");
279 }
280 pub(crate) static ID_PCA9956B_BUSID_ADDR_OUTPUTCHANGE: usize = 29;
281 lazy_static! {
282 pub static ref REGEX_PCA9956B_BUSID_ADDR_OUTPUTCHANGE: regex::Regex =
283 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/outputChange$")
284 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_OUTPUTCHANGE");
285 }
286 pub(crate) static ID_PCA9956B_BUSID_ADDR_OUTPUTCHANGE_OUTPUTCHANGE: usize = 30;
287 lazy_static! {
288 pub static ref REGEX_PCA9956B_BUSID_ADDR_OUTPUTCHANGE_OUTPUTCHANGE: regex::Regex =
289 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/outputChange/(?P<outputChange>[^/?#]*)$")
290 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_OUTPUTCHANGE_OUTPUTCHANGE");
291 }
292 pub(crate) static ID_PCA9956B_BUSID_ADDR_OVERTEMP: usize = 31;
293 lazy_static! {
294 pub static ref REGEX_PCA9956B_BUSID_ADDR_OVERTEMP: regex::Regex =
295 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/overTemp$")
296 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_OVERTEMP");
297 }
298 pub(crate) static ID_PCA9956B_BUSID_ADDR_PWM: usize = 32;
299 lazy_static! {
300 pub static ref REGEX_PCA9956B_BUSID_ADDR_PWM: regex::Regex =
301 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/pwm$")
302 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_PWM");
303 }
304 pub(crate) static ID_PCA9956B_BUSID_ADDR_PWM_PWM: usize = 33;
305 lazy_static! {
306 pub static ref REGEX_PCA9956B_BUSID_ADDR_PWM_PWM: regex::Regex =
307 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/pwm/(?P<pwm>[^/?#]*)$")
308 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_PWM_PWM");
309 }
310 pub(crate) static ID_PCA9956B_BUSID_ADDR_SLEEP: usize = 34;
311 lazy_static! {
312 pub static ref REGEX_PCA9956B_BUSID_ADDR_SLEEP: regex::Regex =
313 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/sleep$")
314 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_SLEEP");
315 }
316 pub(crate) static ID_PCA9956B_BUSID_ADDR_SLEEP_SLEEP: usize = 35;
317 lazy_static! {
318 pub static ref REGEX_PCA9956B_BUSID_ADDR_SLEEP_SLEEP: regex::Regex =
319 regex::Regex::new(r"^/pca9956b/(?P<busId>[^/?#]*)/(?P<addr>[^/?#]*)/sleep/(?P<sleep>[^/?#]*)$")
320 .expect("Unable to create regex for PCA9956B_BUSID_ADDR_SLEEP_SLEEP");
321 }
322}
323
324pub struct MakeService<T, RC> {
325 api_impl: T,
326 marker: PhantomData<RC>,
327}
328
329impl<T, RC> MakeService<T, RC>
330where
331 T: Api<RC> + Clone + Send + 'static,
332 RC: Has<XSpanIdString> + 'static
333{
334 pub fn new(api_impl: T) -> Self {
335 MakeService {
336 api_impl,
337 marker: PhantomData
338 }
339 }
340}
341
342impl<'a, T, SC, RC> hyper::service::MakeService<&'a SC> for MakeService<T, RC>
343where
344 T: Api<RC> + Clone + Send + 'static,
345 RC: Has<XSpanIdString> + 'static + Send
346{
347 type ReqBody = ContextualPayload<Body, RC>;
348 type ResBody = Body;
349 type Error = Error;
350 type Service = Service<T, RC>;
351 type Future = future::FutureResult<Self::Service, Self::MakeError>;
352 type MakeError = Error;
353
354 fn make_service(&mut self, _ctx: &'a SC) -> Self::Future {
355 future::FutureResult::from(Ok(Service::new(
356 self.api_impl.clone(),
357 )))
358 }
359}
360
361type ServiceFuture = Box<dyn Future<Item = Response<Body>, Error = Error> + Send>;
362
363fn method_not_allowed() -> ServiceFuture {
364 Box::new(future::ok(
365 Response::builder().status(StatusCode::METHOD_NOT_ALLOWED)
366 .body(Body::empty())
367 .expect("Unable to create Method Not Allowed response")
368 ))
369}
370
371pub struct Service<T, RC> {
372 api_impl: T,
373 marker: PhantomData<RC>,
374}
375
376impl<T, RC> Service<T, RC>
377where
378 T: Api<RC> + Clone + Send + 'static,
379 RC: Has<XSpanIdString> + 'static {
380 pub fn new(api_impl: T) -> Self {
381 Service {
382 api_impl: api_impl,
383 marker: PhantomData
384 }
385 }
386}
387
388impl<T, C> hyper::service::Service for Service<T, C>
389where
390 T: Api<C> + Clone + Send + 'static,
391 C: Has<XSpanIdString> + 'static + Send
392{
393 type ReqBody = ContextualPayload<Body, C>;
394 type ResBody = Body;
395 type Error = Error;
396 type Future = ServiceFuture;
397
398 fn call(&mut self, req: Request<Self::ReqBody>) -> Self::Future {
399 let api_impl = self.api_impl.clone();
400 let (parts, body) = req.into_parts();
401 let (method, uri, headers) = (parts.method, parts.uri, parts.headers);
402 let path = paths::GLOBAL_REGEX_SET.matches(uri.path());
403 let mut context = body.context;
404 let body = body.inner;
405
406 match &method {
407
408 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_ERROR_CLEAR) => {
410 let path: &str = &uri.path().to_string();
412 let path_params =
413 paths::REGEX_PCA9956B_BUSID_ADDR_ERROR_CLEAR
414 .captures(&path)
415 .unwrap_or_else(||
416 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_ERROR_CLEAR in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_ERROR_CLEAR.as_str())
417 );
418
419 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
420 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
421 Ok(param_bus_id) => param_bus_id,
422 Err(e) => return Box::new(future::ok(Response::builder()
423 .status(StatusCode::BAD_REQUEST)
424 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
425 .expect("Unable to create Bad Request response for invalid path parameter"))),
426 },
427 Err(_) => return Box::new(future::ok(Response::builder()
428 .status(StatusCode::BAD_REQUEST)
429 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
430 .expect("Unable to create Bad Request response for invalid percent decode")))
431 };
432
433 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
434 Ok(param_addr) => match param_addr.parse::<i32>() {
435 Ok(param_addr) => param_addr,
436 Err(e) => return Box::new(future::ok(Response::builder()
437 .status(StatusCode::BAD_REQUEST)
438 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
439 .expect("Unable to create Bad Request response for invalid path parameter"))),
440 },
441 Err(_) => return Box::new(future::ok(Response::builder()
442 .status(StatusCode::BAD_REQUEST)
443 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
444 .expect("Unable to create Bad Request response for invalid percent decode")))
445 };
446
447 Box::new({
448 {{
449 Box::new(
450 api_impl.clear_error(
451 param_bus_id,
452 param_addr,
453 &context
454 ).then(move |result| {
455 let mut response = Response::new(Body::empty());
456 response.headers_mut().insert(
457 HeaderName::from_static("x-span-id"),
458 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
459 .expect("Unable to create X-Span-ID header value"));
460
461 match result {
462 Ok(rsp) => match rsp {
463 ClearErrorResponse::OK
464 => {
465 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
466 },
467 ClearErrorResponse::BadRequest
468 (body)
469 => {
470 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
471 response.headers_mut().insert(
472 CONTENT_TYPE,
473 HeaderValue::from_str("application/json")
474 .expect("Unable to create Content-Type header for CLEAR_ERROR_BAD_REQUEST"));
475 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
476 *response.body_mut() = Body::from(body);
477 },
478 ClearErrorResponse::OperationFailed
479 (body)
480 => {
481 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
482 response.headers_mut().insert(
483 CONTENT_TYPE,
484 HeaderValue::from_str("application/json")
485 .expect("Unable to create Content-Type header for CLEAR_ERROR_OPERATION_FAILED"));
486 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
487 *response.body_mut() = Body::from(body);
488 },
489 },
490 Err(_) => {
491 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
494 *response.body_mut() = Body::from("An internal error occurred");
495 },
496 }
497
498 future::ok(response)
499 }
500 ))
501 }}
502 }) as Self::Future
503 },
504
505 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_ADDR_NUM_ENABLED) => {
507 let path: &str = &uri.path().to_string();
509 let path_params =
510 paths::REGEX_PCA9956B_BUSID_ADDR_ADDR_NUM_ENABLED
511 .captures(&path)
512 .unwrap_or_else(||
513 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_ADDR_NUM_ENABLED in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_ADDR_NUM_ENABLED.as_str())
514 );
515
516 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
517 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
518 Ok(param_bus_id) => param_bus_id,
519 Err(e) => return Box::new(future::ok(Response::builder()
520 .status(StatusCode::BAD_REQUEST)
521 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
522 .expect("Unable to create Bad Request response for invalid path parameter"))),
523 },
524 Err(_) => return Box::new(future::ok(Response::builder()
525 .status(StatusCode::BAD_REQUEST)
526 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
527 .expect("Unable to create Bad Request response for invalid percent decode")))
528 };
529
530 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
531 Ok(param_addr) => match param_addr.parse::<i32>() {
532 Ok(param_addr) => param_addr,
533 Err(e) => return Box::new(future::ok(Response::builder()
534 .status(StatusCode::BAD_REQUEST)
535 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
536 .expect("Unable to create Bad Request response for invalid path parameter"))),
537 },
538 Err(_) => return Box::new(future::ok(Response::builder()
539 .status(StatusCode::BAD_REQUEST)
540 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
541 .expect("Unable to create Bad Request response for invalid percent decode")))
542 };
543
544 let param_num = match percent_encoding::percent_decode(path_params["num"].as_bytes()).decode_utf8() {
545 Ok(param_num) => match param_num.parse::<i32>() {
546 Ok(param_num) => param_num,
547 Err(e) => return Box::new(future::ok(Response::builder()
548 .status(StatusCode::BAD_REQUEST)
549 .body(Body::from(format!("Couldn't parse path parameter num: {}", e)))
550 .expect("Unable to create Bad Request response for invalid path parameter"))),
551 },
552 Err(_) => return Box::new(future::ok(Response::builder()
553 .status(StatusCode::BAD_REQUEST)
554 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["num"])))
555 .expect("Unable to create Bad Request response for invalid percent decode")))
556 };
557
558 Box::new({
559 {{
560 Box::new(
561 api_impl.get_addr_enabled(
562 param_bus_id,
563 param_addr,
564 param_num,
565 &context
566 ).then(move |result| {
567 let mut response = Response::new(Body::empty());
568 response.headers_mut().insert(
569 HeaderName::from_static("x-span-id"),
570 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
571 .expect("Unable to create X-Span-ID header value"));
572
573 match result {
574 Ok(rsp) => match rsp {
575 GetAddrEnabledResponse::OK
576 (body)
577 => {
578 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
579 response.headers_mut().insert(
580 CONTENT_TYPE,
581 HeaderValue::from_str("application/json")
582 .expect("Unable to create Content-Type header for GET_ADDR_ENABLED_OK"));
583 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
584 *response.body_mut() = Body::from(body);
585 },
586 GetAddrEnabledResponse::BadRequest
587 (body)
588 => {
589 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
590 response.headers_mut().insert(
591 CONTENT_TYPE,
592 HeaderValue::from_str("application/json")
593 .expect("Unable to create Content-Type header for GET_ADDR_ENABLED_BAD_REQUEST"));
594 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
595 *response.body_mut() = Body::from(body);
596 },
597 GetAddrEnabledResponse::OperationFailed
598 (body)
599 => {
600 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
601 response.headers_mut().insert(
602 CONTENT_TYPE,
603 HeaderValue::from_str("application/json")
604 .expect("Unable to create Content-Type header for GET_ADDR_ENABLED_OPERATION_FAILED"));
605 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
606 *response.body_mut() = Body::from(body);
607 },
608 },
609 Err(_) => {
610 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
613 *response.body_mut() = Body::from("An internal error occurred");
614 },
615 }
616
617 future::ok(response)
618 }
619 ))
620 }}
621 }) as Self::Future
622 },
623
624 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_ADDR_NUM) => {
626 let path: &str = &uri.path().to_string();
628 let path_params =
629 paths::REGEX_PCA9956B_BUSID_ADDR_ADDR_NUM
630 .captures(&path)
631 .unwrap_or_else(||
632 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_ADDR_NUM in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_ADDR_NUM.as_str())
633 );
634
635 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
636 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
637 Ok(param_bus_id) => param_bus_id,
638 Err(e) => return Box::new(future::ok(Response::builder()
639 .status(StatusCode::BAD_REQUEST)
640 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
641 .expect("Unable to create Bad Request response for invalid path parameter"))),
642 },
643 Err(_) => return Box::new(future::ok(Response::builder()
644 .status(StatusCode::BAD_REQUEST)
645 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
646 .expect("Unable to create Bad Request response for invalid percent decode")))
647 };
648
649 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
650 Ok(param_addr) => match param_addr.parse::<i32>() {
651 Ok(param_addr) => param_addr,
652 Err(e) => return Box::new(future::ok(Response::builder()
653 .status(StatusCode::BAD_REQUEST)
654 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
655 .expect("Unable to create Bad Request response for invalid path parameter"))),
656 },
657 Err(_) => return Box::new(future::ok(Response::builder()
658 .status(StatusCode::BAD_REQUEST)
659 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
660 .expect("Unable to create Bad Request response for invalid percent decode")))
661 };
662
663 let param_num = match percent_encoding::percent_decode(path_params["num"].as_bytes()).decode_utf8() {
664 Ok(param_num) => match param_num.parse::<i32>() {
665 Ok(param_num) => param_num,
666 Err(e) => return Box::new(future::ok(Response::builder()
667 .status(StatusCode::BAD_REQUEST)
668 .body(Body::from(format!("Couldn't parse path parameter num: {}", e)))
669 .expect("Unable to create Bad Request response for invalid path parameter"))),
670 },
671 Err(_) => return Box::new(future::ok(Response::builder()
672 .status(StatusCode::BAD_REQUEST)
673 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["num"])))
674 .expect("Unable to create Bad Request response for invalid percent decode")))
675 };
676
677 Box::new({
678 {{
679 Box::new(
680 api_impl.get_addr_info(
681 param_bus_id,
682 param_addr,
683 param_num,
684 &context
685 ).then(move |result| {
686 let mut response = Response::new(Body::empty());
687 response.headers_mut().insert(
688 HeaderName::from_static("x-span-id"),
689 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
690 .expect("Unable to create X-Span-ID header value"));
691
692 match result {
693 Ok(rsp) => match rsp {
694 GetAddrInfoResponse::OK
695 (body)
696 => {
697 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
698 response.headers_mut().insert(
699 CONTENT_TYPE,
700 HeaderValue::from_str("application/json")
701 .expect("Unable to create Content-Type header for GET_ADDR_INFO_OK"));
702 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
703 *response.body_mut() = Body::from(body);
704 },
705 GetAddrInfoResponse::BadRequest
706 (body)
707 => {
708 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
709 response.headers_mut().insert(
710 CONTENT_TYPE,
711 HeaderValue::from_str("application/json")
712 .expect("Unable to create Content-Type header for GET_ADDR_INFO_BAD_REQUEST"));
713 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
714 *response.body_mut() = Body::from(body);
715 },
716 GetAddrInfoResponse::OperationFailed
717 (body)
718 => {
719 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
720 response.headers_mut().insert(
721 CONTENT_TYPE,
722 HeaderValue::from_str("application/json")
723 .expect("Unable to create Content-Type header for GET_ADDR_INFO_OPERATION_FAILED"));
724 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
725 *response.body_mut() = Body::from(body);
726 },
727 },
728 Err(_) => {
729 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
732 *response.body_mut() = Body::from("An internal error occurred");
733 },
734 }
735
736 future::ok(response)
737 }
738 ))
739 }}
740 }) as Self::Future
741 },
742
743 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_ADDR_NUM_ADDR) => {
745 let path: &str = &uri.path().to_string();
747 let path_params =
748 paths::REGEX_PCA9956B_BUSID_ADDR_ADDR_NUM_ADDR
749 .captures(&path)
750 .unwrap_or_else(||
751 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_ADDR_NUM_ADDR in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_ADDR_NUM_ADDR.as_str())
752 );
753
754 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
755 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
756 Ok(param_bus_id) => param_bus_id,
757 Err(e) => return Box::new(future::ok(Response::builder()
758 .status(StatusCode::BAD_REQUEST)
759 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
760 .expect("Unable to create Bad Request response for invalid path parameter"))),
761 },
762 Err(_) => return Box::new(future::ok(Response::builder()
763 .status(StatusCode::BAD_REQUEST)
764 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
765 .expect("Unable to create Bad Request response for invalid percent decode")))
766 };
767
768 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
769 Ok(param_addr) => match param_addr.parse::<i32>() {
770 Ok(param_addr) => param_addr,
771 Err(e) => return Box::new(future::ok(Response::builder()
772 .status(StatusCode::BAD_REQUEST)
773 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
774 .expect("Unable to create Bad Request response for invalid path parameter"))),
775 },
776 Err(_) => return Box::new(future::ok(Response::builder()
777 .status(StatusCode::BAD_REQUEST)
778 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
779 .expect("Unable to create Bad Request response for invalid percent decode")))
780 };
781
782 let param_num = match percent_encoding::percent_decode(path_params["num"].as_bytes()).decode_utf8() {
783 Ok(param_num) => match param_num.parse::<i32>() {
784 Ok(param_num) => param_num,
785 Err(e) => return Box::new(future::ok(Response::builder()
786 .status(StatusCode::BAD_REQUEST)
787 .body(Body::from(format!("Couldn't parse path parameter num: {}", e)))
788 .expect("Unable to create Bad Request response for invalid path parameter"))),
789 },
790 Err(_) => return Box::new(future::ok(Response::builder()
791 .status(StatusCode::BAD_REQUEST)
792 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["num"])))
793 .expect("Unable to create Bad Request response for invalid percent decode")))
794 };
795
796 Box::new({
797 {{
798 Box::new(
799 api_impl.get_addr_value(
800 param_bus_id,
801 param_addr,
802 param_num,
803 &context
804 ).then(move |result| {
805 let mut response = Response::new(Body::empty());
806 response.headers_mut().insert(
807 HeaderName::from_static("x-span-id"),
808 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
809 .expect("Unable to create X-Span-ID header value"));
810
811 match result {
812 Ok(rsp) => match rsp {
813 GetAddrValueResponse::OK
814 (body)
815 => {
816 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
817 response.headers_mut().insert(
818 CONTENT_TYPE,
819 HeaderValue::from_str("application/json")
820 .expect("Unable to create Content-Type header for GET_ADDR_VALUE_OK"));
821 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
822 *response.body_mut() = Body::from(body);
823 },
824 GetAddrValueResponse::BadRequest
825 (body)
826 => {
827 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
828 response.headers_mut().insert(
829 CONTENT_TYPE,
830 HeaderValue::from_str("application/json")
831 .expect("Unable to create Content-Type header for GET_ADDR_VALUE_BAD_REQUEST"));
832 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
833 *response.body_mut() = Body::from(body);
834 },
835 GetAddrValueResponse::OperationFailed
836 (body)
837 => {
838 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
839 response.headers_mut().insert(
840 CONTENT_TYPE,
841 HeaderValue::from_str("application/json")
842 .expect("Unable to create Content-Type header for GET_ADDR_VALUE_OPERATION_FAILED"));
843 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
844 *response.body_mut() = Body::from(body);
845 },
846 },
847 Err(_) => {
848 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
851 *response.body_mut() = Body::from("An internal error occurred");
852 },
853 }
854
855 future::ok(response)
856 }
857 ))
858 }}
859 }) as Self::Future
860 },
861
862 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_API) => {
864 Box::new({
865 {{
866 Box::new(
867 api_impl.get_api(
868 &context
869 ).then(move |result| {
870 let mut response = Response::new(Body::empty());
871 response.headers_mut().insert(
872 HeaderName::from_static("x-span-id"),
873 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
874 .expect("Unable to create X-Span-ID header value"));
875
876 match result {
877 Ok(rsp) => match rsp {
878 GetApiResponse::OK
879 (body)
880 => {
881 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
882 response.headers_mut().insert(
883 CONTENT_TYPE,
884 HeaderValue::from_str("text/x-yaml")
885 .expect("Unable to create Content-Type header for GET_API_OK"));
886 let body = body;
887 *response.body_mut() = Body::from(body);
888 },
889 GetApiResponse::FileNotFound
890 (body)
891 => {
892 *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
893 response.headers_mut().insert(
894 CONTENT_TYPE,
895 HeaderValue::from_str("text/plain")
896 .expect("Unable to create Content-Type header for GET_API_FILE_NOT_FOUND"));
897 let body = body;
898 *response.body_mut() = Body::from(body);
899 },
900 },
901 Err(_) => {
902 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
905 *response.body_mut() = Body::from("An internal error occurred");
906 },
907 }
908
909 future::ok(response)
910 }
911 ))
912 }}
913 }) as Self::Future
914 },
915
916 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_CONFIG) => {
918 let path: &str = &uri.path().to_string();
920 let path_params =
921 paths::REGEX_PCA9956B_BUSID_ADDR_CONFIG
922 .captures(&path)
923 .unwrap_or_else(||
924 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_CONFIG in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_CONFIG.as_str())
925 );
926
927 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
928 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
929 Ok(param_bus_id) => param_bus_id,
930 Err(e) => return Box::new(future::ok(Response::builder()
931 .status(StatusCode::BAD_REQUEST)
932 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
933 .expect("Unable to create Bad Request response for invalid path parameter"))),
934 },
935 Err(_) => return Box::new(future::ok(Response::builder()
936 .status(StatusCode::BAD_REQUEST)
937 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
938 .expect("Unable to create Bad Request response for invalid percent decode")))
939 };
940
941 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
942 Ok(param_addr) => match param_addr.parse::<i32>() {
943 Ok(param_addr) => param_addr,
944 Err(e) => return Box::new(future::ok(Response::builder()
945 .status(StatusCode::BAD_REQUEST)
946 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
947 .expect("Unable to create Bad Request response for invalid path parameter"))),
948 },
949 Err(_) => return Box::new(future::ok(Response::builder()
950 .status(StatusCode::BAD_REQUEST)
951 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
952 .expect("Unable to create Bad Request response for invalid percent decode")))
953 };
954
955 Box::new({
956 {{
957 Box::new(
958 api_impl.get_config(
959 param_bus_id,
960 param_addr,
961 &context
962 ).then(move |result| {
963 let mut response = Response::new(Body::empty());
964 response.headers_mut().insert(
965 HeaderName::from_static("x-span-id"),
966 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
967 .expect("Unable to create X-Span-ID header value"));
968
969 match result {
970 Ok(rsp) => match rsp {
971 GetConfigResponse::OK
972 (body)
973 => {
974 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
975 response.headers_mut().insert(
976 CONTENT_TYPE,
977 HeaderValue::from_str("application/json")
978 .expect("Unable to create Content-Type header for GET_CONFIG_OK"));
979 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
980 *response.body_mut() = Body::from(body);
981 },
982 GetConfigResponse::BadRequest
983 (body)
984 => {
985 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
986 response.headers_mut().insert(
987 CONTENT_TYPE,
988 HeaderValue::from_str("application/json")
989 .expect("Unable to create Content-Type header for GET_CONFIG_BAD_REQUEST"));
990 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
991 *response.body_mut() = Body::from(body);
992 },
993 GetConfigResponse::OperationFailed
994 (body)
995 => {
996 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
997 response.headers_mut().insert(
998 CONTENT_TYPE,
999 HeaderValue::from_str("application/json")
1000 .expect("Unable to create Content-Type header for GET_CONFIG_OPERATION_FAILED"));
1001 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
1002 *response.body_mut() = Body::from(body);
1003 },
1004 },
1005 Err(_) => {
1006 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
1009 *response.body_mut() = Body::from("An internal error occurred");
1010 },
1011 }
1012
1013 future::ok(response)
1014 }
1015 ))
1016 }}
1017 }) as Self::Future
1018 },
1019
1020 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_CURRENT) => {
1022 let path: &str = &uri.path().to_string();
1024 let path_params =
1025 paths::REGEX_PCA9956B_BUSID_ADDR_CURRENT
1026 .captures(&path)
1027 .unwrap_or_else(||
1028 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_CURRENT in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_CURRENT.as_str())
1029 );
1030
1031 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
1032 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
1033 Ok(param_bus_id) => param_bus_id,
1034 Err(e) => return Box::new(future::ok(Response::builder()
1035 .status(StatusCode::BAD_REQUEST)
1036 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
1037 .expect("Unable to create Bad Request response for invalid path parameter"))),
1038 },
1039 Err(_) => return Box::new(future::ok(Response::builder()
1040 .status(StatusCode::BAD_REQUEST)
1041 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
1042 .expect("Unable to create Bad Request response for invalid percent decode")))
1043 };
1044
1045 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
1046 Ok(param_addr) => match param_addr.parse::<i32>() {
1047 Ok(param_addr) => param_addr,
1048 Err(e) => return Box::new(future::ok(Response::builder()
1049 .status(StatusCode::BAD_REQUEST)
1050 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
1051 .expect("Unable to create Bad Request response for invalid path parameter"))),
1052 },
1053 Err(_) => return Box::new(future::ok(Response::builder()
1054 .status(StatusCode::BAD_REQUEST)
1055 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
1056 .expect("Unable to create Bad Request response for invalid percent decode")))
1057 };
1058
1059 Box::new({
1060 {{
1061 Box::new(
1062 api_impl.get_current(
1063 param_bus_id,
1064 param_addr,
1065 &context
1066 ).then(move |result| {
1067 let mut response = Response::new(Body::empty());
1068 response.headers_mut().insert(
1069 HeaderName::from_static("x-span-id"),
1070 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
1071 .expect("Unable to create X-Span-ID header value"));
1072
1073 match result {
1074 Ok(rsp) => match rsp {
1075 GetCurrentResponse::OK
1076 (body)
1077 => {
1078 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
1079 response.headers_mut().insert(
1080 CONTENT_TYPE,
1081 HeaderValue::from_str("application/json")
1082 .expect("Unable to create Content-Type header for GET_CURRENT_OK"));
1083 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
1084 *response.body_mut() = Body::from(body);
1085 },
1086 GetCurrentResponse::BadRequest
1087 (body)
1088 => {
1089 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
1090 response.headers_mut().insert(
1091 CONTENT_TYPE,
1092 HeaderValue::from_str("application/json")
1093 .expect("Unable to create Content-Type header for GET_CURRENT_BAD_REQUEST"));
1094 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
1095 *response.body_mut() = Body::from(body);
1096 },
1097 GetCurrentResponse::OperationFailed
1098 (body)
1099 => {
1100 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
1101 response.headers_mut().insert(
1102 CONTENT_TYPE,
1103 HeaderValue::from_str("application/json")
1104 .expect("Unable to create Content-Type header for GET_CURRENT_OPERATION_FAILED"));
1105 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
1106 *response.body_mut() = Body::from(body);
1107 },
1108 },
1109 Err(_) => {
1110 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
1113 *response.body_mut() = Body::from("An internal error occurred");
1114 },
1115 }
1116
1117 future::ok(response)
1118 }
1119 ))
1120 }}
1121 }) as Self::Future
1122 },
1123
1124 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_ERROR) => {
1126 let path: &str = &uri.path().to_string();
1128 let path_params =
1129 paths::REGEX_PCA9956B_BUSID_ADDR_ERROR
1130 .captures(&path)
1131 .unwrap_or_else(||
1132 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_ERROR in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_ERROR.as_str())
1133 );
1134
1135 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
1136 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
1137 Ok(param_bus_id) => param_bus_id,
1138 Err(e) => return Box::new(future::ok(Response::builder()
1139 .status(StatusCode::BAD_REQUEST)
1140 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
1141 .expect("Unable to create Bad Request response for invalid path parameter"))),
1142 },
1143 Err(_) => return Box::new(future::ok(Response::builder()
1144 .status(StatusCode::BAD_REQUEST)
1145 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
1146 .expect("Unable to create Bad Request response for invalid percent decode")))
1147 };
1148
1149 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
1150 Ok(param_addr) => match param_addr.parse::<i32>() {
1151 Ok(param_addr) => param_addr,
1152 Err(e) => return Box::new(future::ok(Response::builder()
1153 .status(StatusCode::BAD_REQUEST)
1154 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
1155 .expect("Unable to create Bad Request response for invalid path parameter"))),
1156 },
1157 Err(_) => return Box::new(future::ok(Response::builder()
1158 .status(StatusCode::BAD_REQUEST)
1159 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
1160 .expect("Unable to create Bad Request response for invalid percent decode")))
1161 };
1162
1163 Box::new({
1164 {{
1165 Box::new(
1166 api_impl.get_error(
1167 param_bus_id,
1168 param_addr,
1169 &context
1170 ).then(move |result| {
1171 let mut response = Response::new(Body::empty());
1172 response.headers_mut().insert(
1173 HeaderName::from_static("x-span-id"),
1174 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
1175 .expect("Unable to create X-Span-ID header value"));
1176
1177 match result {
1178 Ok(rsp) => match rsp {
1179 GetErrorResponse::OK
1180 (body)
1181 => {
1182 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
1183 response.headers_mut().insert(
1184 CONTENT_TYPE,
1185 HeaderValue::from_str("application/json")
1186 .expect("Unable to create Content-Type header for GET_ERROR_OK"));
1187 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
1188 *response.body_mut() = Body::from(body);
1189 },
1190 GetErrorResponse::BadRequest
1191 (body)
1192 => {
1193 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
1194 response.headers_mut().insert(
1195 CONTENT_TYPE,
1196 HeaderValue::from_str("application/json")
1197 .expect("Unable to create Content-Type header for GET_ERROR_BAD_REQUEST"));
1198 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
1199 *response.body_mut() = Body::from(body);
1200 },
1201 GetErrorResponse::OperationFailed
1202 (body)
1203 => {
1204 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
1205 response.headers_mut().insert(
1206 CONTENT_TYPE,
1207 HeaderValue::from_str("application/json")
1208 .expect("Unable to create Content-Type header for GET_ERROR_OPERATION_FAILED"));
1209 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
1210 *response.body_mut() = Body::from(body);
1211 },
1212 },
1213 Err(_) => {
1214 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
1217 *response.body_mut() = Body::from("An internal error occurred");
1218 },
1219 }
1220
1221 future::ok(response)
1222 }
1223 ))
1224 }}
1225 }) as Self::Future
1226 },
1227
1228 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_ERRORS) => {
1230 let path: &str = &uri.path().to_string();
1232 let path_params =
1233 paths::REGEX_PCA9956B_BUSID_ADDR_ERRORS
1234 .captures(&path)
1235 .unwrap_or_else(||
1236 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_ERRORS in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_ERRORS.as_str())
1237 );
1238
1239 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
1240 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
1241 Ok(param_bus_id) => param_bus_id,
1242 Err(e) => return Box::new(future::ok(Response::builder()
1243 .status(StatusCode::BAD_REQUEST)
1244 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
1245 .expect("Unable to create Bad Request response for invalid path parameter"))),
1246 },
1247 Err(_) => return Box::new(future::ok(Response::builder()
1248 .status(StatusCode::BAD_REQUEST)
1249 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
1250 .expect("Unable to create Bad Request response for invalid percent decode")))
1251 };
1252
1253 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
1254 Ok(param_addr) => match param_addr.parse::<i32>() {
1255 Ok(param_addr) => param_addr,
1256 Err(e) => return Box::new(future::ok(Response::builder()
1257 .status(StatusCode::BAD_REQUEST)
1258 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
1259 .expect("Unable to create Bad Request response for invalid path parameter"))),
1260 },
1261 Err(_) => return Box::new(future::ok(Response::builder()
1262 .status(StatusCode::BAD_REQUEST)
1263 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
1264 .expect("Unable to create Bad Request response for invalid percent decode")))
1265 };
1266
1267 Box::new({
1268 {{
1269 Box::new(
1270 api_impl.get_errors(
1271 param_bus_id,
1272 param_addr,
1273 &context
1274 ).then(move |result| {
1275 let mut response = Response::new(Body::empty());
1276 response.headers_mut().insert(
1277 HeaderName::from_static("x-span-id"),
1278 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
1279 .expect("Unable to create X-Span-ID header value"));
1280
1281 match result {
1282 Ok(rsp) => match rsp {
1283 GetErrorsResponse::OK
1284 (body)
1285 => {
1286 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
1287 response.headers_mut().insert(
1288 CONTENT_TYPE,
1289 HeaderValue::from_str("application/json")
1290 .expect("Unable to create Content-Type header for GET_ERRORS_OK"));
1291 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
1292 *response.body_mut() = Body::from(body);
1293 },
1294 GetErrorsResponse::BadRequest
1295 (body)
1296 => {
1297 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
1298 response.headers_mut().insert(
1299 CONTENT_TYPE,
1300 HeaderValue::from_str("application/json")
1301 .expect("Unable to create Content-Type header for GET_ERRORS_BAD_REQUEST"));
1302 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
1303 *response.body_mut() = Body::from(body);
1304 },
1305 GetErrorsResponse::OperationFailed
1306 (body)
1307 => {
1308 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
1309 response.headers_mut().insert(
1310 CONTENT_TYPE,
1311 HeaderValue::from_str("application/json")
1312 .expect("Unable to create Content-Type header for GET_ERRORS_OPERATION_FAILED"));
1313 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
1314 *response.body_mut() = Body::from(body);
1315 },
1316 },
1317 Err(_) => {
1318 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
1321 *response.body_mut() = Body::from("An internal error occurred");
1322 },
1323 }
1324
1325 future::ok(response)
1326 }
1327 ))
1328 }}
1329 }) as Self::Future
1330 },
1331
1332 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_FREQ) => {
1334 let path: &str = &uri.path().to_string();
1336 let path_params =
1337 paths::REGEX_PCA9956B_BUSID_ADDR_FREQ
1338 .captures(&path)
1339 .unwrap_or_else(||
1340 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_FREQ in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_FREQ.as_str())
1341 );
1342
1343 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
1344 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
1345 Ok(param_bus_id) => param_bus_id,
1346 Err(e) => return Box::new(future::ok(Response::builder()
1347 .status(StatusCode::BAD_REQUEST)
1348 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
1349 .expect("Unable to create Bad Request response for invalid path parameter"))),
1350 },
1351 Err(_) => return Box::new(future::ok(Response::builder()
1352 .status(StatusCode::BAD_REQUEST)
1353 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
1354 .expect("Unable to create Bad Request response for invalid percent decode")))
1355 };
1356
1357 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
1358 Ok(param_addr) => match param_addr.parse::<i32>() {
1359 Ok(param_addr) => param_addr,
1360 Err(e) => return Box::new(future::ok(Response::builder()
1361 .status(StatusCode::BAD_REQUEST)
1362 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
1363 .expect("Unable to create Bad Request response for invalid path parameter"))),
1364 },
1365 Err(_) => return Box::new(future::ok(Response::builder()
1366 .status(StatusCode::BAD_REQUEST)
1367 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
1368 .expect("Unable to create Bad Request response for invalid percent decode")))
1369 };
1370
1371 Box::new({
1372 {{
1373 Box::new(
1374 api_impl.get_freq(
1375 param_bus_id,
1376 param_addr,
1377 &context
1378 ).then(move |result| {
1379 let mut response = Response::new(Body::empty());
1380 response.headers_mut().insert(
1381 HeaderName::from_static("x-span-id"),
1382 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
1383 .expect("Unable to create X-Span-ID header value"));
1384
1385 match result {
1386 Ok(rsp) => match rsp {
1387 GetFreqResponse::OK
1388 (body)
1389 => {
1390 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
1391 response.headers_mut().insert(
1392 CONTENT_TYPE,
1393 HeaderValue::from_str("application/json")
1394 .expect("Unable to create Content-Type header for GET_FREQ_OK"));
1395 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
1396 *response.body_mut() = Body::from(body);
1397 },
1398 GetFreqResponse::BadRequest
1399 (body)
1400 => {
1401 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
1402 response.headers_mut().insert(
1403 CONTENT_TYPE,
1404 HeaderValue::from_str("application/json")
1405 .expect("Unable to create Content-Type header for GET_FREQ_BAD_REQUEST"));
1406 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
1407 *response.body_mut() = Body::from(body);
1408 },
1409 GetFreqResponse::OperationFailed
1410 (body)
1411 => {
1412 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
1413 response.headers_mut().insert(
1414 CONTENT_TYPE,
1415 HeaderValue::from_str("application/json")
1416 .expect("Unable to create Content-Type header for GET_FREQ_OPERATION_FAILED"));
1417 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
1418 *response.body_mut() = Body::from(body);
1419 },
1420 },
1421 Err(_) => {
1422 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
1425 *response.body_mut() = Body::from("An internal error occurred");
1426 },
1427 }
1428
1429 future::ok(response)
1430 }
1431 ))
1432 }}
1433 }) as Self::Future
1434 },
1435
1436 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_GROUP) => {
1438 let path: &str = &uri.path().to_string();
1440 let path_params =
1441 paths::REGEX_PCA9956B_BUSID_ADDR_GROUP
1442 .captures(&path)
1443 .unwrap_or_else(||
1444 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_GROUP in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_GROUP.as_str())
1445 );
1446
1447 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
1448 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
1449 Ok(param_bus_id) => param_bus_id,
1450 Err(e) => return Box::new(future::ok(Response::builder()
1451 .status(StatusCode::BAD_REQUEST)
1452 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
1453 .expect("Unable to create Bad Request response for invalid path parameter"))),
1454 },
1455 Err(_) => return Box::new(future::ok(Response::builder()
1456 .status(StatusCode::BAD_REQUEST)
1457 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
1458 .expect("Unable to create Bad Request response for invalid percent decode")))
1459 };
1460
1461 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
1462 Ok(param_addr) => match param_addr.parse::<i32>() {
1463 Ok(param_addr) => param_addr,
1464 Err(e) => return Box::new(future::ok(Response::builder()
1465 .status(StatusCode::BAD_REQUEST)
1466 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
1467 .expect("Unable to create Bad Request response for invalid path parameter"))),
1468 },
1469 Err(_) => return Box::new(future::ok(Response::builder()
1470 .status(StatusCode::BAD_REQUEST)
1471 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
1472 .expect("Unable to create Bad Request response for invalid percent decode")))
1473 };
1474
1475 Box::new({
1476 {{
1477 Box::new(
1478 api_impl.get_group(
1479 param_bus_id,
1480 param_addr,
1481 &context
1482 ).then(move |result| {
1483 let mut response = Response::new(Body::empty());
1484 response.headers_mut().insert(
1485 HeaderName::from_static("x-span-id"),
1486 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
1487 .expect("Unable to create X-Span-ID header value"));
1488
1489 match result {
1490 Ok(rsp) => match rsp {
1491 GetGroupResponse::OK
1492 (body)
1493 => {
1494 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
1495 response.headers_mut().insert(
1496 CONTENT_TYPE,
1497 HeaderValue::from_str("application/json")
1498 .expect("Unable to create Content-Type header for GET_GROUP_OK"));
1499 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
1500 *response.body_mut() = Body::from(body);
1501 },
1502 GetGroupResponse::BadRequest
1503 (body)
1504 => {
1505 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
1506 response.headers_mut().insert(
1507 CONTENT_TYPE,
1508 HeaderValue::from_str("application/json")
1509 .expect("Unable to create Content-Type header for GET_GROUP_BAD_REQUEST"));
1510 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
1511 *response.body_mut() = Body::from(body);
1512 },
1513 GetGroupResponse::OperationFailed
1514 (body)
1515 => {
1516 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
1517 response.headers_mut().insert(
1518 CONTENT_TYPE,
1519 HeaderValue::from_str("application/json")
1520 .expect("Unable to create Content-Type header for GET_GROUP_OPERATION_FAILED"));
1521 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
1522 *response.body_mut() = Body::from(body);
1523 },
1524 },
1525 Err(_) => {
1526 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
1529 *response.body_mut() = Body::from("An internal error occurred");
1530 },
1531 }
1532
1533 future::ok(response)
1534 }
1535 ))
1536 }}
1537 }) as Self::Future
1538 },
1539
1540 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED_LED_CURRENT) => {
1542 let path: &str = &uri.path().to_string();
1544 let path_params =
1545 paths::REGEX_PCA9956B_BUSID_ADDR_LED_LED_CURRENT
1546 .captures(&path)
1547 .unwrap_or_else(||
1548 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_LED_LED_CURRENT in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_LED_LED_CURRENT.as_str())
1549 );
1550
1551 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
1552 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
1553 Ok(param_bus_id) => param_bus_id,
1554 Err(e) => return Box::new(future::ok(Response::builder()
1555 .status(StatusCode::BAD_REQUEST)
1556 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
1557 .expect("Unable to create Bad Request response for invalid path parameter"))),
1558 },
1559 Err(_) => return Box::new(future::ok(Response::builder()
1560 .status(StatusCode::BAD_REQUEST)
1561 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
1562 .expect("Unable to create Bad Request response for invalid percent decode")))
1563 };
1564
1565 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
1566 Ok(param_addr) => match param_addr.parse::<i32>() {
1567 Ok(param_addr) => param_addr,
1568 Err(e) => return Box::new(future::ok(Response::builder()
1569 .status(StatusCode::BAD_REQUEST)
1570 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
1571 .expect("Unable to create Bad Request response for invalid path parameter"))),
1572 },
1573 Err(_) => return Box::new(future::ok(Response::builder()
1574 .status(StatusCode::BAD_REQUEST)
1575 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
1576 .expect("Unable to create Bad Request response for invalid percent decode")))
1577 };
1578
1579 let param_led = match percent_encoding::percent_decode(path_params["led"].as_bytes()).decode_utf8() {
1580 Ok(param_led) => match param_led.parse::<i32>() {
1581 Ok(param_led) => param_led,
1582 Err(e) => return Box::new(future::ok(Response::builder()
1583 .status(StatusCode::BAD_REQUEST)
1584 .body(Body::from(format!("Couldn't parse path parameter led: {}", e)))
1585 .expect("Unable to create Bad Request response for invalid path parameter"))),
1586 },
1587 Err(_) => return Box::new(future::ok(Response::builder()
1588 .status(StatusCode::BAD_REQUEST)
1589 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["led"])))
1590 .expect("Unable to create Bad Request response for invalid percent decode")))
1591 };
1592
1593 Box::new({
1594 {{
1595 Box::new(
1596 api_impl.get_led_current(
1597 param_bus_id,
1598 param_addr,
1599 param_led,
1600 &context
1601 ).then(move |result| {
1602 let mut response = Response::new(Body::empty());
1603 response.headers_mut().insert(
1604 HeaderName::from_static("x-span-id"),
1605 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
1606 .expect("Unable to create X-Span-ID header value"));
1607
1608 match result {
1609 Ok(rsp) => match rsp {
1610 GetLedCurrentResponse::OK
1611 (body)
1612 => {
1613 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
1614 response.headers_mut().insert(
1615 CONTENT_TYPE,
1616 HeaderValue::from_str("application/json")
1617 .expect("Unable to create Content-Type header for GET_LED_CURRENT_OK"));
1618 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
1619 *response.body_mut() = Body::from(body);
1620 },
1621 GetLedCurrentResponse::BadRequest
1622 (body)
1623 => {
1624 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
1625 response.headers_mut().insert(
1626 CONTENT_TYPE,
1627 HeaderValue::from_str("application/json")
1628 .expect("Unable to create Content-Type header for GET_LED_CURRENT_BAD_REQUEST"));
1629 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
1630 *response.body_mut() = Body::from(body);
1631 },
1632 GetLedCurrentResponse::OperationFailed
1633 (body)
1634 => {
1635 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
1636 response.headers_mut().insert(
1637 CONTENT_TYPE,
1638 HeaderValue::from_str("application/json")
1639 .expect("Unable to create Content-Type header for GET_LED_CURRENT_OPERATION_FAILED"));
1640 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
1641 *response.body_mut() = Body::from(body);
1642 },
1643 },
1644 Err(_) => {
1645 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
1648 *response.body_mut() = Body::from("An internal error occurred");
1649 },
1650 }
1651
1652 future::ok(response)
1653 }
1654 ))
1655 }}
1656 }) as Self::Future
1657 },
1658
1659 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED_LED_ERROR) => {
1661 let path: &str = &uri.path().to_string();
1663 let path_params =
1664 paths::REGEX_PCA9956B_BUSID_ADDR_LED_LED_ERROR
1665 .captures(&path)
1666 .unwrap_or_else(||
1667 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_LED_LED_ERROR in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_LED_LED_ERROR.as_str())
1668 );
1669
1670 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
1671 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
1672 Ok(param_bus_id) => param_bus_id,
1673 Err(e) => return Box::new(future::ok(Response::builder()
1674 .status(StatusCode::BAD_REQUEST)
1675 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
1676 .expect("Unable to create Bad Request response for invalid path parameter"))),
1677 },
1678 Err(_) => return Box::new(future::ok(Response::builder()
1679 .status(StatusCode::BAD_REQUEST)
1680 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
1681 .expect("Unable to create Bad Request response for invalid percent decode")))
1682 };
1683
1684 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
1685 Ok(param_addr) => match param_addr.parse::<i32>() {
1686 Ok(param_addr) => param_addr,
1687 Err(e) => return Box::new(future::ok(Response::builder()
1688 .status(StatusCode::BAD_REQUEST)
1689 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
1690 .expect("Unable to create Bad Request response for invalid path parameter"))),
1691 },
1692 Err(_) => return Box::new(future::ok(Response::builder()
1693 .status(StatusCode::BAD_REQUEST)
1694 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
1695 .expect("Unable to create Bad Request response for invalid percent decode")))
1696 };
1697
1698 let param_led = match percent_encoding::percent_decode(path_params["led"].as_bytes()).decode_utf8() {
1699 Ok(param_led) => match param_led.parse::<i32>() {
1700 Ok(param_led) => param_led,
1701 Err(e) => return Box::new(future::ok(Response::builder()
1702 .status(StatusCode::BAD_REQUEST)
1703 .body(Body::from(format!("Couldn't parse path parameter led: {}", e)))
1704 .expect("Unable to create Bad Request response for invalid path parameter"))),
1705 },
1706 Err(_) => return Box::new(future::ok(Response::builder()
1707 .status(StatusCode::BAD_REQUEST)
1708 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["led"])))
1709 .expect("Unable to create Bad Request response for invalid percent decode")))
1710 };
1711
1712 Box::new({
1713 {{
1714 Box::new(
1715 api_impl.get_led_error(
1716 param_bus_id,
1717 param_addr,
1718 param_led,
1719 &context
1720 ).then(move |result| {
1721 let mut response = Response::new(Body::empty());
1722 response.headers_mut().insert(
1723 HeaderName::from_static("x-span-id"),
1724 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
1725 .expect("Unable to create X-Span-ID header value"));
1726
1727 match result {
1728 Ok(rsp) => match rsp {
1729 GetLedErrorResponse::OK
1730 (body)
1731 => {
1732 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
1733 response.headers_mut().insert(
1734 CONTENT_TYPE,
1735 HeaderValue::from_str("application/json")
1736 .expect("Unable to create Content-Type header for GET_LED_ERROR_OK"));
1737 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
1738 *response.body_mut() = Body::from(body);
1739 },
1740 GetLedErrorResponse::BadRequest
1741 (body)
1742 => {
1743 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
1744 response.headers_mut().insert(
1745 CONTENT_TYPE,
1746 HeaderValue::from_str("application/json")
1747 .expect("Unable to create Content-Type header for GET_LED_ERROR_BAD_REQUEST"));
1748 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
1749 *response.body_mut() = Body::from(body);
1750 },
1751 GetLedErrorResponse::OperationFailed
1752 (body)
1753 => {
1754 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
1755 response.headers_mut().insert(
1756 CONTENT_TYPE,
1757 HeaderValue::from_str("application/json")
1758 .expect("Unable to create Content-Type header for GET_LED_ERROR_OPERATION_FAILED"));
1759 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
1760 *response.body_mut() = Body::from(body);
1761 },
1762 },
1763 Err(_) => {
1764 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
1767 *response.body_mut() = Body::from("An internal error occurred");
1768 },
1769 }
1770
1771 future::ok(response)
1772 }
1773 ))
1774 }}
1775 }) as Self::Future
1776 },
1777
1778 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED_LED) => {
1780 let path: &str = &uri.path().to_string();
1782 let path_params =
1783 paths::REGEX_PCA9956B_BUSID_ADDR_LED_LED
1784 .captures(&path)
1785 .unwrap_or_else(||
1786 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_LED_LED in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_LED_LED.as_str())
1787 );
1788
1789 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
1790 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
1791 Ok(param_bus_id) => param_bus_id,
1792 Err(e) => return Box::new(future::ok(Response::builder()
1793 .status(StatusCode::BAD_REQUEST)
1794 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
1795 .expect("Unable to create Bad Request response for invalid path parameter"))),
1796 },
1797 Err(_) => return Box::new(future::ok(Response::builder()
1798 .status(StatusCode::BAD_REQUEST)
1799 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
1800 .expect("Unable to create Bad Request response for invalid percent decode")))
1801 };
1802
1803 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
1804 Ok(param_addr) => match param_addr.parse::<i32>() {
1805 Ok(param_addr) => param_addr,
1806 Err(e) => return Box::new(future::ok(Response::builder()
1807 .status(StatusCode::BAD_REQUEST)
1808 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
1809 .expect("Unable to create Bad Request response for invalid path parameter"))),
1810 },
1811 Err(_) => return Box::new(future::ok(Response::builder()
1812 .status(StatusCode::BAD_REQUEST)
1813 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
1814 .expect("Unable to create Bad Request response for invalid percent decode")))
1815 };
1816
1817 let param_led = match percent_encoding::percent_decode(path_params["led"].as_bytes()).decode_utf8() {
1818 Ok(param_led) => match param_led.parse::<i32>() {
1819 Ok(param_led) => param_led,
1820 Err(e) => return Box::new(future::ok(Response::builder()
1821 .status(StatusCode::BAD_REQUEST)
1822 .body(Body::from(format!("Couldn't parse path parameter led: {}", e)))
1823 .expect("Unable to create Bad Request response for invalid path parameter"))),
1824 },
1825 Err(_) => return Box::new(future::ok(Response::builder()
1826 .status(StatusCode::BAD_REQUEST)
1827 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["led"])))
1828 .expect("Unable to create Bad Request response for invalid percent decode")))
1829 };
1830
1831 Box::new({
1832 {{
1833 Box::new(
1834 api_impl.get_led_info(
1835 param_bus_id,
1836 param_addr,
1837 param_led,
1838 &context
1839 ).then(move |result| {
1840 let mut response = Response::new(Body::empty());
1841 response.headers_mut().insert(
1842 HeaderName::from_static("x-span-id"),
1843 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
1844 .expect("Unable to create X-Span-ID header value"));
1845
1846 match result {
1847 Ok(rsp) => match rsp {
1848 GetLedInfoResponse::OK
1849 (body)
1850 => {
1851 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
1852 response.headers_mut().insert(
1853 CONTENT_TYPE,
1854 HeaderValue::from_str("application/json")
1855 .expect("Unable to create Content-Type header for GET_LED_INFO_OK"));
1856 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
1857 *response.body_mut() = Body::from(body);
1858 },
1859 GetLedInfoResponse::BadRequest
1860 (body)
1861 => {
1862 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
1863 response.headers_mut().insert(
1864 CONTENT_TYPE,
1865 HeaderValue::from_str("application/json")
1866 .expect("Unable to create Content-Type header for GET_LED_INFO_BAD_REQUEST"));
1867 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
1868 *response.body_mut() = Body::from(body);
1869 },
1870 GetLedInfoResponse::OperationFailed
1871 (body)
1872 => {
1873 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
1874 response.headers_mut().insert(
1875 CONTENT_TYPE,
1876 HeaderValue::from_str("application/json")
1877 .expect("Unable to create Content-Type header for GET_LED_INFO_OPERATION_FAILED"));
1878 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
1879 *response.body_mut() = Body::from(body);
1880 },
1881 },
1882 Err(_) => {
1883 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
1886 *response.body_mut() = Body::from("An internal error occurred");
1887 },
1888 }
1889
1890 future::ok(response)
1891 }
1892 ))
1893 }}
1894 }) as Self::Future
1895 },
1896
1897 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED) => {
1899 let path: &str = &uri.path().to_string();
1901 let path_params =
1902 paths::REGEX_PCA9956B_BUSID_ADDR_LED
1903 .captures(&path)
1904 .unwrap_or_else(||
1905 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_LED in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_LED.as_str())
1906 );
1907
1908 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
1909 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
1910 Ok(param_bus_id) => param_bus_id,
1911 Err(e) => return Box::new(future::ok(Response::builder()
1912 .status(StatusCode::BAD_REQUEST)
1913 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
1914 .expect("Unable to create Bad Request response for invalid path parameter"))),
1915 },
1916 Err(_) => return Box::new(future::ok(Response::builder()
1917 .status(StatusCode::BAD_REQUEST)
1918 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
1919 .expect("Unable to create Bad Request response for invalid percent decode")))
1920 };
1921
1922 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
1923 Ok(param_addr) => match param_addr.parse::<i32>() {
1924 Ok(param_addr) => param_addr,
1925 Err(e) => return Box::new(future::ok(Response::builder()
1926 .status(StatusCode::BAD_REQUEST)
1927 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
1928 .expect("Unable to create Bad Request response for invalid path parameter"))),
1929 },
1930 Err(_) => return Box::new(future::ok(Response::builder()
1931 .status(StatusCode::BAD_REQUEST)
1932 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
1933 .expect("Unable to create Bad Request response for invalid percent decode")))
1934 };
1935
1936 Box::new({
1937 {{
1938 Box::new(
1939 api_impl.get_led_info_all(
1940 param_bus_id,
1941 param_addr,
1942 &context
1943 ).then(move |result| {
1944 let mut response = Response::new(Body::empty());
1945 response.headers_mut().insert(
1946 HeaderName::from_static("x-span-id"),
1947 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
1948 .expect("Unable to create X-Span-ID header value"));
1949
1950 match result {
1951 Ok(rsp) => match rsp {
1952 GetLedInfoAllResponse::OK
1953 (body)
1954 => {
1955 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
1956 response.headers_mut().insert(
1957 CONTENT_TYPE,
1958 HeaderValue::from_str("application/json")
1959 .expect("Unable to create Content-Type header for GET_LED_INFO_ALL_OK"));
1960 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
1961 *response.body_mut() = Body::from(body);
1962 },
1963 GetLedInfoAllResponse::BadRequest
1964 (body)
1965 => {
1966 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
1967 response.headers_mut().insert(
1968 CONTENT_TYPE,
1969 HeaderValue::from_str("application/json")
1970 .expect("Unable to create Content-Type header for GET_LED_INFO_ALL_BAD_REQUEST"));
1971 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
1972 *response.body_mut() = Body::from(body);
1973 },
1974 GetLedInfoAllResponse::OperationFailed
1975 (body)
1976 => {
1977 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
1978 response.headers_mut().insert(
1979 CONTENT_TYPE,
1980 HeaderValue::from_str("application/json")
1981 .expect("Unable to create Content-Type header for GET_LED_INFO_ALL_OPERATION_FAILED"));
1982 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
1983 *response.body_mut() = Body::from(body);
1984 },
1985 },
1986 Err(_) => {
1987 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
1990 *response.body_mut() = Body::from("An internal error occurred");
1991 },
1992 }
1993
1994 future::ok(response)
1995 }
1996 ))
1997 }}
1998 }) as Self::Future
1999 },
2000
2001 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED_LED_PWM) => {
2003 let path: &str = &uri.path().to_string();
2005 let path_params =
2006 paths::REGEX_PCA9956B_BUSID_ADDR_LED_LED_PWM
2007 .captures(&path)
2008 .unwrap_or_else(||
2009 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_LED_LED_PWM in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_LED_LED_PWM.as_str())
2010 );
2011
2012 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
2013 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
2014 Ok(param_bus_id) => param_bus_id,
2015 Err(e) => return Box::new(future::ok(Response::builder()
2016 .status(StatusCode::BAD_REQUEST)
2017 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
2018 .expect("Unable to create Bad Request response for invalid path parameter"))),
2019 },
2020 Err(_) => return Box::new(future::ok(Response::builder()
2021 .status(StatusCode::BAD_REQUEST)
2022 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
2023 .expect("Unable to create Bad Request response for invalid percent decode")))
2024 };
2025
2026 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
2027 Ok(param_addr) => match param_addr.parse::<i32>() {
2028 Ok(param_addr) => param_addr,
2029 Err(e) => return Box::new(future::ok(Response::builder()
2030 .status(StatusCode::BAD_REQUEST)
2031 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
2032 .expect("Unable to create Bad Request response for invalid path parameter"))),
2033 },
2034 Err(_) => return Box::new(future::ok(Response::builder()
2035 .status(StatusCode::BAD_REQUEST)
2036 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
2037 .expect("Unable to create Bad Request response for invalid percent decode")))
2038 };
2039
2040 let param_led = match percent_encoding::percent_decode(path_params["led"].as_bytes()).decode_utf8() {
2041 Ok(param_led) => match param_led.parse::<i32>() {
2042 Ok(param_led) => param_led,
2043 Err(e) => return Box::new(future::ok(Response::builder()
2044 .status(StatusCode::BAD_REQUEST)
2045 .body(Body::from(format!("Couldn't parse path parameter led: {}", e)))
2046 .expect("Unable to create Bad Request response for invalid path parameter"))),
2047 },
2048 Err(_) => return Box::new(future::ok(Response::builder()
2049 .status(StatusCode::BAD_REQUEST)
2050 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["led"])))
2051 .expect("Unable to create Bad Request response for invalid percent decode")))
2052 };
2053
2054 Box::new({
2055 {{
2056 Box::new(
2057 api_impl.get_led_pwm(
2058 param_bus_id,
2059 param_addr,
2060 param_led,
2061 &context
2062 ).then(move |result| {
2063 let mut response = Response::new(Body::empty());
2064 response.headers_mut().insert(
2065 HeaderName::from_static("x-span-id"),
2066 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
2067 .expect("Unable to create X-Span-ID header value"));
2068
2069 match result {
2070 Ok(rsp) => match rsp {
2071 GetLedPwmResponse::OK
2072 (body)
2073 => {
2074 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
2075 response.headers_mut().insert(
2076 CONTENT_TYPE,
2077 HeaderValue::from_str("application/json")
2078 .expect("Unable to create Content-Type header for GET_LED_PWM_OK"));
2079 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
2080 *response.body_mut() = Body::from(body);
2081 },
2082 GetLedPwmResponse::BadRequest
2083 (body)
2084 => {
2085 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
2086 response.headers_mut().insert(
2087 CONTENT_TYPE,
2088 HeaderValue::from_str("application/json")
2089 .expect("Unable to create Content-Type header for GET_LED_PWM_BAD_REQUEST"));
2090 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
2091 *response.body_mut() = Body::from(body);
2092 },
2093 GetLedPwmResponse::OperationFailed
2094 (body)
2095 => {
2096 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
2097 response.headers_mut().insert(
2098 CONTENT_TYPE,
2099 HeaderValue::from_str("application/json")
2100 .expect("Unable to create Content-Type header for GET_LED_PWM_OPERATION_FAILED"));
2101 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
2102 *response.body_mut() = Body::from(body);
2103 },
2104 },
2105 Err(_) => {
2106 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
2109 *response.body_mut() = Body::from("An internal error occurred");
2110 },
2111 }
2112
2113 future::ok(response)
2114 }
2115 ))
2116 }}
2117 }) as Self::Future
2118 },
2119
2120 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED_LED_STATE) => {
2122 let path: &str = &uri.path().to_string();
2124 let path_params =
2125 paths::REGEX_PCA9956B_BUSID_ADDR_LED_LED_STATE
2126 .captures(&path)
2127 .unwrap_or_else(||
2128 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_LED_LED_STATE in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_LED_LED_STATE.as_str())
2129 );
2130
2131 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
2132 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
2133 Ok(param_bus_id) => param_bus_id,
2134 Err(e) => return Box::new(future::ok(Response::builder()
2135 .status(StatusCode::BAD_REQUEST)
2136 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
2137 .expect("Unable to create Bad Request response for invalid path parameter"))),
2138 },
2139 Err(_) => return Box::new(future::ok(Response::builder()
2140 .status(StatusCode::BAD_REQUEST)
2141 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
2142 .expect("Unable to create Bad Request response for invalid percent decode")))
2143 };
2144
2145 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
2146 Ok(param_addr) => match param_addr.parse::<i32>() {
2147 Ok(param_addr) => param_addr,
2148 Err(e) => return Box::new(future::ok(Response::builder()
2149 .status(StatusCode::BAD_REQUEST)
2150 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
2151 .expect("Unable to create Bad Request response for invalid path parameter"))),
2152 },
2153 Err(_) => return Box::new(future::ok(Response::builder()
2154 .status(StatusCode::BAD_REQUEST)
2155 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
2156 .expect("Unable to create Bad Request response for invalid percent decode")))
2157 };
2158
2159 let param_led = match percent_encoding::percent_decode(path_params["led"].as_bytes()).decode_utf8() {
2160 Ok(param_led) => match param_led.parse::<i32>() {
2161 Ok(param_led) => param_led,
2162 Err(e) => return Box::new(future::ok(Response::builder()
2163 .status(StatusCode::BAD_REQUEST)
2164 .body(Body::from(format!("Couldn't parse path parameter led: {}", e)))
2165 .expect("Unable to create Bad Request response for invalid path parameter"))),
2166 },
2167 Err(_) => return Box::new(future::ok(Response::builder()
2168 .status(StatusCode::BAD_REQUEST)
2169 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["led"])))
2170 .expect("Unable to create Bad Request response for invalid percent decode")))
2171 };
2172
2173 Box::new({
2174 {{
2175 Box::new(
2176 api_impl.get_led_state(
2177 param_bus_id,
2178 param_addr,
2179 param_led,
2180 &context
2181 ).then(move |result| {
2182 let mut response = Response::new(Body::empty());
2183 response.headers_mut().insert(
2184 HeaderName::from_static("x-span-id"),
2185 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
2186 .expect("Unable to create X-Span-ID header value"));
2187
2188 match result {
2189 Ok(rsp) => match rsp {
2190 GetLedStateResponse::OK
2191 (body)
2192 => {
2193 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
2194 response.headers_mut().insert(
2195 CONTENT_TYPE,
2196 HeaderValue::from_str("application/json")
2197 .expect("Unable to create Content-Type header for GET_LED_STATE_OK"));
2198 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
2199 *response.body_mut() = Body::from(body);
2200 },
2201 GetLedStateResponse::BadRequest
2202 (body)
2203 => {
2204 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
2205 response.headers_mut().insert(
2206 CONTENT_TYPE,
2207 HeaderValue::from_str("application/json")
2208 .expect("Unable to create Content-Type header for GET_LED_STATE_BAD_REQUEST"));
2209 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
2210 *response.body_mut() = Body::from(body);
2211 },
2212 GetLedStateResponse::OperationFailed
2213 (body)
2214 => {
2215 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
2216 response.headers_mut().insert(
2217 CONTENT_TYPE,
2218 HeaderValue::from_str("application/json")
2219 .expect("Unable to create Content-Type header for GET_LED_STATE_OPERATION_FAILED"));
2220 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
2221 *response.body_mut() = Body::from(body);
2222 },
2223 },
2224 Err(_) => {
2225 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
2228 *response.body_mut() = Body::from("An internal error occurred");
2229 },
2230 }
2231
2232 future::ok(response)
2233 }
2234 ))
2235 }}
2236 }) as Self::Future
2237 },
2238
2239 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_OFFSET) => {
2241 let path: &str = &uri.path().to_string();
2243 let path_params =
2244 paths::REGEX_PCA9956B_BUSID_ADDR_OFFSET
2245 .captures(&path)
2246 .unwrap_or_else(||
2247 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_OFFSET in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_OFFSET.as_str())
2248 );
2249
2250 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
2251 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
2252 Ok(param_bus_id) => param_bus_id,
2253 Err(e) => return Box::new(future::ok(Response::builder()
2254 .status(StatusCode::BAD_REQUEST)
2255 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
2256 .expect("Unable to create Bad Request response for invalid path parameter"))),
2257 },
2258 Err(_) => return Box::new(future::ok(Response::builder()
2259 .status(StatusCode::BAD_REQUEST)
2260 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
2261 .expect("Unable to create Bad Request response for invalid percent decode")))
2262 };
2263
2264 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
2265 Ok(param_addr) => match param_addr.parse::<i32>() {
2266 Ok(param_addr) => param_addr,
2267 Err(e) => return Box::new(future::ok(Response::builder()
2268 .status(StatusCode::BAD_REQUEST)
2269 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
2270 .expect("Unable to create Bad Request response for invalid path parameter"))),
2271 },
2272 Err(_) => return Box::new(future::ok(Response::builder()
2273 .status(StatusCode::BAD_REQUEST)
2274 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
2275 .expect("Unable to create Bad Request response for invalid percent decode")))
2276 };
2277
2278 Box::new({
2279 {{
2280 Box::new(
2281 api_impl.get_offset(
2282 param_bus_id,
2283 param_addr,
2284 &context
2285 ).then(move |result| {
2286 let mut response = Response::new(Body::empty());
2287 response.headers_mut().insert(
2288 HeaderName::from_static("x-span-id"),
2289 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
2290 .expect("Unable to create X-Span-ID header value"));
2291
2292 match result {
2293 Ok(rsp) => match rsp {
2294 GetOffsetResponse::OK
2295 (body)
2296 => {
2297 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
2298 response.headers_mut().insert(
2299 CONTENT_TYPE,
2300 HeaderValue::from_str("application/json")
2301 .expect("Unable to create Content-Type header for GET_OFFSET_OK"));
2302 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
2303 *response.body_mut() = Body::from(body);
2304 },
2305 GetOffsetResponse::BadRequest
2306 (body)
2307 => {
2308 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
2309 response.headers_mut().insert(
2310 CONTENT_TYPE,
2311 HeaderValue::from_str("application/json")
2312 .expect("Unable to create Content-Type header for GET_OFFSET_BAD_REQUEST"));
2313 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
2314 *response.body_mut() = Body::from(body);
2315 },
2316 GetOffsetResponse::OperationFailed
2317 (body)
2318 => {
2319 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
2320 response.headers_mut().insert(
2321 CONTENT_TYPE,
2322 HeaderValue::from_str("application/json")
2323 .expect("Unable to create Content-Type header for GET_OFFSET_OPERATION_FAILED"));
2324 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
2325 *response.body_mut() = Body::from(body);
2326 },
2327 },
2328 Err(_) => {
2329 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
2332 *response.body_mut() = Body::from("An internal error occurred");
2333 },
2334 }
2335
2336 future::ok(response)
2337 }
2338 ))
2339 }}
2340 }) as Self::Future
2341 },
2342
2343 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_OUTPUTCHANGE) => {
2345 let path: &str = &uri.path().to_string();
2347 let path_params =
2348 paths::REGEX_PCA9956B_BUSID_ADDR_OUTPUTCHANGE
2349 .captures(&path)
2350 .unwrap_or_else(||
2351 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_OUTPUTCHANGE in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_OUTPUTCHANGE.as_str())
2352 );
2353
2354 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
2355 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
2356 Ok(param_bus_id) => param_bus_id,
2357 Err(e) => return Box::new(future::ok(Response::builder()
2358 .status(StatusCode::BAD_REQUEST)
2359 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
2360 .expect("Unable to create Bad Request response for invalid path parameter"))),
2361 },
2362 Err(_) => return Box::new(future::ok(Response::builder()
2363 .status(StatusCode::BAD_REQUEST)
2364 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
2365 .expect("Unable to create Bad Request response for invalid percent decode")))
2366 };
2367
2368 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
2369 Ok(param_addr) => match param_addr.parse::<i32>() {
2370 Ok(param_addr) => param_addr,
2371 Err(e) => return Box::new(future::ok(Response::builder()
2372 .status(StatusCode::BAD_REQUEST)
2373 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
2374 .expect("Unable to create Bad Request response for invalid path parameter"))),
2375 },
2376 Err(_) => return Box::new(future::ok(Response::builder()
2377 .status(StatusCode::BAD_REQUEST)
2378 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
2379 .expect("Unable to create Bad Request response for invalid percent decode")))
2380 };
2381
2382 Box::new({
2383 {{
2384 Box::new(
2385 api_impl.get_output_change(
2386 param_bus_id,
2387 param_addr,
2388 &context
2389 ).then(move |result| {
2390 let mut response = Response::new(Body::empty());
2391 response.headers_mut().insert(
2392 HeaderName::from_static("x-span-id"),
2393 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
2394 .expect("Unable to create X-Span-ID header value"));
2395
2396 match result {
2397 Ok(rsp) => match rsp {
2398 GetOutputChangeResponse::OK
2399 (body)
2400 => {
2401 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
2402 response.headers_mut().insert(
2403 CONTENT_TYPE,
2404 HeaderValue::from_str("application/json")
2405 .expect("Unable to create Content-Type header for GET_OUTPUT_CHANGE_OK"));
2406 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
2407 *response.body_mut() = Body::from(body);
2408 },
2409 GetOutputChangeResponse::BadRequest
2410 (body)
2411 => {
2412 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
2413 response.headers_mut().insert(
2414 CONTENT_TYPE,
2415 HeaderValue::from_str("application/json")
2416 .expect("Unable to create Content-Type header for GET_OUTPUT_CHANGE_BAD_REQUEST"));
2417 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
2418 *response.body_mut() = Body::from(body);
2419 },
2420 GetOutputChangeResponse::OperationFailed
2421 (body)
2422 => {
2423 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
2424 response.headers_mut().insert(
2425 CONTENT_TYPE,
2426 HeaderValue::from_str("application/json")
2427 .expect("Unable to create Content-Type header for GET_OUTPUT_CHANGE_OPERATION_FAILED"));
2428 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
2429 *response.body_mut() = Body::from(body);
2430 },
2431 },
2432 Err(_) => {
2433 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
2436 *response.body_mut() = Body::from("An internal error occurred");
2437 },
2438 }
2439
2440 future::ok(response)
2441 }
2442 ))
2443 }}
2444 }) as Self::Future
2445 },
2446
2447 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_OVERTEMP) => {
2449 let path: &str = &uri.path().to_string();
2451 let path_params =
2452 paths::REGEX_PCA9956B_BUSID_ADDR_OVERTEMP
2453 .captures(&path)
2454 .unwrap_or_else(||
2455 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_OVERTEMP in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_OVERTEMP.as_str())
2456 );
2457
2458 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
2459 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
2460 Ok(param_bus_id) => param_bus_id,
2461 Err(e) => return Box::new(future::ok(Response::builder()
2462 .status(StatusCode::BAD_REQUEST)
2463 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
2464 .expect("Unable to create Bad Request response for invalid path parameter"))),
2465 },
2466 Err(_) => return Box::new(future::ok(Response::builder()
2467 .status(StatusCode::BAD_REQUEST)
2468 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
2469 .expect("Unable to create Bad Request response for invalid percent decode")))
2470 };
2471
2472 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
2473 Ok(param_addr) => match param_addr.parse::<i32>() {
2474 Ok(param_addr) => param_addr,
2475 Err(e) => return Box::new(future::ok(Response::builder()
2476 .status(StatusCode::BAD_REQUEST)
2477 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
2478 .expect("Unable to create Bad Request response for invalid path parameter"))),
2479 },
2480 Err(_) => return Box::new(future::ok(Response::builder()
2481 .status(StatusCode::BAD_REQUEST)
2482 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
2483 .expect("Unable to create Bad Request response for invalid percent decode")))
2484 };
2485
2486 Box::new({
2487 {{
2488 Box::new(
2489 api_impl.get_over_temp(
2490 param_bus_id,
2491 param_addr,
2492 &context
2493 ).then(move |result| {
2494 let mut response = Response::new(Body::empty());
2495 response.headers_mut().insert(
2496 HeaderName::from_static("x-span-id"),
2497 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
2498 .expect("Unable to create X-Span-ID header value"));
2499
2500 match result {
2501 Ok(rsp) => match rsp {
2502 GetOverTempResponse::OK
2503 (body)
2504 => {
2505 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
2506 response.headers_mut().insert(
2507 CONTENT_TYPE,
2508 HeaderValue::from_str("application/json")
2509 .expect("Unable to create Content-Type header for GET_OVER_TEMP_OK"));
2510 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
2511 *response.body_mut() = Body::from(body);
2512 },
2513 GetOverTempResponse::BadRequest
2514 (body)
2515 => {
2516 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
2517 response.headers_mut().insert(
2518 CONTENT_TYPE,
2519 HeaderValue::from_str("application/json")
2520 .expect("Unable to create Content-Type header for GET_OVER_TEMP_BAD_REQUEST"));
2521 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
2522 *response.body_mut() = Body::from(body);
2523 },
2524 GetOverTempResponse::OperationFailed
2525 (body)
2526 => {
2527 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
2528 response.headers_mut().insert(
2529 CONTENT_TYPE,
2530 HeaderValue::from_str("application/json")
2531 .expect("Unable to create Content-Type header for GET_OVER_TEMP_OPERATION_FAILED"));
2532 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
2533 *response.body_mut() = Body::from(body);
2534 },
2535 },
2536 Err(_) => {
2537 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
2540 *response.body_mut() = Body::from("An internal error occurred");
2541 },
2542 }
2543
2544 future::ok(response)
2545 }
2546 ))
2547 }}
2548 }) as Self::Future
2549 },
2550
2551 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_PWM) => {
2553 let path: &str = &uri.path().to_string();
2555 let path_params =
2556 paths::REGEX_PCA9956B_BUSID_ADDR_PWM
2557 .captures(&path)
2558 .unwrap_or_else(||
2559 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_PWM in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_PWM.as_str())
2560 );
2561
2562 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
2563 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
2564 Ok(param_bus_id) => param_bus_id,
2565 Err(e) => return Box::new(future::ok(Response::builder()
2566 .status(StatusCode::BAD_REQUEST)
2567 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
2568 .expect("Unable to create Bad Request response for invalid path parameter"))),
2569 },
2570 Err(_) => return Box::new(future::ok(Response::builder()
2571 .status(StatusCode::BAD_REQUEST)
2572 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
2573 .expect("Unable to create Bad Request response for invalid percent decode")))
2574 };
2575
2576 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
2577 Ok(param_addr) => match param_addr.parse::<i32>() {
2578 Ok(param_addr) => param_addr,
2579 Err(e) => return Box::new(future::ok(Response::builder()
2580 .status(StatusCode::BAD_REQUEST)
2581 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
2582 .expect("Unable to create Bad Request response for invalid path parameter"))),
2583 },
2584 Err(_) => return Box::new(future::ok(Response::builder()
2585 .status(StatusCode::BAD_REQUEST)
2586 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
2587 .expect("Unable to create Bad Request response for invalid percent decode")))
2588 };
2589
2590 Box::new({
2591 {{
2592 Box::new(
2593 api_impl.get_pwm(
2594 param_bus_id,
2595 param_addr,
2596 &context
2597 ).then(move |result| {
2598 let mut response = Response::new(Body::empty());
2599 response.headers_mut().insert(
2600 HeaderName::from_static("x-span-id"),
2601 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
2602 .expect("Unable to create X-Span-ID header value"));
2603
2604 match result {
2605 Ok(rsp) => match rsp {
2606 GetPwmResponse::OK
2607 (body)
2608 => {
2609 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
2610 response.headers_mut().insert(
2611 CONTENT_TYPE,
2612 HeaderValue::from_str("application/json")
2613 .expect("Unable to create Content-Type header for GET_PWM_OK"));
2614 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
2615 *response.body_mut() = Body::from(body);
2616 },
2617 GetPwmResponse::BadRequest
2618 (body)
2619 => {
2620 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
2621 response.headers_mut().insert(
2622 CONTENT_TYPE,
2623 HeaderValue::from_str("application/json")
2624 .expect("Unable to create Content-Type header for GET_PWM_BAD_REQUEST"));
2625 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
2626 *response.body_mut() = Body::from(body);
2627 },
2628 GetPwmResponse::OperationFailed
2629 (body)
2630 => {
2631 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
2632 response.headers_mut().insert(
2633 CONTENT_TYPE,
2634 HeaderValue::from_str("application/json")
2635 .expect("Unable to create Content-Type header for GET_PWM_OPERATION_FAILED"));
2636 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
2637 *response.body_mut() = Body::from(body);
2638 },
2639 },
2640 Err(_) => {
2641 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
2644 *response.body_mut() = Body::from("An internal error occurred");
2645 },
2646 }
2647
2648 future::ok(response)
2649 }
2650 ))
2651 }}
2652 }) as Self::Future
2653 },
2654
2655 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_SLEEP) => {
2657 let path: &str = &uri.path().to_string();
2659 let path_params =
2660 paths::REGEX_PCA9956B_BUSID_ADDR_SLEEP
2661 .captures(&path)
2662 .unwrap_or_else(||
2663 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_SLEEP in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_SLEEP.as_str())
2664 );
2665
2666 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
2667 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
2668 Ok(param_bus_id) => param_bus_id,
2669 Err(e) => return Box::new(future::ok(Response::builder()
2670 .status(StatusCode::BAD_REQUEST)
2671 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
2672 .expect("Unable to create Bad Request response for invalid path parameter"))),
2673 },
2674 Err(_) => return Box::new(future::ok(Response::builder()
2675 .status(StatusCode::BAD_REQUEST)
2676 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
2677 .expect("Unable to create Bad Request response for invalid percent decode")))
2678 };
2679
2680 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
2681 Ok(param_addr) => match param_addr.parse::<i32>() {
2682 Ok(param_addr) => param_addr,
2683 Err(e) => return Box::new(future::ok(Response::builder()
2684 .status(StatusCode::BAD_REQUEST)
2685 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
2686 .expect("Unable to create Bad Request response for invalid path parameter"))),
2687 },
2688 Err(_) => return Box::new(future::ok(Response::builder()
2689 .status(StatusCode::BAD_REQUEST)
2690 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
2691 .expect("Unable to create Bad Request response for invalid percent decode")))
2692 };
2693
2694 Box::new({
2695 {{
2696 Box::new(
2697 api_impl.get_sleep(
2698 param_bus_id,
2699 param_addr,
2700 &context
2701 ).then(move |result| {
2702 let mut response = Response::new(Body::empty());
2703 response.headers_mut().insert(
2704 HeaderName::from_static("x-span-id"),
2705 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
2706 .expect("Unable to create X-Span-ID header value"));
2707
2708 match result {
2709 Ok(rsp) => match rsp {
2710 GetSleepResponse::OK
2711 (body)
2712 => {
2713 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
2714 response.headers_mut().insert(
2715 CONTENT_TYPE,
2716 HeaderValue::from_str("application/json")
2717 .expect("Unable to create Content-Type header for GET_SLEEP_OK"));
2718 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
2719 *response.body_mut() = Body::from(body);
2720 },
2721 GetSleepResponse::BadRequest
2722 (body)
2723 => {
2724 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
2725 response.headers_mut().insert(
2726 CONTENT_TYPE,
2727 HeaderValue::from_str("application/json")
2728 .expect("Unable to create Content-Type header for GET_SLEEP_BAD_REQUEST"));
2729 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
2730 *response.body_mut() = Body::from(body);
2731 },
2732 GetSleepResponse::OperationFailed
2733 (body)
2734 => {
2735 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
2736 response.headers_mut().insert(
2737 CONTENT_TYPE,
2738 HeaderValue::from_str("application/json")
2739 .expect("Unable to create Content-Type header for GET_SLEEP_OPERATION_FAILED"));
2740 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
2741 *response.body_mut() = Body::from(body);
2742 },
2743 },
2744 Err(_) => {
2745 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
2748 *response.body_mut() = Body::from("An internal error occurred");
2749 },
2750 }
2751
2752 future::ok(response)
2753 }
2754 ))
2755 }}
2756 }) as Self::Future
2757 },
2758
2759 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_RESET) => {
2761 let path: &str = &uri.path().to_string();
2763 let path_params =
2764 paths::REGEX_PCA9956B_BUSID_RESET
2765 .captures(&path)
2766 .unwrap_or_else(||
2767 panic!("Path {} matched RE PCA9956B_BUSID_RESET in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_RESET.as_str())
2768 );
2769
2770 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
2771 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
2772 Ok(param_bus_id) => param_bus_id,
2773 Err(e) => return Box::new(future::ok(Response::builder()
2774 .status(StatusCode::BAD_REQUEST)
2775 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
2776 .expect("Unable to create Bad Request response for invalid path parameter"))),
2777 },
2778 Err(_) => return Box::new(future::ok(Response::builder()
2779 .status(StatusCode::BAD_REQUEST)
2780 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
2781 .expect("Unable to create Bad Request response for invalid percent decode")))
2782 };
2783
2784 Box::new({
2785 {{
2786 Box::new(
2787 api_impl.reset(
2788 param_bus_id,
2789 &context
2790 ).then(move |result| {
2791 let mut response = Response::new(Body::empty());
2792 response.headers_mut().insert(
2793 HeaderName::from_static("x-span-id"),
2794 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
2795 .expect("Unable to create X-Span-ID header value"));
2796
2797 match result {
2798 Ok(rsp) => match rsp {
2799 ResetResponse::OK
2800 => {
2801 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
2802 },
2803 ResetResponse::BadRequest
2804 (body)
2805 => {
2806 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
2807 response.headers_mut().insert(
2808 CONTENT_TYPE,
2809 HeaderValue::from_str("application/json")
2810 .expect("Unable to create Content-Type header for RESET_BAD_REQUEST"));
2811 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
2812 *response.body_mut() = Body::from(body);
2813 },
2814 ResetResponse::OperationFailed
2815 (body)
2816 => {
2817 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
2818 response.headers_mut().insert(
2819 CONTENT_TYPE,
2820 HeaderValue::from_str("application/json")
2821 .expect("Unable to create Content-Type header for RESET_OPERATION_FAILED"));
2822 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
2823 *response.body_mut() = Body::from(body);
2824 },
2825 },
2826 Err(_) => {
2827 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
2830 *response.body_mut() = Body::from("An internal error occurred");
2831 },
2832 }
2833
2834 future::ok(response)
2835 }
2836 ))
2837 }}
2838 }) as Self::Future
2839 },
2840
2841 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_ADDR_NUM_ENABLED_ENABLED) => {
2843 let path: &str = &uri.path().to_string();
2845 let path_params =
2846 paths::REGEX_PCA9956B_BUSID_ADDR_ADDR_NUM_ENABLED_ENABLED
2847 .captures(&path)
2848 .unwrap_or_else(||
2849 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_ADDR_NUM_ENABLED_ENABLED in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_ADDR_NUM_ENABLED_ENABLED.as_str())
2850 );
2851
2852 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
2853 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
2854 Ok(param_bus_id) => param_bus_id,
2855 Err(e) => return Box::new(future::ok(Response::builder()
2856 .status(StatusCode::BAD_REQUEST)
2857 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
2858 .expect("Unable to create Bad Request response for invalid path parameter"))),
2859 },
2860 Err(_) => return Box::new(future::ok(Response::builder()
2861 .status(StatusCode::BAD_REQUEST)
2862 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
2863 .expect("Unable to create Bad Request response for invalid percent decode")))
2864 };
2865
2866 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
2867 Ok(param_addr) => match param_addr.parse::<i32>() {
2868 Ok(param_addr) => param_addr,
2869 Err(e) => return Box::new(future::ok(Response::builder()
2870 .status(StatusCode::BAD_REQUEST)
2871 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
2872 .expect("Unable to create Bad Request response for invalid path parameter"))),
2873 },
2874 Err(_) => return Box::new(future::ok(Response::builder()
2875 .status(StatusCode::BAD_REQUEST)
2876 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
2877 .expect("Unable to create Bad Request response for invalid percent decode")))
2878 };
2879
2880 let param_num = match percent_encoding::percent_decode(path_params["num"].as_bytes()).decode_utf8() {
2881 Ok(param_num) => match param_num.parse::<i32>() {
2882 Ok(param_num) => param_num,
2883 Err(e) => return Box::new(future::ok(Response::builder()
2884 .status(StatusCode::BAD_REQUEST)
2885 .body(Body::from(format!("Couldn't parse path parameter num: {}", e)))
2886 .expect("Unable to create Bad Request response for invalid path parameter"))),
2887 },
2888 Err(_) => return Box::new(future::ok(Response::builder()
2889 .status(StatusCode::BAD_REQUEST)
2890 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["num"])))
2891 .expect("Unable to create Bad Request response for invalid percent decode")))
2892 };
2893
2894 let param_enabled = match percent_encoding::percent_decode(path_params["enabled"].as_bytes()).decode_utf8() {
2895 Ok(param_enabled) => match param_enabled.parse::<bool>() {
2896 Ok(param_enabled) => param_enabled,
2897 Err(e) => return Box::new(future::ok(Response::builder()
2898 .status(StatusCode::BAD_REQUEST)
2899 .body(Body::from(format!("Couldn't parse path parameter enabled: {}", e)))
2900 .expect("Unable to create Bad Request response for invalid path parameter"))),
2901 },
2902 Err(_) => return Box::new(future::ok(Response::builder()
2903 .status(StatusCode::BAD_REQUEST)
2904 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["enabled"])))
2905 .expect("Unable to create Bad Request response for invalid percent decode")))
2906 };
2907
2908 Box::new({
2909 {{
2910 Box::new(
2911 api_impl.set_addr_enabled(
2912 param_bus_id,
2913 param_addr,
2914 param_num,
2915 param_enabled,
2916 &context
2917 ).then(move |result| {
2918 let mut response = Response::new(Body::empty());
2919 response.headers_mut().insert(
2920 HeaderName::from_static("x-span-id"),
2921 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
2922 .expect("Unable to create X-Span-ID header value"));
2923
2924 match result {
2925 Ok(rsp) => match rsp {
2926 SetAddrEnabledResponse::OK
2927 => {
2928 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
2929 },
2930 SetAddrEnabledResponse::BadRequest
2931 (body)
2932 => {
2933 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
2934 response.headers_mut().insert(
2935 CONTENT_TYPE,
2936 HeaderValue::from_str("application/json")
2937 .expect("Unable to create Content-Type header for SET_ADDR_ENABLED_BAD_REQUEST"));
2938 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
2939 *response.body_mut() = Body::from(body);
2940 },
2941 SetAddrEnabledResponse::OperationFailed
2942 (body)
2943 => {
2944 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
2945 response.headers_mut().insert(
2946 CONTENT_TYPE,
2947 HeaderValue::from_str("application/json")
2948 .expect("Unable to create Content-Type header for SET_ADDR_ENABLED_OPERATION_FAILED"));
2949 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
2950 *response.body_mut() = Body::from(body);
2951 },
2952 },
2953 Err(_) => {
2954 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
2957 *response.body_mut() = Body::from("An internal error occurred");
2958 },
2959 }
2960
2961 future::ok(response)
2962 }
2963 ))
2964 }}
2965 }) as Self::Future
2966 },
2967
2968 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_ADDR_NUM_ADDR_ADDRVAL) => {
2970 let path: &str = &uri.path().to_string();
2972 let path_params =
2973 paths::REGEX_PCA9956B_BUSID_ADDR_ADDR_NUM_ADDR_ADDRVAL
2974 .captures(&path)
2975 .unwrap_or_else(||
2976 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_ADDR_NUM_ADDR_ADDRVAL in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_ADDR_NUM_ADDR_ADDRVAL.as_str())
2977 );
2978
2979 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
2980 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
2981 Ok(param_bus_id) => param_bus_id,
2982 Err(e) => return Box::new(future::ok(Response::builder()
2983 .status(StatusCode::BAD_REQUEST)
2984 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
2985 .expect("Unable to create Bad Request response for invalid path parameter"))),
2986 },
2987 Err(_) => return Box::new(future::ok(Response::builder()
2988 .status(StatusCode::BAD_REQUEST)
2989 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
2990 .expect("Unable to create Bad Request response for invalid percent decode")))
2991 };
2992
2993 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
2994 Ok(param_addr) => match param_addr.parse::<i32>() {
2995 Ok(param_addr) => param_addr,
2996 Err(e) => return Box::new(future::ok(Response::builder()
2997 .status(StatusCode::BAD_REQUEST)
2998 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
2999 .expect("Unable to create Bad Request response for invalid path parameter"))),
3000 },
3001 Err(_) => return Box::new(future::ok(Response::builder()
3002 .status(StatusCode::BAD_REQUEST)
3003 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
3004 .expect("Unable to create Bad Request response for invalid percent decode")))
3005 };
3006
3007 let param_num = match percent_encoding::percent_decode(path_params["num"].as_bytes()).decode_utf8() {
3008 Ok(param_num) => match param_num.parse::<i32>() {
3009 Ok(param_num) => param_num,
3010 Err(e) => return Box::new(future::ok(Response::builder()
3011 .status(StatusCode::BAD_REQUEST)
3012 .body(Body::from(format!("Couldn't parse path parameter num: {}", e)))
3013 .expect("Unable to create Bad Request response for invalid path parameter"))),
3014 },
3015 Err(_) => return Box::new(future::ok(Response::builder()
3016 .status(StatusCode::BAD_REQUEST)
3017 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["num"])))
3018 .expect("Unable to create Bad Request response for invalid percent decode")))
3019 };
3020
3021 let param_addr_val = match percent_encoding::percent_decode(path_params["addrVal"].as_bytes()).decode_utf8() {
3022 Ok(param_addr_val) => match param_addr_val.parse::<i32>() {
3023 Ok(param_addr_val) => param_addr_val,
3024 Err(e) => return Box::new(future::ok(Response::builder()
3025 .status(StatusCode::BAD_REQUEST)
3026 .body(Body::from(format!("Couldn't parse path parameter addrVal: {}", e)))
3027 .expect("Unable to create Bad Request response for invalid path parameter"))),
3028 },
3029 Err(_) => return Box::new(future::ok(Response::builder()
3030 .status(StatusCode::BAD_REQUEST)
3031 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addrVal"])))
3032 .expect("Unable to create Bad Request response for invalid percent decode")))
3033 };
3034
3035 Box::new({
3036 {{
3037 Box::new(
3038 api_impl.set_addr_value(
3039 param_bus_id,
3040 param_addr,
3041 param_num,
3042 param_addr_val,
3043 &context
3044 ).then(move |result| {
3045 let mut response = Response::new(Body::empty());
3046 response.headers_mut().insert(
3047 HeaderName::from_static("x-span-id"),
3048 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
3049 .expect("Unable to create X-Span-ID header value"));
3050
3051 match result {
3052 Ok(rsp) => match rsp {
3053 SetAddrValueResponse::OK
3054 => {
3055 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
3056 },
3057 SetAddrValueResponse::BadRequest
3058 (body)
3059 => {
3060 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
3061 response.headers_mut().insert(
3062 CONTENT_TYPE,
3063 HeaderValue::from_str("application/json")
3064 .expect("Unable to create Content-Type header for SET_ADDR_VALUE_BAD_REQUEST"));
3065 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
3066 *response.body_mut() = Body::from(body);
3067 },
3068 SetAddrValueResponse::OperationFailed
3069 (body)
3070 => {
3071 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
3072 response.headers_mut().insert(
3073 CONTENT_TYPE,
3074 HeaderValue::from_str("application/json")
3075 .expect("Unable to create Content-Type header for SET_ADDR_VALUE_OPERATION_FAILED"));
3076 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
3077 *response.body_mut() = Body::from(body);
3078 },
3079 },
3080 Err(_) => {
3081 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
3084 *response.body_mut() = Body::from("An internal error occurred");
3085 },
3086 }
3087
3088 future::ok(response)
3089 }
3090 ))
3091 }}
3092 }) as Self::Future
3093 },
3094
3095 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_CONFIG) => {
3097 let path: &str = &uri.path().to_string();
3099 let path_params =
3100 paths::REGEX_PCA9956B_BUSID_ADDR_CONFIG
3101 .captures(&path)
3102 .unwrap_or_else(||
3103 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_CONFIG in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_CONFIG.as_str())
3104 );
3105
3106 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
3107 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
3108 Ok(param_bus_id) => param_bus_id,
3109 Err(e) => return Box::new(future::ok(Response::builder()
3110 .status(StatusCode::BAD_REQUEST)
3111 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
3112 .expect("Unable to create Bad Request response for invalid path parameter"))),
3113 },
3114 Err(_) => return Box::new(future::ok(Response::builder()
3115 .status(StatusCode::BAD_REQUEST)
3116 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
3117 .expect("Unable to create Bad Request response for invalid percent decode")))
3118 };
3119
3120 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
3121 Ok(param_addr) => match param_addr.parse::<i32>() {
3122 Ok(param_addr) => param_addr,
3123 Err(e) => return Box::new(future::ok(Response::builder()
3124 .status(StatusCode::BAD_REQUEST)
3125 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
3126 .expect("Unable to create Bad Request response for invalid path parameter"))),
3127 },
3128 Err(_) => return Box::new(future::ok(Response::builder()
3129 .status(StatusCode::BAD_REQUEST)
3130 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
3131 .expect("Unable to create Bad Request response for invalid percent decode")))
3132 };
3133
3134 Box::new(body.concat2()
3138 .then(move |result| -> Self::Future {
3139 match result {
3140 Ok(body) => {
3141 let mut unused_elements = Vec::new();
3142 let param_config: Option<models::Config> = if !body.is_empty() {
3143 let deserializer = &mut serde_json::Deserializer::from_slice(&*body);
3144 match serde_ignored::deserialize(deserializer, |path| {
3145 warn!("Ignoring unknown field in body: {}", path);
3146 unused_elements.push(path.to_string());
3147 }) {
3148 Ok(param_config) => param_config,
3149 Err(e) => return Box::new(future::ok(Response::builder()
3150 .status(StatusCode::BAD_REQUEST)
3151 .body(Body::from(format!("Couldn't parse body parameter Config - doesn't match schema: {}", e)))
3152 .expect("Unable to create Bad Request response for invalid body parameter Config due to schema"))),
3153 }
3154 } else {
3155 None
3156 };
3157 let param_config = match param_config {
3158 Some(param_config) => param_config,
3159 None => return Box::new(future::ok(Response::builder()
3160 .status(StatusCode::BAD_REQUEST)
3161 .body(Body::from("Missing required body parameter Config"))
3162 .expect("Unable to create Bad Request response for missing body parameter Config"))),
3163 };
3164
3165 Box::new(
3166 api_impl.set_config(
3167 param_bus_id,
3168 param_addr,
3169 param_config,
3170 &context
3171 ).then(move |result| {
3172 let mut response = Response::new(Body::empty());
3173 response.headers_mut().insert(
3174 HeaderName::from_static("x-span-id"),
3175 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
3176 .expect("Unable to create X-Span-ID header value"));
3177
3178 if !unused_elements.is_empty() {
3179 response.headers_mut().insert(
3180 HeaderName::from_static("warning"),
3181 HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
3182 .expect("Unable to create Warning header value"));
3183 }
3184
3185 match result {
3186 Ok(rsp) => match rsp {
3187 SetConfigResponse::OK
3188 => {
3189 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
3190 },
3191 SetConfigResponse::BadRequest
3192 (body)
3193 => {
3194 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
3195 response.headers_mut().insert(
3196 CONTENT_TYPE,
3197 HeaderValue::from_str("application/json")
3198 .expect("Unable to create Content-Type header for SET_CONFIG_BAD_REQUEST"));
3199 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
3200 *response.body_mut() = Body::from(body);
3201 },
3202 SetConfigResponse::OperationFailed
3203 (body)
3204 => {
3205 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
3206 response.headers_mut().insert(
3207 CONTENT_TYPE,
3208 HeaderValue::from_str("application/json")
3209 .expect("Unable to create Content-Type header for SET_CONFIG_OPERATION_FAILED"));
3210 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
3211 *response.body_mut() = Body::from(body);
3212 },
3213 },
3214 Err(_) => {
3215 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
3218 *response.body_mut() = Body::from("An internal error occurred");
3219 },
3220 }
3221
3222 future::ok(response)
3223 }
3224 ))
3225 },
3226 Err(e) => Box::new(future::ok(Response::builder()
3227 .status(StatusCode::BAD_REQUEST)
3228 .body(Body::from(format!("Couldn't read body parameter Config: {}", e)))
3229 .expect("Unable to create Bad Request response due to unable to read body parameter Config"))),
3230 }
3231 })
3232 ) as Self::Future
3233 },
3234
3235 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_CURRENT_CURRENT) => {
3237 let path: &str = &uri.path().to_string();
3239 let path_params =
3240 paths::REGEX_PCA9956B_BUSID_ADDR_CURRENT_CURRENT
3241 .captures(&path)
3242 .unwrap_or_else(||
3243 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_CURRENT_CURRENT in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_CURRENT_CURRENT.as_str())
3244 );
3245
3246 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
3247 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
3248 Ok(param_bus_id) => param_bus_id,
3249 Err(e) => return Box::new(future::ok(Response::builder()
3250 .status(StatusCode::BAD_REQUEST)
3251 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
3252 .expect("Unable to create Bad Request response for invalid path parameter"))),
3253 },
3254 Err(_) => return Box::new(future::ok(Response::builder()
3255 .status(StatusCode::BAD_REQUEST)
3256 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
3257 .expect("Unable to create Bad Request response for invalid percent decode")))
3258 };
3259
3260 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
3261 Ok(param_addr) => match param_addr.parse::<i32>() {
3262 Ok(param_addr) => param_addr,
3263 Err(e) => return Box::new(future::ok(Response::builder()
3264 .status(StatusCode::BAD_REQUEST)
3265 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
3266 .expect("Unable to create Bad Request response for invalid path parameter"))),
3267 },
3268 Err(_) => return Box::new(future::ok(Response::builder()
3269 .status(StatusCode::BAD_REQUEST)
3270 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
3271 .expect("Unable to create Bad Request response for invalid percent decode")))
3272 };
3273
3274 let param_current = match percent_encoding::percent_decode(path_params["current"].as_bytes()).decode_utf8() {
3275 Ok(param_current) => match param_current.parse::<i32>() {
3276 Ok(param_current) => param_current,
3277 Err(e) => return Box::new(future::ok(Response::builder()
3278 .status(StatusCode::BAD_REQUEST)
3279 .body(Body::from(format!("Couldn't parse path parameter current: {}", e)))
3280 .expect("Unable to create Bad Request response for invalid path parameter"))),
3281 },
3282 Err(_) => return Box::new(future::ok(Response::builder()
3283 .status(StatusCode::BAD_REQUEST)
3284 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["current"])))
3285 .expect("Unable to create Bad Request response for invalid percent decode")))
3286 };
3287
3288 Box::new({
3289 {{
3290 Box::new(
3291 api_impl.set_current(
3292 param_bus_id,
3293 param_addr,
3294 param_current,
3295 &context
3296 ).then(move |result| {
3297 let mut response = Response::new(Body::empty());
3298 response.headers_mut().insert(
3299 HeaderName::from_static("x-span-id"),
3300 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
3301 .expect("Unable to create X-Span-ID header value"));
3302
3303 match result {
3304 Ok(rsp) => match rsp {
3305 SetCurrentResponse::OK
3306 => {
3307 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
3308 },
3309 SetCurrentResponse::BadRequest
3310 (body)
3311 => {
3312 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
3313 response.headers_mut().insert(
3314 CONTENT_TYPE,
3315 HeaderValue::from_str("application/json")
3316 .expect("Unable to create Content-Type header for SET_CURRENT_BAD_REQUEST"));
3317 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
3318 *response.body_mut() = Body::from(body);
3319 },
3320 SetCurrentResponse::OperationFailed
3321 (body)
3322 => {
3323 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
3324 response.headers_mut().insert(
3325 CONTENT_TYPE,
3326 HeaderValue::from_str("application/json")
3327 .expect("Unable to create Content-Type header for SET_CURRENT_OPERATION_FAILED"));
3328 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
3329 *response.body_mut() = Body::from(body);
3330 },
3331 },
3332 Err(_) => {
3333 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
3336 *response.body_mut() = Body::from("An internal error occurred");
3337 },
3338 }
3339
3340 future::ok(response)
3341 }
3342 ))
3343 }}
3344 }) as Self::Future
3345 },
3346
3347 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_FREQ_FREQ) => {
3349 let path: &str = &uri.path().to_string();
3351 let path_params =
3352 paths::REGEX_PCA9956B_BUSID_ADDR_FREQ_FREQ
3353 .captures(&path)
3354 .unwrap_or_else(||
3355 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_FREQ_FREQ in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_FREQ_FREQ.as_str())
3356 );
3357
3358 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
3359 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
3360 Ok(param_bus_id) => param_bus_id,
3361 Err(e) => return Box::new(future::ok(Response::builder()
3362 .status(StatusCode::BAD_REQUEST)
3363 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
3364 .expect("Unable to create Bad Request response for invalid path parameter"))),
3365 },
3366 Err(_) => return Box::new(future::ok(Response::builder()
3367 .status(StatusCode::BAD_REQUEST)
3368 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
3369 .expect("Unable to create Bad Request response for invalid percent decode")))
3370 };
3371
3372 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
3373 Ok(param_addr) => match param_addr.parse::<i32>() {
3374 Ok(param_addr) => param_addr,
3375 Err(e) => return Box::new(future::ok(Response::builder()
3376 .status(StatusCode::BAD_REQUEST)
3377 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
3378 .expect("Unable to create Bad Request response for invalid path parameter"))),
3379 },
3380 Err(_) => return Box::new(future::ok(Response::builder()
3381 .status(StatusCode::BAD_REQUEST)
3382 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
3383 .expect("Unable to create Bad Request response for invalid percent decode")))
3384 };
3385
3386 let param_freq = match percent_encoding::percent_decode(path_params["freq"].as_bytes()).decode_utf8() {
3387 Ok(param_freq) => match param_freq.parse::<i32>() {
3388 Ok(param_freq) => param_freq,
3389 Err(e) => return Box::new(future::ok(Response::builder()
3390 .status(StatusCode::BAD_REQUEST)
3391 .body(Body::from(format!("Couldn't parse path parameter freq: {}", e)))
3392 .expect("Unable to create Bad Request response for invalid path parameter"))),
3393 },
3394 Err(_) => return Box::new(future::ok(Response::builder()
3395 .status(StatusCode::BAD_REQUEST)
3396 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["freq"])))
3397 .expect("Unable to create Bad Request response for invalid percent decode")))
3398 };
3399
3400 Box::new({
3401 {{
3402 Box::new(
3403 api_impl.set_freq(
3404 param_bus_id,
3405 param_addr,
3406 param_freq,
3407 &context
3408 ).then(move |result| {
3409 let mut response = Response::new(Body::empty());
3410 response.headers_mut().insert(
3411 HeaderName::from_static("x-span-id"),
3412 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
3413 .expect("Unable to create X-Span-ID header value"));
3414
3415 match result {
3416 Ok(rsp) => match rsp {
3417 SetFreqResponse::OK
3418 => {
3419 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
3420 },
3421 SetFreqResponse::BadRequest
3422 (body)
3423 => {
3424 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
3425 response.headers_mut().insert(
3426 CONTENT_TYPE,
3427 HeaderValue::from_str("application/json")
3428 .expect("Unable to create Content-Type header for SET_FREQ_BAD_REQUEST"));
3429 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
3430 *response.body_mut() = Body::from(body);
3431 },
3432 SetFreqResponse::OperationFailed
3433 (body)
3434 => {
3435 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
3436 response.headers_mut().insert(
3437 CONTENT_TYPE,
3438 HeaderValue::from_str("application/json")
3439 .expect("Unable to create Content-Type header for SET_FREQ_OPERATION_FAILED"));
3440 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
3441 *response.body_mut() = Body::from(body);
3442 },
3443 },
3444 Err(_) => {
3445 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
3448 *response.body_mut() = Body::from("An internal error occurred");
3449 },
3450 }
3451
3452 future::ok(response)
3453 }
3454 ))
3455 }}
3456 }) as Self::Future
3457 },
3458
3459 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_GROUP_GROUP) => {
3461 let path: &str = &uri.path().to_string();
3463 let path_params =
3464 paths::REGEX_PCA9956B_BUSID_ADDR_GROUP_GROUP
3465 .captures(&path)
3466 .unwrap_or_else(||
3467 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_GROUP_GROUP in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_GROUP_GROUP.as_str())
3468 );
3469
3470 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
3471 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
3472 Ok(param_bus_id) => param_bus_id,
3473 Err(e) => return Box::new(future::ok(Response::builder()
3474 .status(StatusCode::BAD_REQUEST)
3475 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
3476 .expect("Unable to create Bad Request response for invalid path parameter"))),
3477 },
3478 Err(_) => return Box::new(future::ok(Response::builder()
3479 .status(StatusCode::BAD_REQUEST)
3480 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
3481 .expect("Unable to create Bad Request response for invalid percent decode")))
3482 };
3483
3484 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
3485 Ok(param_addr) => match param_addr.parse::<i32>() {
3486 Ok(param_addr) => param_addr,
3487 Err(e) => return Box::new(future::ok(Response::builder()
3488 .status(StatusCode::BAD_REQUEST)
3489 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
3490 .expect("Unable to create Bad Request response for invalid path parameter"))),
3491 },
3492 Err(_) => return Box::new(future::ok(Response::builder()
3493 .status(StatusCode::BAD_REQUEST)
3494 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
3495 .expect("Unable to create Bad Request response for invalid percent decode")))
3496 };
3497
3498 let param_group = match percent_encoding::percent_decode(path_params["group"].as_bytes()).decode_utf8() {
3499 Ok(param_group) => match param_group.parse::<models::Group>() {
3500 Ok(param_group) => param_group,
3501 Err(e) => return Box::new(future::ok(Response::builder()
3502 .status(StatusCode::BAD_REQUEST)
3503 .body(Body::from(format!("Couldn't parse path parameter group: {}", e)))
3504 .expect("Unable to create Bad Request response for invalid path parameter"))),
3505 },
3506 Err(_) => return Box::new(future::ok(Response::builder()
3507 .status(StatusCode::BAD_REQUEST)
3508 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["group"])))
3509 .expect("Unable to create Bad Request response for invalid percent decode")))
3510 };
3511
3512 Box::new({
3513 {{
3514 Box::new(
3515 api_impl.set_group(
3516 param_bus_id,
3517 param_addr,
3518 param_group,
3519 &context
3520 ).then(move |result| {
3521 let mut response = Response::new(Body::empty());
3522 response.headers_mut().insert(
3523 HeaderName::from_static("x-span-id"),
3524 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
3525 .expect("Unable to create X-Span-ID header value"));
3526
3527 match result {
3528 Ok(rsp) => match rsp {
3529 SetGroupResponse::OK
3530 => {
3531 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
3532 },
3533 SetGroupResponse::BadRequest
3534 (body)
3535 => {
3536 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
3537 response.headers_mut().insert(
3538 CONTENT_TYPE,
3539 HeaderValue::from_str("application/json")
3540 .expect("Unable to create Content-Type header for SET_GROUP_BAD_REQUEST"));
3541 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
3542 *response.body_mut() = Body::from(body);
3543 },
3544 SetGroupResponse::OperationFailed
3545 (body)
3546 => {
3547 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
3548 response.headers_mut().insert(
3549 CONTENT_TYPE,
3550 HeaderValue::from_str("application/json")
3551 .expect("Unable to create Content-Type header for SET_GROUP_OPERATION_FAILED"));
3552 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
3553 *response.body_mut() = Body::from(body);
3554 },
3555 },
3556 Err(_) => {
3557 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
3560 *response.body_mut() = Body::from("An internal error occurred");
3561 },
3562 }
3563
3564 future::ok(response)
3565 }
3566 ))
3567 }}
3568 }) as Self::Future
3569 },
3570
3571 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED_LED_CURRENT_CURRENT) => {
3573 let path: &str = &uri.path().to_string();
3575 let path_params =
3576 paths::REGEX_PCA9956B_BUSID_ADDR_LED_LED_CURRENT_CURRENT
3577 .captures(&path)
3578 .unwrap_or_else(||
3579 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_LED_LED_CURRENT_CURRENT in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_LED_LED_CURRENT_CURRENT.as_str())
3580 );
3581
3582 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
3583 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
3584 Ok(param_bus_id) => param_bus_id,
3585 Err(e) => return Box::new(future::ok(Response::builder()
3586 .status(StatusCode::BAD_REQUEST)
3587 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
3588 .expect("Unable to create Bad Request response for invalid path parameter"))),
3589 },
3590 Err(_) => return Box::new(future::ok(Response::builder()
3591 .status(StatusCode::BAD_REQUEST)
3592 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
3593 .expect("Unable to create Bad Request response for invalid percent decode")))
3594 };
3595
3596 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
3597 Ok(param_addr) => match param_addr.parse::<i32>() {
3598 Ok(param_addr) => param_addr,
3599 Err(e) => return Box::new(future::ok(Response::builder()
3600 .status(StatusCode::BAD_REQUEST)
3601 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
3602 .expect("Unable to create Bad Request response for invalid path parameter"))),
3603 },
3604 Err(_) => return Box::new(future::ok(Response::builder()
3605 .status(StatusCode::BAD_REQUEST)
3606 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
3607 .expect("Unable to create Bad Request response for invalid percent decode")))
3608 };
3609
3610 let param_led = match percent_encoding::percent_decode(path_params["led"].as_bytes()).decode_utf8() {
3611 Ok(param_led) => match param_led.parse::<i32>() {
3612 Ok(param_led) => param_led,
3613 Err(e) => return Box::new(future::ok(Response::builder()
3614 .status(StatusCode::BAD_REQUEST)
3615 .body(Body::from(format!("Couldn't parse path parameter led: {}", e)))
3616 .expect("Unable to create Bad Request response for invalid path parameter"))),
3617 },
3618 Err(_) => return Box::new(future::ok(Response::builder()
3619 .status(StatusCode::BAD_REQUEST)
3620 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["led"])))
3621 .expect("Unable to create Bad Request response for invalid percent decode")))
3622 };
3623
3624 let param_current = match percent_encoding::percent_decode(path_params["current"].as_bytes()).decode_utf8() {
3625 Ok(param_current) => match param_current.parse::<i32>() {
3626 Ok(param_current) => param_current,
3627 Err(e) => return Box::new(future::ok(Response::builder()
3628 .status(StatusCode::BAD_REQUEST)
3629 .body(Body::from(format!("Couldn't parse path parameter current: {}", e)))
3630 .expect("Unable to create Bad Request response for invalid path parameter"))),
3631 },
3632 Err(_) => return Box::new(future::ok(Response::builder()
3633 .status(StatusCode::BAD_REQUEST)
3634 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["current"])))
3635 .expect("Unable to create Bad Request response for invalid percent decode")))
3636 };
3637
3638 Box::new({
3639 {{
3640 Box::new(
3641 api_impl.set_led_current(
3642 param_bus_id,
3643 param_addr,
3644 param_led,
3645 param_current,
3646 &context
3647 ).then(move |result| {
3648 let mut response = Response::new(Body::empty());
3649 response.headers_mut().insert(
3650 HeaderName::from_static("x-span-id"),
3651 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
3652 .expect("Unable to create X-Span-ID header value"));
3653
3654 match result {
3655 Ok(rsp) => match rsp {
3656 SetLedCurrentResponse::OK
3657 => {
3658 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
3659 },
3660 SetLedCurrentResponse::BadRequest
3661 (body)
3662 => {
3663 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
3664 response.headers_mut().insert(
3665 CONTENT_TYPE,
3666 HeaderValue::from_str("application/json")
3667 .expect("Unable to create Content-Type header for SET_LED_CURRENT_BAD_REQUEST"));
3668 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
3669 *response.body_mut() = Body::from(body);
3670 },
3671 SetLedCurrentResponse::OperationFailed
3672 (body)
3673 => {
3674 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
3675 response.headers_mut().insert(
3676 CONTENT_TYPE,
3677 HeaderValue::from_str("application/json")
3678 .expect("Unable to create Content-Type header for SET_LED_CURRENT_OPERATION_FAILED"));
3679 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
3680 *response.body_mut() = Body::from(body);
3681 },
3682 },
3683 Err(_) => {
3684 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
3687 *response.body_mut() = Body::from("An internal error occurred");
3688 },
3689 }
3690
3691 future::ok(response)
3692 }
3693 ))
3694 }}
3695 }) as Self::Future
3696 },
3697
3698 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED_LED_ERROR_ERROR) => {
3700 let path: &str = &uri.path().to_string();
3702 let path_params =
3703 paths::REGEX_PCA9956B_BUSID_ADDR_LED_LED_ERROR_ERROR
3704 .captures(&path)
3705 .unwrap_or_else(||
3706 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_LED_LED_ERROR_ERROR in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_LED_LED_ERROR_ERROR.as_str())
3707 );
3708
3709 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
3710 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
3711 Ok(param_bus_id) => param_bus_id,
3712 Err(e) => return Box::new(future::ok(Response::builder()
3713 .status(StatusCode::BAD_REQUEST)
3714 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
3715 .expect("Unable to create Bad Request response for invalid path parameter"))),
3716 },
3717 Err(_) => return Box::new(future::ok(Response::builder()
3718 .status(StatusCode::BAD_REQUEST)
3719 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
3720 .expect("Unable to create Bad Request response for invalid percent decode")))
3721 };
3722
3723 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
3724 Ok(param_addr) => match param_addr.parse::<i32>() {
3725 Ok(param_addr) => param_addr,
3726 Err(e) => return Box::new(future::ok(Response::builder()
3727 .status(StatusCode::BAD_REQUEST)
3728 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
3729 .expect("Unable to create Bad Request response for invalid path parameter"))),
3730 },
3731 Err(_) => return Box::new(future::ok(Response::builder()
3732 .status(StatusCode::BAD_REQUEST)
3733 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
3734 .expect("Unable to create Bad Request response for invalid percent decode")))
3735 };
3736
3737 let param_led = match percent_encoding::percent_decode(path_params["led"].as_bytes()).decode_utf8() {
3738 Ok(param_led) => match param_led.parse::<i32>() {
3739 Ok(param_led) => param_led,
3740 Err(e) => return Box::new(future::ok(Response::builder()
3741 .status(StatusCode::BAD_REQUEST)
3742 .body(Body::from(format!("Couldn't parse path parameter led: {}", e)))
3743 .expect("Unable to create Bad Request response for invalid path parameter"))),
3744 },
3745 Err(_) => return Box::new(future::ok(Response::builder()
3746 .status(StatusCode::BAD_REQUEST)
3747 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["led"])))
3748 .expect("Unable to create Bad Request response for invalid percent decode")))
3749 };
3750
3751 let param_error = match percent_encoding::percent_decode(path_params["error"].as_bytes()).decode_utf8() {
3752 Ok(param_error) => match param_error.parse::<models::LedError>() {
3753 Ok(param_error) => param_error,
3754 Err(e) => return Box::new(future::ok(Response::builder()
3755 .status(StatusCode::BAD_REQUEST)
3756 .body(Body::from(format!("Couldn't parse path parameter error: {}", e)))
3757 .expect("Unable to create Bad Request response for invalid path parameter"))),
3758 },
3759 Err(_) => return Box::new(future::ok(Response::builder()
3760 .status(StatusCode::BAD_REQUEST)
3761 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["error"])))
3762 .expect("Unable to create Bad Request response for invalid percent decode")))
3763 };
3764
3765 Box::new({
3766 {{
3767 Box::new(
3768 api_impl.set_led_error(
3769 param_bus_id,
3770 param_addr,
3771 param_led,
3772 param_error,
3773 &context
3774 ).then(move |result| {
3775 let mut response = Response::new(Body::empty());
3776 response.headers_mut().insert(
3777 HeaderName::from_static("x-span-id"),
3778 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
3779 .expect("Unable to create X-Span-ID header value"));
3780
3781 match result {
3782 Ok(rsp) => match rsp {
3783 SetLedErrorResponse::OK
3784 => {
3785 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
3786 },
3787 SetLedErrorResponse::BadRequest
3788 (body)
3789 => {
3790 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
3791 response.headers_mut().insert(
3792 CONTENT_TYPE,
3793 HeaderValue::from_str("application/json")
3794 .expect("Unable to create Content-Type header for SET_LED_ERROR_BAD_REQUEST"));
3795 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
3796 *response.body_mut() = Body::from(body);
3797 },
3798 SetLedErrorResponse::OperationFailed
3799 (body)
3800 => {
3801 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
3802 response.headers_mut().insert(
3803 CONTENT_TYPE,
3804 HeaderValue::from_str("application/json")
3805 .expect("Unable to create Content-Type header for SET_LED_ERROR_OPERATION_FAILED"));
3806 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
3807 *response.body_mut() = Body::from(body);
3808 },
3809 },
3810 Err(_) => {
3811 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
3814 *response.body_mut() = Body::from("An internal error occurred");
3815 },
3816 }
3817
3818 future::ok(response)
3819 }
3820 ))
3821 }}
3822 }) as Self::Future
3823 },
3824
3825 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED_LED) => {
3827 let path: &str = &uri.path().to_string();
3829 let path_params =
3830 paths::REGEX_PCA9956B_BUSID_ADDR_LED_LED
3831 .captures(&path)
3832 .unwrap_or_else(||
3833 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_LED_LED in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_LED_LED.as_str())
3834 );
3835
3836 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
3837 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
3838 Ok(param_bus_id) => param_bus_id,
3839 Err(e) => return Box::new(future::ok(Response::builder()
3840 .status(StatusCode::BAD_REQUEST)
3841 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
3842 .expect("Unable to create Bad Request response for invalid path parameter"))),
3843 },
3844 Err(_) => return Box::new(future::ok(Response::builder()
3845 .status(StatusCode::BAD_REQUEST)
3846 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
3847 .expect("Unable to create Bad Request response for invalid percent decode")))
3848 };
3849
3850 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
3851 Ok(param_addr) => match param_addr.parse::<i32>() {
3852 Ok(param_addr) => param_addr,
3853 Err(e) => return Box::new(future::ok(Response::builder()
3854 .status(StatusCode::BAD_REQUEST)
3855 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
3856 .expect("Unable to create Bad Request response for invalid path parameter"))),
3857 },
3858 Err(_) => return Box::new(future::ok(Response::builder()
3859 .status(StatusCode::BAD_REQUEST)
3860 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
3861 .expect("Unable to create Bad Request response for invalid percent decode")))
3862 };
3863
3864 let param_led = match percent_encoding::percent_decode(path_params["led"].as_bytes()).decode_utf8() {
3865 Ok(param_led) => match param_led.parse::<i32>() {
3866 Ok(param_led) => param_led,
3867 Err(e) => return Box::new(future::ok(Response::builder()
3868 .status(StatusCode::BAD_REQUEST)
3869 .body(Body::from(format!("Couldn't parse path parameter led: {}", e)))
3870 .expect("Unable to create Bad Request response for invalid path parameter"))),
3871 },
3872 Err(_) => return Box::new(future::ok(Response::builder()
3873 .status(StatusCode::BAD_REQUEST)
3874 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["led"])))
3875 .expect("Unable to create Bad Request response for invalid percent decode")))
3876 };
3877
3878 Box::new(body.concat2()
3882 .then(move |result| -> Self::Future {
3883 match result {
3884 Ok(body) => {
3885 let mut unused_elements = Vec::new();
3886 let param_led_info: Option<models::LedInfo> = if !body.is_empty() {
3887 let deserializer = &mut serde_json::Deserializer::from_slice(&*body);
3888 match serde_ignored::deserialize(deserializer, |path| {
3889 warn!("Ignoring unknown field in body: {}", path);
3890 unused_elements.push(path.to_string());
3891 }) {
3892 Ok(param_led_info) => param_led_info,
3893 Err(e) => return Box::new(future::ok(Response::builder()
3894 .status(StatusCode::BAD_REQUEST)
3895 .body(Body::from(format!("Couldn't parse body parameter LedInfo - doesn't match schema: {}", e)))
3896 .expect("Unable to create Bad Request response for invalid body parameter LedInfo due to schema"))),
3897 }
3898 } else {
3899 None
3900 };
3901 let param_led_info = match param_led_info {
3902 Some(param_led_info) => param_led_info,
3903 None => return Box::new(future::ok(Response::builder()
3904 .status(StatusCode::BAD_REQUEST)
3905 .body(Body::from("Missing required body parameter LedInfo"))
3906 .expect("Unable to create Bad Request response for missing body parameter LedInfo"))),
3907 };
3908
3909 Box::new(
3910 api_impl.set_led_info(
3911 param_bus_id,
3912 param_addr,
3913 param_led,
3914 param_led_info,
3915 &context
3916 ).then(move |result| {
3917 let mut response = Response::new(Body::empty());
3918 response.headers_mut().insert(
3919 HeaderName::from_static("x-span-id"),
3920 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
3921 .expect("Unable to create X-Span-ID header value"));
3922
3923 if !unused_elements.is_empty() {
3924 response.headers_mut().insert(
3925 HeaderName::from_static("warning"),
3926 HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
3927 .expect("Unable to create Warning header value"));
3928 }
3929
3930 match result {
3931 Ok(rsp) => match rsp {
3932 SetLedInfoResponse::OK
3933 => {
3934 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
3935 },
3936 SetLedInfoResponse::BadRequest
3937 (body)
3938 => {
3939 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
3940 response.headers_mut().insert(
3941 CONTENT_TYPE,
3942 HeaderValue::from_str("application/json")
3943 .expect("Unable to create Content-Type header for SET_LED_INFO_BAD_REQUEST"));
3944 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
3945 *response.body_mut() = Body::from(body);
3946 },
3947 SetLedInfoResponse::OperationFailed
3948 (body)
3949 => {
3950 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
3951 response.headers_mut().insert(
3952 CONTENT_TYPE,
3953 HeaderValue::from_str("application/json")
3954 .expect("Unable to create Content-Type header for SET_LED_INFO_OPERATION_FAILED"));
3955 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
3956 *response.body_mut() = Body::from(body);
3957 },
3958 },
3959 Err(_) => {
3960 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
3963 *response.body_mut() = Body::from("An internal error occurred");
3964 },
3965 }
3966
3967 future::ok(response)
3968 }
3969 ))
3970 },
3971 Err(e) => Box::new(future::ok(Response::builder()
3972 .status(StatusCode::BAD_REQUEST)
3973 .body(Body::from(format!("Couldn't read body parameter LedInfo: {}", e)))
3974 .expect("Unable to create Bad Request response due to unable to read body parameter LedInfo"))),
3975 }
3976 })
3977 ) as Self::Future
3978 },
3979
3980 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED) => {
3982 let path: &str = &uri.path().to_string();
3984 let path_params =
3985 paths::REGEX_PCA9956B_BUSID_ADDR_LED
3986 .captures(&path)
3987 .unwrap_or_else(||
3988 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_LED in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_LED.as_str())
3989 );
3990
3991 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
3992 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
3993 Ok(param_bus_id) => param_bus_id,
3994 Err(e) => return Box::new(future::ok(Response::builder()
3995 .status(StatusCode::BAD_REQUEST)
3996 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
3997 .expect("Unable to create Bad Request response for invalid path parameter"))),
3998 },
3999 Err(_) => return Box::new(future::ok(Response::builder()
4000 .status(StatusCode::BAD_REQUEST)
4001 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
4002 .expect("Unable to create Bad Request response for invalid percent decode")))
4003 };
4004
4005 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
4006 Ok(param_addr) => match param_addr.parse::<i32>() {
4007 Ok(param_addr) => param_addr,
4008 Err(e) => return Box::new(future::ok(Response::builder()
4009 .status(StatusCode::BAD_REQUEST)
4010 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
4011 .expect("Unable to create Bad Request response for invalid path parameter"))),
4012 },
4013 Err(_) => return Box::new(future::ok(Response::builder()
4014 .status(StatusCode::BAD_REQUEST)
4015 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
4016 .expect("Unable to create Bad Request response for invalid percent decode")))
4017 };
4018
4019 Box::new(body.concat2()
4023 .then(move |result| -> Self::Future {
4024 match result {
4025 Ok(body) => {
4026 let mut unused_elements = Vec::new();
4027 let param_led_info_array: Option<models::LedInfoArray> = if !body.is_empty() {
4028 let deserializer = &mut serde_json::Deserializer::from_slice(&*body);
4029 match serde_ignored::deserialize(deserializer, |path| {
4030 warn!("Ignoring unknown field in body: {}", path);
4031 unused_elements.push(path.to_string());
4032 }) {
4033 Ok(param_led_info_array) => param_led_info_array,
4034 Err(e) => return Box::new(future::ok(Response::builder()
4035 .status(StatusCode::BAD_REQUEST)
4036 .body(Body::from(format!("Couldn't parse body parameter LedInfoArray - doesn't match schema: {}", e)))
4037 .expect("Unable to create Bad Request response for invalid body parameter LedInfoArray due to schema"))),
4038 }
4039 } else {
4040 None
4041 };
4042 let param_led_info_array = match param_led_info_array {
4043 Some(param_led_info_array) => param_led_info_array,
4044 None => return Box::new(future::ok(Response::builder()
4045 .status(StatusCode::BAD_REQUEST)
4046 .body(Body::from("Missing required body parameter LedInfoArray"))
4047 .expect("Unable to create Bad Request response for missing body parameter LedInfoArray"))),
4048 };
4049
4050 Box::new(
4051 api_impl.set_led_info_all(
4052 param_bus_id,
4053 param_addr,
4054 param_led_info_array,
4055 &context
4056 ).then(move |result| {
4057 let mut response = Response::new(Body::empty());
4058 response.headers_mut().insert(
4059 HeaderName::from_static("x-span-id"),
4060 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
4061 .expect("Unable to create X-Span-ID header value"));
4062
4063 if !unused_elements.is_empty() {
4064 response.headers_mut().insert(
4065 HeaderName::from_static("warning"),
4066 HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
4067 .expect("Unable to create Warning header value"));
4068 }
4069
4070 match result {
4071 Ok(rsp) => match rsp {
4072 SetLedInfoAllResponse::OK
4073 => {
4074 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
4075 },
4076 SetLedInfoAllResponse::BadRequest
4077 (body)
4078 => {
4079 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
4080 response.headers_mut().insert(
4081 CONTENT_TYPE,
4082 HeaderValue::from_str("application/json")
4083 .expect("Unable to create Content-Type header for SET_LED_INFO_ALL_BAD_REQUEST"));
4084 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
4085 *response.body_mut() = Body::from(body);
4086 },
4087 SetLedInfoAllResponse::OperationFailed
4088 (body)
4089 => {
4090 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
4091 response.headers_mut().insert(
4092 CONTENT_TYPE,
4093 HeaderValue::from_str("application/json")
4094 .expect("Unable to create Content-Type header for SET_LED_INFO_ALL_OPERATION_FAILED"));
4095 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
4096 *response.body_mut() = Body::from(body);
4097 },
4098 },
4099 Err(_) => {
4100 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
4103 *response.body_mut() = Body::from("An internal error occurred");
4104 },
4105 }
4106
4107 future::ok(response)
4108 }
4109 ))
4110 },
4111 Err(e) => Box::new(future::ok(Response::builder()
4112 .status(StatusCode::BAD_REQUEST)
4113 .body(Body::from(format!("Couldn't read body parameter LedInfoArray: {}", e)))
4114 .expect("Unable to create Bad Request response due to unable to read body parameter LedInfoArray"))),
4115 }
4116 })
4117 ) as Self::Future
4118 },
4119
4120 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED_LED_PWM_PWM) => {
4122 let path: &str = &uri.path().to_string();
4124 let path_params =
4125 paths::REGEX_PCA9956B_BUSID_ADDR_LED_LED_PWM_PWM
4126 .captures(&path)
4127 .unwrap_or_else(||
4128 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_LED_LED_PWM_PWM in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_LED_LED_PWM_PWM.as_str())
4129 );
4130
4131 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
4132 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
4133 Ok(param_bus_id) => param_bus_id,
4134 Err(e) => return Box::new(future::ok(Response::builder()
4135 .status(StatusCode::BAD_REQUEST)
4136 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
4137 .expect("Unable to create Bad Request response for invalid path parameter"))),
4138 },
4139 Err(_) => return Box::new(future::ok(Response::builder()
4140 .status(StatusCode::BAD_REQUEST)
4141 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
4142 .expect("Unable to create Bad Request response for invalid percent decode")))
4143 };
4144
4145 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
4146 Ok(param_addr) => match param_addr.parse::<i32>() {
4147 Ok(param_addr) => param_addr,
4148 Err(e) => return Box::new(future::ok(Response::builder()
4149 .status(StatusCode::BAD_REQUEST)
4150 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
4151 .expect("Unable to create Bad Request response for invalid path parameter"))),
4152 },
4153 Err(_) => return Box::new(future::ok(Response::builder()
4154 .status(StatusCode::BAD_REQUEST)
4155 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
4156 .expect("Unable to create Bad Request response for invalid percent decode")))
4157 };
4158
4159 let param_led = match percent_encoding::percent_decode(path_params["led"].as_bytes()).decode_utf8() {
4160 Ok(param_led) => match param_led.parse::<i32>() {
4161 Ok(param_led) => param_led,
4162 Err(e) => return Box::new(future::ok(Response::builder()
4163 .status(StatusCode::BAD_REQUEST)
4164 .body(Body::from(format!("Couldn't parse path parameter led: {}", e)))
4165 .expect("Unable to create Bad Request response for invalid path parameter"))),
4166 },
4167 Err(_) => return Box::new(future::ok(Response::builder()
4168 .status(StatusCode::BAD_REQUEST)
4169 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["led"])))
4170 .expect("Unable to create Bad Request response for invalid percent decode")))
4171 };
4172
4173 let param_pwm = match percent_encoding::percent_decode(path_params["pwm"].as_bytes()).decode_utf8() {
4174 Ok(param_pwm) => match param_pwm.parse::<i32>() {
4175 Ok(param_pwm) => param_pwm,
4176 Err(e) => return Box::new(future::ok(Response::builder()
4177 .status(StatusCode::BAD_REQUEST)
4178 .body(Body::from(format!("Couldn't parse path parameter pwm: {}", e)))
4179 .expect("Unable to create Bad Request response for invalid path parameter"))),
4180 },
4181 Err(_) => return Box::new(future::ok(Response::builder()
4182 .status(StatusCode::BAD_REQUEST)
4183 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["pwm"])))
4184 .expect("Unable to create Bad Request response for invalid percent decode")))
4185 };
4186
4187 Box::new({
4188 {{
4189 Box::new(
4190 api_impl.set_led_pwm(
4191 param_bus_id,
4192 param_addr,
4193 param_led,
4194 param_pwm,
4195 &context
4196 ).then(move |result| {
4197 let mut response = Response::new(Body::empty());
4198 response.headers_mut().insert(
4199 HeaderName::from_static("x-span-id"),
4200 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
4201 .expect("Unable to create X-Span-ID header value"));
4202
4203 match result {
4204 Ok(rsp) => match rsp {
4205 SetLedPwmResponse::OK
4206 => {
4207 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
4208 },
4209 SetLedPwmResponse::BadRequest
4210 (body)
4211 => {
4212 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
4213 response.headers_mut().insert(
4214 CONTENT_TYPE,
4215 HeaderValue::from_str("application/json")
4216 .expect("Unable to create Content-Type header for SET_LED_PWM_BAD_REQUEST"));
4217 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
4218 *response.body_mut() = Body::from(body);
4219 },
4220 SetLedPwmResponse::OperationFailed
4221 (body)
4222 => {
4223 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
4224 response.headers_mut().insert(
4225 CONTENT_TYPE,
4226 HeaderValue::from_str("application/json")
4227 .expect("Unable to create Content-Type header for SET_LED_PWM_OPERATION_FAILED"));
4228 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
4229 *response.body_mut() = Body::from(body);
4230 },
4231 },
4232 Err(_) => {
4233 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
4236 *response.body_mut() = Body::from("An internal error occurred");
4237 },
4238 }
4239
4240 future::ok(response)
4241 }
4242 ))
4243 }}
4244 }) as Self::Future
4245 },
4246
4247 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED_LED_STATE_STATE) => {
4249 let path: &str = &uri.path().to_string();
4251 let path_params =
4252 paths::REGEX_PCA9956B_BUSID_ADDR_LED_LED_STATE_STATE
4253 .captures(&path)
4254 .unwrap_or_else(||
4255 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_LED_LED_STATE_STATE in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_LED_LED_STATE_STATE.as_str())
4256 );
4257
4258 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
4259 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
4260 Ok(param_bus_id) => param_bus_id,
4261 Err(e) => return Box::new(future::ok(Response::builder()
4262 .status(StatusCode::BAD_REQUEST)
4263 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
4264 .expect("Unable to create Bad Request response for invalid path parameter"))),
4265 },
4266 Err(_) => return Box::new(future::ok(Response::builder()
4267 .status(StatusCode::BAD_REQUEST)
4268 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
4269 .expect("Unable to create Bad Request response for invalid percent decode")))
4270 };
4271
4272 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
4273 Ok(param_addr) => match param_addr.parse::<i32>() {
4274 Ok(param_addr) => param_addr,
4275 Err(e) => return Box::new(future::ok(Response::builder()
4276 .status(StatusCode::BAD_REQUEST)
4277 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
4278 .expect("Unable to create Bad Request response for invalid path parameter"))),
4279 },
4280 Err(_) => return Box::new(future::ok(Response::builder()
4281 .status(StatusCode::BAD_REQUEST)
4282 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
4283 .expect("Unable to create Bad Request response for invalid percent decode")))
4284 };
4285
4286 let param_led = match percent_encoding::percent_decode(path_params["led"].as_bytes()).decode_utf8() {
4287 Ok(param_led) => match param_led.parse::<i32>() {
4288 Ok(param_led) => param_led,
4289 Err(e) => return Box::new(future::ok(Response::builder()
4290 .status(StatusCode::BAD_REQUEST)
4291 .body(Body::from(format!("Couldn't parse path parameter led: {}", e)))
4292 .expect("Unable to create Bad Request response for invalid path parameter"))),
4293 },
4294 Err(_) => return Box::new(future::ok(Response::builder()
4295 .status(StatusCode::BAD_REQUEST)
4296 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["led"])))
4297 .expect("Unable to create Bad Request response for invalid percent decode")))
4298 };
4299
4300 let param_state = match percent_encoding::percent_decode(path_params["state"].as_bytes()).decode_utf8() {
4301 Ok(param_state) => match param_state.parse::<models::LedState>() {
4302 Ok(param_state) => param_state,
4303 Err(e) => return Box::new(future::ok(Response::builder()
4304 .status(StatusCode::BAD_REQUEST)
4305 .body(Body::from(format!("Couldn't parse path parameter state: {}", e)))
4306 .expect("Unable to create Bad Request response for invalid path parameter"))),
4307 },
4308 Err(_) => return Box::new(future::ok(Response::builder()
4309 .status(StatusCode::BAD_REQUEST)
4310 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["state"])))
4311 .expect("Unable to create Bad Request response for invalid percent decode")))
4312 };
4313
4314 Box::new({
4315 {{
4316 Box::new(
4317 api_impl.set_led_state(
4318 param_bus_id,
4319 param_addr,
4320 param_led,
4321 param_state,
4322 &context
4323 ).then(move |result| {
4324 let mut response = Response::new(Body::empty());
4325 response.headers_mut().insert(
4326 HeaderName::from_static("x-span-id"),
4327 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
4328 .expect("Unable to create X-Span-ID header value"));
4329
4330 match result {
4331 Ok(rsp) => match rsp {
4332 SetLedStateResponse::OK
4333 => {
4334 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
4335 },
4336 SetLedStateResponse::BadRequest
4337 (body)
4338 => {
4339 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
4340 response.headers_mut().insert(
4341 CONTENT_TYPE,
4342 HeaderValue::from_str("application/json")
4343 .expect("Unable to create Content-Type header for SET_LED_STATE_BAD_REQUEST"));
4344 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
4345 *response.body_mut() = Body::from(body);
4346 },
4347 SetLedStateResponse::OperationFailed
4348 (body)
4349 => {
4350 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
4351 response.headers_mut().insert(
4352 CONTENT_TYPE,
4353 HeaderValue::from_str("application/json")
4354 .expect("Unable to create Content-Type header for SET_LED_STATE_OPERATION_FAILED"));
4355 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
4356 *response.body_mut() = Body::from(body);
4357 },
4358 },
4359 Err(_) => {
4360 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
4363 *response.body_mut() = Body::from("An internal error occurred");
4364 },
4365 }
4366
4367 future::ok(response)
4368 }
4369 ))
4370 }}
4371 }) as Self::Future
4372 },
4373
4374 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_OFFSET_OFFSET) => {
4376 let path: &str = &uri.path().to_string();
4378 let path_params =
4379 paths::REGEX_PCA9956B_BUSID_ADDR_OFFSET_OFFSET
4380 .captures(&path)
4381 .unwrap_or_else(||
4382 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_OFFSET_OFFSET in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_OFFSET_OFFSET.as_str())
4383 );
4384
4385 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
4386 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
4387 Ok(param_bus_id) => param_bus_id,
4388 Err(e) => return Box::new(future::ok(Response::builder()
4389 .status(StatusCode::BAD_REQUEST)
4390 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
4391 .expect("Unable to create Bad Request response for invalid path parameter"))),
4392 },
4393 Err(_) => return Box::new(future::ok(Response::builder()
4394 .status(StatusCode::BAD_REQUEST)
4395 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
4396 .expect("Unable to create Bad Request response for invalid percent decode")))
4397 };
4398
4399 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
4400 Ok(param_addr) => match param_addr.parse::<i32>() {
4401 Ok(param_addr) => param_addr,
4402 Err(e) => return Box::new(future::ok(Response::builder()
4403 .status(StatusCode::BAD_REQUEST)
4404 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
4405 .expect("Unable to create Bad Request response for invalid path parameter"))),
4406 },
4407 Err(_) => return Box::new(future::ok(Response::builder()
4408 .status(StatusCode::BAD_REQUEST)
4409 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
4410 .expect("Unable to create Bad Request response for invalid percent decode")))
4411 };
4412
4413 let param_offset = match percent_encoding::percent_decode(path_params["offset"].as_bytes()).decode_utf8() {
4414 Ok(param_offset) => match param_offset.parse::<i32>() {
4415 Ok(param_offset) => param_offset,
4416 Err(e) => return Box::new(future::ok(Response::builder()
4417 .status(StatusCode::BAD_REQUEST)
4418 .body(Body::from(format!("Couldn't parse path parameter offset: {}", e)))
4419 .expect("Unable to create Bad Request response for invalid path parameter"))),
4420 },
4421 Err(_) => return Box::new(future::ok(Response::builder()
4422 .status(StatusCode::BAD_REQUEST)
4423 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["offset"])))
4424 .expect("Unable to create Bad Request response for invalid percent decode")))
4425 };
4426
4427 Box::new({
4428 {{
4429 Box::new(
4430 api_impl.set_offset(
4431 param_bus_id,
4432 param_addr,
4433 param_offset,
4434 &context
4435 ).then(move |result| {
4436 let mut response = Response::new(Body::empty());
4437 response.headers_mut().insert(
4438 HeaderName::from_static("x-span-id"),
4439 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
4440 .expect("Unable to create X-Span-ID header value"));
4441
4442 match result {
4443 Ok(rsp) => match rsp {
4444 SetOffsetResponse::OK
4445 => {
4446 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
4447 },
4448 SetOffsetResponse::BadRequest
4449 (body)
4450 => {
4451 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
4452 response.headers_mut().insert(
4453 CONTENT_TYPE,
4454 HeaderValue::from_str("application/json")
4455 .expect("Unable to create Content-Type header for SET_OFFSET_BAD_REQUEST"));
4456 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
4457 *response.body_mut() = Body::from(body);
4458 },
4459 SetOffsetResponse::OperationFailed
4460 (body)
4461 => {
4462 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
4463 response.headers_mut().insert(
4464 CONTENT_TYPE,
4465 HeaderValue::from_str("application/json")
4466 .expect("Unable to create Content-Type header for SET_OFFSET_OPERATION_FAILED"));
4467 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
4468 *response.body_mut() = Body::from(body);
4469 },
4470 },
4471 Err(_) => {
4472 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
4475 *response.body_mut() = Body::from("An internal error occurred");
4476 },
4477 }
4478
4479 future::ok(response)
4480 }
4481 ))
4482 }}
4483 }) as Self::Future
4484 },
4485
4486 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_OUTPUTCHANGE_OUTPUTCHANGE) => {
4488 let path: &str = &uri.path().to_string();
4490 let path_params =
4491 paths::REGEX_PCA9956B_BUSID_ADDR_OUTPUTCHANGE_OUTPUTCHANGE
4492 .captures(&path)
4493 .unwrap_or_else(||
4494 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_OUTPUTCHANGE_OUTPUTCHANGE in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_OUTPUTCHANGE_OUTPUTCHANGE.as_str())
4495 );
4496
4497 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
4498 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
4499 Ok(param_bus_id) => param_bus_id,
4500 Err(e) => return Box::new(future::ok(Response::builder()
4501 .status(StatusCode::BAD_REQUEST)
4502 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
4503 .expect("Unable to create Bad Request response for invalid path parameter"))),
4504 },
4505 Err(_) => return Box::new(future::ok(Response::builder()
4506 .status(StatusCode::BAD_REQUEST)
4507 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
4508 .expect("Unable to create Bad Request response for invalid percent decode")))
4509 };
4510
4511 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
4512 Ok(param_addr) => match param_addr.parse::<i32>() {
4513 Ok(param_addr) => param_addr,
4514 Err(e) => return Box::new(future::ok(Response::builder()
4515 .status(StatusCode::BAD_REQUEST)
4516 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
4517 .expect("Unable to create Bad Request response for invalid path parameter"))),
4518 },
4519 Err(_) => return Box::new(future::ok(Response::builder()
4520 .status(StatusCode::BAD_REQUEST)
4521 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
4522 .expect("Unable to create Bad Request response for invalid percent decode")))
4523 };
4524
4525 let param_output_change = match percent_encoding::percent_decode(path_params["outputChange"].as_bytes()).decode_utf8() {
4526 Ok(param_output_change) => match param_output_change.parse::<models::OutputChange>() {
4527 Ok(param_output_change) => param_output_change,
4528 Err(e) => return Box::new(future::ok(Response::builder()
4529 .status(StatusCode::BAD_REQUEST)
4530 .body(Body::from(format!("Couldn't parse path parameter outputChange: {}", e)))
4531 .expect("Unable to create Bad Request response for invalid path parameter"))),
4532 },
4533 Err(_) => return Box::new(future::ok(Response::builder()
4534 .status(StatusCode::BAD_REQUEST)
4535 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["outputChange"])))
4536 .expect("Unable to create Bad Request response for invalid percent decode")))
4537 };
4538
4539 Box::new({
4540 {{
4541 Box::new(
4542 api_impl.set_output_change(
4543 param_bus_id,
4544 param_addr,
4545 param_output_change,
4546 &context
4547 ).then(move |result| {
4548 let mut response = Response::new(Body::empty());
4549 response.headers_mut().insert(
4550 HeaderName::from_static("x-span-id"),
4551 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
4552 .expect("Unable to create X-Span-ID header value"));
4553
4554 match result {
4555 Ok(rsp) => match rsp {
4556 SetOutputChangeResponse::OK
4557 => {
4558 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
4559 },
4560 SetOutputChangeResponse::BadRequest
4561 (body)
4562 => {
4563 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
4564 response.headers_mut().insert(
4565 CONTENT_TYPE,
4566 HeaderValue::from_str("application/json")
4567 .expect("Unable to create Content-Type header for SET_OUTPUT_CHANGE_BAD_REQUEST"));
4568 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
4569 *response.body_mut() = Body::from(body);
4570 },
4571 SetOutputChangeResponse::OperationFailed
4572 (body)
4573 => {
4574 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
4575 response.headers_mut().insert(
4576 CONTENT_TYPE,
4577 HeaderValue::from_str("application/json")
4578 .expect("Unable to create Content-Type header for SET_OUTPUT_CHANGE_OPERATION_FAILED"));
4579 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
4580 *response.body_mut() = Body::from(body);
4581 },
4582 },
4583 Err(_) => {
4584 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
4587 *response.body_mut() = Body::from("An internal error occurred");
4588 },
4589 }
4590
4591 future::ok(response)
4592 }
4593 ))
4594 }}
4595 }) as Self::Future
4596 },
4597
4598 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_PWM_PWM) => {
4600 let path: &str = &uri.path().to_string();
4602 let path_params =
4603 paths::REGEX_PCA9956B_BUSID_ADDR_PWM_PWM
4604 .captures(&path)
4605 .unwrap_or_else(||
4606 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_PWM_PWM in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_PWM_PWM.as_str())
4607 );
4608
4609 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
4610 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
4611 Ok(param_bus_id) => param_bus_id,
4612 Err(e) => return Box::new(future::ok(Response::builder()
4613 .status(StatusCode::BAD_REQUEST)
4614 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
4615 .expect("Unable to create Bad Request response for invalid path parameter"))),
4616 },
4617 Err(_) => return Box::new(future::ok(Response::builder()
4618 .status(StatusCode::BAD_REQUEST)
4619 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
4620 .expect("Unable to create Bad Request response for invalid percent decode")))
4621 };
4622
4623 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
4624 Ok(param_addr) => match param_addr.parse::<i32>() {
4625 Ok(param_addr) => param_addr,
4626 Err(e) => return Box::new(future::ok(Response::builder()
4627 .status(StatusCode::BAD_REQUEST)
4628 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
4629 .expect("Unable to create Bad Request response for invalid path parameter"))),
4630 },
4631 Err(_) => return Box::new(future::ok(Response::builder()
4632 .status(StatusCode::BAD_REQUEST)
4633 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
4634 .expect("Unable to create Bad Request response for invalid percent decode")))
4635 };
4636
4637 let param_pwm = match percent_encoding::percent_decode(path_params["pwm"].as_bytes()).decode_utf8() {
4638 Ok(param_pwm) => match param_pwm.parse::<i32>() {
4639 Ok(param_pwm) => param_pwm,
4640 Err(e) => return Box::new(future::ok(Response::builder()
4641 .status(StatusCode::BAD_REQUEST)
4642 .body(Body::from(format!("Couldn't parse path parameter pwm: {}", e)))
4643 .expect("Unable to create Bad Request response for invalid path parameter"))),
4644 },
4645 Err(_) => return Box::new(future::ok(Response::builder()
4646 .status(StatusCode::BAD_REQUEST)
4647 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["pwm"])))
4648 .expect("Unable to create Bad Request response for invalid percent decode")))
4649 };
4650
4651 Box::new({
4652 {{
4653 Box::new(
4654 api_impl.set_pwm(
4655 param_bus_id,
4656 param_addr,
4657 param_pwm,
4658 &context
4659 ).then(move |result| {
4660 let mut response = Response::new(Body::empty());
4661 response.headers_mut().insert(
4662 HeaderName::from_static("x-span-id"),
4663 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
4664 .expect("Unable to create X-Span-ID header value"));
4665
4666 match result {
4667 Ok(rsp) => match rsp {
4668 SetPwmResponse::OK
4669 => {
4670 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
4671 },
4672 SetPwmResponse::BadRequest
4673 (body)
4674 => {
4675 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
4676 response.headers_mut().insert(
4677 CONTENT_TYPE,
4678 HeaderValue::from_str("application/json")
4679 .expect("Unable to create Content-Type header for SET_PWM_BAD_REQUEST"));
4680 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
4681 *response.body_mut() = Body::from(body);
4682 },
4683 SetPwmResponse::OperationFailed
4684 (body)
4685 => {
4686 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
4687 response.headers_mut().insert(
4688 CONTENT_TYPE,
4689 HeaderValue::from_str("application/json")
4690 .expect("Unable to create Content-Type header for SET_PWM_OPERATION_FAILED"));
4691 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
4692 *response.body_mut() = Body::from(body);
4693 },
4694 },
4695 Err(_) => {
4696 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
4699 *response.body_mut() = Body::from("An internal error occurred");
4700 },
4701 }
4702
4703 future::ok(response)
4704 }
4705 ))
4706 }}
4707 }) as Self::Future
4708 },
4709
4710 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_SLEEP_SLEEP) => {
4712 let path: &str = &uri.path().to_string();
4714 let path_params =
4715 paths::REGEX_PCA9956B_BUSID_ADDR_SLEEP_SLEEP
4716 .captures(&path)
4717 .unwrap_or_else(||
4718 panic!("Path {} matched RE PCA9956B_BUSID_ADDR_SLEEP_SLEEP in set but failed match against \"{}\"", path, paths::REGEX_PCA9956B_BUSID_ADDR_SLEEP_SLEEP.as_str())
4719 );
4720
4721 let param_bus_id = match percent_encoding::percent_decode(path_params["busId"].as_bytes()).decode_utf8() {
4722 Ok(param_bus_id) => match param_bus_id.parse::<i32>() {
4723 Ok(param_bus_id) => param_bus_id,
4724 Err(e) => return Box::new(future::ok(Response::builder()
4725 .status(StatusCode::BAD_REQUEST)
4726 .body(Body::from(format!("Couldn't parse path parameter busId: {}", e)))
4727 .expect("Unable to create Bad Request response for invalid path parameter"))),
4728 },
4729 Err(_) => return Box::new(future::ok(Response::builder()
4730 .status(StatusCode::BAD_REQUEST)
4731 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["busId"])))
4732 .expect("Unable to create Bad Request response for invalid percent decode")))
4733 };
4734
4735 let param_addr = match percent_encoding::percent_decode(path_params["addr"].as_bytes()).decode_utf8() {
4736 Ok(param_addr) => match param_addr.parse::<i32>() {
4737 Ok(param_addr) => param_addr,
4738 Err(e) => return Box::new(future::ok(Response::builder()
4739 .status(StatusCode::BAD_REQUEST)
4740 .body(Body::from(format!("Couldn't parse path parameter addr: {}", e)))
4741 .expect("Unable to create Bad Request response for invalid path parameter"))),
4742 },
4743 Err(_) => return Box::new(future::ok(Response::builder()
4744 .status(StatusCode::BAD_REQUEST)
4745 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["addr"])))
4746 .expect("Unable to create Bad Request response for invalid percent decode")))
4747 };
4748
4749 let param_sleep = match percent_encoding::percent_decode(path_params["sleep"].as_bytes()).decode_utf8() {
4750 Ok(param_sleep) => match param_sleep.parse::<bool>() {
4751 Ok(param_sleep) => param_sleep,
4752 Err(e) => return Box::new(future::ok(Response::builder()
4753 .status(StatusCode::BAD_REQUEST)
4754 .body(Body::from(format!("Couldn't parse path parameter sleep: {}", e)))
4755 .expect("Unable to create Bad Request response for invalid path parameter"))),
4756 },
4757 Err(_) => return Box::new(future::ok(Response::builder()
4758 .status(StatusCode::BAD_REQUEST)
4759 .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["sleep"])))
4760 .expect("Unable to create Bad Request response for invalid percent decode")))
4761 };
4762
4763 Box::new({
4764 {{
4765 Box::new(
4766 api_impl.set_sleep(
4767 param_bus_id,
4768 param_addr,
4769 param_sleep,
4770 &context
4771 ).then(move |result| {
4772 let mut response = Response::new(Body::empty());
4773 response.headers_mut().insert(
4774 HeaderName::from_static("x-span-id"),
4775 HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
4776 .expect("Unable to create X-Span-ID header value"));
4777
4778 match result {
4779 Ok(rsp) => match rsp {
4780 SetSleepResponse::OK
4781 => {
4782 *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
4783 },
4784 SetSleepResponse::BadRequest
4785 (body)
4786 => {
4787 *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
4788 response.headers_mut().insert(
4789 CONTENT_TYPE,
4790 HeaderValue::from_str("application/json")
4791 .expect("Unable to create Content-Type header for SET_SLEEP_BAD_REQUEST"));
4792 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
4793 *response.body_mut() = Body::from(body);
4794 },
4795 SetSleepResponse::OperationFailed
4796 (body)
4797 => {
4798 *response.status_mut() = StatusCode::from_u16(502).expect("Unable to turn 502 into a StatusCode");
4799 response.headers_mut().insert(
4800 CONTENT_TYPE,
4801 HeaderValue::from_str("application/json")
4802 .expect("Unable to create Content-Type header for SET_SLEEP_OPERATION_FAILED"));
4803 let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
4804 *response.body_mut() = Body::from(body);
4805 },
4806 },
4807 Err(_) => {
4808 *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
4811 *response.body_mut() = Body::from("An internal error occurred");
4812 },
4813 }
4814
4815 future::ok(response)
4816 }
4817 ))
4818 }}
4819 }) as Self::Future
4820 },
4821
4822 _ if path.matched(paths::ID_PCA9956B_API) => method_not_allowed(),
4823 _ if path.matched(paths::ID_PCA9956B_BUSID_RESET) => method_not_allowed(),
4824 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_ADDR_NUM) => method_not_allowed(),
4825 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_ADDR_NUM_ADDR) => method_not_allowed(),
4826 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_ADDR_NUM_ADDR_ADDRVAL) => method_not_allowed(),
4827 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_ADDR_NUM_ENABLED) => method_not_allowed(),
4828 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_ADDR_NUM_ENABLED_ENABLED) => method_not_allowed(),
4829 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_CONFIG) => method_not_allowed(),
4830 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_CURRENT) => method_not_allowed(),
4831 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_CURRENT_CURRENT) => method_not_allowed(),
4832 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_ERROR) => method_not_allowed(),
4833 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_ERROR_CLEAR) => method_not_allowed(),
4834 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_ERRORS) => method_not_allowed(),
4835 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_FREQ) => method_not_allowed(),
4836 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_FREQ_FREQ) => method_not_allowed(),
4837 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_GROUP) => method_not_allowed(),
4838 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_GROUP_GROUP) => method_not_allowed(),
4839 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED) => method_not_allowed(),
4840 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED_LED) => method_not_allowed(),
4841 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED_LED_CURRENT) => method_not_allowed(),
4842 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED_LED_CURRENT_CURRENT) => method_not_allowed(),
4843 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED_LED_ERROR) => method_not_allowed(),
4844 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED_LED_ERROR_ERROR) => method_not_allowed(),
4845 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED_LED_PWM) => method_not_allowed(),
4846 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED_LED_PWM_PWM) => method_not_allowed(),
4847 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED_LED_STATE) => method_not_allowed(),
4848 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED_LED_STATE_STATE) => method_not_allowed(),
4849 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_OFFSET) => method_not_allowed(),
4850 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_OFFSET_OFFSET) => method_not_allowed(),
4851 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_OUTPUTCHANGE) => method_not_allowed(),
4852 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_OUTPUTCHANGE_OUTPUTCHANGE) => method_not_allowed(),
4853 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_OVERTEMP) => method_not_allowed(),
4854 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_PWM) => method_not_allowed(),
4855 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_PWM_PWM) => method_not_allowed(),
4856 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_SLEEP) => method_not_allowed(),
4857 _ if path.matched(paths::ID_PCA9956B_BUSID_ADDR_SLEEP_SLEEP) => method_not_allowed(),
4858 _ => Box::new(future::ok(
4859 Response::builder().status(StatusCode::NOT_FOUND)
4860 .body(Body::empty())
4861 .expect("Unable to create Not Found response")
4862 )) as Self::Future
4863 }
4864 }
4865}
4866
4867impl<T, C> Clone for Service<T, C> where T: Clone
4868{
4869 fn clone(&self) -> Self {
4870 Service {
4871 api_impl: self.api_impl.clone(),
4872 marker: self.marker.clone(),
4873 }
4874 }
4875}
4876
4877pub struct ApiRequestParser;
4879impl<T> RequestParser<T> for ApiRequestParser {
4880 fn parse_operation_id(request: &Request<T>) -> Result<&'static str, ()> {
4881 let path = paths::GLOBAL_REGEX_SET.matches(request.uri().path());
4882 match request.method() {
4883 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_ERROR_CLEAR) => Ok("ClearError"),
4885 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_ADDR_NUM_ENABLED) => Ok("GetAddrEnabled"),
4887 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_ADDR_NUM) => Ok("GetAddrInfo"),
4889 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_ADDR_NUM_ADDR) => Ok("GetAddrValue"),
4891 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_API) => Ok("GetApi"),
4893 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_CONFIG) => Ok("GetConfig"),
4895 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_CURRENT) => Ok("GetCurrent"),
4897 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_ERROR) => Ok("GetError"),
4899 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_ERRORS) => Ok("GetErrors"),
4901 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_FREQ) => Ok("GetFreq"),
4903 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_GROUP) => Ok("GetGroup"),
4905 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED_LED_CURRENT) => Ok("GetLedCurrent"),
4907 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED_LED_ERROR) => Ok("GetLedError"),
4909 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED_LED) => Ok("GetLedInfo"),
4911 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED) => Ok("GetLedInfoAll"),
4913 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED_LED_PWM) => Ok("GetLedPwm"),
4915 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED_LED_STATE) => Ok("GetLedState"),
4917 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_OFFSET) => Ok("GetOffset"),
4919 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_OUTPUTCHANGE) => Ok("GetOutputChange"),
4921 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_OVERTEMP) => Ok("GetOverTemp"),
4923 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_PWM) => Ok("GetPwm"),
4925 &hyper::Method::GET if path.matched(paths::ID_PCA9956B_BUSID_ADDR_SLEEP) => Ok("GetSleep"),
4927 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_RESET) => Ok("Reset"),
4929 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_ADDR_NUM_ENABLED_ENABLED) => Ok("SetAddrEnabled"),
4931 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_ADDR_NUM_ADDR_ADDRVAL) => Ok("SetAddrValue"),
4933 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_CONFIG) => Ok("SetConfig"),
4935 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_CURRENT_CURRENT) => Ok("SetCurrent"),
4937 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_FREQ_FREQ) => Ok("SetFreq"),
4939 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_GROUP_GROUP) => Ok("SetGroup"),
4941 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED_LED_CURRENT_CURRENT) => Ok("SetLedCurrent"),
4943 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED_LED_ERROR_ERROR) => Ok("SetLedError"),
4945 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED_LED) => Ok("SetLedInfo"),
4947 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED) => Ok("SetLedInfoAll"),
4949 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED_LED_PWM_PWM) => Ok("SetLedPwm"),
4951 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_LED_LED_STATE_STATE) => Ok("SetLedState"),
4953 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_OFFSET_OFFSET) => Ok("SetOffset"),
4955 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_OUTPUTCHANGE_OUTPUTCHANGE) => Ok("SetOutputChange"),
4957 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_PWM_PWM) => Ok("SetPwm"),
4959 &hyper::Method::POST if path.matched(paths::ID_PCA9956B_BUSID_ADDR_SLEEP_SLEEP) => Ok("SetSleep"),
4961 _ => Err(()),
4962 }
4963 }
4964}