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