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