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