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