1use super::*;
2#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct Canal {
6 pub r#additional_property: Vec<AdditionalPropertyProperty>,
8 pub r#address: Vec<AddressProperty>,
10 pub r#aggregate_rating: Vec<AggregateRatingProperty>,
12 pub r#amenity_feature: Vec<AmenityFeatureProperty>,
14 pub r#branch_code: Vec<BranchCodeProperty>,
16 #[deprecated = "This schema is superseded by <https://schema.org/containedInPlace>."]
18 pub r#contained_in: Vec<ContainedInProperty>,
19 pub r#contained_in_place: Vec<ContainedInPlaceProperty>,
21 pub r#contains_place: Vec<ContainsPlaceProperty>,
23 pub r#event: Vec<EventProperty>,
25 #[deprecated = "This schema is superseded by <https://schema.org/event>."]
27 pub r#events: Vec<EventsProperty>,
28 pub r#fax_number: Vec<FaxNumberProperty>,
30 pub r#geo: Vec<GeoProperty>,
32 pub r#geo_contains: Vec<GeoContainsProperty>,
34 pub r#geo_covered_by: Vec<GeoCoveredByProperty>,
36 pub r#geo_covers: Vec<GeoCoversProperty>,
38 pub r#geo_crosses: Vec<GeoCrossesProperty>,
40 pub r#geo_disjoint: Vec<GeoDisjointProperty>,
42 pub r#geo_equals: Vec<GeoEqualsProperty>,
44 pub r#geo_intersects: Vec<GeoIntersectsProperty>,
46 pub r#geo_overlaps: Vec<GeoOverlapsProperty>,
48 pub r#geo_touches: Vec<GeoTouchesProperty>,
50 pub r#geo_within: Vec<GeoWithinProperty>,
52 pub r#global_location_number: Vec<GlobalLocationNumberProperty>,
54 pub r#has_drive_through_service: Vec<HasDriveThroughServiceProperty>,
56 pub r#has_map: Vec<HasMapProperty>,
58 pub r#is_accessible_for_free: Vec<IsAccessibleForFreeProperty>,
60 pub r#isic_v_4: Vec<IsicV4Property>,
62 pub r#keywords: Vec<KeywordsProperty>,
64 pub r#latitude: Vec<LatitudeProperty>,
66 pub r#logo: Vec<LogoProperty>,
68 pub r#longitude: Vec<LongitudeProperty>,
70 #[deprecated = "This schema is superseded by <https://schema.org/hasMap>."]
72 pub r#map: Vec<MapProperty>,
73 #[deprecated = "This schema is superseded by <https://schema.org/hasMap>."]
75 pub r#maps: Vec<MapsProperty>,
76 pub r#maximum_attendee_capacity: Vec<MaximumAttendeeCapacityProperty>,
78 pub r#opening_hours_specification: Vec<OpeningHoursSpecificationProperty>,
80 pub r#photo: Vec<PhotoProperty>,
82 #[deprecated = "This schema is superseded by <https://schema.org/photo>."]
84 pub r#photos: Vec<PhotosProperty>,
85 pub r#public_access: Vec<PublicAccessProperty>,
87 pub r#review: Vec<ReviewProperty>,
89 #[deprecated = "This schema is superseded by <https://schema.org/review>."]
91 pub r#reviews: Vec<ReviewsProperty>,
92 pub r#slogan: Vec<SloganProperty>,
94 pub r#smoking_allowed: Vec<SmokingAllowedProperty>,
96 pub r#special_opening_hours_specification: Vec<SpecialOpeningHoursSpecificationProperty>,
98 pub r#telephone: Vec<TelephoneProperty>,
100 pub r#tour_booking_page: Vec<TourBookingPageProperty>,
102 pub r#additional_type: Vec<AdditionalTypeProperty>,
104 pub r#alternate_name: Vec<AlternateNameProperty>,
106 pub r#description: Vec<DescriptionProperty>,
108 pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
110 pub r#identifier: Vec<IdentifierProperty>,
112 pub r#image: Vec<ImageProperty>,
114 pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
116 pub r#name: Vec<NameProperty>,
118 pub r#potential_action: Vec<PotentialActionProperty>,
120 pub r#same_as: Vec<SameAsProperty>,
122 pub r#subject_of: Vec<SubjectOfProperty>,
124 pub r#url: Vec<UrlProperty>,
126}
127pub trait CanalTrait {}
129impl CanalTrait for Canal {}
130impl BodyOfWaterTrait for Canal {}
131impl LandformTrait for Canal {}
132impl PlaceTrait for Canal {
133 fn get_additional_property(&self) -> &[AdditionalPropertyProperty] {
134 self.r#additional_property.as_slice()
135 }
136 fn take_additional_property(&mut self) -> Vec<AdditionalPropertyProperty> {
137 std::mem::take(&mut self.r#additional_property)
138 }
139 fn get_address(&self) -> &[AddressProperty] {
140 self.r#address.as_slice()
141 }
142 fn take_address(&mut self) -> Vec<AddressProperty> {
143 std::mem::take(&mut self.r#address)
144 }
145 fn get_aggregate_rating(&self) -> &[AggregateRatingProperty] {
146 self.r#aggregate_rating.as_slice()
147 }
148 fn take_aggregate_rating(&mut self) -> Vec<AggregateRatingProperty> {
149 std::mem::take(&mut self.r#aggregate_rating)
150 }
151 fn get_amenity_feature(&self) -> &[AmenityFeatureProperty] {
152 self.r#amenity_feature.as_slice()
153 }
154 fn take_amenity_feature(&mut self) -> Vec<AmenityFeatureProperty> {
155 std::mem::take(&mut self.r#amenity_feature)
156 }
157 fn get_branch_code(&self) -> &[BranchCodeProperty] {
158 self.r#branch_code.as_slice()
159 }
160 fn take_branch_code(&mut self) -> Vec<BranchCodeProperty> {
161 std::mem::take(&mut self.r#branch_code)
162 }
163 fn get_contained_in(&self) -> &[ContainedInProperty] {
164 self.r#contained_in.as_slice()
165 }
166 fn take_contained_in(&mut self) -> Vec<ContainedInProperty> {
167 std::mem::take(&mut self.r#contained_in)
168 }
169 fn get_contained_in_place(&self) -> &[ContainedInPlaceProperty] {
170 self.r#contained_in_place.as_slice()
171 }
172 fn take_contained_in_place(&mut self) -> Vec<ContainedInPlaceProperty> {
173 std::mem::take(&mut self.r#contained_in_place)
174 }
175 fn get_contains_place(&self) -> &[ContainsPlaceProperty] {
176 self.r#contains_place.as_slice()
177 }
178 fn take_contains_place(&mut self) -> Vec<ContainsPlaceProperty> {
179 std::mem::take(&mut self.r#contains_place)
180 }
181 fn get_event(&self) -> &[EventProperty] {
182 self.r#event.as_slice()
183 }
184 fn take_event(&mut self) -> Vec<EventProperty> {
185 std::mem::take(&mut self.r#event)
186 }
187 fn get_events(&self) -> &[EventsProperty] {
188 self.r#events.as_slice()
189 }
190 fn take_events(&mut self) -> Vec<EventsProperty> {
191 std::mem::take(&mut self.r#events)
192 }
193 fn get_fax_number(&self) -> &[FaxNumberProperty] {
194 self.r#fax_number.as_slice()
195 }
196 fn take_fax_number(&mut self) -> Vec<FaxNumberProperty> {
197 std::mem::take(&mut self.r#fax_number)
198 }
199 fn get_geo(&self) -> &[GeoProperty] {
200 self.r#geo.as_slice()
201 }
202 fn take_geo(&mut self) -> Vec<GeoProperty> {
203 std::mem::take(&mut self.r#geo)
204 }
205 fn get_geo_contains(&self) -> &[GeoContainsProperty] {
206 self.r#geo_contains.as_slice()
207 }
208 fn take_geo_contains(&mut self) -> Vec<GeoContainsProperty> {
209 std::mem::take(&mut self.r#geo_contains)
210 }
211 fn get_geo_covered_by(&self) -> &[GeoCoveredByProperty] {
212 self.r#geo_covered_by.as_slice()
213 }
214 fn take_geo_covered_by(&mut self) -> Vec<GeoCoveredByProperty> {
215 std::mem::take(&mut self.r#geo_covered_by)
216 }
217 fn get_geo_covers(&self) -> &[GeoCoversProperty] {
218 self.r#geo_covers.as_slice()
219 }
220 fn take_geo_covers(&mut self) -> Vec<GeoCoversProperty> {
221 std::mem::take(&mut self.r#geo_covers)
222 }
223 fn get_geo_crosses(&self) -> &[GeoCrossesProperty] {
224 self.r#geo_crosses.as_slice()
225 }
226 fn take_geo_crosses(&mut self) -> Vec<GeoCrossesProperty> {
227 std::mem::take(&mut self.r#geo_crosses)
228 }
229 fn get_geo_disjoint(&self) -> &[GeoDisjointProperty] {
230 self.r#geo_disjoint.as_slice()
231 }
232 fn take_geo_disjoint(&mut self) -> Vec<GeoDisjointProperty> {
233 std::mem::take(&mut self.r#geo_disjoint)
234 }
235 fn get_geo_equals(&self) -> &[GeoEqualsProperty] {
236 self.r#geo_equals.as_slice()
237 }
238 fn take_geo_equals(&mut self) -> Vec<GeoEqualsProperty> {
239 std::mem::take(&mut self.r#geo_equals)
240 }
241 fn get_geo_intersects(&self) -> &[GeoIntersectsProperty] {
242 self.r#geo_intersects.as_slice()
243 }
244 fn take_geo_intersects(&mut self) -> Vec<GeoIntersectsProperty> {
245 std::mem::take(&mut self.r#geo_intersects)
246 }
247 fn get_geo_overlaps(&self) -> &[GeoOverlapsProperty] {
248 self.r#geo_overlaps.as_slice()
249 }
250 fn take_geo_overlaps(&mut self) -> Vec<GeoOverlapsProperty> {
251 std::mem::take(&mut self.r#geo_overlaps)
252 }
253 fn get_geo_touches(&self) -> &[GeoTouchesProperty] {
254 self.r#geo_touches.as_slice()
255 }
256 fn take_geo_touches(&mut self) -> Vec<GeoTouchesProperty> {
257 std::mem::take(&mut self.r#geo_touches)
258 }
259 fn get_geo_within(&self) -> &[GeoWithinProperty] {
260 self.r#geo_within.as_slice()
261 }
262 fn take_geo_within(&mut self) -> Vec<GeoWithinProperty> {
263 std::mem::take(&mut self.r#geo_within)
264 }
265 fn get_global_location_number(&self) -> &[GlobalLocationNumberProperty] {
266 self.r#global_location_number.as_slice()
267 }
268 fn take_global_location_number(&mut self) -> Vec<GlobalLocationNumberProperty> {
269 std::mem::take(&mut self.r#global_location_number)
270 }
271 fn get_has_drive_through_service(&self) -> &[HasDriveThroughServiceProperty] {
272 self.r#has_drive_through_service.as_slice()
273 }
274 fn take_has_drive_through_service(&mut self) -> Vec<HasDriveThroughServiceProperty> {
275 std::mem::take(&mut self.r#has_drive_through_service)
276 }
277 fn get_has_map(&self) -> &[HasMapProperty] {
278 self.r#has_map.as_slice()
279 }
280 fn take_has_map(&mut self) -> Vec<HasMapProperty> {
281 std::mem::take(&mut self.r#has_map)
282 }
283 fn get_is_accessible_for_free(&self) -> &[IsAccessibleForFreeProperty] {
284 self.r#is_accessible_for_free.as_slice()
285 }
286 fn take_is_accessible_for_free(&mut self) -> Vec<IsAccessibleForFreeProperty> {
287 std::mem::take(&mut self.r#is_accessible_for_free)
288 }
289 fn get_isic_v_4(&self) -> &[IsicV4Property] {
290 self.r#isic_v_4.as_slice()
291 }
292 fn take_isic_v_4(&mut self) -> Vec<IsicV4Property> {
293 std::mem::take(&mut self.r#isic_v_4)
294 }
295 fn get_keywords(&self) -> &[KeywordsProperty] {
296 self.r#keywords.as_slice()
297 }
298 fn take_keywords(&mut self) -> Vec<KeywordsProperty> {
299 std::mem::take(&mut self.r#keywords)
300 }
301 fn get_latitude(&self) -> &[LatitudeProperty] {
302 self.r#latitude.as_slice()
303 }
304 fn take_latitude(&mut self) -> Vec<LatitudeProperty> {
305 std::mem::take(&mut self.r#latitude)
306 }
307 fn get_logo(&self) -> &[LogoProperty] {
308 self.r#logo.as_slice()
309 }
310 fn take_logo(&mut self) -> Vec<LogoProperty> {
311 std::mem::take(&mut self.r#logo)
312 }
313 fn get_longitude(&self) -> &[LongitudeProperty] {
314 self.r#longitude.as_slice()
315 }
316 fn take_longitude(&mut self) -> Vec<LongitudeProperty> {
317 std::mem::take(&mut self.r#longitude)
318 }
319 fn get_map(&self) -> &[MapProperty] {
320 self.r#map.as_slice()
321 }
322 fn take_map(&mut self) -> Vec<MapProperty> {
323 std::mem::take(&mut self.r#map)
324 }
325 fn get_maps(&self) -> &[MapsProperty] {
326 self.r#maps.as_slice()
327 }
328 fn take_maps(&mut self) -> Vec<MapsProperty> {
329 std::mem::take(&mut self.r#maps)
330 }
331 fn get_maximum_attendee_capacity(&self) -> &[MaximumAttendeeCapacityProperty] {
332 self.r#maximum_attendee_capacity.as_slice()
333 }
334 fn take_maximum_attendee_capacity(&mut self) -> Vec<MaximumAttendeeCapacityProperty> {
335 std::mem::take(&mut self.r#maximum_attendee_capacity)
336 }
337 fn get_opening_hours_specification(&self) -> &[OpeningHoursSpecificationProperty] {
338 self.r#opening_hours_specification.as_slice()
339 }
340 fn take_opening_hours_specification(&mut self) -> Vec<OpeningHoursSpecificationProperty> {
341 std::mem::take(&mut self.r#opening_hours_specification)
342 }
343 fn get_photo(&self) -> &[PhotoProperty] {
344 self.r#photo.as_slice()
345 }
346 fn take_photo(&mut self) -> Vec<PhotoProperty> {
347 std::mem::take(&mut self.r#photo)
348 }
349 fn get_photos(&self) -> &[PhotosProperty] {
350 self.r#photos.as_slice()
351 }
352 fn take_photos(&mut self) -> Vec<PhotosProperty> {
353 std::mem::take(&mut self.r#photos)
354 }
355 fn get_public_access(&self) -> &[PublicAccessProperty] {
356 self.r#public_access.as_slice()
357 }
358 fn take_public_access(&mut self) -> Vec<PublicAccessProperty> {
359 std::mem::take(&mut self.r#public_access)
360 }
361 fn get_review(&self) -> &[ReviewProperty] {
362 self.r#review.as_slice()
363 }
364 fn take_review(&mut self) -> Vec<ReviewProperty> {
365 std::mem::take(&mut self.r#review)
366 }
367 fn get_reviews(&self) -> &[ReviewsProperty] {
368 self.r#reviews.as_slice()
369 }
370 fn take_reviews(&mut self) -> Vec<ReviewsProperty> {
371 std::mem::take(&mut self.r#reviews)
372 }
373 fn get_slogan(&self) -> &[SloganProperty] {
374 self.r#slogan.as_slice()
375 }
376 fn take_slogan(&mut self) -> Vec<SloganProperty> {
377 std::mem::take(&mut self.r#slogan)
378 }
379 fn get_smoking_allowed(&self) -> &[SmokingAllowedProperty] {
380 self.r#smoking_allowed.as_slice()
381 }
382 fn take_smoking_allowed(&mut self) -> Vec<SmokingAllowedProperty> {
383 std::mem::take(&mut self.r#smoking_allowed)
384 }
385 fn get_special_opening_hours_specification(
386 &self,
387 ) -> &[SpecialOpeningHoursSpecificationProperty] {
388 self.r#special_opening_hours_specification.as_slice()
389 }
390 fn take_special_opening_hours_specification(
391 &mut self,
392 ) -> Vec<SpecialOpeningHoursSpecificationProperty> {
393 std::mem::take(&mut self.r#special_opening_hours_specification)
394 }
395 fn get_telephone(&self) -> &[TelephoneProperty] {
396 self.r#telephone.as_slice()
397 }
398 fn take_telephone(&mut self) -> Vec<TelephoneProperty> {
399 std::mem::take(&mut self.r#telephone)
400 }
401 fn get_tour_booking_page(&self) -> &[TourBookingPageProperty] {
402 self.r#tour_booking_page.as_slice()
403 }
404 fn take_tour_booking_page(&mut self) -> Vec<TourBookingPageProperty> {
405 std::mem::take(&mut self.r#tour_booking_page)
406 }
407}
408impl ThingTrait for Canal {
409 fn get_additional_type(&self) -> &[AdditionalTypeProperty] {
410 self.r#additional_type.as_slice()
411 }
412 fn take_additional_type(&mut self) -> Vec<AdditionalTypeProperty> {
413 std::mem::take(&mut self.r#additional_type)
414 }
415 fn get_alternate_name(&self) -> &[AlternateNameProperty] {
416 self.r#alternate_name.as_slice()
417 }
418 fn take_alternate_name(&mut self) -> Vec<AlternateNameProperty> {
419 std::mem::take(&mut self.r#alternate_name)
420 }
421 fn get_description(&self) -> &[DescriptionProperty] {
422 self.r#description.as_slice()
423 }
424 fn take_description(&mut self) -> Vec<DescriptionProperty> {
425 std::mem::take(&mut self.r#description)
426 }
427 fn get_disambiguating_description(&self) -> &[DisambiguatingDescriptionProperty] {
428 self.r#disambiguating_description.as_slice()
429 }
430 fn take_disambiguating_description(&mut self) -> Vec<DisambiguatingDescriptionProperty> {
431 std::mem::take(&mut self.r#disambiguating_description)
432 }
433 fn get_identifier(&self) -> &[IdentifierProperty] {
434 self.r#identifier.as_slice()
435 }
436 fn take_identifier(&mut self) -> Vec<IdentifierProperty> {
437 std::mem::take(&mut self.r#identifier)
438 }
439 fn get_image(&self) -> &[ImageProperty] {
440 self.r#image.as_slice()
441 }
442 fn take_image(&mut self) -> Vec<ImageProperty> {
443 std::mem::take(&mut self.r#image)
444 }
445 fn get_main_entity_of_page(&self) -> &[MainEntityOfPageProperty] {
446 self.r#main_entity_of_page.as_slice()
447 }
448 fn take_main_entity_of_page(&mut self) -> Vec<MainEntityOfPageProperty> {
449 std::mem::take(&mut self.r#main_entity_of_page)
450 }
451 fn get_name(&self) -> &[NameProperty] {
452 self.r#name.as_slice()
453 }
454 fn take_name(&mut self) -> Vec<NameProperty> {
455 std::mem::take(&mut self.r#name)
456 }
457 fn get_potential_action(&self) -> &[PotentialActionProperty] {
458 self.r#potential_action.as_slice()
459 }
460 fn take_potential_action(&mut self) -> Vec<PotentialActionProperty> {
461 std::mem::take(&mut self.r#potential_action)
462 }
463 fn get_same_as(&self) -> &[SameAsProperty] {
464 self.r#same_as.as_slice()
465 }
466 fn take_same_as(&mut self) -> Vec<SameAsProperty> {
467 std::mem::take(&mut self.r#same_as)
468 }
469 fn get_subject_of(&self) -> &[SubjectOfProperty] {
470 self.r#subject_of.as_slice()
471 }
472 fn take_subject_of(&mut self) -> Vec<SubjectOfProperty> {
473 std::mem::take(&mut self.r#subject_of)
474 }
475 fn get_url(&self) -> &[UrlProperty] {
476 self.r#url.as_slice()
477 }
478 fn take_url(&mut self) -> Vec<UrlProperty> {
479 std::mem::take(&mut self.r#url)
480 }
481}
482#[cfg(feature = "serde")]
483mod serde {
484 use std::{fmt, fmt::Formatter};
485
486 use ::serde::{
487 de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
488 };
489
490 use super::*;
491 impl Serialize for Canal {
492 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
493 where
494 S: Serializer,
495 {
496 let len: usize = [
497 !Vec::is_empty(&self.r#additional_property) as usize,
498 !Vec::is_empty(&self.r#address) as usize,
499 !Vec::is_empty(&self.r#aggregate_rating) as usize,
500 !Vec::is_empty(&self.r#amenity_feature) as usize,
501 !Vec::is_empty(&self.r#branch_code) as usize,
502 !Vec::is_empty(&self.r#contained_in) as usize,
503 !Vec::is_empty(&self.r#contained_in_place) as usize,
504 !Vec::is_empty(&self.r#contains_place) as usize,
505 !Vec::is_empty(&self.r#event) as usize,
506 !Vec::is_empty(&self.r#events) as usize,
507 !Vec::is_empty(&self.r#fax_number) as usize,
508 !Vec::is_empty(&self.r#geo) as usize,
509 !Vec::is_empty(&self.r#geo_contains) as usize,
510 !Vec::is_empty(&self.r#geo_covered_by) as usize,
511 !Vec::is_empty(&self.r#geo_covers) as usize,
512 !Vec::is_empty(&self.r#geo_crosses) as usize,
513 !Vec::is_empty(&self.r#geo_disjoint) as usize,
514 !Vec::is_empty(&self.r#geo_equals) as usize,
515 !Vec::is_empty(&self.r#geo_intersects) as usize,
516 !Vec::is_empty(&self.r#geo_overlaps) as usize,
517 !Vec::is_empty(&self.r#geo_touches) as usize,
518 !Vec::is_empty(&self.r#geo_within) as usize,
519 !Vec::is_empty(&self.r#global_location_number) as usize,
520 !Vec::is_empty(&self.r#has_drive_through_service) as usize,
521 !Vec::is_empty(&self.r#has_map) as usize,
522 !Vec::is_empty(&self.r#is_accessible_for_free) as usize,
523 !Vec::is_empty(&self.r#isic_v_4) as usize,
524 !Vec::is_empty(&self.r#keywords) as usize,
525 !Vec::is_empty(&self.r#latitude) as usize,
526 !Vec::is_empty(&self.r#logo) as usize,
527 !Vec::is_empty(&self.r#longitude) as usize,
528 !Vec::is_empty(&self.r#map) as usize,
529 !Vec::is_empty(&self.r#maps) as usize,
530 !Vec::is_empty(&self.r#maximum_attendee_capacity) as usize,
531 !Vec::is_empty(&self.r#opening_hours_specification) as usize,
532 !Vec::is_empty(&self.r#photo) as usize,
533 !Vec::is_empty(&self.r#photos) as usize,
534 !Vec::is_empty(&self.r#public_access) as usize,
535 !Vec::is_empty(&self.r#review) as usize,
536 !Vec::is_empty(&self.r#reviews) as usize,
537 !Vec::is_empty(&self.r#slogan) as usize,
538 !Vec::is_empty(&self.r#smoking_allowed) as usize,
539 !Vec::is_empty(&self.r#special_opening_hours_specification) as usize,
540 !Vec::is_empty(&self.r#telephone) as usize,
541 !Vec::is_empty(&self.r#tour_booking_page) as usize,
542 !Vec::is_empty(&self.r#additional_type) as usize,
543 !Vec::is_empty(&self.r#alternate_name) as usize,
544 !Vec::is_empty(&self.r#description) as usize,
545 !Vec::is_empty(&self.r#disambiguating_description) as usize,
546 !Vec::is_empty(&self.r#identifier) as usize,
547 !Vec::is_empty(&self.r#image) as usize,
548 !Vec::is_empty(&self.r#main_entity_of_page) as usize,
549 !Vec::is_empty(&self.r#name) as usize,
550 !Vec::is_empty(&self.r#potential_action) as usize,
551 !Vec::is_empty(&self.r#same_as) as usize,
552 !Vec::is_empty(&self.r#subject_of) as usize,
553 !Vec::is_empty(&self.r#url) as usize,
554 ]
555 .iter()
556 .sum();
557 let mut serialize_struct = Serializer::serialize_struct(serializer, "Canal", len)?;
558 if !Vec::is_empty(&self.r#additional_property) {
559 serialize_struct.serialize_field("additionalProperty", {
560 struct SerializeWith<'a>(&'a Vec<AdditionalPropertyProperty>);
561 impl<'a> Serialize for SerializeWith<'a> {
562 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
563 where
564 S: Serializer,
565 {
566 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
567 self.0, serializer,
568 )
569 }
570 }
571 &SerializeWith(&self.r#additional_property)
572 })?;
573 } else {
574 serialize_struct.skip_field("additionalProperty")?;
575 }
576 if !Vec::is_empty(&self.r#address) {
577 serialize_struct.serialize_field("address", {
578 struct SerializeWith<'a>(&'a Vec<AddressProperty>);
579 impl<'a> Serialize for SerializeWith<'a> {
580 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
581 where
582 S: Serializer,
583 {
584 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
585 self.0, serializer,
586 )
587 }
588 }
589 &SerializeWith(&self.r#address)
590 })?;
591 } else {
592 serialize_struct.skip_field("address")?;
593 }
594 if !Vec::is_empty(&self.r#aggregate_rating) {
595 serialize_struct.serialize_field("aggregateRating", {
596 struct SerializeWith<'a>(&'a Vec<AggregateRatingProperty>);
597 impl<'a> Serialize for SerializeWith<'a> {
598 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
599 where
600 S: Serializer,
601 {
602 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
603 self.0, serializer,
604 )
605 }
606 }
607 &SerializeWith(&self.r#aggregate_rating)
608 })?;
609 } else {
610 serialize_struct.skip_field("aggregateRating")?;
611 }
612 if !Vec::is_empty(&self.r#amenity_feature) {
613 serialize_struct.serialize_field("amenityFeature", {
614 struct SerializeWith<'a>(&'a Vec<AmenityFeatureProperty>);
615 impl<'a> Serialize for SerializeWith<'a> {
616 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
617 where
618 S: Serializer,
619 {
620 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
621 self.0, serializer,
622 )
623 }
624 }
625 &SerializeWith(&self.r#amenity_feature)
626 })?;
627 } else {
628 serialize_struct.skip_field("amenityFeature")?;
629 }
630 if !Vec::is_empty(&self.r#branch_code) {
631 serialize_struct.serialize_field("branchCode", {
632 struct SerializeWith<'a>(&'a Vec<BranchCodeProperty>);
633 impl<'a> Serialize for SerializeWith<'a> {
634 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
635 where
636 S: Serializer,
637 {
638 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
639 self.0, serializer,
640 )
641 }
642 }
643 &SerializeWith(&self.r#branch_code)
644 })?;
645 } else {
646 serialize_struct.skip_field("branchCode")?;
647 }
648 if !Vec::is_empty(&self.r#contained_in) {
649 serialize_struct.serialize_field("containedIn", {
650 struct SerializeWith<'a>(&'a Vec<ContainedInProperty>);
651 impl<'a> Serialize for SerializeWith<'a> {
652 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
653 where
654 S: Serializer,
655 {
656 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
657 self.0, serializer,
658 )
659 }
660 }
661 &SerializeWith(&self.r#contained_in)
662 })?;
663 } else {
664 serialize_struct.skip_field("containedIn")?;
665 }
666 if !Vec::is_empty(&self.r#contained_in_place) {
667 serialize_struct.serialize_field("containedInPlace", {
668 struct SerializeWith<'a>(&'a Vec<ContainedInPlaceProperty>);
669 impl<'a> Serialize for SerializeWith<'a> {
670 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
671 where
672 S: Serializer,
673 {
674 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
675 self.0, serializer,
676 )
677 }
678 }
679 &SerializeWith(&self.r#contained_in_place)
680 })?;
681 } else {
682 serialize_struct.skip_field("containedInPlace")?;
683 }
684 if !Vec::is_empty(&self.r#contains_place) {
685 serialize_struct.serialize_field("containsPlace", {
686 struct SerializeWith<'a>(&'a Vec<ContainsPlaceProperty>);
687 impl<'a> Serialize for SerializeWith<'a> {
688 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
689 where
690 S: Serializer,
691 {
692 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
693 self.0, serializer,
694 )
695 }
696 }
697 &SerializeWith(&self.r#contains_place)
698 })?;
699 } else {
700 serialize_struct.skip_field("containsPlace")?;
701 }
702 if !Vec::is_empty(&self.r#event) {
703 serialize_struct.serialize_field("event", {
704 struct SerializeWith<'a>(&'a Vec<EventProperty>);
705 impl<'a> Serialize for SerializeWith<'a> {
706 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
707 where
708 S: Serializer,
709 {
710 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
711 self.0, serializer,
712 )
713 }
714 }
715 &SerializeWith(&self.r#event)
716 })?;
717 } else {
718 serialize_struct.skip_field("event")?;
719 }
720 if !Vec::is_empty(&self.r#events) {
721 serialize_struct.serialize_field("events", {
722 struct SerializeWith<'a>(&'a Vec<EventsProperty>);
723 impl<'a> Serialize for SerializeWith<'a> {
724 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
725 where
726 S: Serializer,
727 {
728 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
729 self.0, serializer,
730 )
731 }
732 }
733 &SerializeWith(&self.r#events)
734 })?;
735 } else {
736 serialize_struct.skip_field("events")?;
737 }
738 if !Vec::is_empty(&self.r#fax_number) {
739 serialize_struct.serialize_field("faxNumber", {
740 struct SerializeWith<'a>(&'a Vec<FaxNumberProperty>);
741 impl<'a> Serialize for SerializeWith<'a> {
742 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
743 where
744 S: Serializer,
745 {
746 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
747 self.0, serializer,
748 )
749 }
750 }
751 &SerializeWith(&self.r#fax_number)
752 })?;
753 } else {
754 serialize_struct.skip_field("faxNumber")?;
755 }
756 if !Vec::is_empty(&self.r#geo) {
757 serialize_struct.serialize_field("geo", {
758 struct SerializeWith<'a>(&'a Vec<GeoProperty>);
759 impl<'a> Serialize for SerializeWith<'a> {
760 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
761 where
762 S: Serializer,
763 {
764 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
765 self.0, serializer,
766 )
767 }
768 }
769 &SerializeWith(&self.r#geo)
770 })?;
771 } else {
772 serialize_struct.skip_field("geo")?;
773 }
774 if !Vec::is_empty(&self.r#geo_contains) {
775 serialize_struct.serialize_field("geoContains", {
776 struct SerializeWith<'a>(&'a Vec<GeoContainsProperty>);
777 impl<'a> Serialize for SerializeWith<'a> {
778 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
779 where
780 S: Serializer,
781 {
782 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
783 self.0, serializer,
784 )
785 }
786 }
787 &SerializeWith(&self.r#geo_contains)
788 })?;
789 } else {
790 serialize_struct.skip_field("geoContains")?;
791 }
792 if !Vec::is_empty(&self.r#geo_covered_by) {
793 serialize_struct.serialize_field("geoCoveredBy", {
794 struct SerializeWith<'a>(&'a Vec<GeoCoveredByProperty>);
795 impl<'a> Serialize for SerializeWith<'a> {
796 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
797 where
798 S: Serializer,
799 {
800 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
801 self.0, serializer,
802 )
803 }
804 }
805 &SerializeWith(&self.r#geo_covered_by)
806 })?;
807 } else {
808 serialize_struct.skip_field("geoCoveredBy")?;
809 }
810 if !Vec::is_empty(&self.r#geo_covers) {
811 serialize_struct.serialize_field("geoCovers", {
812 struct SerializeWith<'a>(&'a Vec<GeoCoversProperty>);
813 impl<'a> Serialize for SerializeWith<'a> {
814 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
815 where
816 S: Serializer,
817 {
818 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
819 self.0, serializer,
820 )
821 }
822 }
823 &SerializeWith(&self.r#geo_covers)
824 })?;
825 } else {
826 serialize_struct.skip_field("geoCovers")?;
827 }
828 if !Vec::is_empty(&self.r#geo_crosses) {
829 serialize_struct.serialize_field("geoCrosses", {
830 struct SerializeWith<'a>(&'a Vec<GeoCrossesProperty>);
831 impl<'a> Serialize for SerializeWith<'a> {
832 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
833 where
834 S: Serializer,
835 {
836 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
837 self.0, serializer,
838 )
839 }
840 }
841 &SerializeWith(&self.r#geo_crosses)
842 })?;
843 } else {
844 serialize_struct.skip_field("geoCrosses")?;
845 }
846 if !Vec::is_empty(&self.r#geo_disjoint) {
847 serialize_struct.serialize_field("geoDisjoint", {
848 struct SerializeWith<'a>(&'a Vec<GeoDisjointProperty>);
849 impl<'a> Serialize for SerializeWith<'a> {
850 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
851 where
852 S: Serializer,
853 {
854 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
855 self.0, serializer,
856 )
857 }
858 }
859 &SerializeWith(&self.r#geo_disjoint)
860 })?;
861 } else {
862 serialize_struct.skip_field("geoDisjoint")?;
863 }
864 if !Vec::is_empty(&self.r#geo_equals) {
865 serialize_struct.serialize_field("geoEquals", {
866 struct SerializeWith<'a>(&'a Vec<GeoEqualsProperty>);
867 impl<'a> Serialize for SerializeWith<'a> {
868 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
869 where
870 S: Serializer,
871 {
872 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
873 self.0, serializer,
874 )
875 }
876 }
877 &SerializeWith(&self.r#geo_equals)
878 })?;
879 } else {
880 serialize_struct.skip_field("geoEquals")?;
881 }
882 if !Vec::is_empty(&self.r#geo_intersects) {
883 serialize_struct.serialize_field("geoIntersects", {
884 struct SerializeWith<'a>(&'a Vec<GeoIntersectsProperty>);
885 impl<'a> Serialize for SerializeWith<'a> {
886 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
887 where
888 S: Serializer,
889 {
890 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
891 self.0, serializer,
892 )
893 }
894 }
895 &SerializeWith(&self.r#geo_intersects)
896 })?;
897 } else {
898 serialize_struct.skip_field("geoIntersects")?;
899 }
900 if !Vec::is_empty(&self.r#geo_overlaps) {
901 serialize_struct.serialize_field("geoOverlaps", {
902 struct SerializeWith<'a>(&'a Vec<GeoOverlapsProperty>);
903 impl<'a> Serialize for SerializeWith<'a> {
904 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
905 where
906 S: Serializer,
907 {
908 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
909 self.0, serializer,
910 )
911 }
912 }
913 &SerializeWith(&self.r#geo_overlaps)
914 })?;
915 } else {
916 serialize_struct.skip_field("geoOverlaps")?;
917 }
918 if !Vec::is_empty(&self.r#geo_touches) {
919 serialize_struct.serialize_field("geoTouches", {
920 struct SerializeWith<'a>(&'a Vec<GeoTouchesProperty>);
921 impl<'a> Serialize for SerializeWith<'a> {
922 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
923 where
924 S: Serializer,
925 {
926 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
927 self.0, serializer,
928 )
929 }
930 }
931 &SerializeWith(&self.r#geo_touches)
932 })?;
933 } else {
934 serialize_struct.skip_field("geoTouches")?;
935 }
936 if !Vec::is_empty(&self.r#geo_within) {
937 serialize_struct.serialize_field("geoWithin", {
938 struct SerializeWith<'a>(&'a Vec<GeoWithinProperty>);
939 impl<'a> Serialize for SerializeWith<'a> {
940 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
941 where
942 S: Serializer,
943 {
944 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
945 self.0, serializer,
946 )
947 }
948 }
949 &SerializeWith(&self.r#geo_within)
950 })?;
951 } else {
952 serialize_struct.skip_field("geoWithin")?;
953 }
954 if !Vec::is_empty(&self.r#global_location_number) {
955 serialize_struct.serialize_field("globalLocationNumber", {
956 struct SerializeWith<'a>(&'a Vec<GlobalLocationNumberProperty>);
957 impl<'a> Serialize for SerializeWith<'a> {
958 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
959 where
960 S: Serializer,
961 {
962 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
963 self.0, serializer,
964 )
965 }
966 }
967 &SerializeWith(&self.r#global_location_number)
968 })?;
969 } else {
970 serialize_struct.skip_field("globalLocationNumber")?;
971 }
972 if !Vec::is_empty(&self.r#has_drive_through_service) {
973 serialize_struct.serialize_field("hasDriveThroughService", {
974 struct SerializeWith<'a>(&'a Vec<HasDriveThroughServiceProperty>);
975 impl<'a> Serialize for SerializeWith<'a> {
976 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
977 where
978 S: Serializer,
979 {
980 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
981 self.0, serializer,
982 )
983 }
984 }
985 &SerializeWith(&self.r#has_drive_through_service)
986 })?;
987 } else {
988 serialize_struct.skip_field("hasDriveThroughService")?;
989 }
990 if !Vec::is_empty(&self.r#has_map) {
991 serialize_struct.serialize_field("hasMap", {
992 struct SerializeWith<'a>(&'a Vec<HasMapProperty>);
993 impl<'a> Serialize for SerializeWith<'a> {
994 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
995 where
996 S: Serializer,
997 {
998 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
999 self.0, serializer,
1000 )
1001 }
1002 }
1003 &SerializeWith(&self.r#has_map)
1004 })?;
1005 } else {
1006 serialize_struct.skip_field("hasMap")?;
1007 }
1008 if !Vec::is_empty(&self.r#is_accessible_for_free) {
1009 serialize_struct.serialize_field("isAccessibleForFree", {
1010 struct SerializeWith<'a>(&'a Vec<IsAccessibleForFreeProperty>);
1011 impl<'a> Serialize for SerializeWith<'a> {
1012 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1013 where
1014 S: Serializer,
1015 {
1016 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1017 self.0, serializer,
1018 )
1019 }
1020 }
1021 &SerializeWith(&self.r#is_accessible_for_free)
1022 })?;
1023 } else {
1024 serialize_struct.skip_field("isAccessibleForFree")?;
1025 }
1026 if !Vec::is_empty(&self.r#isic_v_4) {
1027 serialize_struct.serialize_field("isicV4", {
1028 struct SerializeWith<'a>(&'a Vec<IsicV4Property>);
1029 impl<'a> Serialize for SerializeWith<'a> {
1030 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1031 where
1032 S: Serializer,
1033 {
1034 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1035 self.0, serializer,
1036 )
1037 }
1038 }
1039 &SerializeWith(&self.r#isic_v_4)
1040 })?;
1041 } else {
1042 serialize_struct.skip_field("isicV4")?;
1043 }
1044 if !Vec::is_empty(&self.r#keywords) {
1045 serialize_struct.serialize_field("keywords", {
1046 struct SerializeWith<'a>(&'a Vec<KeywordsProperty>);
1047 impl<'a> Serialize for SerializeWith<'a> {
1048 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1049 where
1050 S: Serializer,
1051 {
1052 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1053 self.0, serializer,
1054 )
1055 }
1056 }
1057 &SerializeWith(&self.r#keywords)
1058 })?;
1059 } else {
1060 serialize_struct.skip_field("keywords")?;
1061 }
1062 if !Vec::is_empty(&self.r#latitude) {
1063 serialize_struct.serialize_field("latitude", {
1064 struct SerializeWith<'a>(&'a Vec<LatitudeProperty>);
1065 impl<'a> Serialize for SerializeWith<'a> {
1066 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1067 where
1068 S: Serializer,
1069 {
1070 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1071 self.0, serializer,
1072 )
1073 }
1074 }
1075 &SerializeWith(&self.r#latitude)
1076 })?;
1077 } else {
1078 serialize_struct.skip_field("latitude")?;
1079 }
1080 if !Vec::is_empty(&self.r#logo) {
1081 serialize_struct.serialize_field("logo", {
1082 struct SerializeWith<'a>(&'a Vec<LogoProperty>);
1083 impl<'a> Serialize for SerializeWith<'a> {
1084 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1085 where
1086 S: Serializer,
1087 {
1088 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1089 self.0, serializer,
1090 )
1091 }
1092 }
1093 &SerializeWith(&self.r#logo)
1094 })?;
1095 } else {
1096 serialize_struct.skip_field("logo")?;
1097 }
1098 if !Vec::is_empty(&self.r#longitude) {
1099 serialize_struct.serialize_field("longitude", {
1100 struct SerializeWith<'a>(&'a Vec<LongitudeProperty>);
1101 impl<'a> Serialize for SerializeWith<'a> {
1102 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1103 where
1104 S: Serializer,
1105 {
1106 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1107 self.0, serializer,
1108 )
1109 }
1110 }
1111 &SerializeWith(&self.r#longitude)
1112 })?;
1113 } else {
1114 serialize_struct.skip_field("longitude")?;
1115 }
1116 if !Vec::is_empty(&self.r#map) {
1117 serialize_struct.serialize_field("map", {
1118 struct SerializeWith<'a>(&'a Vec<MapProperty>);
1119 impl<'a> Serialize for SerializeWith<'a> {
1120 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1121 where
1122 S: Serializer,
1123 {
1124 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1125 self.0, serializer,
1126 )
1127 }
1128 }
1129 &SerializeWith(&self.r#map)
1130 })?;
1131 } else {
1132 serialize_struct.skip_field("map")?;
1133 }
1134 if !Vec::is_empty(&self.r#maps) {
1135 serialize_struct.serialize_field("maps", {
1136 struct SerializeWith<'a>(&'a Vec<MapsProperty>);
1137 impl<'a> Serialize for SerializeWith<'a> {
1138 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1139 where
1140 S: Serializer,
1141 {
1142 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1143 self.0, serializer,
1144 )
1145 }
1146 }
1147 &SerializeWith(&self.r#maps)
1148 })?;
1149 } else {
1150 serialize_struct.skip_field("maps")?;
1151 }
1152 if !Vec::is_empty(&self.r#maximum_attendee_capacity) {
1153 serialize_struct.serialize_field("maximumAttendeeCapacity", {
1154 struct SerializeWith<'a>(&'a Vec<MaximumAttendeeCapacityProperty>);
1155 impl<'a> Serialize for SerializeWith<'a> {
1156 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1157 where
1158 S: Serializer,
1159 {
1160 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1161 self.0, serializer,
1162 )
1163 }
1164 }
1165 &SerializeWith(&self.r#maximum_attendee_capacity)
1166 })?;
1167 } else {
1168 serialize_struct.skip_field("maximumAttendeeCapacity")?;
1169 }
1170 if !Vec::is_empty(&self.r#opening_hours_specification) {
1171 serialize_struct.serialize_field("openingHoursSpecification", {
1172 struct SerializeWith<'a>(&'a Vec<OpeningHoursSpecificationProperty>);
1173 impl<'a> Serialize for SerializeWith<'a> {
1174 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1175 where
1176 S: Serializer,
1177 {
1178 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1179 self.0, serializer,
1180 )
1181 }
1182 }
1183 &SerializeWith(&self.r#opening_hours_specification)
1184 })?;
1185 } else {
1186 serialize_struct.skip_field("openingHoursSpecification")?;
1187 }
1188 if !Vec::is_empty(&self.r#photo) {
1189 serialize_struct.serialize_field("photo", {
1190 struct SerializeWith<'a>(&'a Vec<PhotoProperty>);
1191 impl<'a> Serialize for SerializeWith<'a> {
1192 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1193 where
1194 S: Serializer,
1195 {
1196 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1197 self.0, serializer,
1198 )
1199 }
1200 }
1201 &SerializeWith(&self.r#photo)
1202 })?;
1203 } else {
1204 serialize_struct.skip_field("photo")?;
1205 }
1206 if !Vec::is_empty(&self.r#photos) {
1207 serialize_struct.serialize_field("photos", {
1208 struct SerializeWith<'a>(&'a Vec<PhotosProperty>);
1209 impl<'a> Serialize for SerializeWith<'a> {
1210 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1211 where
1212 S: Serializer,
1213 {
1214 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1215 self.0, serializer,
1216 )
1217 }
1218 }
1219 &SerializeWith(&self.r#photos)
1220 })?;
1221 } else {
1222 serialize_struct.skip_field("photos")?;
1223 }
1224 if !Vec::is_empty(&self.r#public_access) {
1225 serialize_struct.serialize_field("publicAccess", {
1226 struct SerializeWith<'a>(&'a Vec<PublicAccessProperty>);
1227 impl<'a> Serialize for SerializeWith<'a> {
1228 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1229 where
1230 S: Serializer,
1231 {
1232 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1233 self.0, serializer,
1234 )
1235 }
1236 }
1237 &SerializeWith(&self.r#public_access)
1238 })?;
1239 } else {
1240 serialize_struct.skip_field("publicAccess")?;
1241 }
1242 if !Vec::is_empty(&self.r#review) {
1243 serialize_struct.serialize_field("review", {
1244 struct SerializeWith<'a>(&'a Vec<ReviewProperty>);
1245 impl<'a> Serialize for SerializeWith<'a> {
1246 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1247 where
1248 S: Serializer,
1249 {
1250 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1251 self.0, serializer,
1252 )
1253 }
1254 }
1255 &SerializeWith(&self.r#review)
1256 })?;
1257 } else {
1258 serialize_struct.skip_field("review")?;
1259 }
1260 if !Vec::is_empty(&self.r#reviews) {
1261 serialize_struct.serialize_field("reviews", {
1262 struct SerializeWith<'a>(&'a Vec<ReviewsProperty>);
1263 impl<'a> Serialize for SerializeWith<'a> {
1264 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1265 where
1266 S: Serializer,
1267 {
1268 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1269 self.0, serializer,
1270 )
1271 }
1272 }
1273 &SerializeWith(&self.r#reviews)
1274 })?;
1275 } else {
1276 serialize_struct.skip_field("reviews")?;
1277 }
1278 if !Vec::is_empty(&self.r#slogan) {
1279 serialize_struct.serialize_field("slogan", {
1280 struct SerializeWith<'a>(&'a Vec<SloganProperty>);
1281 impl<'a> Serialize for SerializeWith<'a> {
1282 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1283 where
1284 S: Serializer,
1285 {
1286 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1287 self.0, serializer,
1288 )
1289 }
1290 }
1291 &SerializeWith(&self.r#slogan)
1292 })?;
1293 } else {
1294 serialize_struct.skip_field("slogan")?;
1295 }
1296 if !Vec::is_empty(&self.r#smoking_allowed) {
1297 serialize_struct.serialize_field("smokingAllowed", {
1298 struct SerializeWith<'a>(&'a Vec<SmokingAllowedProperty>);
1299 impl<'a> Serialize for SerializeWith<'a> {
1300 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1301 where
1302 S: Serializer,
1303 {
1304 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1305 self.0, serializer,
1306 )
1307 }
1308 }
1309 &SerializeWith(&self.r#smoking_allowed)
1310 })?;
1311 } else {
1312 serialize_struct.skip_field("smokingAllowed")?;
1313 }
1314 if !Vec::is_empty(&self.r#special_opening_hours_specification) {
1315 serialize_struct.serialize_field("specialOpeningHoursSpecification", {
1316 struct SerializeWith<'a>(&'a Vec<SpecialOpeningHoursSpecificationProperty>);
1317 impl<'a> Serialize for SerializeWith<'a> {
1318 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1319 where
1320 S: Serializer,
1321 {
1322 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1323 self.0, serializer,
1324 )
1325 }
1326 }
1327 &SerializeWith(&self.r#special_opening_hours_specification)
1328 })?;
1329 } else {
1330 serialize_struct.skip_field("specialOpeningHoursSpecification")?;
1331 }
1332 if !Vec::is_empty(&self.r#telephone) {
1333 serialize_struct.serialize_field("telephone", {
1334 struct SerializeWith<'a>(&'a Vec<TelephoneProperty>);
1335 impl<'a> Serialize for SerializeWith<'a> {
1336 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1337 where
1338 S: Serializer,
1339 {
1340 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1341 self.0, serializer,
1342 )
1343 }
1344 }
1345 &SerializeWith(&self.r#telephone)
1346 })?;
1347 } else {
1348 serialize_struct.skip_field("telephone")?;
1349 }
1350 if !Vec::is_empty(&self.r#tour_booking_page) {
1351 serialize_struct.serialize_field("tourBookingPage", {
1352 struct SerializeWith<'a>(&'a Vec<TourBookingPageProperty>);
1353 impl<'a> Serialize for SerializeWith<'a> {
1354 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1355 where
1356 S: Serializer,
1357 {
1358 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1359 self.0, serializer,
1360 )
1361 }
1362 }
1363 &SerializeWith(&self.r#tour_booking_page)
1364 })?;
1365 } else {
1366 serialize_struct.skip_field("tourBookingPage")?;
1367 }
1368 if !Vec::is_empty(&self.r#additional_type) {
1369 serialize_struct.serialize_field("additionalType", {
1370 struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
1371 impl<'a> Serialize for SerializeWith<'a> {
1372 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1373 where
1374 S: Serializer,
1375 {
1376 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1377 self.0, serializer,
1378 )
1379 }
1380 }
1381 &SerializeWith(&self.r#additional_type)
1382 })?;
1383 } else {
1384 serialize_struct.skip_field("additionalType")?;
1385 }
1386 if !Vec::is_empty(&self.r#alternate_name) {
1387 serialize_struct.serialize_field("alternateName", {
1388 struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
1389 impl<'a> Serialize for SerializeWith<'a> {
1390 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1391 where
1392 S: Serializer,
1393 {
1394 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1395 self.0, serializer,
1396 )
1397 }
1398 }
1399 &SerializeWith(&self.r#alternate_name)
1400 })?;
1401 } else {
1402 serialize_struct.skip_field("alternateName")?;
1403 }
1404 if !Vec::is_empty(&self.r#description) {
1405 serialize_struct.serialize_field("description", {
1406 struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
1407 impl<'a> Serialize for SerializeWith<'a> {
1408 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1409 where
1410 S: Serializer,
1411 {
1412 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1413 self.0, serializer,
1414 )
1415 }
1416 }
1417 &SerializeWith(&self.r#description)
1418 })?;
1419 } else {
1420 serialize_struct.skip_field("description")?;
1421 }
1422 if !Vec::is_empty(&self.r#disambiguating_description) {
1423 serialize_struct.serialize_field("disambiguatingDescription", {
1424 struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
1425 impl<'a> Serialize for SerializeWith<'a> {
1426 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1427 where
1428 S: Serializer,
1429 {
1430 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1431 self.0, serializer,
1432 )
1433 }
1434 }
1435 &SerializeWith(&self.r#disambiguating_description)
1436 })?;
1437 } else {
1438 serialize_struct.skip_field("disambiguatingDescription")?;
1439 }
1440 if !Vec::is_empty(&self.r#identifier) {
1441 serialize_struct.serialize_field("identifier", {
1442 struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
1443 impl<'a> Serialize for SerializeWith<'a> {
1444 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1445 where
1446 S: Serializer,
1447 {
1448 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1449 self.0, serializer,
1450 )
1451 }
1452 }
1453 &SerializeWith(&self.r#identifier)
1454 })?;
1455 } else {
1456 serialize_struct.skip_field("identifier")?;
1457 }
1458 if !Vec::is_empty(&self.r#image) {
1459 serialize_struct.serialize_field("image", {
1460 struct SerializeWith<'a>(&'a Vec<ImageProperty>);
1461 impl<'a> Serialize for SerializeWith<'a> {
1462 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1463 where
1464 S: Serializer,
1465 {
1466 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1467 self.0, serializer,
1468 )
1469 }
1470 }
1471 &SerializeWith(&self.r#image)
1472 })?;
1473 } else {
1474 serialize_struct.skip_field("image")?;
1475 }
1476 if !Vec::is_empty(&self.r#main_entity_of_page) {
1477 serialize_struct.serialize_field("mainEntityOfPage", {
1478 struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
1479 impl<'a> Serialize for SerializeWith<'a> {
1480 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1481 where
1482 S: Serializer,
1483 {
1484 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1485 self.0, serializer,
1486 )
1487 }
1488 }
1489 &SerializeWith(&self.r#main_entity_of_page)
1490 })?;
1491 } else {
1492 serialize_struct.skip_field("mainEntityOfPage")?;
1493 }
1494 if !Vec::is_empty(&self.r#name) {
1495 serialize_struct.serialize_field("name", {
1496 struct SerializeWith<'a>(&'a Vec<NameProperty>);
1497 impl<'a> Serialize for SerializeWith<'a> {
1498 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1499 where
1500 S: Serializer,
1501 {
1502 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1503 self.0, serializer,
1504 )
1505 }
1506 }
1507 &SerializeWith(&self.r#name)
1508 })?;
1509 } else {
1510 serialize_struct.skip_field("name")?;
1511 }
1512 if !Vec::is_empty(&self.r#potential_action) {
1513 serialize_struct.serialize_field("potentialAction", {
1514 struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
1515 impl<'a> Serialize for SerializeWith<'a> {
1516 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1517 where
1518 S: Serializer,
1519 {
1520 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1521 self.0, serializer,
1522 )
1523 }
1524 }
1525 &SerializeWith(&self.r#potential_action)
1526 })?;
1527 } else {
1528 serialize_struct.skip_field("potentialAction")?;
1529 }
1530 if !Vec::is_empty(&self.r#same_as) {
1531 serialize_struct.serialize_field("sameAs", {
1532 struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
1533 impl<'a> Serialize for SerializeWith<'a> {
1534 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1535 where
1536 S: Serializer,
1537 {
1538 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1539 self.0, serializer,
1540 )
1541 }
1542 }
1543 &SerializeWith(&self.r#same_as)
1544 })?;
1545 } else {
1546 serialize_struct.skip_field("sameAs")?;
1547 }
1548 if !Vec::is_empty(&self.r#subject_of) {
1549 serialize_struct.serialize_field("subjectOf", {
1550 struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
1551 impl<'a> Serialize for SerializeWith<'a> {
1552 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1553 where
1554 S: Serializer,
1555 {
1556 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1557 self.0, serializer,
1558 )
1559 }
1560 }
1561 &SerializeWith(&self.r#subject_of)
1562 })?;
1563 } else {
1564 serialize_struct.skip_field("subjectOf")?;
1565 }
1566 if !Vec::is_empty(&self.r#url) {
1567 serialize_struct.serialize_field("url", {
1568 struct SerializeWith<'a>(&'a Vec<UrlProperty>);
1569 impl<'a> Serialize for SerializeWith<'a> {
1570 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1571 where
1572 S: Serializer,
1573 {
1574 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1575 self.0, serializer,
1576 )
1577 }
1578 }
1579 &SerializeWith(&self.r#url)
1580 })?;
1581 } else {
1582 serialize_struct.skip_field("url")?;
1583 }
1584 serialize_struct.end()
1585 }
1586 }
1587 impl<'de> Deserialize<'de> for Canal {
1588 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1589 where
1590 D: Deserializer<'de>,
1591 {
1592 enum Field {
1593 AdditionalProperty,
1594 Address,
1595 AggregateRating,
1596 AmenityFeature,
1597 BranchCode,
1598 ContainedIn,
1599 ContainedInPlace,
1600 ContainsPlace,
1601 Event,
1602 Events,
1603 FaxNumber,
1604 Geo,
1605 GeoContains,
1606 GeoCoveredBy,
1607 GeoCovers,
1608 GeoCrosses,
1609 GeoDisjoint,
1610 GeoEquals,
1611 GeoIntersects,
1612 GeoOverlaps,
1613 GeoTouches,
1614 GeoWithin,
1615 GlobalLocationNumber,
1616 HasDriveThroughService,
1617 HasMap,
1618 IsAccessibleForFree,
1619 IsicV4,
1620 Keywords,
1621 Latitude,
1622 Logo,
1623 Longitude,
1624 Map,
1625 Maps,
1626 MaximumAttendeeCapacity,
1627 OpeningHoursSpecification,
1628 Photo,
1629 Photos,
1630 PublicAccess,
1631 Review,
1632 Reviews,
1633 Slogan,
1634 SmokingAllowed,
1635 SpecialOpeningHoursSpecification,
1636 Telephone,
1637 TourBookingPage,
1638 AdditionalType,
1639 AlternateName,
1640 Description,
1641 DisambiguatingDescription,
1642 Identifier,
1643 Image,
1644 MainEntityOfPage,
1645 Name,
1646 PotentialAction,
1647 SameAs,
1648 SubjectOf,
1649 Url,
1650 Ignore,
1651 }
1652 struct FieldVisitor;
1653 impl<'de> Visitor<'de> for FieldVisitor {
1654 type Value = Field;
1655 fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
1656 formatter.write_str("field identifier")
1657 }
1658 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
1659 where
1660 E: de::Error,
1661 {
1662 match value {
1663 "additionalProperty" => Ok(Field::AdditionalProperty),
1664 "address" => Ok(Field::Address),
1665 "aggregateRating" => Ok(Field::AggregateRating),
1666 "amenityFeature" => Ok(Field::AmenityFeature),
1667 "branchCode" => Ok(Field::BranchCode),
1668 "containedIn" => Ok(Field::ContainedIn),
1669 "containedInPlace" => Ok(Field::ContainedInPlace),
1670 "containsPlace" => Ok(Field::ContainsPlace),
1671 "event" => Ok(Field::Event),
1672 "events" => Ok(Field::Events),
1673 "faxNumber" => Ok(Field::FaxNumber),
1674 "geo" => Ok(Field::Geo),
1675 "geoContains" => Ok(Field::GeoContains),
1676 "geoCoveredBy" => Ok(Field::GeoCoveredBy),
1677 "geoCovers" => Ok(Field::GeoCovers),
1678 "geoCrosses" => Ok(Field::GeoCrosses),
1679 "geoDisjoint" => Ok(Field::GeoDisjoint),
1680 "geoEquals" => Ok(Field::GeoEquals),
1681 "geoIntersects" => Ok(Field::GeoIntersects),
1682 "geoOverlaps" => Ok(Field::GeoOverlaps),
1683 "geoTouches" => Ok(Field::GeoTouches),
1684 "geoWithin" => Ok(Field::GeoWithin),
1685 "globalLocationNumber" => Ok(Field::GlobalLocationNumber),
1686 "hasDriveThroughService" => Ok(Field::HasDriveThroughService),
1687 "hasMap" => Ok(Field::HasMap),
1688 "isAccessibleForFree" => Ok(Field::IsAccessibleForFree),
1689 "isicV4" => Ok(Field::IsicV4),
1690 "keywords" => Ok(Field::Keywords),
1691 "latitude" => Ok(Field::Latitude),
1692 "logo" => Ok(Field::Logo),
1693 "longitude" => Ok(Field::Longitude),
1694 "map" => Ok(Field::Map),
1695 "maps" => Ok(Field::Maps),
1696 "maximumAttendeeCapacity" => Ok(Field::MaximumAttendeeCapacity),
1697 "openingHoursSpecification" => Ok(Field::OpeningHoursSpecification),
1698 "photo" => Ok(Field::Photo),
1699 "photos" => Ok(Field::Photos),
1700 "publicAccess" => Ok(Field::PublicAccess),
1701 "review" => Ok(Field::Review),
1702 "reviews" => Ok(Field::Reviews),
1703 "slogan" => Ok(Field::Slogan),
1704 "smokingAllowed" => Ok(Field::SmokingAllowed),
1705 "specialOpeningHoursSpecification" => {
1706 Ok(Field::SpecialOpeningHoursSpecification)
1707 }
1708 "telephone" => Ok(Field::Telephone),
1709 "tourBookingPage" => Ok(Field::TourBookingPage),
1710 "additionalType" => Ok(Field::AdditionalType),
1711 "alternateName" => Ok(Field::AlternateName),
1712 "description" => Ok(Field::Description),
1713 "disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
1714 "identifier" => Ok(Field::Identifier),
1715 "image" => Ok(Field::Image),
1716 "mainEntityOfPage" => Ok(Field::MainEntityOfPage),
1717 "name" => Ok(Field::Name),
1718 "potentialAction" => Ok(Field::PotentialAction),
1719 "sameAs" => Ok(Field::SameAs),
1720 "subjectOf" => Ok(Field::SubjectOf),
1721 "url" => Ok(Field::Url),
1722 "id" | "type" => Ok(Field::Ignore),
1723 _ => Err(de::Error::unknown_field(value, FIELDS)),
1724 }
1725 }
1726 fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
1727 where
1728 E: de::Error,
1729 {
1730 match value {
1731 b"additionalProperty" => Ok(Field::AdditionalProperty),
1732 b"address" => Ok(Field::Address),
1733 b"aggregateRating" => Ok(Field::AggregateRating),
1734 b"amenityFeature" => Ok(Field::AmenityFeature),
1735 b"branchCode" => Ok(Field::BranchCode),
1736 b"containedIn" => Ok(Field::ContainedIn),
1737 b"containedInPlace" => Ok(Field::ContainedInPlace),
1738 b"containsPlace" => Ok(Field::ContainsPlace),
1739 b"event" => Ok(Field::Event),
1740 b"events" => Ok(Field::Events),
1741 b"faxNumber" => Ok(Field::FaxNumber),
1742 b"geo" => Ok(Field::Geo),
1743 b"geoContains" => Ok(Field::GeoContains),
1744 b"geoCoveredBy" => Ok(Field::GeoCoveredBy),
1745 b"geoCovers" => Ok(Field::GeoCovers),
1746 b"geoCrosses" => Ok(Field::GeoCrosses),
1747 b"geoDisjoint" => Ok(Field::GeoDisjoint),
1748 b"geoEquals" => Ok(Field::GeoEquals),
1749 b"geoIntersects" => Ok(Field::GeoIntersects),
1750 b"geoOverlaps" => Ok(Field::GeoOverlaps),
1751 b"geoTouches" => Ok(Field::GeoTouches),
1752 b"geoWithin" => Ok(Field::GeoWithin),
1753 b"globalLocationNumber" => Ok(Field::GlobalLocationNumber),
1754 b"hasDriveThroughService" => Ok(Field::HasDriveThroughService),
1755 b"hasMap" => Ok(Field::HasMap),
1756 b"isAccessibleForFree" => Ok(Field::IsAccessibleForFree),
1757 b"isicV4" => Ok(Field::IsicV4),
1758 b"keywords" => Ok(Field::Keywords),
1759 b"latitude" => Ok(Field::Latitude),
1760 b"logo" => Ok(Field::Logo),
1761 b"longitude" => Ok(Field::Longitude),
1762 b"map" => Ok(Field::Map),
1763 b"maps" => Ok(Field::Maps),
1764 b"maximumAttendeeCapacity" => Ok(Field::MaximumAttendeeCapacity),
1765 b"openingHoursSpecification" => Ok(Field::OpeningHoursSpecification),
1766 b"photo" => Ok(Field::Photo),
1767 b"photos" => Ok(Field::Photos),
1768 b"publicAccess" => Ok(Field::PublicAccess),
1769 b"review" => Ok(Field::Review),
1770 b"reviews" => Ok(Field::Reviews),
1771 b"slogan" => Ok(Field::Slogan),
1772 b"smokingAllowed" => Ok(Field::SmokingAllowed),
1773 b"specialOpeningHoursSpecification" => {
1774 Ok(Field::SpecialOpeningHoursSpecification)
1775 }
1776 b"telephone" => Ok(Field::Telephone),
1777 b"tourBookingPage" => Ok(Field::TourBookingPage),
1778 b"additionalType" => Ok(Field::AdditionalType),
1779 b"alternateName" => Ok(Field::AlternateName),
1780 b"description" => Ok(Field::Description),
1781 b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
1782 b"identifier" => Ok(Field::Identifier),
1783 b"image" => Ok(Field::Image),
1784 b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
1785 b"name" => Ok(Field::Name),
1786 b"potentialAction" => Ok(Field::PotentialAction),
1787 b"sameAs" => Ok(Field::SameAs),
1788 b"subjectOf" => Ok(Field::SubjectOf),
1789 b"url" => Ok(Field::Url),
1790 b"id" | b"type" => Ok(Field::Ignore),
1791 _ => {
1792 let value = &String::from_utf8_lossy(value);
1793 Err(de::Error::unknown_field(value, FIELDS))
1794 }
1795 }
1796 }
1797 }
1798 impl<'de> Deserialize<'de> for Field {
1799 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1800 where
1801 D: Deserializer<'de>,
1802 {
1803 deserializer.deserialize_identifier(FieldVisitor)
1804 }
1805 }
1806 struct ClassVisitor;
1807 impl<'de> Visitor<'de> for ClassVisitor {
1808 type Value = Canal;
1809 fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
1810 formatter.write_str("schema.org schema Canal")
1811 }
1812 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
1813 where
1814 A: de::MapAccess<'de>,
1815 {
1816 let mut r#additional_property_property = None;
1817 let mut r#address_property = None;
1818 let mut r#aggregate_rating_property = None;
1819 let mut r#amenity_feature_property = None;
1820 let mut r#branch_code_property = None;
1821 let mut r#contained_in_property = None;
1822 let mut r#contained_in_place_property = None;
1823 let mut r#contains_place_property = None;
1824 let mut r#event_property = None;
1825 let mut r#events_property = None;
1826 let mut r#fax_number_property = None;
1827 let mut r#geo_property = None;
1828 let mut r#geo_contains_property = None;
1829 let mut r#geo_covered_by_property = None;
1830 let mut r#geo_covers_property = None;
1831 let mut r#geo_crosses_property = None;
1832 let mut r#geo_disjoint_property = None;
1833 let mut r#geo_equals_property = None;
1834 let mut r#geo_intersects_property = None;
1835 let mut r#geo_overlaps_property = None;
1836 let mut r#geo_touches_property = None;
1837 let mut r#geo_within_property = None;
1838 let mut r#global_location_number_property = None;
1839 let mut r#has_drive_through_service_property = None;
1840 let mut r#has_map_property = None;
1841 let mut r#is_accessible_for_free_property = None;
1842 let mut r#isic_v_4_property = None;
1843 let mut r#keywords_property = None;
1844 let mut r#latitude_property = None;
1845 let mut r#logo_property = None;
1846 let mut r#longitude_property = None;
1847 let mut r#map_property = None;
1848 let mut r#maps_property = None;
1849 let mut r#maximum_attendee_capacity_property = None;
1850 let mut r#opening_hours_specification_property = None;
1851 let mut r#photo_property = None;
1852 let mut r#photos_property = None;
1853 let mut r#public_access_property = None;
1854 let mut r#review_property = None;
1855 let mut r#reviews_property = None;
1856 let mut r#slogan_property = None;
1857 let mut r#smoking_allowed_property = None;
1858 let mut r#special_opening_hours_specification_property = None;
1859 let mut r#telephone_property = None;
1860 let mut r#tour_booking_page_property = None;
1861 let mut r#additional_type_property = None;
1862 let mut r#alternate_name_property = None;
1863 let mut r#description_property = None;
1864 let mut r#disambiguating_description_property = None;
1865 let mut r#identifier_property = None;
1866 let mut r#image_property = None;
1867 let mut r#main_entity_of_page_property = None;
1868 let mut r#name_property = None;
1869 let mut r#potential_action_property = None;
1870 let mut r#same_as_property = None;
1871 let mut r#subject_of_property = None;
1872 let mut r#url_property = None;
1873 while let Some(key) = map.next_key::<Field>()? {
1874 match key {
1875 Field::AdditionalProperty => {
1876 if r#additional_property_property.is_some() {
1877 return Err(<A::Error as de::Error>::duplicate_field(
1878 "additionalProperty",
1879 ));
1880 }
1881 r#additional_property_property = Some({
1882 struct DeserializeWith(Vec<AdditionalPropertyProperty>);
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::Address => {
1902 if r#address_property.is_some() {
1903 return Err(<A::Error as de::Error>::duplicate_field(
1904 "address",
1905 ));
1906 }
1907 r#address_property = Some({
1908 struct DeserializeWith(Vec<AddressProperty>);
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::AggregateRating => {
1928 if r#aggregate_rating_property.is_some() {
1929 return Err(<A::Error as de::Error>::duplicate_field(
1930 "aggregateRating",
1931 ));
1932 }
1933 r#aggregate_rating_property = Some({
1934 struct DeserializeWith(Vec<AggregateRatingProperty>);
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::AmenityFeature => {
1954 if r#amenity_feature_property.is_some() {
1955 return Err(<A::Error as de::Error>::duplicate_field(
1956 "amenityFeature",
1957 ));
1958 }
1959 r#amenity_feature_property = Some({
1960 struct DeserializeWith(Vec<AmenityFeatureProperty>);
1961 impl<'de> Deserialize<'de> for DeserializeWith {
1962 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1963 where
1964 D: Deserializer<'de>,
1965 {
1966 Ok(DeserializeWith(serde_with::As::<
1967 serde_with::OneOrMany<serde_with::Same>,
1968 >::deserialize(deserializer)?))
1969 }
1970 }
1971 match map.next_value::<DeserializeWith>() {
1972 Ok(deserialize_with) => deserialize_with.0,
1973 Err(err) => {
1974 return Err(err);
1975 }
1976 }
1977 });
1978 }
1979 Field::BranchCode => {
1980 if r#branch_code_property.is_some() {
1981 return Err(<A::Error as de::Error>::duplicate_field(
1982 "branchCode",
1983 ));
1984 }
1985 r#branch_code_property = Some({
1986 struct DeserializeWith(Vec<BranchCodeProperty>);
1987 impl<'de> Deserialize<'de> for DeserializeWith {
1988 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1989 where
1990 D: Deserializer<'de>,
1991 {
1992 Ok(DeserializeWith(serde_with::As::<
1993 serde_with::OneOrMany<serde_with::Same>,
1994 >::deserialize(deserializer)?))
1995 }
1996 }
1997 match map.next_value::<DeserializeWith>() {
1998 Ok(deserialize_with) => deserialize_with.0,
1999 Err(err) => {
2000 return Err(err);
2001 }
2002 }
2003 });
2004 }
2005 Field::ContainedIn => {
2006 if r#contained_in_property.is_some() {
2007 return Err(<A::Error as de::Error>::duplicate_field(
2008 "containedIn",
2009 ));
2010 }
2011 r#contained_in_property = Some({
2012 struct DeserializeWith(Vec<ContainedInProperty>);
2013 impl<'de> Deserialize<'de> for DeserializeWith {
2014 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2015 where
2016 D: Deserializer<'de>,
2017 {
2018 Ok(DeserializeWith(serde_with::As::<
2019 serde_with::OneOrMany<serde_with::Same>,
2020 >::deserialize(deserializer)?))
2021 }
2022 }
2023 match map.next_value::<DeserializeWith>() {
2024 Ok(deserialize_with) => deserialize_with.0,
2025 Err(err) => {
2026 return Err(err);
2027 }
2028 }
2029 });
2030 }
2031 Field::ContainedInPlace => {
2032 if r#contained_in_place_property.is_some() {
2033 return Err(<A::Error as de::Error>::duplicate_field(
2034 "containedInPlace",
2035 ));
2036 }
2037 r#contained_in_place_property = Some({
2038 struct DeserializeWith(Vec<ContainedInPlaceProperty>);
2039 impl<'de> Deserialize<'de> for DeserializeWith {
2040 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2041 where
2042 D: Deserializer<'de>,
2043 {
2044 Ok(DeserializeWith(serde_with::As::<
2045 serde_with::OneOrMany<serde_with::Same>,
2046 >::deserialize(deserializer)?))
2047 }
2048 }
2049 match map.next_value::<DeserializeWith>() {
2050 Ok(deserialize_with) => deserialize_with.0,
2051 Err(err) => {
2052 return Err(err);
2053 }
2054 }
2055 });
2056 }
2057 Field::ContainsPlace => {
2058 if r#contains_place_property.is_some() {
2059 return Err(<A::Error as de::Error>::duplicate_field(
2060 "containsPlace",
2061 ));
2062 }
2063 r#contains_place_property = Some({
2064 struct DeserializeWith(Vec<ContainsPlaceProperty>);
2065 impl<'de> Deserialize<'de> for DeserializeWith {
2066 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2067 where
2068 D: Deserializer<'de>,
2069 {
2070 Ok(DeserializeWith(serde_with::As::<
2071 serde_with::OneOrMany<serde_with::Same>,
2072 >::deserialize(deserializer)?))
2073 }
2074 }
2075 match map.next_value::<DeserializeWith>() {
2076 Ok(deserialize_with) => deserialize_with.0,
2077 Err(err) => {
2078 return Err(err);
2079 }
2080 }
2081 });
2082 }
2083 Field::Event => {
2084 if r#event_property.is_some() {
2085 return Err(<A::Error as de::Error>::duplicate_field("event"));
2086 }
2087 r#event_property = Some({
2088 struct DeserializeWith(Vec<EventProperty>);
2089 impl<'de> Deserialize<'de> for DeserializeWith {
2090 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2091 where
2092 D: Deserializer<'de>,
2093 {
2094 Ok(DeserializeWith(serde_with::As::<
2095 serde_with::OneOrMany<serde_with::Same>,
2096 >::deserialize(deserializer)?))
2097 }
2098 }
2099 match map.next_value::<DeserializeWith>() {
2100 Ok(deserialize_with) => deserialize_with.0,
2101 Err(err) => {
2102 return Err(err);
2103 }
2104 }
2105 });
2106 }
2107 Field::Events => {
2108 if r#events_property.is_some() {
2109 return Err(<A::Error as de::Error>::duplicate_field("events"));
2110 }
2111 r#events_property = Some({
2112 struct DeserializeWith(Vec<EventsProperty>);
2113 impl<'de> Deserialize<'de> for DeserializeWith {
2114 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2115 where
2116 D: Deserializer<'de>,
2117 {
2118 Ok(DeserializeWith(serde_with::As::<
2119 serde_with::OneOrMany<serde_with::Same>,
2120 >::deserialize(deserializer)?))
2121 }
2122 }
2123 match map.next_value::<DeserializeWith>() {
2124 Ok(deserialize_with) => deserialize_with.0,
2125 Err(err) => {
2126 return Err(err);
2127 }
2128 }
2129 });
2130 }
2131 Field::FaxNumber => {
2132 if r#fax_number_property.is_some() {
2133 return Err(<A::Error as de::Error>::duplicate_field(
2134 "faxNumber",
2135 ));
2136 }
2137 r#fax_number_property = Some({
2138 struct DeserializeWith(Vec<FaxNumberProperty>);
2139 impl<'de> Deserialize<'de> for DeserializeWith {
2140 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2141 where
2142 D: Deserializer<'de>,
2143 {
2144 Ok(DeserializeWith(serde_with::As::<
2145 serde_with::OneOrMany<serde_with::Same>,
2146 >::deserialize(deserializer)?))
2147 }
2148 }
2149 match map.next_value::<DeserializeWith>() {
2150 Ok(deserialize_with) => deserialize_with.0,
2151 Err(err) => {
2152 return Err(err);
2153 }
2154 }
2155 });
2156 }
2157 Field::Geo => {
2158 if r#geo_property.is_some() {
2159 return Err(<A::Error as de::Error>::duplicate_field("geo"));
2160 }
2161 r#geo_property = Some({
2162 struct DeserializeWith(Vec<GeoProperty>);
2163 impl<'de> Deserialize<'de> for DeserializeWith {
2164 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2165 where
2166 D: Deserializer<'de>,
2167 {
2168 Ok(DeserializeWith(serde_with::As::<
2169 serde_with::OneOrMany<serde_with::Same>,
2170 >::deserialize(deserializer)?))
2171 }
2172 }
2173 match map.next_value::<DeserializeWith>() {
2174 Ok(deserialize_with) => deserialize_with.0,
2175 Err(err) => {
2176 return Err(err);
2177 }
2178 }
2179 });
2180 }
2181 Field::GeoContains => {
2182 if r#geo_contains_property.is_some() {
2183 return Err(<A::Error as de::Error>::duplicate_field(
2184 "geoContains",
2185 ));
2186 }
2187 r#geo_contains_property = Some({
2188 struct DeserializeWith(Vec<GeoContainsProperty>);
2189 impl<'de> Deserialize<'de> for DeserializeWith {
2190 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2191 where
2192 D: Deserializer<'de>,
2193 {
2194 Ok(DeserializeWith(serde_with::As::<
2195 serde_with::OneOrMany<serde_with::Same>,
2196 >::deserialize(deserializer)?))
2197 }
2198 }
2199 match map.next_value::<DeserializeWith>() {
2200 Ok(deserialize_with) => deserialize_with.0,
2201 Err(err) => {
2202 return Err(err);
2203 }
2204 }
2205 });
2206 }
2207 Field::GeoCoveredBy => {
2208 if r#geo_covered_by_property.is_some() {
2209 return Err(<A::Error as de::Error>::duplicate_field(
2210 "geoCoveredBy",
2211 ));
2212 }
2213 r#geo_covered_by_property = Some({
2214 struct DeserializeWith(Vec<GeoCoveredByProperty>);
2215 impl<'de> Deserialize<'de> for DeserializeWith {
2216 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2217 where
2218 D: Deserializer<'de>,
2219 {
2220 Ok(DeserializeWith(serde_with::As::<
2221 serde_with::OneOrMany<serde_with::Same>,
2222 >::deserialize(deserializer)?))
2223 }
2224 }
2225 match map.next_value::<DeserializeWith>() {
2226 Ok(deserialize_with) => deserialize_with.0,
2227 Err(err) => {
2228 return Err(err);
2229 }
2230 }
2231 });
2232 }
2233 Field::GeoCovers => {
2234 if r#geo_covers_property.is_some() {
2235 return Err(<A::Error as de::Error>::duplicate_field(
2236 "geoCovers",
2237 ));
2238 }
2239 r#geo_covers_property = Some({
2240 struct DeserializeWith(Vec<GeoCoversProperty>);
2241 impl<'de> Deserialize<'de> for DeserializeWith {
2242 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2243 where
2244 D: Deserializer<'de>,
2245 {
2246 Ok(DeserializeWith(serde_with::As::<
2247 serde_with::OneOrMany<serde_with::Same>,
2248 >::deserialize(deserializer)?))
2249 }
2250 }
2251 match map.next_value::<DeserializeWith>() {
2252 Ok(deserialize_with) => deserialize_with.0,
2253 Err(err) => {
2254 return Err(err);
2255 }
2256 }
2257 });
2258 }
2259 Field::GeoCrosses => {
2260 if r#geo_crosses_property.is_some() {
2261 return Err(<A::Error as de::Error>::duplicate_field(
2262 "geoCrosses",
2263 ));
2264 }
2265 r#geo_crosses_property = Some({
2266 struct DeserializeWith(Vec<GeoCrossesProperty>);
2267 impl<'de> Deserialize<'de> for DeserializeWith {
2268 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2269 where
2270 D: Deserializer<'de>,
2271 {
2272 Ok(DeserializeWith(serde_with::As::<
2273 serde_with::OneOrMany<serde_with::Same>,
2274 >::deserialize(deserializer)?))
2275 }
2276 }
2277 match map.next_value::<DeserializeWith>() {
2278 Ok(deserialize_with) => deserialize_with.0,
2279 Err(err) => {
2280 return Err(err);
2281 }
2282 }
2283 });
2284 }
2285 Field::GeoDisjoint => {
2286 if r#geo_disjoint_property.is_some() {
2287 return Err(<A::Error as de::Error>::duplicate_field(
2288 "geoDisjoint",
2289 ));
2290 }
2291 r#geo_disjoint_property = Some({
2292 struct DeserializeWith(Vec<GeoDisjointProperty>);
2293 impl<'de> Deserialize<'de> for DeserializeWith {
2294 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2295 where
2296 D: Deserializer<'de>,
2297 {
2298 Ok(DeserializeWith(serde_with::As::<
2299 serde_with::OneOrMany<serde_with::Same>,
2300 >::deserialize(deserializer)?))
2301 }
2302 }
2303 match map.next_value::<DeserializeWith>() {
2304 Ok(deserialize_with) => deserialize_with.0,
2305 Err(err) => {
2306 return Err(err);
2307 }
2308 }
2309 });
2310 }
2311 Field::GeoEquals => {
2312 if r#geo_equals_property.is_some() {
2313 return Err(<A::Error as de::Error>::duplicate_field(
2314 "geoEquals",
2315 ));
2316 }
2317 r#geo_equals_property = Some({
2318 struct DeserializeWith(Vec<GeoEqualsProperty>);
2319 impl<'de> Deserialize<'de> for DeserializeWith {
2320 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2321 where
2322 D: Deserializer<'de>,
2323 {
2324 Ok(DeserializeWith(serde_with::As::<
2325 serde_with::OneOrMany<serde_with::Same>,
2326 >::deserialize(deserializer)?))
2327 }
2328 }
2329 match map.next_value::<DeserializeWith>() {
2330 Ok(deserialize_with) => deserialize_with.0,
2331 Err(err) => {
2332 return Err(err);
2333 }
2334 }
2335 });
2336 }
2337 Field::GeoIntersects => {
2338 if r#geo_intersects_property.is_some() {
2339 return Err(<A::Error as de::Error>::duplicate_field(
2340 "geoIntersects",
2341 ));
2342 }
2343 r#geo_intersects_property = Some({
2344 struct DeserializeWith(Vec<GeoIntersectsProperty>);
2345 impl<'de> Deserialize<'de> for DeserializeWith {
2346 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2347 where
2348 D: Deserializer<'de>,
2349 {
2350 Ok(DeserializeWith(serde_with::As::<
2351 serde_with::OneOrMany<serde_with::Same>,
2352 >::deserialize(deserializer)?))
2353 }
2354 }
2355 match map.next_value::<DeserializeWith>() {
2356 Ok(deserialize_with) => deserialize_with.0,
2357 Err(err) => {
2358 return Err(err);
2359 }
2360 }
2361 });
2362 }
2363 Field::GeoOverlaps => {
2364 if r#geo_overlaps_property.is_some() {
2365 return Err(<A::Error as de::Error>::duplicate_field(
2366 "geoOverlaps",
2367 ));
2368 }
2369 r#geo_overlaps_property = Some({
2370 struct DeserializeWith(Vec<GeoOverlapsProperty>);
2371 impl<'de> Deserialize<'de> for DeserializeWith {
2372 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2373 where
2374 D: Deserializer<'de>,
2375 {
2376 Ok(DeserializeWith(serde_with::As::<
2377 serde_with::OneOrMany<serde_with::Same>,
2378 >::deserialize(deserializer)?))
2379 }
2380 }
2381 match map.next_value::<DeserializeWith>() {
2382 Ok(deserialize_with) => deserialize_with.0,
2383 Err(err) => {
2384 return Err(err);
2385 }
2386 }
2387 });
2388 }
2389 Field::GeoTouches => {
2390 if r#geo_touches_property.is_some() {
2391 return Err(<A::Error as de::Error>::duplicate_field(
2392 "geoTouches",
2393 ));
2394 }
2395 r#geo_touches_property = Some({
2396 struct DeserializeWith(Vec<GeoTouchesProperty>);
2397 impl<'de> Deserialize<'de> for DeserializeWith {
2398 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2399 where
2400 D: Deserializer<'de>,
2401 {
2402 Ok(DeserializeWith(serde_with::As::<
2403 serde_with::OneOrMany<serde_with::Same>,
2404 >::deserialize(deserializer)?))
2405 }
2406 }
2407 match map.next_value::<DeserializeWith>() {
2408 Ok(deserialize_with) => deserialize_with.0,
2409 Err(err) => {
2410 return Err(err);
2411 }
2412 }
2413 });
2414 }
2415 Field::GeoWithin => {
2416 if r#geo_within_property.is_some() {
2417 return Err(<A::Error as de::Error>::duplicate_field(
2418 "geoWithin",
2419 ));
2420 }
2421 r#geo_within_property = Some({
2422 struct DeserializeWith(Vec<GeoWithinProperty>);
2423 impl<'de> Deserialize<'de> for DeserializeWith {
2424 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2425 where
2426 D: Deserializer<'de>,
2427 {
2428 Ok(DeserializeWith(serde_with::As::<
2429 serde_with::OneOrMany<serde_with::Same>,
2430 >::deserialize(deserializer)?))
2431 }
2432 }
2433 match map.next_value::<DeserializeWith>() {
2434 Ok(deserialize_with) => deserialize_with.0,
2435 Err(err) => {
2436 return Err(err);
2437 }
2438 }
2439 });
2440 }
2441 Field::GlobalLocationNumber => {
2442 if r#global_location_number_property.is_some() {
2443 return Err(<A::Error as de::Error>::duplicate_field(
2444 "globalLocationNumber",
2445 ));
2446 }
2447 r#global_location_number_property = Some({
2448 struct DeserializeWith(Vec<GlobalLocationNumberProperty>);
2449 impl<'de> Deserialize<'de> for DeserializeWith {
2450 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2451 where
2452 D: Deserializer<'de>,
2453 {
2454 Ok(DeserializeWith(serde_with::As::<
2455 serde_with::OneOrMany<serde_with::Same>,
2456 >::deserialize(deserializer)?))
2457 }
2458 }
2459 match map.next_value::<DeserializeWith>() {
2460 Ok(deserialize_with) => deserialize_with.0,
2461 Err(err) => {
2462 return Err(err);
2463 }
2464 }
2465 });
2466 }
2467 Field::HasDriveThroughService => {
2468 if r#has_drive_through_service_property.is_some() {
2469 return Err(<A::Error as de::Error>::duplicate_field(
2470 "hasDriveThroughService",
2471 ));
2472 }
2473 r#has_drive_through_service_property = Some({
2474 struct DeserializeWith(Vec<HasDriveThroughServiceProperty>);
2475 impl<'de> Deserialize<'de> for DeserializeWith {
2476 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2477 where
2478 D: Deserializer<'de>,
2479 {
2480 Ok(DeserializeWith(serde_with::As::<
2481 serde_with::OneOrMany<serde_with::Same>,
2482 >::deserialize(deserializer)?))
2483 }
2484 }
2485 match map.next_value::<DeserializeWith>() {
2486 Ok(deserialize_with) => deserialize_with.0,
2487 Err(err) => {
2488 return Err(err);
2489 }
2490 }
2491 });
2492 }
2493 Field::HasMap => {
2494 if r#has_map_property.is_some() {
2495 return Err(<A::Error as de::Error>::duplicate_field("hasMap"));
2496 }
2497 r#has_map_property = Some({
2498 struct DeserializeWith(Vec<HasMapProperty>);
2499 impl<'de> Deserialize<'de> for DeserializeWith {
2500 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2501 where
2502 D: Deserializer<'de>,
2503 {
2504 Ok(DeserializeWith(serde_with::As::<
2505 serde_with::OneOrMany<serde_with::Same>,
2506 >::deserialize(deserializer)?))
2507 }
2508 }
2509 match map.next_value::<DeserializeWith>() {
2510 Ok(deserialize_with) => deserialize_with.0,
2511 Err(err) => {
2512 return Err(err);
2513 }
2514 }
2515 });
2516 }
2517 Field::IsAccessibleForFree => {
2518 if r#is_accessible_for_free_property.is_some() {
2519 return Err(<A::Error as de::Error>::duplicate_field(
2520 "isAccessibleForFree",
2521 ));
2522 }
2523 r#is_accessible_for_free_property = Some({
2524 struct DeserializeWith(Vec<IsAccessibleForFreeProperty>);
2525 impl<'de> Deserialize<'de> for DeserializeWith {
2526 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2527 where
2528 D: Deserializer<'de>,
2529 {
2530 Ok(DeserializeWith(serde_with::As::<
2531 serde_with::OneOrMany<serde_with::Same>,
2532 >::deserialize(deserializer)?))
2533 }
2534 }
2535 match map.next_value::<DeserializeWith>() {
2536 Ok(deserialize_with) => deserialize_with.0,
2537 Err(err) => {
2538 return Err(err);
2539 }
2540 }
2541 });
2542 }
2543 Field::IsicV4 => {
2544 if r#isic_v_4_property.is_some() {
2545 return Err(<A::Error as de::Error>::duplicate_field("isicV4"));
2546 }
2547 r#isic_v_4_property = Some({
2548 struct DeserializeWith(Vec<IsicV4Property>);
2549 impl<'de> Deserialize<'de> for DeserializeWith {
2550 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2551 where
2552 D: Deserializer<'de>,
2553 {
2554 Ok(DeserializeWith(serde_with::As::<
2555 serde_with::OneOrMany<serde_with::Same>,
2556 >::deserialize(deserializer)?))
2557 }
2558 }
2559 match map.next_value::<DeserializeWith>() {
2560 Ok(deserialize_with) => deserialize_with.0,
2561 Err(err) => {
2562 return Err(err);
2563 }
2564 }
2565 });
2566 }
2567 Field::Keywords => {
2568 if r#keywords_property.is_some() {
2569 return Err(<A::Error as de::Error>::duplicate_field(
2570 "keywords",
2571 ));
2572 }
2573 r#keywords_property = Some({
2574 struct DeserializeWith(Vec<KeywordsProperty>);
2575 impl<'de> Deserialize<'de> for DeserializeWith {
2576 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2577 where
2578 D: Deserializer<'de>,
2579 {
2580 Ok(DeserializeWith(serde_with::As::<
2581 serde_with::OneOrMany<serde_with::Same>,
2582 >::deserialize(deserializer)?))
2583 }
2584 }
2585 match map.next_value::<DeserializeWith>() {
2586 Ok(deserialize_with) => deserialize_with.0,
2587 Err(err) => {
2588 return Err(err);
2589 }
2590 }
2591 });
2592 }
2593 Field::Latitude => {
2594 if r#latitude_property.is_some() {
2595 return Err(<A::Error as de::Error>::duplicate_field(
2596 "latitude",
2597 ));
2598 }
2599 r#latitude_property = Some({
2600 struct DeserializeWith(Vec<LatitudeProperty>);
2601 impl<'de> Deserialize<'de> for DeserializeWith {
2602 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2603 where
2604 D: Deserializer<'de>,
2605 {
2606 Ok(DeserializeWith(serde_with::As::<
2607 serde_with::OneOrMany<serde_with::Same>,
2608 >::deserialize(deserializer)?))
2609 }
2610 }
2611 match map.next_value::<DeserializeWith>() {
2612 Ok(deserialize_with) => deserialize_with.0,
2613 Err(err) => {
2614 return Err(err);
2615 }
2616 }
2617 });
2618 }
2619 Field::Logo => {
2620 if r#logo_property.is_some() {
2621 return Err(<A::Error as de::Error>::duplicate_field("logo"));
2622 }
2623 r#logo_property = Some({
2624 struct DeserializeWith(Vec<LogoProperty>);
2625 impl<'de> Deserialize<'de> for DeserializeWith {
2626 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2627 where
2628 D: Deserializer<'de>,
2629 {
2630 Ok(DeserializeWith(serde_with::As::<
2631 serde_with::OneOrMany<serde_with::Same>,
2632 >::deserialize(deserializer)?))
2633 }
2634 }
2635 match map.next_value::<DeserializeWith>() {
2636 Ok(deserialize_with) => deserialize_with.0,
2637 Err(err) => {
2638 return Err(err);
2639 }
2640 }
2641 });
2642 }
2643 Field::Longitude => {
2644 if r#longitude_property.is_some() {
2645 return Err(<A::Error as de::Error>::duplicate_field(
2646 "longitude",
2647 ));
2648 }
2649 r#longitude_property = Some({
2650 struct DeserializeWith(Vec<LongitudeProperty>);
2651 impl<'de> Deserialize<'de> for DeserializeWith {
2652 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2653 where
2654 D: Deserializer<'de>,
2655 {
2656 Ok(DeserializeWith(serde_with::As::<
2657 serde_with::OneOrMany<serde_with::Same>,
2658 >::deserialize(deserializer)?))
2659 }
2660 }
2661 match map.next_value::<DeserializeWith>() {
2662 Ok(deserialize_with) => deserialize_with.0,
2663 Err(err) => {
2664 return Err(err);
2665 }
2666 }
2667 });
2668 }
2669 Field::Map => {
2670 if r#map_property.is_some() {
2671 return Err(<A::Error as de::Error>::duplicate_field("map"));
2672 }
2673 r#map_property = Some({
2674 struct DeserializeWith(Vec<MapProperty>);
2675 impl<'de> Deserialize<'de> for DeserializeWith {
2676 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2677 where
2678 D: Deserializer<'de>,
2679 {
2680 Ok(DeserializeWith(serde_with::As::<
2681 serde_with::OneOrMany<serde_with::Same>,
2682 >::deserialize(deserializer)?))
2683 }
2684 }
2685 match map.next_value::<DeserializeWith>() {
2686 Ok(deserialize_with) => deserialize_with.0,
2687 Err(err) => {
2688 return Err(err);
2689 }
2690 }
2691 });
2692 }
2693 Field::Maps => {
2694 if r#maps_property.is_some() {
2695 return Err(<A::Error as de::Error>::duplicate_field("maps"));
2696 }
2697 r#maps_property = Some({
2698 struct DeserializeWith(Vec<MapsProperty>);
2699 impl<'de> Deserialize<'de> for DeserializeWith {
2700 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2701 where
2702 D: Deserializer<'de>,
2703 {
2704 Ok(DeserializeWith(serde_with::As::<
2705 serde_with::OneOrMany<serde_with::Same>,
2706 >::deserialize(deserializer)?))
2707 }
2708 }
2709 match map.next_value::<DeserializeWith>() {
2710 Ok(deserialize_with) => deserialize_with.0,
2711 Err(err) => {
2712 return Err(err);
2713 }
2714 }
2715 });
2716 }
2717 Field::MaximumAttendeeCapacity => {
2718 if r#maximum_attendee_capacity_property.is_some() {
2719 return Err(<A::Error as de::Error>::duplicate_field(
2720 "maximumAttendeeCapacity",
2721 ));
2722 }
2723 r#maximum_attendee_capacity_property = Some({
2724 struct DeserializeWith(Vec<MaximumAttendeeCapacityProperty>);
2725 impl<'de> Deserialize<'de> for DeserializeWith {
2726 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2727 where
2728 D: Deserializer<'de>,
2729 {
2730 Ok(DeserializeWith(serde_with::As::<
2731 serde_with::OneOrMany<serde_with::Same>,
2732 >::deserialize(deserializer)?))
2733 }
2734 }
2735 match map.next_value::<DeserializeWith>() {
2736 Ok(deserialize_with) => deserialize_with.0,
2737 Err(err) => {
2738 return Err(err);
2739 }
2740 }
2741 });
2742 }
2743 Field::OpeningHoursSpecification => {
2744 if r#opening_hours_specification_property.is_some() {
2745 return Err(<A::Error as de::Error>::duplicate_field(
2746 "openingHoursSpecification",
2747 ));
2748 }
2749 r#opening_hours_specification_property = Some({
2750 struct DeserializeWith(Vec<OpeningHoursSpecificationProperty>);
2751 impl<'de> Deserialize<'de> for DeserializeWith {
2752 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2753 where
2754 D: Deserializer<'de>,
2755 {
2756 Ok(DeserializeWith(serde_with::As::<
2757 serde_with::OneOrMany<serde_with::Same>,
2758 >::deserialize(deserializer)?))
2759 }
2760 }
2761 match map.next_value::<DeserializeWith>() {
2762 Ok(deserialize_with) => deserialize_with.0,
2763 Err(err) => {
2764 return Err(err);
2765 }
2766 }
2767 });
2768 }
2769 Field::Photo => {
2770 if r#photo_property.is_some() {
2771 return Err(<A::Error as de::Error>::duplicate_field("photo"));
2772 }
2773 r#photo_property = Some({
2774 struct DeserializeWith(Vec<PhotoProperty>);
2775 impl<'de> Deserialize<'de> for DeserializeWith {
2776 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2777 where
2778 D: Deserializer<'de>,
2779 {
2780 Ok(DeserializeWith(serde_with::As::<
2781 serde_with::OneOrMany<serde_with::Same>,
2782 >::deserialize(deserializer)?))
2783 }
2784 }
2785 match map.next_value::<DeserializeWith>() {
2786 Ok(deserialize_with) => deserialize_with.0,
2787 Err(err) => {
2788 return Err(err);
2789 }
2790 }
2791 });
2792 }
2793 Field::Photos => {
2794 if r#photos_property.is_some() {
2795 return Err(<A::Error as de::Error>::duplicate_field("photos"));
2796 }
2797 r#photos_property = Some({
2798 struct DeserializeWith(Vec<PhotosProperty>);
2799 impl<'de> Deserialize<'de> for DeserializeWith {
2800 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2801 where
2802 D: Deserializer<'de>,
2803 {
2804 Ok(DeserializeWith(serde_with::As::<
2805 serde_with::OneOrMany<serde_with::Same>,
2806 >::deserialize(deserializer)?))
2807 }
2808 }
2809 match map.next_value::<DeserializeWith>() {
2810 Ok(deserialize_with) => deserialize_with.0,
2811 Err(err) => {
2812 return Err(err);
2813 }
2814 }
2815 });
2816 }
2817 Field::PublicAccess => {
2818 if r#public_access_property.is_some() {
2819 return Err(<A::Error as de::Error>::duplicate_field(
2820 "publicAccess",
2821 ));
2822 }
2823 r#public_access_property = Some({
2824 struct DeserializeWith(Vec<PublicAccessProperty>);
2825 impl<'de> Deserialize<'de> for DeserializeWith {
2826 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2827 where
2828 D: Deserializer<'de>,
2829 {
2830 Ok(DeserializeWith(serde_with::As::<
2831 serde_with::OneOrMany<serde_with::Same>,
2832 >::deserialize(deserializer)?))
2833 }
2834 }
2835 match map.next_value::<DeserializeWith>() {
2836 Ok(deserialize_with) => deserialize_with.0,
2837 Err(err) => {
2838 return Err(err);
2839 }
2840 }
2841 });
2842 }
2843 Field::Review => {
2844 if r#review_property.is_some() {
2845 return Err(<A::Error as de::Error>::duplicate_field("review"));
2846 }
2847 r#review_property = Some({
2848 struct DeserializeWith(Vec<ReviewProperty>);
2849 impl<'de> Deserialize<'de> for DeserializeWith {
2850 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2851 where
2852 D: Deserializer<'de>,
2853 {
2854 Ok(DeserializeWith(serde_with::As::<
2855 serde_with::OneOrMany<serde_with::Same>,
2856 >::deserialize(deserializer)?))
2857 }
2858 }
2859 match map.next_value::<DeserializeWith>() {
2860 Ok(deserialize_with) => deserialize_with.0,
2861 Err(err) => {
2862 return Err(err);
2863 }
2864 }
2865 });
2866 }
2867 Field::Reviews => {
2868 if r#reviews_property.is_some() {
2869 return Err(<A::Error as de::Error>::duplicate_field(
2870 "reviews",
2871 ));
2872 }
2873 r#reviews_property = Some({
2874 struct DeserializeWith(Vec<ReviewsProperty>);
2875 impl<'de> Deserialize<'de> for DeserializeWith {
2876 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2877 where
2878 D: Deserializer<'de>,
2879 {
2880 Ok(DeserializeWith(serde_with::As::<
2881 serde_with::OneOrMany<serde_with::Same>,
2882 >::deserialize(deserializer)?))
2883 }
2884 }
2885 match map.next_value::<DeserializeWith>() {
2886 Ok(deserialize_with) => deserialize_with.0,
2887 Err(err) => {
2888 return Err(err);
2889 }
2890 }
2891 });
2892 }
2893 Field::Slogan => {
2894 if r#slogan_property.is_some() {
2895 return Err(<A::Error as de::Error>::duplicate_field("slogan"));
2896 }
2897 r#slogan_property = Some({
2898 struct DeserializeWith(Vec<SloganProperty>);
2899 impl<'de> Deserialize<'de> for DeserializeWith {
2900 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2901 where
2902 D: Deserializer<'de>,
2903 {
2904 Ok(DeserializeWith(serde_with::As::<
2905 serde_with::OneOrMany<serde_with::Same>,
2906 >::deserialize(deserializer)?))
2907 }
2908 }
2909 match map.next_value::<DeserializeWith>() {
2910 Ok(deserialize_with) => deserialize_with.0,
2911 Err(err) => {
2912 return Err(err);
2913 }
2914 }
2915 });
2916 }
2917 Field::SmokingAllowed => {
2918 if r#smoking_allowed_property.is_some() {
2919 return Err(<A::Error as de::Error>::duplicate_field(
2920 "smokingAllowed",
2921 ));
2922 }
2923 r#smoking_allowed_property = Some({
2924 struct DeserializeWith(Vec<SmokingAllowedProperty>);
2925 impl<'de> Deserialize<'de> for DeserializeWith {
2926 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2927 where
2928 D: Deserializer<'de>,
2929 {
2930 Ok(DeserializeWith(serde_with::As::<
2931 serde_with::OneOrMany<serde_with::Same>,
2932 >::deserialize(deserializer)?))
2933 }
2934 }
2935 match map.next_value::<DeserializeWith>() {
2936 Ok(deserialize_with) => deserialize_with.0,
2937 Err(err) => {
2938 return Err(err);
2939 }
2940 }
2941 });
2942 }
2943 Field::SpecialOpeningHoursSpecification => {
2944 if r#special_opening_hours_specification_property.is_some() {
2945 return Err(<A::Error as de::Error>::duplicate_field(
2946 "specialOpeningHoursSpecification",
2947 ));
2948 }
2949 r#special_opening_hours_specification_property = Some({
2950 struct DeserializeWith(
2951 Vec<SpecialOpeningHoursSpecificationProperty>,
2952 );
2953 impl<'de> Deserialize<'de> for DeserializeWith {
2954 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2955 where
2956 D: Deserializer<'de>,
2957 {
2958 Ok(DeserializeWith(serde_with::As::<
2959 serde_with::OneOrMany<serde_with::Same>,
2960 >::deserialize(deserializer)?))
2961 }
2962 }
2963 match map.next_value::<DeserializeWith>() {
2964 Ok(deserialize_with) => deserialize_with.0,
2965 Err(err) => {
2966 return Err(err);
2967 }
2968 }
2969 });
2970 }
2971 Field::Telephone => {
2972 if r#telephone_property.is_some() {
2973 return Err(<A::Error as de::Error>::duplicate_field(
2974 "telephone",
2975 ));
2976 }
2977 r#telephone_property = Some({
2978 struct DeserializeWith(Vec<TelephoneProperty>);
2979 impl<'de> Deserialize<'de> for DeserializeWith {
2980 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2981 where
2982 D: Deserializer<'de>,
2983 {
2984 Ok(DeserializeWith(serde_with::As::<
2985 serde_with::OneOrMany<serde_with::Same>,
2986 >::deserialize(deserializer)?))
2987 }
2988 }
2989 match map.next_value::<DeserializeWith>() {
2990 Ok(deserialize_with) => deserialize_with.0,
2991 Err(err) => {
2992 return Err(err);
2993 }
2994 }
2995 });
2996 }
2997 Field::TourBookingPage => {
2998 if r#tour_booking_page_property.is_some() {
2999 return Err(<A::Error as de::Error>::duplicate_field(
3000 "tourBookingPage",
3001 ));
3002 }
3003 r#tour_booking_page_property = Some({
3004 struct DeserializeWith(Vec<TourBookingPageProperty>);
3005 impl<'de> Deserialize<'de> for DeserializeWith {
3006 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3007 where
3008 D: Deserializer<'de>,
3009 {
3010 Ok(DeserializeWith(serde_with::As::<
3011 serde_with::OneOrMany<serde_with::Same>,
3012 >::deserialize(deserializer)?))
3013 }
3014 }
3015 match map.next_value::<DeserializeWith>() {
3016 Ok(deserialize_with) => deserialize_with.0,
3017 Err(err) => {
3018 return Err(err);
3019 }
3020 }
3021 });
3022 }
3023 Field::AdditionalType => {
3024 if r#additional_type_property.is_some() {
3025 return Err(<A::Error as de::Error>::duplicate_field(
3026 "additionalType",
3027 ));
3028 }
3029 r#additional_type_property = Some({
3030 struct DeserializeWith(Vec<AdditionalTypeProperty>);
3031 impl<'de> Deserialize<'de> for DeserializeWith {
3032 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3033 where
3034 D: Deserializer<'de>,
3035 {
3036 Ok(DeserializeWith(serde_with::As::<
3037 serde_with::OneOrMany<serde_with::Same>,
3038 >::deserialize(deserializer)?))
3039 }
3040 }
3041 match map.next_value::<DeserializeWith>() {
3042 Ok(deserialize_with) => deserialize_with.0,
3043 Err(err) => {
3044 return Err(err);
3045 }
3046 }
3047 });
3048 }
3049 Field::AlternateName => {
3050 if r#alternate_name_property.is_some() {
3051 return Err(<A::Error as de::Error>::duplicate_field(
3052 "alternateName",
3053 ));
3054 }
3055 r#alternate_name_property = Some({
3056 struct DeserializeWith(Vec<AlternateNameProperty>);
3057 impl<'de> Deserialize<'de> for DeserializeWith {
3058 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3059 where
3060 D: Deserializer<'de>,
3061 {
3062 Ok(DeserializeWith(serde_with::As::<
3063 serde_with::OneOrMany<serde_with::Same>,
3064 >::deserialize(deserializer)?))
3065 }
3066 }
3067 match map.next_value::<DeserializeWith>() {
3068 Ok(deserialize_with) => deserialize_with.0,
3069 Err(err) => {
3070 return Err(err);
3071 }
3072 }
3073 });
3074 }
3075 Field::Description => {
3076 if r#description_property.is_some() {
3077 return Err(<A::Error as de::Error>::duplicate_field(
3078 "description",
3079 ));
3080 }
3081 r#description_property = Some({
3082 struct DeserializeWith(Vec<DescriptionProperty>);
3083 impl<'de> Deserialize<'de> for DeserializeWith {
3084 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3085 where
3086 D: Deserializer<'de>,
3087 {
3088 Ok(DeserializeWith(serde_with::As::<
3089 serde_with::OneOrMany<serde_with::Same>,
3090 >::deserialize(deserializer)?))
3091 }
3092 }
3093 match map.next_value::<DeserializeWith>() {
3094 Ok(deserialize_with) => deserialize_with.0,
3095 Err(err) => {
3096 return Err(err);
3097 }
3098 }
3099 });
3100 }
3101 Field::DisambiguatingDescription => {
3102 if r#disambiguating_description_property.is_some() {
3103 return Err(<A::Error as de::Error>::duplicate_field(
3104 "disambiguatingDescription",
3105 ));
3106 }
3107 r#disambiguating_description_property = Some({
3108 struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
3109 impl<'de> Deserialize<'de> for DeserializeWith {
3110 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3111 where
3112 D: Deserializer<'de>,
3113 {
3114 Ok(DeserializeWith(serde_with::As::<
3115 serde_with::OneOrMany<serde_with::Same>,
3116 >::deserialize(deserializer)?))
3117 }
3118 }
3119 match map.next_value::<DeserializeWith>() {
3120 Ok(deserialize_with) => deserialize_with.0,
3121 Err(err) => {
3122 return Err(err);
3123 }
3124 }
3125 });
3126 }
3127 Field::Identifier => {
3128 if r#identifier_property.is_some() {
3129 return Err(<A::Error as de::Error>::duplicate_field(
3130 "identifier",
3131 ));
3132 }
3133 r#identifier_property = Some({
3134 struct DeserializeWith(Vec<IdentifierProperty>);
3135 impl<'de> Deserialize<'de> for DeserializeWith {
3136 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3137 where
3138 D: Deserializer<'de>,
3139 {
3140 Ok(DeserializeWith(serde_with::As::<
3141 serde_with::OneOrMany<serde_with::Same>,
3142 >::deserialize(deserializer)?))
3143 }
3144 }
3145 match map.next_value::<DeserializeWith>() {
3146 Ok(deserialize_with) => deserialize_with.0,
3147 Err(err) => {
3148 return Err(err);
3149 }
3150 }
3151 });
3152 }
3153 Field::Image => {
3154 if r#image_property.is_some() {
3155 return Err(<A::Error as de::Error>::duplicate_field("image"));
3156 }
3157 r#image_property = Some({
3158 struct DeserializeWith(Vec<ImageProperty>);
3159 impl<'de> Deserialize<'de> for DeserializeWith {
3160 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3161 where
3162 D: Deserializer<'de>,
3163 {
3164 Ok(DeserializeWith(serde_with::As::<
3165 serde_with::OneOrMany<serde_with::Same>,
3166 >::deserialize(deserializer)?))
3167 }
3168 }
3169 match map.next_value::<DeserializeWith>() {
3170 Ok(deserialize_with) => deserialize_with.0,
3171 Err(err) => {
3172 return Err(err);
3173 }
3174 }
3175 });
3176 }
3177 Field::MainEntityOfPage => {
3178 if r#main_entity_of_page_property.is_some() {
3179 return Err(<A::Error as de::Error>::duplicate_field(
3180 "mainEntityOfPage",
3181 ));
3182 }
3183 r#main_entity_of_page_property = Some({
3184 struct DeserializeWith(Vec<MainEntityOfPageProperty>);
3185 impl<'de> Deserialize<'de> for DeserializeWith {
3186 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3187 where
3188 D: Deserializer<'de>,
3189 {
3190 Ok(DeserializeWith(serde_with::As::<
3191 serde_with::OneOrMany<serde_with::Same>,
3192 >::deserialize(deserializer)?))
3193 }
3194 }
3195 match map.next_value::<DeserializeWith>() {
3196 Ok(deserialize_with) => deserialize_with.0,
3197 Err(err) => {
3198 return Err(err);
3199 }
3200 }
3201 });
3202 }
3203 Field::Name => {
3204 if r#name_property.is_some() {
3205 return Err(<A::Error as de::Error>::duplicate_field("name"));
3206 }
3207 r#name_property = Some({
3208 struct DeserializeWith(Vec<NameProperty>);
3209 impl<'de> Deserialize<'de> for DeserializeWith {
3210 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3211 where
3212 D: Deserializer<'de>,
3213 {
3214 Ok(DeserializeWith(serde_with::As::<
3215 serde_with::OneOrMany<serde_with::Same>,
3216 >::deserialize(deserializer)?))
3217 }
3218 }
3219 match map.next_value::<DeserializeWith>() {
3220 Ok(deserialize_with) => deserialize_with.0,
3221 Err(err) => {
3222 return Err(err);
3223 }
3224 }
3225 });
3226 }
3227 Field::PotentialAction => {
3228 if r#potential_action_property.is_some() {
3229 return Err(<A::Error as de::Error>::duplicate_field(
3230 "potentialAction",
3231 ));
3232 }
3233 r#potential_action_property = Some({
3234 struct DeserializeWith(Vec<PotentialActionProperty>);
3235 impl<'de> Deserialize<'de> for DeserializeWith {
3236 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3237 where
3238 D: Deserializer<'de>,
3239 {
3240 Ok(DeserializeWith(serde_with::As::<
3241 serde_with::OneOrMany<serde_with::Same>,
3242 >::deserialize(deserializer)?))
3243 }
3244 }
3245 match map.next_value::<DeserializeWith>() {
3246 Ok(deserialize_with) => deserialize_with.0,
3247 Err(err) => {
3248 return Err(err);
3249 }
3250 }
3251 });
3252 }
3253 Field::SameAs => {
3254 if r#same_as_property.is_some() {
3255 return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
3256 }
3257 r#same_as_property = Some({
3258 struct DeserializeWith(Vec<SameAsProperty>);
3259 impl<'de> Deserialize<'de> for DeserializeWith {
3260 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3261 where
3262 D: Deserializer<'de>,
3263 {
3264 Ok(DeserializeWith(serde_with::As::<
3265 serde_with::OneOrMany<serde_with::Same>,
3266 >::deserialize(deserializer)?))
3267 }
3268 }
3269 match map.next_value::<DeserializeWith>() {
3270 Ok(deserialize_with) => deserialize_with.0,
3271 Err(err) => {
3272 return Err(err);
3273 }
3274 }
3275 });
3276 }
3277 Field::SubjectOf => {
3278 if r#subject_of_property.is_some() {
3279 return Err(<A::Error as de::Error>::duplicate_field(
3280 "subjectOf",
3281 ));
3282 }
3283 r#subject_of_property = Some({
3284 struct DeserializeWith(Vec<SubjectOfProperty>);
3285 impl<'de> Deserialize<'de> for DeserializeWith {
3286 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3287 where
3288 D: Deserializer<'de>,
3289 {
3290 Ok(DeserializeWith(serde_with::As::<
3291 serde_with::OneOrMany<serde_with::Same>,
3292 >::deserialize(deserializer)?))
3293 }
3294 }
3295 match map.next_value::<DeserializeWith>() {
3296 Ok(deserialize_with) => deserialize_with.0,
3297 Err(err) => {
3298 return Err(err);
3299 }
3300 }
3301 });
3302 }
3303 Field::Url => {
3304 if r#url_property.is_some() {
3305 return Err(<A::Error as de::Error>::duplicate_field("url"));
3306 }
3307 r#url_property = Some({
3308 struct DeserializeWith(Vec<UrlProperty>);
3309 impl<'de> Deserialize<'de> for DeserializeWith {
3310 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3311 where
3312 D: Deserializer<'de>,
3313 {
3314 Ok(DeserializeWith(serde_with::As::<
3315 serde_with::OneOrMany<serde_with::Same>,
3316 >::deserialize(deserializer)?))
3317 }
3318 }
3319 match map.next_value::<DeserializeWith>() {
3320 Ok(deserialize_with) => deserialize_with.0,
3321 Err(err) => {
3322 return Err(err);
3323 }
3324 }
3325 });
3326 }
3327 Field::Ignore => {
3328 let _ = map.next_value::<de::IgnoredAny>()?;
3329 }
3330 }
3331 }
3332 Ok(Canal {
3333 r#additional_property: r#additional_property_property.unwrap_or_default(),
3334 r#address: r#address_property.unwrap_or_default(),
3335 r#aggregate_rating: r#aggregate_rating_property.unwrap_or_default(),
3336 r#amenity_feature: r#amenity_feature_property.unwrap_or_default(),
3337 r#branch_code: r#branch_code_property.unwrap_or_default(),
3338 r#contained_in: r#contained_in_property.unwrap_or_default(),
3339 r#contained_in_place: r#contained_in_place_property.unwrap_or_default(),
3340 r#contains_place: r#contains_place_property.unwrap_or_default(),
3341 r#event: r#event_property.unwrap_or_default(),
3342 r#events: r#events_property.unwrap_or_default(),
3343 r#fax_number: r#fax_number_property.unwrap_or_default(),
3344 r#geo: r#geo_property.unwrap_or_default(),
3345 r#geo_contains: r#geo_contains_property.unwrap_or_default(),
3346 r#geo_covered_by: r#geo_covered_by_property.unwrap_or_default(),
3347 r#geo_covers: r#geo_covers_property.unwrap_or_default(),
3348 r#geo_crosses: r#geo_crosses_property.unwrap_or_default(),
3349 r#geo_disjoint: r#geo_disjoint_property.unwrap_or_default(),
3350 r#geo_equals: r#geo_equals_property.unwrap_or_default(),
3351 r#geo_intersects: r#geo_intersects_property.unwrap_or_default(),
3352 r#geo_overlaps: r#geo_overlaps_property.unwrap_or_default(),
3353 r#geo_touches: r#geo_touches_property.unwrap_or_default(),
3354 r#geo_within: r#geo_within_property.unwrap_or_default(),
3355 r#global_location_number: r#global_location_number_property
3356 .unwrap_or_default(),
3357 r#has_drive_through_service: r#has_drive_through_service_property
3358 .unwrap_or_default(),
3359 r#has_map: r#has_map_property.unwrap_or_default(),
3360 r#is_accessible_for_free: r#is_accessible_for_free_property
3361 .unwrap_or_default(),
3362 r#isic_v_4: r#isic_v_4_property.unwrap_or_default(),
3363 r#keywords: r#keywords_property.unwrap_or_default(),
3364 r#latitude: r#latitude_property.unwrap_or_default(),
3365 r#logo: r#logo_property.unwrap_or_default(),
3366 r#longitude: r#longitude_property.unwrap_or_default(),
3367 r#map: r#map_property.unwrap_or_default(),
3368 r#maps: r#maps_property.unwrap_or_default(),
3369 r#maximum_attendee_capacity: r#maximum_attendee_capacity_property
3370 .unwrap_or_default(),
3371 r#opening_hours_specification: r#opening_hours_specification_property
3372 .unwrap_or_default(),
3373 r#photo: r#photo_property.unwrap_or_default(),
3374 r#photos: r#photos_property.unwrap_or_default(),
3375 r#public_access: r#public_access_property.unwrap_or_default(),
3376 r#review: r#review_property.unwrap_or_default(),
3377 r#reviews: r#reviews_property.unwrap_or_default(),
3378 r#slogan: r#slogan_property.unwrap_or_default(),
3379 r#smoking_allowed: r#smoking_allowed_property.unwrap_or_default(),
3380 r#special_opening_hours_specification:
3381 r#special_opening_hours_specification_property.unwrap_or_default(),
3382 r#telephone: r#telephone_property.unwrap_or_default(),
3383 r#tour_booking_page: r#tour_booking_page_property.unwrap_or_default(),
3384 r#additional_type: r#additional_type_property.unwrap_or_default(),
3385 r#alternate_name: r#alternate_name_property.unwrap_or_default(),
3386 r#description: r#description_property.unwrap_or_default(),
3387 r#disambiguating_description: r#disambiguating_description_property
3388 .unwrap_or_default(),
3389 r#identifier: r#identifier_property.unwrap_or_default(),
3390 r#image: r#image_property.unwrap_or_default(),
3391 r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
3392 r#name: r#name_property.unwrap_or_default(),
3393 r#potential_action: r#potential_action_property.unwrap_or_default(),
3394 r#same_as: r#same_as_property.unwrap_or_default(),
3395 r#subject_of: r#subject_of_property.unwrap_or_default(),
3396 r#url: r#url_property.unwrap_or_default(),
3397 })
3398 }
3399 }
3400 const FIELDS: &[&str] = &[
3401 "additionalProperty",
3402 "address",
3403 "aggregateRating",
3404 "amenityFeature",
3405 "branchCode",
3406 "containedIn",
3407 "containedInPlace",
3408 "containsPlace",
3409 "event",
3410 "events",
3411 "faxNumber",
3412 "geo",
3413 "geoContains",
3414 "geoCoveredBy",
3415 "geoCovers",
3416 "geoCrosses",
3417 "geoDisjoint",
3418 "geoEquals",
3419 "geoIntersects",
3420 "geoOverlaps",
3421 "geoTouches",
3422 "geoWithin",
3423 "globalLocationNumber",
3424 "hasDriveThroughService",
3425 "hasMap",
3426 "isAccessibleForFree",
3427 "isicV4",
3428 "keywords",
3429 "latitude",
3430 "logo",
3431 "longitude",
3432 "map",
3433 "maps",
3434 "maximumAttendeeCapacity",
3435 "openingHoursSpecification",
3436 "photo",
3437 "photos",
3438 "publicAccess",
3439 "review",
3440 "reviews",
3441 "slogan",
3442 "smokingAllowed",
3443 "specialOpeningHoursSpecification",
3444 "telephone",
3445 "tourBookingPage",
3446 "additionalType",
3447 "alternateName",
3448 "description",
3449 "disambiguatingDescription",
3450 "identifier",
3451 "image",
3452 "mainEntityOfPage",
3453 "name",
3454 "potentialAction",
3455 "sameAs",
3456 "subjectOf",
3457 "url",
3458 ];
3459 deserializer.deserialize_struct("Canal", FIELDS, ClassVisitor)
3460 }
3461 }
3462}