1use super::*;
2#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct Flight {
6 pub r#aircraft: Vec<AircraftProperty>,
8 pub r#arrival_airport: Vec<ArrivalAirportProperty>,
10 pub r#arrival_gate: Vec<ArrivalGateProperty>,
12 pub r#arrival_terminal: Vec<ArrivalTerminalProperty>,
14 pub r#boarding_policy: Vec<BoardingPolicyProperty>,
16 #[deprecated = "This schema is superseded by <https://schema.org/provider>."]
18 pub r#carrier: Vec<CarrierProperty>,
19 pub r#departure_airport: Vec<DepartureAirportProperty>,
21 pub r#departure_gate: Vec<DepartureGateProperty>,
23 pub r#departure_terminal: Vec<DepartureTerminalProperty>,
25 pub r#estimated_flight_duration: Vec<EstimatedFlightDurationProperty>,
27 pub r#flight_distance: Vec<FlightDistanceProperty>,
29 pub r#flight_number: Vec<FlightNumberProperty>,
31 pub r#meal_service: Vec<MealServiceProperty>,
33 pub r#seller: Vec<SellerProperty>,
35 pub r#web_checkin_time: Vec<WebCheckinTimeProperty>,
37 pub r#additional_type: Vec<AdditionalTypeProperty>,
39 pub r#alternate_name: Vec<AlternateNameProperty>,
41 pub r#description: Vec<DescriptionProperty>,
43 pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
45 pub r#identifier: Vec<IdentifierProperty>,
47 pub r#image: Vec<ImageProperty>,
49 pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
51 pub r#name: Vec<NameProperty>,
53 pub r#potential_action: Vec<PotentialActionProperty>,
55 pub r#same_as: Vec<SameAsProperty>,
57 pub r#subject_of: Vec<SubjectOfProperty>,
59 pub r#url: Vec<UrlProperty>,
61 pub r#arrival_time: Vec<ArrivalTimeProperty>,
63 pub r#departure_time: Vec<DepartureTimeProperty>,
65 pub r#itinerary: Vec<ItineraryProperty>,
67 pub r#offers: Vec<OffersProperty>,
69 pub r#part_of_trip: Vec<PartOfTripProperty>,
71 pub r#provider: Vec<ProviderProperty>,
73 pub r#sub_trip: Vec<SubTripProperty>,
75 pub r#trip_origin: Vec<TripOriginProperty>,
77}
78pub trait FlightTrait {
80 fn get_aircraft(&self) -> &[AircraftProperty];
82 fn take_aircraft(&mut self) -> Vec<AircraftProperty>;
84 fn get_arrival_airport(&self) -> &[ArrivalAirportProperty];
86 fn take_arrival_airport(&mut self) -> Vec<ArrivalAirportProperty>;
88 fn get_arrival_gate(&self) -> &[ArrivalGateProperty];
90 fn take_arrival_gate(&mut self) -> Vec<ArrivalGateProperty>;
92 fn get_arrival_terminal(&self) -> &[ArrivalTerminalProperty];
94 fn take_arrival_terminal(&mut self) -> Vec<ArrivalTerminalProperty>;
96 fn get_boarding_policy(&self) -> &[BoardingPolicyProperty];
98 fn take_boarding_policy(&mut self) -> Vec<BoardingPolicyProperty>;
100 #[deprecated = "This schema is superseded by <https://schema.org/provider>."]
102 fn get_carrier(&self) -> &[CarrierProperty];
103 #[deprecated = "This schema is superseded by <https://schema.org/provider>."]
105 fn take_carrier(&mut self) -> Vec<CarrierProperty>;
106 fn get_departure_airport(&self) -> &[DepartureAirportProperty];
108 fn take_departure_airport(&mut self) -> Vec<DepartureAirportProperty>;
110 fn get_departure_gate(&self) -> &[DepartureGateProperty];
112 fn take_departure_gate(&mut self) -> Vec<DepartureGateProperty>;
114 fn get_departure_terminal(&self) -> &[DepartureTerminalProperty];
116 fn take_departure_terminal(&mut self) -> Vec<DepartureTerminalProperty>;
118 fn get_estimated_flight_duration(&self) -> &[EstimatedFlightDurationProperty];
120 fn take_estimated_flight_duration(&mut self) -> Vec<EstimatedFlightDurationProperty>;
122 fn get_flight_distance(&self) -> &[FlightDistanceProperty];
124 fn take_flight_distance(&mut self) -> Vec<FlightDistanceProperty>;
126 fn get_flight_number(&self) -> &[FlightNumberProperty];
128 fn take_flight_number(&mut self) -> Vec<FlightNumberProperty>;
130 fn get_meal_service(&self) -> &[MealServiceProperty];
132 fn take_meal_service(&mut self) -> Vec<MealServiceProperty>;
134 fn get_seller(&self) -> &[SellerProperty];
136 fn take_seller(&mut self) -> Vec<SellerProperty>;
138 fn get_web_checkin_time(&self) -> &[WebCheckinTimeProperty];
140 fn take_web_checkin_time(&mut self) -> Vec<WebCheckinTimeProperty>;
142}
143impl FlightTrait for Flight {
144 fn get_aircraft(&self) -> &[AircraftProperty] {
145 self.r#aircraft.as_slice()
146 }
147 fn take_aircraft(&mut self) -> Vec<AircraftProperty> {
148 std::mem::take(&mut self.r#aircraft)
149 }
150 fn get_arrival_airport(&self) -> &[ArrivalAirportProperty] {
151 self.r#arrival_airport.as_slice()
152 }
153 fn take_arrival_airport(&mut self) -> Vec<ArrivalAirportProperty> {
154 std::mem::take(&mut self.r#arrival_airport)
155 }
156 fn get_arrival_gate(&self) -> &[ArrivalGateProperty] {
157 self.r#arrival_gate.as_slice()
158 }
159 fn take_arrival_gate(&mut self) -> Vec<ArrivalGateProperty> {
160 std::mem::take(&mut self.r#arrival_gate)
161 }
162 fn get_arrival_terminal(&self) -> &[ArrivalTerminalProperty] {
163 self.r#arrival_terminal.as_slice()
164 }
165 fn take_arrival_terminal(&mut self) -> Vec<ArrivalTerminalProperty> {
166 std::mem::take(&mut self.r#arrival_terminal)
167 }
168 fn get_boarding_policy(&self) -> &[BoardingPolicyProperty] {
169 self.r#boarding_policy.as_slice()
170 }
171 fn take_boarding_policy(&mut self) -> Vec<BoardingPolicyProperty> {
172 std::mem::take(&mut self.r#boarding_policy)
173 }
174 fn get_carrier(&self) -> &[CarrierProperty] {
175 self.r#carrier.as_slice()
176 }
177 fn take_carrier(&mut self) -> Vec<CarrierProperty> {
178 std::mem::take(&mut self.r#carrier)
179 }
180 fn get_departure_airport(&self) -> &[DepartureAirportProperty] {
181 self.r#departure_airport.as_slice()
182 }
183 fn take_departure_airport(&mut self) -> Vec<DepartureAirportProperty> {
184 std::mem::take(&mut self.r#departure_airport)
185 }
186 fn get_departure_gate(&self) -> &[DepartureGateProperty] {
187 self.r#departure_gate.as_slice()
188 }
189 fn take_departure_gate(&mut self) -> Vec<DepartureGateProperty> {
190 std::mem::take(&mut self.r#departure_gate)
191 }
192 fn get_departure_terminal(&self) -> &[DepartureTerminalProperty] {
193 self.r#departure_terminal.as_slice()
194 }
195 fn take_departure_terminal(&mut self) -> Vec<DepartureTerminalProperty> {
196 std::mem::take(&mut self.r#departure_terminal)
197 }
198 fn get_estimated_flight_duration(&self) -> &[EstimatedFlightDurationProperty] {
199 self.r#estimated_flight_duration.as_slice()
200 }
201 fn take_estimated_flight_duration(&mut self) -> Vec<EstimatedFlightDurationProperty> {
202 std::mem::take(&mut self.r#estimated_flight_duration)
203 }
204 fn get_flight_distance(&self) -> &[FlightDistanceProperty] {
205 self.r#flight_distance.as_slice()
206 }
207 fn take_flight_distance(&mut self) -> Vec<FlightDistanceProperty> {
208 std::mem::take(&mut self.r#flight_distance)
209 }
210 fn get_flight_number(&self) -> &[FlightNumberProperty] {
211 self.r#flight_number.as_slice()
212 }
213 fn take_flight_number(&mut self) -> Vec<FlightNumberProperty> {
214 std::mem::take(&mut self.r#flight_number)
215 }
216 fn get_meal_service(&self) -> &[MealServiceProperty] {
217 self.r#meal_service.as_slice()
218 }
219 fn take_meal_service(&mut self) -> Vec<MealServiceProperty> {
220 std::mem::take(&mut self.r#meal_service)
221 }
222 fn get_seller(&self) -> &[SellerProperty] {
223 self.r#seller.as_slice()
224 }
225 fn take_seller(&mut self) -> Vec<SellerProperty> {
226 std::mem::take(&mut self.r#seller)
227 }
228 fn get_web_checkin_time(&self) -> &[WebCheckinTimeProperty] {
229 self.r#web_checkin_time.as_slice()
230 }
231 fn take_web_checkin_time(&mut self) -> Vec<WebCheckinTimeProperty> {
232 std::mem::take(&mut self.r#web_checkin_time)
233 }
234}
235impl ThingTrait for Flight {
236 fn get_additional_type(&self) -> &[AdditionalTypeProperty] {
237 self.r#additional_type.as_slice()
238 }
239 fn take_additional_type(&mut self) -> Vec<AdditionalTypeProperty> {
240 std::mem::take(&mut self.r#additional_type)
241 }
242 fn get_alternate_name(&self) -> &[AlternateNameProperty] {
243 self.r#alternate_name.as_slice()
244 }
245 fn take_alternate_name(&mut self) -> Vec<AlternateNameProperty> {
246 std::mem::take(&mut self.r#alternate_name)
247 }
248 fn get_description(&self) -> &[DescriptionProperty] {
249 self.r#description.as_slice()
250 }
251 fn take_description(&mut self) -> Vec<DescriptionProperty> {
252 std::mem::take(&mut self.r#description)
253 }
254 fn get_disambiguating_description(&self) -> &[DisambiguatingDescriptionProperty] {
255 self.r#disambiguating_description.as_slice()
256 }
257 fn take_disambiguating_description(&mut self) -> Vec<DisambiguatingDescriptionProperty> {
258 std::mem::take(&mut self.r#disambiguating_description)
259 }
260 fn get_identifier(&self) -> &[IdentifierProperty] {
261 self.r#identifier.as_slice()
262 }
263 fn take_identifier(&mut self) -> Vec<IdentifierProperty> {
264 std::mem::take(&mut self.r#identifier)
265 }
266 fn get_image(&self) -> &[ImageProperty] {
267 self.r#image.as_slice()
268 }
269 fn take_image(&mut self) -> Vec<ImageProperty> {
270 std::mem::take(&mut self.r#image)
271 }
272 fn get_main_entity_of_page(&self) -> &[MainEntityOfPageProperty] {
273 self.r#main_entity_of_page.as_slice()
274 }
275 fn take_main_entity_of_page(&mut self) -> Vec<MainEntityOfPageProperty> {
276 std::mem::take(&mut self.r#main_entity_of_page)
277 }
278 fn get_name(&self) -> &[NameProperty] {
279 self.r#name.as_slice()
280 }
281 fn take_name(&mut self) -> Vec<NameProperty> {
282 std::mem::take(&mut self.r#name)
283 }
284 fn get_potential_action(&self) -> &[PotentialActionProperty] {
285 self.r#potential_action.as_slice()
286 }
287 fn take_potential_action(&mut self) -> Vec<PotentialActionProperty> {
288 std::mem::take(&mut self.r#potential_action)
289 }
290 fn get_same_as(&self) -> &[SameAsProperty] {
291 self.r#same_as.as_slice()
292 }
293 fn take_same_as(&mut self) -> Vec<SameAsProperty> {
294 std::mem::take(&mut self.r#same_as)
295 }
296 fn get_subject_of(&self) -> &[SubjectOfProperty] {
297 self.r#subject_of.as_slice()
298 }
299 fn take_subject_of(&mut self) -> Vec<SubjectOfProperty> {
300 std::mem::take(&mut self.r#subject_of)
301 }
302 fn get_url(&self) -> &[UrlProperty] {
303 self.r#url.as_slice()
304 }
305 fn take_url(&mut self) -> Vec<UrlProperty> {
306 std::mem::take(&mut self.r#url)
307 }
308}
309impl TripTrait for Flight {
310 fn get_arrival_time(&self) -> &[ArrivalTimeProperty] {
311 self.r#arrival_time.as_slice()
312 }
313 fn take_arrival_time(&mut self) -> Vec<ArrivalTimeProperty> {
314 std::mem::take(&mut self.r#arrival_time)
315 }
316 fn get_departure_time(&self) -> &[DepartureTimeProperty] {
317 self.r#departure_time.as_slice()
318 }
319 fn take_departure_time(&mut self) -> Vec<DepartureTimeProperty> {
320 std::mem::take(&mut self.r#departure_time)
321 }
322 fn get_itinerary(&self) -> &[ItineraryProperty] {
323 self.r#itinerary.as_slice()
324 }
325 fn take_itinerary(&mut self) -> Vec<ItineraryProperty> {
326 std::mem::take(&mut self.r#itinerary)
327 }
328 fn get_offers(&self) -> &[OffersProperty] {
329 self.r#offers.as_slice()
330 }
331 fn take_offers(&mut self) -> Vec<OffersProperty> {
332 std::mem::take(&mut self.r#offers)
333 }
334 fn get_part_of_trip(&self) -> &[PartOfTripProperty] {
335 self.r#part_of_trip.as_slice()
336 }
337 fn take_part_of_trip(&mut self) -> Vec<PartOfTripProperty> {
338 std::mem::take(&mut self.r#part_of_trip)
339 }
340 fn get_provider(&self) -> &[ProviderProperty] {
341 self.r#provider.as_slice()
342 }
343 fn take_provider(&mut self) -> Vec<ProviderProperty> {
344 std::mem::take(&mut self.r#provider)
345 }
346 fn get_sub_trip(&self) -> &[SubTripProperty] {
347 self.r#sub_trip.as_slice()
348 }
349 fn take_sub_trip(&mut self) -> Vec<SubTripProperty> {
350 std::mem::take(&mut self.r#sub_trip)
351 }
352 fn get_trip_origin(&self) -> &[TripOriginProperty] {
353 self.r#trip_origin.as_slice()
354 }
355 fn take_trip_origin(&mut self) -> Vec<TripOriginProperty> {
356 std::mem::take(&mut self.r#trip_origin)
357 }
358}
359#[cfg(feature = "serde")]
360mod serde {
361 use std::{fmt, fmt::Formatter};
362
363 use ::serde::{
364 de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
365 };
366
367 use super::*;
368 impl Serialize for Flight {
369 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
370 where
371 S: Serializer,
372 {
373 let len: usize = [
374 !Vec::is_empty(&self.r#aircraft) as usize,
375 !Vec::is_empty(&self.r#arrival_airport) as usize,
376 !Vec::is_empty(&self.r#arrival_gate) as usize,
377 !Vec::is_empty(&self.r#arrival_terminal) as usize,
378 !Vec::is_empty(&self.r#boarding_policy) as usize,
379 !Vec::is_empty(&self.r#carrier) as usize,
380 !Vec::is_empty(&self.r#departure_airport) as usize,
381 !Vec::is_empty(&self.r#departure_gate) as usize,
382 !Vec::is_empty(&self.r#departure_terminal) as usize,
383 !Vec::is_empty(&self.r#estimated_flight_duration) as usize,
384 !Vec::is_empty(&self.r#flight_distance) as usize,
385 !Vec::is_empty(&self.r#flight_number) as usize,
386 !Vec::is_empty(&self.r#meal_service) as usize,
387 !Vec::is_empty(&self.r#seller) as usize,
388 !Vec::is_empty(&self.r#web_checkin_time) as usize,
389 !Vec::is_empty(&self.r#additional_type) as usize,
390 !Vec::is_empty(&self.r#alternate_name) as usize,
391 !Vec::is_empty(&self.r#description) as usize,
392 !Vec::is_empty(&self.r#disambiguating_description) as usize,
393 !Vec::is_empty(&self.r#identifier) as usize,
394 !Vec::is_empty(&self.r#image) as usize,
395 !Vec::is_empty(&self.r#main_entity_of_page) as usize,
396 !Vec::is_empty(&self.r#name) as usize,
397 !Vec::is_empty(&self.r#potential_action) as usize,
398 !Vec::is_empty(&self.r#same_as) as usize,
399 !Vec::is_empty(&self.r#subject_of) as usize,
400 !Vec::is_empty(&self.r#url) as usize,
401 !Vec::is_empty(&self.r#arrival_time) as usize,
402 !Vec::is_empty(&self.r#departure_time) as usize,
403 !Vec::is_empty(&self.r#itinerary) as usize,
404 !Vec::is_empty(&self.r#offers) as usize,
405 !Vec::is_empty(&self.r#part_of_trip) as usize,
406 !Vec::is_empty(&self.r#provider) as usize,
407 !Vec::is_empty(&self.r#sub_trip) as usize,
408 !Vec::is_empty(&self.r#trip_origin) as usize,
409 ]
410 .iter()
411 .sum();
412 let mut serialize_struct = Serializer::serialize_struct(serializer, "Flight", len)?;
413 if !Vec::is_empty(&self.r#aircraft) {
414 serialize_struct.serialize_field("aircraft", {
415 struct SerializeWith<'a>(&'a Vec<AircraftProperty>);
416 impl<'a> Serialize for SerializeWith<'a> {
417 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
418 where
419 S: Serializer,
420 {
421 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
422 self.0, serializer,
423 )
424 }
425 }
426 &SerializeWith(&self.r#aircraft)
427 })?;
428 } else {
429 serialize_struct.skip_field("aircraft")?;
430 }
431 if !Vec::is_empty(&self.r#arrival_airport) {
432 serialize_struct.serialize_field("arrivalAirport", {
433 struct SerializeWith<'a>(&'a Vec<ArrivalAirportProperty>);
434 impl<'a> Serialize for SerializeWith<'a> {
435 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
436 where
437 S: Serializer,
438 {
439 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
440 self.0, serializer,
441 )
442 }
443 }
444 &SerializeWith(&self.r#arrival_airport)
445 })?;
446 } else {
447 serialize_struct.skip_field("arrivalAirport")?;
448 }
449 if !Vec::is_empty(&self.r#arrival_gate) {
450 serialize_struct.serialize_field("arrivalGate", {
451 struct SerializeWith<'a>(&'a Vec<ArrivalGateProperty>);
452 impl<'a> Serialize for SerializeWith<'a> {
453 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
454 where
455 S: Serializer,
456 {
457 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
458 self.0, serializer,
459 )
460 }
461 }
462 &SerializeWith(&self.r#arrival_gate)
463 })?;
464 } else {
465 serialize_struct.skip_field("arrivalGate")?;
466 }
467 if !Vec::is_empty(&self.r#arrival_terminal) {
468 serialize_struct.serialize_field("arrivalTerminal", {
469 struct SerializeWith<'a>(&'a Vec<ArrivalTerminalProperty>);
470 impl<'a> Serialize for SerializeWith<'a> {
471 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
472 where
473 S: Serializer,
474 {
475 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
476 self.0, serializer,
477 )
478 }
479 }
480 &SerializeWith(&self.r#arrival_terminal)
481 })?;
482 } else {
483 serialize_struct.skip_field("arrivalTerminal")?;
484 }
485 if !Vec::is_empty(&self.r#boarding_policy) {
486 serialize_struct.serialize_field("boardingPolicy", {
487 struct SerializeWith<'a>(&'a Vec<BoardingPolicyProperty>);
488 impl<'a> Serialize for SerializeWith<'a> {
489 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
490 where
491 S: Serializer,
492 {
493 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
494 self.0, serializer,
495 )
496 }
497 }
498 &SerializeWith(&self.r#boarding_policy)
499 })?;
500 } else {
501 serialize_struct.skip_field("boardingPolicy")?;
502 }
503 if !Vec::is_empty(&self.r#carrier) {
504 serialize_struct.serialize_field("carrier", {
505 struct SerializeWith<'a>(&'a Vec<CarrierProperty>);
506 impl<'a> Serialize for SerializeWith<'a> {
507 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
508 where
509 S: Serializer,
510 {
511 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
512 self.0, serializer,
513 )
514 }
515 }
516 &SerializeWith(&self.r#carrier)
517 })?;
518 } else {
519 serialize_struct.skip_field("carrier")?;
520 }
521 if !Vec::is_empty(&self.r#departure_airport) {
522 serialize_struct.serialize_field("departureAirport", {
523 struct SerializeWith<'a>(&'a Vec<DepartureAirportProperty>);
524 impl<'a> Serialize for SerializeWith<'a> {
525 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
526 where
527 S: Serializer,
528 {
529 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
530 self.0, serializer,
531 )
532 }
533 }
534 &SerializeWith(&self.r#departure_airport)
535 })?;
536 } else {
537 serialize_struct.skip_field("departureAirport")?;
538 }
539 if !Vec::is_empty(&self.r#departure_gate) {
540 serialize_struct.serialize_field("departureGate", {
541 struct SerializeWith<'a>(&'a Vec<DepartureGateProperty>);
542 impl<'a> Serialize for SerializeWith<'a> {
543 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
544 where
545 S: Serializer,
546 {
547 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
548 self.0, serializer,
549 )
550 }
551 }
552 &SerializeWith(&self.r#departure_gate)
553 })?;
554 } else {
555 serialize_struct.skip_field("departureGate")?;
556 }
557 if !Vec::is_empty(&self.r#departure_terminal) {
558 serialize_struct.serialize_field("departureTerminal", {
559 struct SerializeWith<'a>(&'a Vec<DepartureTerminalProperty>);
560 impl<'a> Serialize for SerializeWith<'a> {
561 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
562 where
563 S: Serializer,
564 {
565 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
566 self.0, serializer,
567 )
568 }
569 }
570 &SerializeWith(&self.r#departure_terminal)
571 })?;
572 } else {
573 serialize_struct.skip_field("departureTerminal")?;
574 }
575 if !Vec::is_empty(&self.r#estimated_flight_duration) {
576 serialize_struct.serialize_field("estimatedFlightDuration", {
577 struct SerializeWith<'a>(&'a Vec<EstimatedFlightDurationProperty>);
578 impl<'a> Serialize for SerializeWith<'a> {
579 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
580 where
581 S: Serializer,
582 {
583 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
584 self.0, serializer,
585 )
586 }
587 }
588 &SerializeWith(&self.r#estimated_flight_duration)
589 })?;
590 } else {
591 serialize_struct.skip_field("estimatedFlightDuration")?;
592 }
593 if !Vec::is_empty(&self.r#flight_distance) {
594 serialize_struct.serialize_field("flightDistance", {
595 struct SerializeWith<'a>(&'a Vec<FlightDistanceProperty>);
596 impl<'a> Serialize for SerializeWith<'a> {
597 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
598 where
599 S: Serializer,
600 {
601 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
602 self.0, serializer,
603 )
604 }
605 }
606 &SerializeWith(&self.r#flight_distance)
607 })?;
608 } else {
609 serialize_struct.skip_field("flightDistance")?;
610 }
611 if !Vec::is_empty(&self.r#flight_number) {
612 serialize_struct.serialize_field("flightNumber", {
613 struct SerializeWith<'a>(&'a Vec<FlightNumberProperty>);
614 impl<'a> Serialize for SerializeWith<'a> {
615 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
616 where
617 S: Serializer,
618 {
619 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
620 self.0, serializer,
621 )
622 }
623 }
624 &SerializeWith(&self.r#flight_number)
625 })?;
626 } else {
627 serialize_struct.skip_field("flightNumber")?;
628 }
629 if !Vec::is_empty(&self.r#meal_service) {
630 serialize_struct.serialize_field("mealService", {
631 struct SerializeWith<'a>(&'a Vec<MealServiceProperty>);
632 impl<'a> Serialize for SerializeWith<'a> {
633 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
634 where
635 S: Serializer,
636 {
637 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
638 self.0, serializer,
639 )
640 }
641 }
642 &SerializeWith(&self.r#meal_service)
643 })?;
644 } else {
645 serialize_struct.skip_field("mealService")?;
646 }
647 if !Vec::is_empty(&self.r#seller) {
648 serialize_struct.serialize_field("seller", {
649 struct SerializeWith<'a>(&'a Vec<SellerProperty>);
650 impl<'a> Serialize for SerializeWith<'a> {
651 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
652 where
653 S: Serializer,
654 {
655 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
656 self.0, serializer,
657 )
658 }
659 }
660 &SerializeWith(&self.r#seller)
661 })?;
662 } else {
663 serialize_struct.skip_field("seller")?;
664 }
665 if !Vec::is_empty(&self.r#web_checkin_time) {
666 serialize_struct.serialize_field("webCheckinTime", {
667 struct SerializeWith<'a>(&'a Vec<WebCheckinTimeProperty>);
668 impl<'a> Serialize for SerializeWith<'a> {
669 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
670 where
671 S: Serializer,
672 {
673 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
674 self.0, serializer,
675 )
676 }
677 }
678 &SerializeWith(&self.r#web_checkin_time)
679 })?;
680 } else {
681 serialize_struct.skip_field("webCheckinTime")?;
682 }
683 if !Vec::is_empty(&self.r#additional_type) {
684 serialize_struct.serialize_field("additionalType", {
685 struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
686 impl<'a> Serialize for SerializeWith<'a> {
687 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
688 where
689 S: Serializer,
690 {
691 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
692 self.0, serializer,
693 )
694 }
695 }
696 &SerializeWith(&self.r#additional_type)
697 })?;
698 } else {
699 serialize_struct.skip_field("additionalType")?;
700 }
701 if !Vec::is_empty(&self.r#alternate_name) {
702 serialize_struct.serialize_field("alternateName", {
703 struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
704 impl<'a> Serialize for SerializeWith<'a> {
705 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
706 where
707 S: Serializer,
708 {
709 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
710 self.0, serializer,
711 )
712 }
713 }
714 &SerializeWith(&self.r#alternate_name)
715 })?;
716 } else {
717 serialize_struct.skip_field("alternateName")?;
718 }
719 if !Vec::is_empty(&self.r#description) {
720 serialize_struct.serialize_field("description", {
721 struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
722 impl<'a> Serialize for SerializeWith<'a> {
723 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
724 where
725 S: Serializer,
726 {
727 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
728 self.0, serializer,
729 )
730 }
731 }
732 &SerializeWith(&self.r#description)
733 })?;
734 } else {
735 serialize_struct.skip_field("description")?;
736 }
737 if !Vec::is_empty(&self.r#disambiguating_description) {
738 serialize_struct.serialize_field("disambiguatingDescription", {
739 struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
740 impl<'a> Serialize for SerializeWith<'a> {
741 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
742 where
743 S: Serializer,
744 {
745 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
746 self.0, serializer,
747 )
748 }
749 }
750 &SerializeWith(&self.r#disambiguating_description)
751 })?;
752 } else {
753 serialize_struct.skip_field("disambiguatingDescription")?;
754 }
755 if !Vec::is_empty(&self.r#identifier) {
756 serialize_struct.serialize_field("identifier", {
757 struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
758 impl<'a> Serialize for SerializeWith<'a> {
759 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
760 where
761 S: Serializer,
762 {
763 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
764 self.0, serializer,
765 )
766 }
767 }
768 &SerializeWith(&self.r#identifier)
769 })?;
770 } else {
771 serialize_struct.skip_field("identifier")?;
772 }
773 if !Vec::is_empty(&self.r#image) {
774 serialize_struct.serialize_field("image", {
775 struct SerializeWith<'a>(&'a Vec<ImageProperty>);
776 impl<'a> Serialize for SerializeWith<'a> {
777 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
778 where
779 S: Serializer,
780 {
781 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
782 self.0, serializer,
783 )
784 }
785 }
786 &SerializeWith(&self.r#image)
787 })?;
788 } else {
789 serialize_struct.skip_field("image")?;
790 }
791 if !Vec::is_empty(&self.r#main_entity_of_page) {
792 serialize_struct.serialize_field("mainEntityOfPage", {
793 struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
794 impl<'a> Serialize for SerializeWith<'a> {
795 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
796 where
797 S: Serializer,
798 {
799 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
800 self.0, serializer,
801 )
802 }
803 }
804 &SerializeWith(&self.r#main_entity_of_page)
805 })?;
806 } else {
807 serialize_struct.skip_field("mainEntityOfPage")?;
808 }
809 if !Vec::is_empty(&self.r#name) {
810 serialize_struct.serialize_field("name", {
811 struct SerializeWith<'a>(&'a Vec<NameProperty>);
812 impl<'a> Serialize for SerializeWith<'a> {
813 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
814 where
815 S: Serializer,
816 {
817 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
818 self.0, serializer,
819 )
820 }
821 }
822 &SerializeWith(&self.r#name)
823 })?;
824 } else {
825 serialize_struct.skip_field("name")?;
826 }
827 if !Vec::is_empty(&self.r#potential_action) {
828 serialize_struct.serialize_field("potentialAction", {
829 struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
830 impl<'a> Serialize for SerializeWith<'a> {
831 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
832 where
833 S: Serializer,
834 {
835 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
836 self.0, serializer,
837 )
838 }
839 }
840 &SerializeWith(&self.r#potential_action)
841 })?;
842 } else {
843 serialize_struct.skip_field("potentialAction")?;
844 }
845 if !Vec::is_empty(&self.r#same_as) {
846 serialize_struct.serialize_field("sameAs", {
847 struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
848 impl<'a> Serialize for SerializeWith<'a> {
849 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
850 where
851 S: Serializer,
852 {
853 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
854 self.0, serializer,
855 )
856 }
857 }
858 &SerializeWith(&self.r#same_as)
859 })?;
860 } else {
861 serialize_struct.skip_field("sameAs")?;
862 }
863 if !Vec::is_empty(&self.r#subject_of) {
864 serialize_struct.serialize_field("subjectOf", {
865 struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
866 impl<'a> Serialize for SerializeWith<'a> {
867 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
868 where
869 S: Serializer,
870 {
871 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
872 self.0, serializer,
873 )
874 }
875 }
876 &SerializeWith(&self.r#subject_of)
877 })?;
878 } else {
879 serialize_struct.skip_field("subjectOf")?;
880 }
881 if !Vec::is_empty(&self.r#url) {
882 serialize_struct.serialize_field("url", {
883 struct SerializeWith<'a>(&'a Vec<UrlProperty>);
884 impl<'a> Serialize for SerializeWith<'a> {
885 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
886 where
887 S: Serializer,
888 {
889 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
890 self.0, serializer,
891 )
892 }
893 }
894 &SerializeWith(&self.r#url)
895 })?;
896 } else {
897 serialize_struct.skip_field("url")?;
898 }
899 if !Vec::is_empty(&self.r#arrival_time) {
900 serialize_struct.serialize_field("arrivalTime", {
901 struct SerializeWith<'a>(&'a Vec<ArrivalTimeProperty>);
902 impl<'a> Serialize for SerializeWith<'a> {
903 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
904 where
905 S: Serializer,
906 {
907 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
908 self.0, serializer,
909 )
910 }
911 }
912 &SerializeWith(&self.r#arrival_time)
913 })?;
914 } else {
915 serialize_struct.skip_field("arrivalTime")?;
916 }
917 if !Vec::is_empty(&self.r#departure_time) {
918 serialize_struct.serialize_field("departureTime", {
919 struct SerializeWith<'a>(&'a Vec<DepartureTimeProperty>);
920 impl<'a> Serialize for SerializeWith<'a> {
921 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
922 where
923 S: Serializer,
924 {
925 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
926 self.0, serializer,
927 )
928 }
929 }
930 &SerializeWith(&self.r#departure_time)
931 })?;
932 } else {
933 serialize_struct.skip_field("departureTime")?;
934 }
935 if !Vec::is_empty(&self.r#itinerary) {
936 serialize_struct.serialize_field("itinerary", {
937 struct SerializeWith<'a>(&'a Vec<ItineraryProperty>);
938 impl<'a> Serialize for SerializeWith<'a> {
939 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
940 where
941 S: Serializer,
942 {
943 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
944 self.0, serializer,
945 )
946 }
947 }
948 &SerializeWith(&self.r#itinerary)
949 })?;
950 } else {
951 serialize_struct.skip_field("itinerary")?;
952 }
953 if !Vec::is_empty(&self.r#offers) {
954 serialize_struct.serialize_field("offers", {
955 struct SerializeWith<'a>(&'a Vec<OffersProperty>);
956 impl<'a> Serialize for SerializeWith<'a> {
957 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
958 where
959 S: Serializer,
960 {
961 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
962 self.0, serializer,
963 )
964 }
965 }
966 &SerializeWith(&self.r#offers)
967 })?;
968 } else {
969 serialize_struct.skip_field("offers")?;
970 }
971 if !Vec::is_empty(&self.r#part_of_trip) {
972 serialize_struct.serialize_field("partOfTrip", {
973 struct SerializeWith<'a>(&'a Vec<PartOfTripProperty>);
974 impl<'a> Serialize for SerializeWith<'a> {
975 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
976 where
977 S: Serializer,
978 {
979 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
980 self.0, serializer,
981 )
982 }
983 }
984 &SerializeWith(&self.r#part_of_trip)
985 })?;
986 } else {
987 serialize_struct.skip_field("partOfTrip")?;
988 }
989 if !Vec::is_empty(&self.r#provider) {
990 serialize_struct.serialize_field("provider", {
991 struct SerializeWith<'a>(&'a Vec<ProviderProperty>);
992 impl<'a> Serialize for SerializeWith<'a> {
993 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
994 where
995 S: Serializer,
996 {
997 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
998 self.0, serializer,
999 )
1000 }
1001 }
1002 &SerializeWith(&self.r#provider)
1003 })?;
1004 } else {
1005 serialize_struct.skip_field("provider")?;
1006 }
1007 if !Vec::is_empty(&self.r#sub_trip) {
1008 serialize_struct.serialize_field("subTrip", {
1009 struct SerializeWith<'a>(&'a Vec<SubTripProperty>);
1010 impl<'a> Serialize for SerializeWith<'a> {
1011 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1012 where
1013 S: Serializer,
1014 {
1015 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1016 self.0, serializer,
1017 )
1018 }
1019 }
1020 &SerializeWith(&self.r#sub_trip)
1021 })?;
1022 } else {
1023 serialize_struct.skip_field("subTrip")?;
1024 }
1025 if !Vec::is_empty(&self.r#trip_origin) {
1026 serialize_struct.serialize_field("tripOrigin", {
1027 struct SerializeWith<'a>(&'a Vec<TripOriginProperty>);
1028 impl<'a> Serialize for SerializeWith<'a> {
1029 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1030 where
1031 S: Serializer,
1032 {
1033 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1034 self.0, serializer,
1035 )
1036 }
1037 }
1038 &SerializeWith(&self.r#trip_origin)
1039 })?;
1040 } else {
1041 serialize_struct.skip_field("tripOrigin")?;
1042 }
1043 serialize_struct.end()
1044 }
1045 }
1046 impl<'de> Deserialize<'de> for Flight {
1047 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1048 where
1049 D: Deserializer<'de>,
1050 {
1051 enum Field {
1052 Aircraft,
1053 ArrivalAirport,
1054 ArrivalGate,
1055 ArrivalTerminal,
1056 BoardingPolicy,
1057 Carrier,
1058 DepartureAirport,
1059 DepartureGate,
1060 DepartureTerminal,
1061 EstimatedFlightDuration,
1062 FlightDistance,
1063 FlightNumber,
1064 MealService,
1065 Seller,
1066 WebCheckinTime,
1067 AdditionalType,
1068 AlternateName,
1069 Description,
1070 DisambiguatingDescription,
1071 Identifier,
1072 Image,
1073 MainEntityOfPage,
1074 Name,
1075 PotentialAction,
1076 SameAs,
1077 SubjectOf,
1078 Url,
1079 ArrivalTime,
1080 DepartureTime,
1081 Itinerary,
1082 Offers,
1083 PartOfTrip,
1084 Provider,
1085 SubTrip,
1086 TripOrigin,
1087 Ignore,
1088 }
1089 struct FieldVisitor;
1090 impl<'de> Visitor<'de> for FieldVisitor {
1091 type Value = Field;
1092 fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
1093 formatter.write_str("field identifier")
1094 }
1095 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
1096 where
1097 E: de::Error,
1098 {
1099 match value {
1100 "aircraft" => Ok(Field::Aircraft),
1101 "arrivalAirport" => Ok(Field::ArrivalAirport),
1102 "arrivalGate" => Ok(Field::ArrivalGate),
1103 "arrivalTerminal" => Ok(Field::ArrivalTerminal),
1104 "boardingPolicy" => Ok(Field::BoardingPolicy),
1105 "carrier" => Ok(Field::Carrier),
1106 "departureAirport" => Ok(Field::DepartureAirport),
1107 "departureGate" => Ok(Field::DepartureGate),
1108 "departureTerminal" => Ok(Field::DepartureTerminal),
1109 "estimatedFlightDuration" => Ok(Field::EstimatedFlightDuration),
1110 "flightDistance" => Ok(Field::FlightDistance),
1111 "flightNumber" => Ok(Field::FlightNumber),
1112 "mealService" => Ok(Field::MealService),
1113 "seller" => Ok(Field::Seller),
1114 "webCheckinTime" => Ok(Field::WebCheckinTime),
1115 "additionalType" => Ok(Field::AdditionalType),
1116 "alternateName" => Ok(Field::AlternateName),
1117 "description" => Ok(Field::Description),
1118 "disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
1119 "identifier" => Ok(Field::Identifier),
1120 "image" => Ok(Field::Image),
1121 "mainEntityOfPage" => Ok(Field::MainEntityOfPage),
1122 "name" => Ok(Field::Name),
1123 "potentialAction" => Ok(Field::PotentialAction),
1124 "sameAs" => Ok(Field::SameAs),
1125 "subjectOf" => Ok(Field::SubjectOf),
1126 "url" => Ok(Field::Url),
1127 "arrivalTime" => Ok(Field::ArrivalTime),
1128 "departureTime" => Ok(Field::DepartureTime),
1129 "itinerary" => Ok(Field::Itinerary),
1130 "offers" => Ok(Field::Offers),
1131 "partOfTrip" => Ok(Field::PartOfTrip),
1132 "provider" => Ok(Field::Provider),
1133 "subTrip" => Ok(Field::SubTrip),
1134 "tripOrigin" => Ok(Field::TripOrigin),
1135 "id" | "type" => Ok(Field::Ignore),
1136 _ => Err(de::Error::unknown_field(value, FIELDS)),
1137 }
1138 }
1139 fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
1140 where
1141 E: de::Error,
1142 {
1143 match value {
1144 b"aircraft" => Ok(Field::Aircraft),
1145 b"arrivalAirport" => Ok(Field::ArrivalAirport),
1146 b"arrivalGate" => Ok(Field::ArrivalGate),
1147 b"arrivalTerminal" => Ok(Field::ArrivalTerminal),
1148 b"boardingPolicy" => Ok(Field::BoardingPolicy),
1149 b"carrier" => Ok(Field::Carrier),
1150 b"departureAirport" => Ok(Field::DepartureAirport),
1151 b"departureGate" => Ok(Field::DepartureGate),
1152 b"departureTerminal" => Ok(Field::DepartureTerminal),
1153 b"estimatedFlightDuration" => Ok(Field::EstimatedFlightDuration),
1154 b"flightDistance" => Ok(Field::FlightDistance),
1155 b"flightNumber" => Ok(Field::FlightNumber),
1156 b"mealService" => Ok(Field::MealService),
1157 b"seller" => Ok(Field::Seller),
1158 b"webCheckinTime" => Ok(Field::WebCheckinTime),
1159 b"additionalType" => Ok(Field::AdditionalType),
1160 b"alternateName" => Ok(Field::AlternateName),
1161 b"description" => Ok(Field::Description),
1162 b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
1163 b"identifier" => Ok(Field::Identifier),
1164 b"image" => Ok(Field::Image),
1165 b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
1166 b"name" => Ok(Field::Name),
1167 b"potentialAction" => Ok(Field::PotentialAction),
1168 b"sameAs" => Ok(Field::SameAs),
1169 b"subjectOf" => Ok(Field::SubjectOf),
1170 b"url" => Ok(Field::Url),
1171 b"arrivalTime" => Ok(Field::ArrivalTime),
1172 b"departureTime" => Ok(Field::DepartureTime),
1173 b"itinerary" => Ok(Field::Itinerary),
1174 b"offers" => Ok(Field::Offers),
1175 b"partOfTrip" => Ok(Field::PartOfTrip),
1176 b"provider" => Ok(Field::Provider),
1177 b"subTrip" => Ok(Field::SubTrip),
1178 b"tripOrigin" => Ok(Field::TripOrigin),
1179 b"id" | b"type" => Ok(Field::Ignore),
1180 _ => {
1181 let value = &String::from_utf8_lossy(value);
1182 Err(de::Error::unknown_field(value, FIELDS))
1183 }
1184 }
1185 }
1186 }
1187 impl<'de> Deserialize<'de> for Field {
1188 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1189 where
1190 D: Deserializer<'de>,
1191 {
1192 deserializer.deserialize_identifier(FieldVisitor)
1193 }
1194 }
1195 struct ClassVisitor;
1196 impl<'de> Visitor<'de> for ClassVisitor {
1197 type Value = Flight;
1198 fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
1199 formatter.write_str("schema.org schema Flight")
1200 }
1201 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
1202 where
1203 A: de::MapAccess<'de>,
1204 {
1205 let mut r#aircraft_property = None;
1206 let mut r#arrival_airport_property = None;
1207 let mut r#arrival_gate_property = None;
1208 let mut r#arrival_terminal_property = None;
1209 let mut r#boarding_policy_property = None;
1210 let mut r#carrier_property = None;
1211 let mut r#departure_airport_property = None;
1212 let mut r#departure_gate_property = None;
1213 let mut r#departure_terminal_property = None;
1214 let mut r#estimated_flight_duration_property = None;
1215 let mut r#flight_distance_property = None;
1216 let mut r#flight_number_property = None;
1217 let mut r#meal_service_property = None;
1218 let mut r#seller_property = None;
1219 let mut r#web_checkin_time_property = None;
1220 let mut r#additional_type_property = None;
1221 let mut r#alternate_name_property = None;
1222 let mut r#description_property = None;
1223 let mut r#disambiguating_description_property = None;
1224 let mut r#identifier_property = None;
1225 let mut r#image_property = None;
1226 let mut r#main_entity_of_page_property = None;
1227 let mut r#name_property = None;
1228 let mut r#potential_action_property = None;
1229 let mut r#same_as_property = None;
1230 let mut r#subject_of_property = None;
1231 let mut r#url_property = None;
1232 let mut r#arrival_time_property = None;
1233 let mut r#departure_time_property = None;
1234 let mut r#itinerary_property = None;
1235 let mut r#offers_property = None;
1236 let mut r#part_of_trip_property = None;
1237 let mut r#provider_property = None;
1238 let mut r#sub_trip_property = None;
1239 let mut r#trip_origin_property = None;
1240 while let Some(key) = map.next_key::<Field>()? {
1241 match key {
1242 Field::Aircraft => {
1243 if r#aircraft_property.is_some() {
1244 return Err(<A::Error as de::Error>::duplicate_field(
1245 "aircraft",
1246 ));
1247 }
1248 r#aircraft_property = Some({
1249 struct DeserializeWith(Vec<AircraftProperty>);
1250 impl<'de> Deserialize<'de> for DeserializeWith {
1251 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1252 where
1253 D: Deserializer<'de>,
1254 {
1255 Ok(DeserializeWith(serde_with::As::<
1256 serde_with::OneOrMany<serde_with::Same>,
1257 >::deserialize(deserializer)?))
1258 }
1259 }
1260 match map.next_value::<DeserializeWith>() {
1261 Ok(deserialize_with) => deserialize_with.0,
1262 Err(err) => {
1263 return Err(err);
1264 }
1265 }
1266 });
1267 }
1268 Field::ArrivalAirport => {
1269 if r#arrival_airport_property.is_some() {
1270 return Err(<A::Error as de::Error>::duplicate_field(
1271 "arrivalAirport",
1272 ));
1273 }
1274 r#arrival_airport_property = Some({
1275 struct DeserializeWith(Vec<ArrivalAirportProperty>);
1276 impl<'de> Deserialize<'de> for DeserializeWith {
1277 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1278 where
1279 D: Deserializer<'de>,
1280 {
1281 Ok(DeserializeWith(serde_with::As::<
1282 serde_with::OneOrMany<serde_with::Same>,
1283 >::deserialize(deserializer)?))
1284 }
1285 }
1286 match map.next_value::<DeserializeWith>() {
1287 Ok(deserialize_with) => deserialize_with.0,
1288 Err(err) => {
1289 return Err(err);
1290 }
1291 }
1292 });
1293 }
1294 Field::ArrivalGate => {
1295 if r#arrival_gate_property.is_some() {
1296 return Err(<A::Error as de::Error>::duplicate_field(
1297 "arrivalGate",
1298 ));
1299 }
1300 r#arrival_gate_property = Some({
1301 struct DeserializeWith(Vec<ArrivalGateProperty>);
1302 impl<'de> Deserialize<'de> for DeserializeWith {
1303 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1304 where
1305 D: Deserializer<'de>,
1306 {
1307 Ok(DeserializeWith(serde_with::As::<
1308 serde_with::OneOrMany<serde_with::Same>,
1309 >::deserialize(deserializer)?))
1310 }
1311 }
1312 match map.next_value::<DeserializeWith>() {
1313 Ok(deserialize_with) => deserialize_with.0,
1314 Err(err) => {
1315 return Err(err);
1316 }
1317 }
1318 });
1319 }
1320 Field::ArrivalTerminal => {
1321 if r#arrival_terminal_property.is_some() {
1322 return Err(<A::Error as de::Error>::duplicate_field(
1323 "arrivalTerminal",
1324 ));
1325 }
1326 r#arrival_terminal_property = Some({
1327 struct DeserializeWith(Vec<ArrivalTerminalProperty>);
1328 impl<'de> Deserialize<'de> for DeserializeWith {
1329 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1330 where
1331 D: Deserializer<'de>,
1332 {
1333 Ok(DeserializeWith(serde_with::As::<
1334 serde_with::OneOrMany<serde_with::Same>,
1335 >::deserialize(deserializer)?))
1336 }
1337 }
1338 match map.next_value::<DeserializeWith>() {
1339 Ok(deserialize_with) => deserialize_with.0,
1340 Err(err) => {
1341 return Err(err);
1342 }
1343 }
1344 });
1345 }
1346 Field::BoardingPolicy => {
1347 if r#boarding_policy_property.is_some() {
1348 return Err(<A::Error as de::Error>::duplicate_field(
1349 "boardingPolicy",
1350 ));
1351 }
1352 r#boarding_policy_property = Some({
1353 struct DeserializeWith(Vec<BoardingPolicyProperty>);
1354 impl<'de> Deserialize<'de> for DeserializeWith {
1355 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1356 where
1357 D: Deserializer<'de>,
1358 {
1359 Ok(DeserializeWith(serde_with::As::<
1360 serde_with::OneOrMany<serde_with::Same>,
1361 >::deserialize(deserializer)?))
1362 }
1363 }
1364 match map.next_value::<DeserializeWith>() {
1365 Ok(deserialize_with) => deserialize_with.0,
1366 Err(err) => {
1367 return Err(err);
1368 }
1369 }
1370 });
1371 }
1372 Field::Carrier => {
1373 if r#carrier_property.is_some() {
1374 return Err(<A::Error as de::Error>::duplicate_field(
1375 "carrier",
1376 ));
1377 }
1378 r#carrier_property = Some({
1379 struct DeserializeWith(Vec<CarrierProperty>);
1380 impl<'de> Deserialize<'de> for DeserializeWith {
1381 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1382 where
1383 D: Deserializer<'de>,
1384 {
1385 Ok(DeserializeWith(serde_with::As::<
1386 serde_with::OneOrMany<serde_with::Same>,
1387 >::deserialize(deserializer)?))
1388 }
1389 }
1390 match map.next_value::<DeserializeWith>() {
1391 Ok(deserialize_with) => deserialize_with.0,
1392 Err(err) => {
1393 return Err(err);
1394 }
1395 }
1396 });
1397 }
1398 Field::DepartureAirport => {
1399 if r#departure_airport_property.is_some() {
1400 return Err(<A::Error as de::Error>::duplicate_field(
1401 "departureAirport",
1402 ));
1403 }
1404 r#departure_airport_property = Some({
1405 struct DeserializeWith(Vec<DepartureAirportProperty>);
1406 impl<'de> Deserialize<'de> for DeserializeWith {
1407 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1408 where
1409 D: Deserializer<'de>,
1410 {
1411 Ok(DeserializeWith(serde_with::As::<
1412 serde_with::OneOrMany<serde_with::Same>,
1413 >::deserialize(deserializer)?))
1414 }
1415 }
1416 match map.next_value::<DeserializeWith>() {
1417 Ok(deserialize_with) => deserialize_with.0,
1418 Err(err) => {
1419 return Err(err);
1420 }
1421 }
1422 });
1423 }
1424 Field::DepartureGate => {
1425 if r#departure_gate_property.is_some() {
1426 return Err(<A::Error as de::Error>::duplicate_field(
1427 "departureGate",
1428 ));
1429 }
1430 r#departure_gate_property = Some({
1431 struct DeserializeWith(Vec<DepartureGateProperty>);
1432 impl<'de> Deserialize<'de> for DeserializeWith {
1433 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1434 where
1435 D: Deserializer<'de>,
1436 {
1437 Ok(DeserializeWith(serde_with::As::<
1438 serde_with::OneOrMany<serde_with::Same>,
1439 >::deserialize(deserializer)?))
1440 }
1441 }
1442 match map.next_value::<DeserializeWith>() {
1443 Ok(deserialize_with) => deserialize_with.0,
1444 Err(err) => {
1445 return Err(err);
1446 }
1447 }
1448 });
1449 }
1450 Field::DepartureTerminal => {
1451 if r#departure_terminal_property.is_some() {
1452 return Err(<A::Error as de::Error>::duplicate_field(
1453 "departureTerminal",
1454 ));
1455 }
1456 r#departure_terminal_property = Some({
1457 struct DeserializeWith(Vec<DepartureTerminalProperty>);
1458 impl<'de> Deserialize<'de> for DeserializeWith {
1459 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1460 where
1461 D: Deserializer<'de>,
1462 {
1463 Ok(DeserializeWith(serde_with::As::<
1464 serde_with::OneOrMany<serde_with::Same>,
1465 >::deserialize(deserializer)?))
1466 }
1467 }
1468 match map.next_value::<DeserializeWith>() {
1469 Ok(deserialize_with) => deserialize_with.0,
1470 Err(err) => {
1471 return Err(err);
1472 }
1473 }
1474 });
1475 }
1476 Field::EstimatedFlightDuration => {
1477 if r#estimated_flight_duration_property.is_some() {
1478 return Err(<A::Error as de::Error>::duplicate_field(
1479 "estimatedFlightDuration",
1480 ));
1481 }
1482 r#estimated_flight_duration_property = Some({
1483 struct DeserializeWith(Vec<EstimatedFlightDurationProperty>);
1484 impl<'de> Deserialize<'de> for DeserializeWith {
1485 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1486 where
1487 D: Deserializer<'de>,
1488 {
1489 Ok(DeserializeWith(serde_with::As::<
1490 serde_with::OneOrMany<serde_with::Same>,
1491 >::deserialize(deserializer)?))
1492 }
1493 }
1494 match map.next_value::<DeserializeWith>() {
1495 Ok(deserialize_with) => deserialize_with.0,
1496 Err(err) => {
1497 return Err(err);
1498 }
1499 }
1500 });
1501 }
1502 Field::FlightDistance => {
1503 if r#flight_distance_property.is_some() {
1504 return Err(<A::Error as de::Error>::duplicate_field(
1505 "flightDistance",
1506 ));
1507 }
1508 r#flight_distance_property = Some({
1509 struct DeserializeWith(Vec<FlightDistanceProperty>);
1510 impl<'de> Deserialize<'de> for DeserializeWith {
1511 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1512 where
1513 D: Deserializer<'de>,
1514 {
1515 Ok(DeserializeWith(serde_with::As::<
1516 serde_with::OneOrMany<serde_with::Same>,
1517 >::deserialize(deserializer)?))
1518 }
1519 }
1520 match map.next_value::<DeserializeWith>() {
1521 Ok(deserialize_with) => deserialize_with.0,
1522 Err(err) => {
1523 return Err(err);
1524 }
1525 }
1526 });
1527 }
1528 Field::FlightNumber => {
1529 if r#flight_number_property.is_some() {
1530 return Err(<A::Error as de::Error>::duplicate_field(
1531 "flightNumber",
1532 ));
1533 }
1534 r#flight_number_property = Some({
1535 struct DeserializeWith(Vec<FlightNumberProperty>);
1536 impl<'de> Deserialize<'de> for DeserializeWith {
1537 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1538 where
1539 D: Deserializer<'de>,
1540 {
1541 Ok(DeserializeWith(serde_with::As::<
1542 serde_with::OneOrMany<serde_with::Same>,
1543 >::deserialize(deserializer)?))
1544 }
1545 }
1546 match map.next_value::<DeserializeWith>() {
1547 Ok(deserialize_with) => deserialize_with.0,
1548 Err(err) => {
1549 return Err(err);
1550 }
1551 }
1552 });
1553 }
1554 Field::MealService => {
1555 if r#meal_service_property.is_some() {
1556 return Err(<A::Error as de::Error>::duplicate_field(
1557 "mealService",
1558 ));
1559 }
1560 r#meal_service_property = Some({
1561 struct DeserializeWith(Vec<MealServiceProperty>);
1562 impl<'de> Deserialize<'de> for DeserializeWith {
1563 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1564 where
1565 D: Deserializer<'de>,
1566 {
1567 Ok(DeserializeWith(serde_with::As::<
1568 serde_with::OneOrMany<serde_with::Same>,
1569 >::deserialize(deserializer)?))
1570 }
1571 }
1572 match map.next_value::<DeserializeWith>() {
1573 Ok(deserialize_with) => deserialize_with.0,
1574 Err(err) => {
1575 return Err(err);
1576 }
1577 }
1578 });
1579 }
1580 Field::Seller => {
1581 if r#seller_property.is_some() {
1582 return Err(<A::Error as de::Error>::duplicate_field("seller"));
1583 }
1584 r#seller_property = Some({
1585 struct DeserializeWith(Vec<SellerProperty>);
1586 impl<'de> Deserialize<'de> for DeserializeWith {
1587 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1588 where
1589 D: Deserializer<'de>,
1590 {
1591 Ok(DeserializeWith(serde_with::As::<
1592 serde_with::OneOrMany<serde_with::Same>,
1593 >::deserialize(deserializer)?))
1594 }
1595 }
1596 match map.next_value::<DeserializeWith>() {
1597 Ok(deserialize_with) => deserialize_with.0,
1598 Err(err) => {
1599 return Err(err);
1600 }
1601 }
1602 });
1603 }
1604 Field::WebCheckinTime => {
1605 if r#web_checkin_time_property.is_some() {
1606 return Err(<A::Error as de::Error>::duplicate_field(
1607 "webCheckinTime",
1608 ));
1609 }
1610 r#web_checkin_time_property = Some({
1611 struct DeserializeWith(Vec<WebCheckinTimeProperty>);
1612 impl<'de> Deserialize<'de> for DeserializeWith {
1613 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1614 where
1615 D: Deserializer<'de>,
1616 {
1617 Ok(DeserializeWith(serde_with::As::<
1618 serde_with::OneOrMany<serde_with::Same>,
1619 >::deserialize(deserializer)?))
1620 }
1621 }
1622 match map.next_value::<DeserializeWith>() {
1623 Ok(deserialize_with) => deserialize_with.0,
1624 Err(err) => {
1625 return Err(err);
1626 }
1627 }
1628 });
1629 }
1630 Field::AdditionalType => {
1631 if r#additional_type_property.is_some() {
1632 return Err(<A::Error as de::Error>::duplicate_field(
1633 "additionalType",
1634 ));
1635 }
1636 r#additional_type_property = Some({
1637 struct DeserializeWith(Vec<AdditionalTypeProperty>);
1638 impl<'de> Deserialize<'de> for DeserializeWith {
1639 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1640 where
1641 D: Deserializer<'de>,
1642 {
1643 Ok(DeserializeWith(serde_with::As::<
1644 serde_with::OneOrMany<serde_with::Same>,
1645 >::deserialize(deserializer)?))
1646 }
1647 }
1648 match map.next_value::<DeserializeWith>() {
1649 Ok(deserialize_with) => deserialize_with.0,
1650 Err(err) => {
1651 return Err(err);
1652 }
1653 }
1654 });
1655 }
1656 Field::AlternateName => {
1657 if r#alternate_name_property.is_some() {
1658 return Err(<A::Error as de::Error>::duplicate_field(
1659 "alternateName",
1660 ));
1661 }
1662 r#alternate_name_property = Some({
1663 struct DeserializeWith(Vec<AlternateNameProperty>);
1664 impl<'de> Deserialize<'de> for DeserializeWith {
1665 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1666 where
1667 D: Deserializer<'de>,
1668 {
1669 Ok(DeserializeWith(serde_with::As::<
1670 serde_with::OneOrMany<serde_with::Same>,
1671 >::deserialize(deserializer)?))
1672 }
1673 }
1674 match map.next_value::<DeserializeWith>() {
1675 Ok(deserialize_with) => deserialize_with.0,
1676 Err(err) => {
1677 return Err(err);
1678 }
1679 }
1680 });
1681 }
1682 Field::Description => {
1683 if r#description_property.is_some() {
1684 return Err(<A::Error as de::Error>::duplicate_field(
1685 "description",
1686 ));
1687 }
1688 r#description_property = Some({
1689 struct DeserializeWith(Vec<DescriptionProperty>);
1690 impl<'de> Deserialize<'de> for DeserializeWith {
1691 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1692 where
1693 D: Deserializer<'de>,
1694 {
1695 Ok(DeserializeWith(serde_with::As::<
1696 serde_with::OneOrMany<serde_with::Same>,
1697 >::deserialize(deserializer)?))
1698 }
1699 }
1700 match map.next_value::<DeserializeWith>() {
1701 Ok(deserialize_with) => deserialize_with.0,
1702 Err(err) => {
1703 return Err(err);
1704 }
1705 }
1706 });
1707 }
1708 Field::DisambiguatingDescription => {
1709 if r#disambiguating_description_property.is_some() {
1710 return Err(<A::Error as de::Error>::duplicate_field(
1711 "disambiguatingDescription",
1712 ));
1713 }
1714 r#disambiguating_description_property = Some({
1715 struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
1716 impl<'de> Deserialize<'de> for DeserializeWith {
1717 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1718 where
1719 D: Deserializer<'de>,
1720 {
1721 Ok(DeserializeWith(serde_with::As::<
1722 serde_with::OneOrMany<serde_with::Same>,
1723 >::deserialize(deserializer)?))
1724 }
1725 }
1726 match map.next_value::<DeserializeWith>() {
1727 Ok(deserialize_with) => deserialize_with.0,
1728 Err(err) => {
1729 return Err(err);
1730 }
1731 }
1732 });
1733 }
1734 Field::Identifier => {
1735 if r#identifier_property.is_some() {
1736 return Err(<A::Error as de::Error>::duplicate_field(
1737 "identifier",
1738 ));
1739 }
1740 r#identifier_property = Some({
1741 struct DeserializeWith(Vec<IdentifierProperty>);
1742 impl<'de> Deserialize<'de> for DeserializeWith {
1743 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1744 where
1745 D: Deserializer<'de>,
1746 {
1747 Ok(DeserializeWith(serde_with::As::<
1748 serde_with::OneOrMany<serde_with::Same>,
1749 >::deserialize(deserializer)?))
1750 }
1751 }
1752 match map.next_value::<DeserializeWith>() {
1753 Ok(deserialize_with) => deserialize_with.0,
1754 Err(err) => {
1755 return Err(err);
1756 }
1757 }
1758 });
1759 }
1760 Field::Image => {
1761 if r#image_property.is_some() {
1762 return Err(<A::Error as de::Error>::duplicate_field("image"));
1763 }
1764 r#image_property = Some({
1765 struct DeserializeWith(Vec<ImageProperty>);
1766 impl<'de> Deserialize<'de> for DeserializeWith {
1767 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1768 where
1769 D: Deserializer<'de>,
1770 {
1771 Ok(DeserializeWith(serde_with::As::<
1772 serde_with::OneOrMany<serde_with::Same>,
1773 >::deserialize(deserializer)?))
1774 }
1775 }
1776 match map.next_value::<DeserializeWith>() {
1777 Ok(deserialize_with) => deserialize_with.0,
1778 Err(err) => {
1779 return Err(err);
1780 }
1781 }
1782 });
1783 }
1784 Field::MainEntityOfPage => {
1785 if r#main_entity_of_page_property.is_some() {
1786 return Err(<A::Error as de::Error>::duplicate_field(
1787 "mainEntityOfPage",
1788 ));
1789 }
1790 r#main_entity_of_page_property = Some({
1791 struct DeserializeWith(Vec<MainEntityOfPageProperty>);
1792 impl<'de> Deserialize<'de> for DeserializeWith {
1793 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1794 where
1795 D: Deserializer<'de>,
1796 {
1797 Ok(DeserializeWith(serde_with::As::<
1798 serde_with::OneOrMany<serde_with::Same>,
1799 >::deserialize(deserializer)?))
1800 }
1801 }
1802 match map.next_value::<DeserializeWith>() {
1803 Ok(deserialize_with) => deserialize_with.0,
1804 Err(err) => {
1805 return Err(err);
1806 }
1807 }
1808 });
1809 }
1810 Field::Name => {
1811 if r#name_property.is_some() {
1812 return Err(<A::Error as de::Error>::duplicate_field("name"));
1813 }
1814 r#name_property = Some({
1815 struct DeserializeWith(Vec<NameProperty>);
1816 impl<'de> Deserialize<'de> for DeserializeWith {
1817 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1818 where
1819 D: Deserializer<'de>,
1820 {
1821 Ok(DeserializeWith(serde_with::As::<
1822 serde_with::OneOrMany<serde_with::Same>,
1823 >::deserialize(deserializer)?))
1824 }
1825 }
1826 match map.next_value::<DeserializeWith>() {
1827 Ok(deserialize_with) => deserialize_with.0,
1828 Err(err) => {
1829 return Err(err);
1830 }
1831 }
1832 });
1833 }
1834 Field::PotentialAction => {
1835 if r#potential_action_property.is_some() {
1836 return Err(<A::Error as de::Error>::duplicate_field(
1837 "potentialAction",
1838 ));
1839 }
1840 r#potential_action_property = Some({
1841 struct DeserializeWith(Vec<PotentialActionProperty>);
1842 impl<'de> Deserialize<'de> for DeserializeWith {
1843 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1844 where
1845 D: Deserializer<'de>,
1846 {
1847 Ok(DeserializeWith(serde_with::As::<
1848 serde_with::OneOrMany<serde_with::Same>,
1849 >::deserialize(deserializer)?))
1850 }
1851 }
1852 match map.next_value::<DeserializeWith>() {
1853 Ok(deserialize_with) => deserialize_with.0,
1854 Err(err) => {
1855 return Err(err);
1856 }
1857 }
1858 });
1859 }
1860 Field::SameAs => {
1861 if r#same_as_property.is_some() {
1862 return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
1863 }
1864 r#same_as_property = Some({
1865 struct DeserializeWith(Vec<SameAsProperty>);
1866 impl<'de> Deserialize<'de> for DeserializeWith {
1867 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1868 where
1869 D: Deserializer<'de>,
1870 {
1871 Ok(DeserializeWith(serde_with::As::<
1872 serde_with::OneOrMany<serde_with::Same>,
1873 >::deserialize(deserializer)?))
1874 }
1875 }
1876 match map.next_value::<DeserializeWith>() {
1877 Ok(deserialize_with) => deserialize_with.0,
1878 Err(err) => {
1879 return Err(err);
1880 }
1881 }
1882 });
1883 }
1884 Field::SubjectOf => {
1885 if r#subject_of_property.is_some() {
1886 return Err(<A::Error as de::Error>::duplicate_field(
1887 "subjectOf",
1888 ));
1889 }
1890 r#subject_of_property = Some({
1891 struct DeserializeWith(Vec<SubjectOfProperty>);
1892 impl<'de> Deserialize<'de> for DeserializeWith {
1893 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1894 where
1895 D: Deserializer<'de>,
1896 {
1897 Ok(DeserializeWith(serde_with::As::<
1898 serde_with::OneOrMany<serde_with::Same>,
1899 >::deserialize(deserializer)?))
1900 }
1901 }
1902 match map.next_value::<DeserializeWith>() {
1903 Ok(deserialize_with) => deserialize_with.0,
1904 Err(err) => {
1905 return Err(err);
1906 }
1907 }
1908 });
1909 }
1910 Field::Url => {
1911 if r#url_property.is_some() {
1912 return Err(<A::Error as de::Error>::duplicate_field("url"));
1913 }
1914 r#url_property = Some({
1915 struct DeserializeWith(Vec<UrlProperty>);
1916 impl<'de> Deserialize<'de> for DeserializeWith {
1917 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1918 where
1919 D: Deserializer<'de>,
1920 {
1921 Ok(DeserializeWith(serde_with::As::<
1922 serde_with::OneOrMany<serde_with::Same>,
1923 >::deserialize(deserializer)?))
1924 }
1925 }
1926 match map.next_value::<DeserializeWith>() {
1927 Ok(deserialize_with) => deserialize_with.0,
1928 Err(err) => {
1929 return Err(err);
1930 }
1931 }
1932 });
1933 }
1934 Field::ArrivalTime => {
1935 if r#arrival_time_property.is_some() {
1936 return Err(<A::Error as de::Error>::duplicate_field(
1937 "arrivalTime",
1938 ));
1939 }
1940 r#arrival_time_property = Some({
1941 struct DeserializeWith(Vec<ArrivalTimeProperty>);
1942 impl<'de> Deserialize<'de> for DeserializeWith {
1943 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1944 where
1945 D: Deserializer<'de>,
1946 {
1947 Ok(DeserializeWith(serde_with::As::<
1948 serde_with::OneOrMany<serde_with::Same>,
1949 >::deserialize(deserializer)?))
1950 }
1951 }
1952 match map.next_value::<DeserializeWith>() {
1953 Ok(deserialize_with) => deserialize_with.0,
1954 Err(err) => {
1955 return Err(err);
1956 }
1957 }
1958 });
1959 }
1960 Field::DepartureTime => {
1961 if r#departure_time_property.is_some() {
1962 return Err(<A::Error as de::Error>::duplicate_field(
1963 "departureTime",
1964 ));
1965 }
1966 r#departure_time_property = Some({
1967 struct DeserializeWith(Vec<DepartureTimeProperty>);
1968 impl<'de> Deserialize<'de> for DeserializeWith {
1969 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1970 where
1971 D: Deserializer<'de>,
1972 {
1973 Ok(DeserializeWith(serde_with::As::<
1974 serde_with::OneOrMany<serde_with::Same>,
1975 >::deserialize(deserializer)?))
1976 }
1977 }
1978 match map.next_value::<DeserializeWith>() {
1979 Ok(deserialize_with) => deserialize_with.0,
1980 Err(err) => {
1981 return Err(err);
1982 }
1983 }
1984 });
1985 }
1986 Field::Itinerary => {
1987 if r#itinerary_property.is_some() {
1988 return Err(<A::Error as de::Error>::duplicate_field(
1989 "itinerary",
1990 ));
1991 }
1992 r#itinerary_property = Some({
1993 struct DeserializeWith(Vec<ItineraryProperty>);
1994 impl<'de> Deserialize<'de> for DeserializeWith {
1995 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1996 where
1997 D: Deserializer<'de>,
1998 {
1999 Ok(DeserializeWith(serde_with::As::<
2000 serde_with::OneOrMany<serde_with::Same>,
2001 >::deserialize(deserializer)?))
2002 }
2003 }
2004 match map.next_value::<DeserializeWith>() {
2005 Ok(deserialize_with) => deserialize_with.0,
2006 Err(err) => {
2007 return Err(err);
2008 }
2009 }
2010 });
2011 }
2012 Field::Offers => {
2013 if r#offers_property.is_some() {
2014 return Err(<A::Error as de::Error>::duplicate_field("offers"));
2015 }
2016 r#offers_property = Some({
2017 struct DeserializeWith(Vec<OffersProperty>);
2018 impl<'de> Deserialize<'de> for DeserializeWith {
2019 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2020 where
2021 D: Deserializer<'de>,
2022 {
2023 Ok(DeserializeWith(serde_with::As::<
2024 serde_with::OneOrMany<serde_with::Same>,
2025 >::deserialize(deserializer)?))
2026 }
2027 }
2028 match map.next_value::<DeserializeWith>() {
2029 Ok(deserialize_with) => deserialize_with.0,
2030 Err(err) => {
2031 return Err(err);
2032 }
2033 }
2034 });
2035 }
2036 Field::PartOfTrip => {
2037 if r#part_of_trip_property.is_some() {
2038 return Err(<A::Error as de::Error>::duplicate_field(
2039 "partOfTrip",
2040 ));
2041 }
2042 r#part_of_trip_property = Some({
2043 struct DeserializeWith(Vec<PartOfTripProperty>);
2044 impl<'de> Deserialize<'de> for DeserializeWith {
2045 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2046 where
2047 D: Deserializer<'de>,
2048 {
2049 Ok(DeserializeWith(serde_with::As::<
2050 serde_with::OneOrMany<serde_with::Same>,
2051 >::deserialize(deserializer)?))
2052 }
2053 }
2054 match map.next_value::<DeserializeWith>() {
2055 Ok(deserialize_with) => deserialize_with.0,
2056 Err(err) => {
2057 return Err(err);
2058 }
2059 }
2060 });
2061 }
2062 Field::Provider => {
2063 if r#provider_property.is_some() {
2064 return Err(<A::Error as de::Error>::duplicate_field(
2065 "provider",
2066 ));
2067 }
2068 r#provider_property = Some({
2069 struct DeserializeWith(Vec<ProviderProperty>);
2070 impl<'de> Deserialize<'de> for DeserializeWith {
2071 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2072 where
2073 D: Deserializer<'de>,
2074 {
2075 Ok(DeserializeWith(serde_with::As::<
2076 serde_with::OneOrMany<serde_with::Same>,
2077 >::deserialize(deserializer)?))
2078 }
2079 }
2080 match map.next_value::<DeserializeWith>() {
2081 Ok(deserialize_with) => deserialize_with.0,
2082 Err(err) => {
2083 return Err(err);
2084 }
2085 }
2086 });
2087 }
2088 Field::SubTrip => {
2089 if r#sub_trip_property.is_some() {
2090 return Err(<A::Error as de::Error>::duplicate_field(
2091 "subTrip",
2092 ));
2093 }
2094 r#sub_trip_property = Some({
2095 struct DeserializeWith(Vec<SubTripProperty>);
2096 impl<'de> Deserialize<'de> for DeserializeWith {
2097 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2098 where
2099 D: Deserializer<'de>,
2100 {
2101 Ok(DeserializeWith(serde_with::As::<
2102 serde_with::OneOrMany<serde_with::Same>,
2103 >::deserialize(deserializer)?))
2104 }
2105 }
2106 match map.next_value::<DeserializeWith>() {
2107 Ok(deserialize_with) => deserialize_with.0,
2108 Err(err) => {
2109 return Err(err);
2110 }
2111 }
2112 });
2113 }
2114 Field::TripOrigin => {
2115 if r#trip_origin_property.is_some() {
2116 return Err(<A::Error as de::Error>::duplicate_field(
2117 "tripOrigin",
2118 ));
2119 }
2120 r#trip_origin_property = Some({
2121 struct DeserializeWith(Vec<TripOriginProperty>);
2122 impl<'de> Deserialize<'de> for DeserializeWith {
2123 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2124 where
2125 D: Deserializer<'de>,
2126 {
2127 Ok(DeserializeWith(serde_with::As::<
2128 serde_with::OneOrMany<serde_with::Same>,
2129 >::deserialize(deserializer)?))
2130 }
2131 }
2132 match map.next_value::<DeserializeWith>() {
2133 Ok(deserialize_with) => deserialize_with.0,
2134 Err(err) => {
2135 return Err(err);
2136 }
2137 }
2138 });
2139 }
2140 Field::Ignore => {
2141 let _ = map.next_value::<de::IgnoredAny>()?;
2142 }
2143 }
2144 }
2145 Ok(Flight {
2146 r#aircraft: r#aircraft_property.unwrap_or_default(),
2147 r#arrival_airport: r#arrival_airport_property.unwrap_or_default(),
2148 r#arrival_gate: r#arrival_gate_property.unwrap_or_default(),
2149 r#arrival_terminal: r#arrival_terminal_property.unwrap_or_default(),
2150 r#boarding_policy: r#boarding_policy_property.unwrap_or_default(),
2151 r#carrier: r#carrier_property.unwrap_or_default(),
2152 r#departure_airport: r#departure_airport_property.unwrap_or_default(),
2153 r#departure_gate: r#departure_gate_property.unwrap_or_default(),
2154 r#departure_terminal: r#departure_terminal_property.unwrap_or_default(),
2155 r#estimated_flight_duration: r#estimated_flight_duration_property
2156 .unwrap_or_default(),
2157 r#flight_distance: r#flight_distance_property.unwrap_or_default(),
2158 r#flight_number: r#flight_number_property.unwrap_or_default(),
2159 r#meal_service: r#meal_service_property.unwrap_or_default(),
2160 r#seller: r#seller_property.unwrap_or_default(),
2161 r#web_checkin_time: r#web_checkin_time_property.unwrap_or_default(),
2162 r#additional_type: r#additional_type_property.unwrap_or_default(),
2163 r#alternate_name: r#alternate_name_property.unwrap_or_default(),
2164 r#description: r#description_property.unwrap_or_default(),
2165 r#disambiguating_description: r#disambiguating_description_property
2166 .unwrap_or_default(),
2167 r#identifier: r#identifier_property.unwrap_or_default(),
2168 r#image: r#image_property.unwrap_or_default(),
2169 r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
2170 r#name: r#name_property.unwrap_or_default(),
2171 r#potential_action: r#potential_action_property.unwrap_or_default(),
2172 r#same_as: r#same_as_property.unwrap_or_default(),
2173 r#subject_of: r#subject_of_property.unwrap_or_default(),
2174 r#url: r#url_property.unwrap_or_default(),
2175 r#arrival_time: r#arrival_time_property.unwrap_or_default(),
2176 r#departure_time: r#departure_time_property.unwrap_or_default(),
2177 r#itinerary: r#itinerary_property.unwrap_or_default(),
2178 r#offers: r#offers_property.unwrap_or_default(),
2179 r#part_of_trip: r#part_of_trip_property.unwrap_or_default(),
2180 r#provider: r#provider_property.unwrap_or_default(),
2181 r#sub_trip: r#sub_trip_property.unwrap_or_default(),
2182 r#trip_origin: r#trip_origin_property.unwrap_or_default(),
2183 })
2184 }
2185 }
2186 const FIELDS: &[&str] = &[
2187 "aircraft",
2188 "arrivalAirport",
2189 "arrivalGate",
2190 "arrivalTerminal",
2191 "boardingPolicy",
2192 "carrier",
2193 "departureAirport",
2194 "departureGate",
2195 "departureTerminal",
2196 "estimatedFlightDuration",
2197 "flightDistance",
2198 "flightNumber",
2199 "mealService",
2200 "seller",
2201 "webCheckinTime",
2202 "additionalType",
2203 "alternateName",
2204 "description",
2205 "disambiguatingDescription",
2206 "identifier",
2207 "image",
2208 "mainEntityOfPage",
2209 "name",
2210 "potentialAction",
2211 "sameAs",
2212 "subjectOf",
2213 "url",
2214 "arrivalTime",
2215 "departureTime",
2216 "itinerary",
2217 "offers",
2218 "partOfTrip",
2219 "provider",
2220 "subTrip",
2221 "tripOrigin",
2222 ];
2223 deserializer.deserialize_struct("Flight", FIELDS, ClassVisitor)
2224 }
2225 }
2226}