1use super::*;
2#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct Artery {
6 pub r#arterial_branch: Vec<ArterialBranchProperty>,
8 pub r#supply_to: Vec<SupplyToProperty>,
10 pub r#associated_pathophysiology: Vec<AssociatedPathophysiologyProperty>,
12 pub r#body_location: Vec<BodyLocationProperty>,
14 pub r#connected_to: Vec<ConnectedToProperty>,
16 pub r#diagram: Vec<DiagramProperty>,
18 pub r#part_of_system: Vec<PartOfSystemProperty>,
20 pub r#related_condition: Vec<RelatedConditionProperty>,
22 pub r#related_therapy: Vec<RelatedTherapyProperty>,
24 pub r#sub_structure: Vec<SubStructureProperty>,
26 pub r#code: Vec<CodeProperty>,
28 pub r#funding: Vec<FundingProperty>,
30 pub r#guideline: Vec<GuidelineProperty>,
32 pub r#legal_status: Vec<LegalStatusProperty>,
34 pub r#medicine_system: Vec<MedicineSystemProperty>,
36 pub r#recognizing_authority: Vec<RecognizingAuthorityProperty>,
38 pub r#relevant_specialty: Vec<RelevantSpecialtyProperty>,
40 pub r#study: Vec<StudyProperty>,
42 pub r#additional_type: Vec<AdditionalTypeProperty>,
44 pub r#alternate_name: Vec<AlternateNameProperty>,
46 pub r#description: Vec<DescriptionProperty>,
48 pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
50 pub r#identifier: Vec<IdentifierProperty>,
52 pub r#image: Vec<ImageProperty>,
54 pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
56 pub r#name: Vec<NameProperty>,
58 pub r#potential_action: Vec<PotentialActionProperty>,
60 pub r#same_as: Vec<SameAsProperty>,
62 pub r#subject_of: Vec<SubjectOfProperty>,
64 pub r#url: Vec<UrlProperty>,
66}
67pub trait ArteryTrait {
69 fn get_arterial_branch(&self) -> &[ArterialBranchProperty];
71 fn take_arterial_branch(&mut self) -> Vec<ArterialBranchProperty>;
73 fn get_supply_to(&self) -> &[SupplyToProperty];
75 fn take_supply_to(&mut self) -> Vec<SupplyToProperty>;
77}
78impl ArteryTrait for Artery {
79 fn get_arterial_branch(&self) -> &[ArterialBranchProperty] {
80 self.r#arterial_branch.as_slice()
81 }
82 fn take_arterial_branch(&mut self) -> Vec<ArterialBranchProperty> {
83 std::mem::take(&mut self.r#arterial_branch)
84 }
85 fn get_supply_to(&self) -> &[SupplyToProperty] {
86 self.r#supply_to.as_slice()
87 }
88 fn take_supply_to(&mut self) -> Vec<SupplyToProperty> {
89 std::mem::take(&mut self.r#supply_to)
90 }
91}
92impl AnatomicalStructureTrait for Artery {
93 fn get_associated_pathophysiology(&self) -> &[AssociatedPathophysiologyProperty] {
94 self.r#associated_pathophysiology.as_slice()
95 }
96 fn take_associated_pathophysiology(&mut self) -> Vec<AssociatedPathophysiologyProperty> {
97 std::mem::take(&mut self.r#associated_pathophysiology)
98 }
99 fn get_body_location(&self) -> &[BodyLocationProperty] {
100 self.r#body_location.as_slice()
101 }
102 fn take_body_location(&mut self) -> Vec<BodyLocationProperty> {
103 std::mem::take(&mut self.r#body_location)
104 }
105 fn get_connected_to(&self) -> &[ConnectedToProperty] {
106 self.r#connected_to.as_slice()
107 }
108 fn take_connected_to(&mut self) -> Vec<ConnectedToProperty> {
109 std::mem::take(&mut self.r#connected_to)
110 }
111 fn get_diagram(&self) -> &[DiagramProperty] {
112 self.r#diagram.as_slice()
113 }
114 fn take_diagram(&mut self) -> Vec<DiagramProperty> {
115 std::mem::take(&mut self.r#diagram)
116 }
117 fn get_part_of_system(&self) -> &[PartOfSystemProperty] {
118 self.r#part_of_system.as_slice()
119 }
120 fn take_part_of_system(&mut self) -> Vec<PartOfSystemProperty> {
121 std::mem::take(&mut self.r#part_of_system)
122 }
123 fn get_related_condition(&self) -> &[RelatedConditionProperty] {
124 self.r#related_condition.as_slice()
125 }
126 fn take_related_condition(&mut self) -> Vec<RelatedConditionProperty> {
127 std::mem::take(&mut self.r#related_condition)
128 }
129 fn get_related_therapy(&self) -> &[RelatedTherapyProperty] {
130 self.r#related_therapy.as_slice()
131 }
132 fn take_related_therapy(&mut self) -> Vec<RelatedTherapyProperty> {
133 std::mem::take(&mut self.r#related_therapy)
134 }
135 fn get_sub_structure(&self) -> &[SubStructureProperty] {
136 self.r#sub_structure.as_slice()
137 }
138 fn take_sub_structure(&mut self) -> Vec<SubStructureProperty> {
139 std::mem::take(&mut self.r#sub_structure)
140 }
141}
142impl MedicalEntityTrait for Artery {
143 fn get_code(&self) -> &[CodeProperty] {
144 self.r#code.as_slice()
145 }
146 fn take_code(&mut self) -> Vec<CodeProperty> {
147 std::mem::take(&mut self.r#code)
148 }
149 fn get_funding(&self) -> &[FundingProperty] {
150 self.r#funding.as_slice()
151 }
152 fn take_funding(&mut self) -> Vec<FundingProperty> {
153 std::mem::take(&mut self.r#funding)
154 }
155 fn get_guideline(&self) -> &[GuidelineProperty] {
156 self.r#guideline.as_slice()
157 }
158 fn take_guideline(&mut self) -> Vec<GuidelineProperty> {
159 std::mem::take(&mut self.r#guideline)
160 }
161 fn get_legal_status(&self) -> &[LegalStatusProperty] {
162 self.r#legal_status.as_slice()
163 }
164 fn take_legal_status(&mut self) -> Vec<LegalStatusProperty> {
165 std::mem::take(&mut self.r#legal_status)
166 }
167 fn get_medicine_system(&self) -> &[MedicineSystemProperty] {
168 self.r#medicine_system.as_slice()
169 }
170 fn take_medicine_system(&mut self) -> Vec<MedicineSystemProperty> {
171 std::mem::take(&mut self.r#medicine_system)
172 }
173 fn get_recognizing_authority(&self) -> &[RecognizingAuthorityProperty] {
174 self.r#recognizing_authority.as_slice()
175 }
176 fn take_recognizing_authority(&mut self) -> Vec<RecognizingAuthorityProperty> {
177 std::mem::take(&mut self.r#recognizing_authority)
178 }
179 fn get_relevant_specialty(&self) -> &[RelevantSpecialtyProperty] {
180 self.r#relevant_specialty.as_slice()
181 }
182 fn take_relevant_specialty(&mut self) -> Vec<RelevantSpecialtyProperty> {
183 std::mem::take(&mut self.r#relevant_specialty)
184 }
185 fn get_study(&self) -> &[StudyProperty] {
186 self.r#study.as_slice()
187 }
188 fn take_study(&mut self) -> Vec<StudyProperty> {
189 std::mem::take(&mut self.r#study)
190 }
191}
192impl ThingTrait for Artery {
193 fn get_additional_type(&self) -> &[AdditionalTypeProperty] {
194 self.r#additional_type.as_slice()
195 }
196 fn take_additional_type(&mut self) -> Vec<AdditionalTypeProperty> {
197 std::mem::take(&mut self.r#additional_type)
198 }
199 fn get_alternate_name(&self) -> &[AlternateNameProperty] {
200 self.r#alternate_name.as_slice()
201 }
202 fn take_alternate_name(&mut self) -> Vec<AlternateNameProperty> {
203 std::mem::take(&mut self.r#alternate_name)
204 }
205 fn get_description(&self) -> &[DescriptionProperty] {
206 self.r#description.as_slice()
207 }
208 fn take_description(&mut self) -> Vec<DescriptionProperty> {
209 std::mem::take(&mut self.r#description)
210 }
211 fn get_disambiguating_description(&self) -> &[DisambiguatingDescriptionProperty] {
212 self.r#disambiguating_description.as_slice()
213 }
214 fn take_disambiguating_description(&mut self) -> Vec<DisambiguatingDescriptionProperty> {
215 std::mem::take(&mut self.r#disambiguating_description)
216 }
217 fn get_identifier(&self) -> &[IdentifierProperty] {
218 self.r#identifier.as_slice()
219 }
220 fn take_identifier(&mut self) -> Vec<IdentifierProperty> {
221 std::mem::take(&mut self.r#identifier)
222 }
223 fn get_image(&self) -> &[ImageProperty] {
224 self.r#image.as_slice()
225 }
226 fn take_image(&mut self) -> Vec<ImageProperty> {
227 std::mem::take(&mut self.r#image)
228 }
229 fn get_main_entity_of_page(&self) -> &[MainEntityOfPageProperty] {
230 self.r#main_entity_of_page.as_slice()
231 }
232 fn take_main_entity_of_page(&mut self) -> Vec<MainEntityOfPageProperty> {
233 std::mem::take(&mut self.r#main_entity_of_page)
234 }
235 fn get_name(&self) -> &[NameProperty] {
236 self.r#name.as_slice()
237 }
238 fn take_name(&mut self) -> Vec<NameProperty> {
239 std::mem::take(&mut self.r#name)
240 }
241 fn get_potential_action(&self) -> &[PotentialActionProperty] {
242 self.r#potential_action.as_slice()
243 }
244 fn take_potential_action(&mut self) -> Vec<PotentialActionProperty> {
245 std::mem::take(&mut self.r#potential_action)
246 }
247 fn get_same_as(&self) -> &[SameAsProperty] {
248 self.r#same_as.as_slice()
249 }
250 fn take_same_as(&mut self) -> Vec<SameAsProperty> {
251 std::mem::take(&mut self.r#same_as)
252 }
253 fn get_subject_of(&self) -> &[SubjectOfProperty] {
254 self.r#subject_of.as_slice()
255 }
256 fn take_subject_of(&mut self) -> Vec<SubjectOfProperty> {
257 std::mem::take(&mut self.r#subject_of)
258 }
259 fn get_url(&self) -> &[UrlProperty] {
260 self.r#url.as_slice()
261 }
262 fn take_url(&mut self) -> Vec<UrlProperty> {
263 std::mem::take(&mut self.r#url)
264 }
265}
266impl VesselTrait for Artery {}
267#[cfg(feature = "serde")]
268mod serde {
269 use std::{fmt, fmt::Formatter};
270
271 use ::serde::{
272 de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
273 };
274
275 use super::*;
276 impl Serialize for Artery {
277 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
278 where
279 S: Serializer,
280 {
281 let len: usize = [
282 !Vec::is_empty(&self.r#arterial_branch) as usize,
283 !Vec::is_empty(&self.r#supply_to) as usize,
284 !Vec::is_empty(&self.r#associated_pathophysiology) as usize,
285 !Vec::is_empty(&self.r#body_location) as usize,
286 !Vec::is_empty(&self.r#connected_to) as usize,
287 !Vec::is_empty(&self.r#diagram) as usize,
288 !Vec::is_empty(&self.r#part_of_system) as usize,
289 !Vec::is_empty(&self.r#related_condition) as usize,
290 !Vec::is_empty(&self.r#related_therapy) as usize,
291 !Vec::is_empty(&self.r#sub_structure) as usize,
292 !Vec::is_empty(&self.r#code) as usize,
293 !Vec::is_empty(&self.r#funding) as usize,
294 !Vec::is_empty(&self.r#guideline) as usize,
295 !Vec::is_empty(&self.r#legal_status) as usize,
296 !Vec::is_empty(&self.r#medicine_system) as usize,
297 !Vec::is_empty(&self.r#recognizing_authority) as usize,
298 !Vec::is_empty(&self.r#relevant_specialty) as usize,
299 !Vec::is_empty(&self.r#study) as usize,
300 !Vec::is_empty(&self.r#additional_type) as usize,
301 !Vec::is_empty(&self.r#alternate_name) as usize,
302 !Vec::is_empty(&self.r#description) as usize,
303 !Vec::is_empty(&self.r#disambiguating_description) as usize,
304 !Vec::is_empty(&self.r#identifier) as usize,
305 !Vec::is_empty(&self.r#image) as usize,
306 !Vec::is_empty(&self.r#main_entity_of_page) as usize,
307 !Vec::is_empty(&self.r#name) as usize,
308 !Vec::is_empty(&self.r#potential_action) as usize,
309 !Vec::is_empty(&self.r#same_as) as usize,
310 !Vec::is_empty(&self.r#subject_of) as usize,
311 !Vec::is_empty(&self.r#url) as usize,
312 ]
313 .iter()
314 .sum();
315 let mut serialize_struct = Serializer::serialize_struct(serializer, "Artery", len)?;
316 if !Vec::is_empty(&self.r#arterial_branch) {
317 serialize_struct.serialize_field("arterialBranch", {
318 struct SerializeWith<'a>(&'a Vec<ArterialBranchProperty>);
319 impl<'a> Serialize for SerializeWith<'a> {
320 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
321 where
322 S: Serializer,
323 {
324 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
325 self.0, serializer,
326 )
327 }
328 }
329 &SerializeWith(&self.r#arterial_branch)
330 })?;
331 } else {
332 serialize_struct.skip_field("arterialBranch")?;
333 }
334 if !Vec::is_empty(&self.r#supply_to) {
335 serialize_struct.serialize_field("supplyTo", {
336 struct SerializeWith<'a>(&'a Vec<SupplyToProperty>);
337 impl<'a> Serialize for SerializeWith<'a> {
338 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
339 where
340 S: Serializer,
341 {
342 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
343 self.0, serializer,
344 )
345 }
346 }
347 &SerializeWith(&self.r#supply_to)
348 })?;
349 } else {
350 serialize_struct.skip_field("supplyTo")?;
351 }
352 if !Vec::is_empty(&self.r#associated_pathophysiology) {
353 serialize_struct.serialize_field("associatedPathophysiology", {
354 struct SerializeWith<'a>(&'a Vec<AssociatedPathophysiologyProperty>);
355 impl<'a> Serialize for SerializeWith<'a> {
356 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
357 where
358 S: Serializer,
359 {
360 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
361 self.0, serializer,
362 )
363 }
364 }
365 &SerializeWith(&self.r#associated_pathophysiology)
366 })?;
367 } else {
368 serialize_struct.skip_field("associatedPathophysiology")?;
369 }
370 if !Vec::is_empty(&self.r#body_location) {
371 serialize_struct.serialize_field("bodyLocation", {
372 struct SerializeWith<'a>(&'a Vec<BodyLocationProperty>);
373 impl<'a> Serialize for SerializeWith<'a> {
374 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
375 where
376 S: Serializer,
377 {
378 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
379 self.0, serializer,
380 )
381 }
382 }
383 &SerializeWith(&self.r#body_location)
384 })?;
385 } else {
386 serialize_struct.skip_field("bodyLocation")?;
387 }
388 if !Vec::is_empty(&self.r#connected_to) {
389 serialize_struct.serialize_field("connectedTo", {
390 struct SerializeWith<'a>(&'a Vec<ConnectedToProperty>);
391 impl<'a> Serialize for SerializeWith<'a> {
392 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
393 where
394 S: Serializer,
395 {
396 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
397 self.0, serializer,
398 )
399 }
400 }
401 &SerializeWith(&self.r#connected_to)
402 })?;
403 } else {
404 serialize_struct.skip_field("connectedTo")?;
405 }
406 if !Vec::is_empty(&self.r#diagram) {
407 serialize_struct.serialize_field("diagram", {
408 struct SerializeWith<'a>(&'a Vec<DiagramProperty>);
409 impl<'a> Serialize for SerializeWith<'a> {
410 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
411 where
412 S: Serializer,
413 {
414 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
415 self.0, serializer,
416 )
417 }
418 }
419 &SerializeWith(&self.r#diagram)
420 })?;
421 } else {
422 serialize_struct.skip_field("diagram")?;
423 }
424 if !Vec::is_empty(&self.r#part_of_system) {
425 serialize_struct.serialize_field("partOfSystem", {
426 struct SerializeWith<'a>(&'a Vec<PartOfSystemProperty>);
427 impl<'a> Serialize for SerializeWith<'a> {
428 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
429 where
430 S: Serializer,
431 {
432 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
433 self.0, serializer,
434 )
435 }
436 }
437 &SerializeWith(&self.r#part_of_system)
438 })?;
439 } else {
440 serialize_struct.skip_field("partOfSystem")?;
441 }
442 if !Vec::is_empty(&self.r#related_condition) {
443 serialize_struct.serialize_field("relatedCondition", {
444 struct SerializeWith<'a>(&'a Vec<RelatedConditionProperty>);
445 impl<'a> Serialize for SerializeWith<'a> {
446 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
447 where
448 S: Serializer,
449 {
450 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
451 self.0, serializer,
452 )
453 }
454 }
455 &SerializeWith(&self.r#related_condition)
456 })?;
457 } else {
458 serialize_struct.skip_field("relatedCondition")?;
459 }
460 if !Vec::is_empty(&self.r#related_therapy) {
461 serialize_struct.serialize_field("relatedTherapy", {
462 struct SerializeWith<'a>(&'a Vec<RelatedTherapyProperty>);
463 impl<'a> Serialize for SerializeWith<'a> {
464 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
465 where
466 S: Serializer,
467 {
468 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
469 self.0, serializer,
470 )
471 }
472 }
473 &SerializeWith(&self.r#related_therapy)
474 })?;
475 } else {
476 serialize_struct.skip_field("relatedTherapy")?;
477 }
478 if !Vec::is_empty(&self.r#sub_structure) {
479 serialize_struct.serialize_field("subStructure", {
480 struct SerializeWith<'a>(&'a Vec<SubStructureProperty>);
481 impl<'a> Serialize for SerializeWith<'a> {
482 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
483 where
484 S: Serializer,
485 {
486 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
487 self.0, serializer,
488 )
489 }
490 }
491 &SerializeWith(&self.r#sub_structure)
492 })?;
493 } else {
494 serialize_struct.skip_field("subStructure")?;
495 }
496 if !Vec::is_empty(&self.r#code) {
497 serialize_struct.serialize_field("code", {
498 struct SerializeWith<'a>(&'a Vec<CodeProperty>);
499 impl<'a> Serialize for SerializeWith<'a> {
500 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
501 where
502 S: Serializer,
503 {
504 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
505 self.0, serializer,
506 )
507 }
508 }
509 &SerializeWith(&self.r#code)
510 })?;
511 } else {
512 serialize_struct.skip_field("code")?;
513 }
514 if !Vec::is_empty(&self.r#funding) {
515 serialize_struct.serialize_field("funding", {
516 struct SerializeWith<'a>(&'a Vec<FundingProperty>);
517 impl<'a> Serialize for SerializeWith<'a> {
518 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
519 where
520 S: Serializer,
521 {
522 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
523 self.0, serializer,
524 )
525 }
526 }
527 &SerializeWith(&self.r#funding)
528 })?;
529 } else {
530 serialize_struct.skip_field("funding")?;
531 }
532 if !Vec::is_empty(&self.r#guideline) {
533 serialize_struct.serialize_field("guideline", {
534 struct SerializeWith<'a>(&'a Vec<GuidelineProperty>);
535 impl<'a> Serialize for SerializeWith<'a> {
536 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
537 where
538 S: Serializer,
539 {
540 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
541 self.0, serializer,
542 )
543 }
544 }
545 &SerializeWith(&self.r#guideline)
546 })?;
547 } else {
548 serialize_struct.skip_field("guideline")?;
549 }
550 if !Vec::is_empty(&self.r#legal_status) {
551 serialize_struct.serialize_field("legalStatus", {
552 struct SerializeWith<'a>(&'a Vec<LegalStatusProperty>);
553 impl<'a> Serialize for SerializeWith<'a> {
554 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
555 where
556 S: Serializer,
557 {
558 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
559 self.0, serializer,
560 )
561 }
562 }
563 &SerializeWith(&self.r#legal_status)
564 })?;
565 } else {
566 serialize_struct.skip_field("legalStatus")?;
567 }
568 if !Vec::is_empty(&self.r#medicine_system) {
569 serialize_struct.serialize_field("medicineSystem", {
570 struct SerializeWith<'a>(&'a Vec<MedicineSystemProperty>);
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#medicine_system)
582 })?;
583 } else {
584 serialize_struct.skip_field("medicineSystem")?;
585 }
586 if !Vec::is_empty(&self.r#recognizing_authority) {
587 serialize_struct.serialize_field("recognizingAuthority", {
588 struct SerializeWith<'a>(&'a Vec<RecognizingAuthorityProperty>);
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#recognizing_authority)
600 })?;
601 } else {
602 serialize_struct.skip_field("recognizingAuthority")?;
603 }
604 if !Vec::is_empty(&self.r#relevant_specialty) {
605 serialize_struct.serialize_field("relevantSpecialty", {
606 struct SerializeWith<'a>(&'a Vec<RelevantSpecialtyProperty>);
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#relevant_specialty)
618 })?;
619 } else {
620 serialize_struct.skip_field("relevantSpecialty")?;
621 }
622 if !Vec::is_empty(&self.r#study) {
623 serialize_struct.serialize_field("study", {
624 struct SerializeWith<'a>(&'a Vec<StudyProperty>);
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#study)
636 })?;
637 } else {
638 serialize_struct.skip_field("study")?;
639 }
640 if !Vec::is_empty(&self.r#additional_type) {
641 serialize_struct.serialize_field("additionalType", {
642 struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
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#additional_type)
654 })?;
655 } else {
656 serialize_struct.skip_field("additionalType")?;
657 }
658 if !Vec::is_empty(&self.r#alternate_name) {
659 serialize_struct.serialize_field("alternateName", {
660 struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
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#alternate_name)
672 })?;
673 } else {
674 serialize_struct.skip_field("alternateName")?;
675 }
676 if !Vec::is_empty(&self.r#description) {
677 serialize_struct.serialize_field("description", {
678 struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
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#description)
690 })?;
691 } else {
692 serialize_struct.skip_field("description")?;
693 }
694 if !Vec::is_empty(&self.r#disambiguating_description) {
695 serialize_struct.serialize_field("disambiguatingDescription", {
696 struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
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#disambiguating_description)
708 })?;
709 } else {
710 serialize_struct.skip_field("disambiguatingDescription")?;
711 }
712 if !Vec::is_empty(&self.r#identifier) {
713 serialize_struct.serialize_field("identifier", {
714 struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
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#identifier)
726 })?;
727 } else {
728 serialize_struct.skip_field("identifier")?;
729 }
730 if !Vec::is_empty(&self.r#image) {
731 serialize_struct.serialize_field("image", {
732 struct SerializeWith<'a>(&'a Vec<ImageProperty>);
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#image)
744 })?;
745 } else {
746 serialize_struct.skip_field("image")?;
747 }
748 if !Vec::is_empty(&self.r#main_entity_of_page) {
749 serialize_struct.serialize_field("mainEntityOfPage", {
750 struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
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#main_entity_of_page)
762 })?;
763 } else {
764 serialize_struct.skip_field("mainEntityOfPage")?;
765 }
766 if !Vec::is_empty(&self.r#name) {
767 serialize_struct.serialize_field("name", {
768 struct SerializeWith<'a>(&'a Vec<NameProperty>);
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#name)
780 })?;
781 } else {
782 serialize_struct.skip_field("name")?;
783 }
784 if !Vec::is_empty(&self.r#potential_action) {
785 serialize_struct.serialize_field("potentialAction", {
786 struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
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#potential_action)
798 })?;
799 } else {
800 serialize_struct.skip_field("potentialAction")?;
801 }
802 if !Vec::is_empty(&self.r#same_as) {
803 serialize_struct.serialize_field("sameAs", {
804 struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
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#same_as)
816 })?;
817 } else {
818 serialize_struct.skip_field("sameAs")?;
819 }
820 if !Vec::is_empty(&self.r#subject_of) {
821 serialize_struct.serialize_field("subjectOf", {
822 struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
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#subject_of)
834 })?;
835 } else {
836 serialize_struct.skip_field("subjectOf")?;
837 }
838 if !Vec::is_empty(&self.r#url) {
839 serialize_struct.serialize_field("url", {
840 struct SerializeWith<'a>(&'a Vec<UrlProperty>);
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#url)
852 })?;
853 } else {
854 serialize_struct.skip_field("url")?;
855 }
856 serialize_struct.end()
857 }
858 }
859 impl<'de> Deserialize<'de> for Artery {
860 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
861 where
862 D: Deserializer<'de>,
863 {
864 enum Field {
865 ArterialBranch,
866 SupplyTo,
867 AssociatedPathophysiology,
868 BodyLocation,
869 ConnectedTo,
870 Diagram,
871 PartOfSystem,
872 RelatedCondition,
873 RelatedTherapy,
874 SubStructure,
875 Code,
876 Funding,
877 Guideline,
878 LegalStatus,
879 MedicineSystem,
880 RecognizingAuthority,
881 RelevantSpecialty,
882 Study,
883 AdditionalType,
884 AlternateName,
885 Description,
886 DisambiguatingDescription,
887 Identifier,
888 Image,
889 MainEntityOfPage,
890 Name,
891 PotentialAction,
892 SameAs,
893 SubjectOf,
894 Url,
895 Ignore,
896 }
897 struct FieldVisitor;
898 impl<'de> Visitor<'de> for FieldVisitor {
899 type Value = Field;
900 fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
901 formatter.write_str("field identifier")
902 }
903 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
904 where
905 E: de::Error,
906 {
907 match value {
908 "arterialBranch" => Ok(Field::ArterialBranch),
909 "supplyTo" => Ok(Field::SupplyTo),
910 "associatedPathophysiology" => Ok(Field::AssociatedPathophysiology),
911 "bodyLocation" => Ok(Field::BodyLocation),
912 "connectedTo" => Ok(Field::ConnectedTo),
913 "diagram" => Ok(Field::Diagram),
914 "partOfSystem" => Ok(Field::PartOfSystem),
915 "relatedCondition" => Ok(Field::RelatedCondition),
916 "relatedTherapy" => Ok(Field::RelatedTherapy),
917 "subStructure" => Ok(Field::SubStructure),
918 "code" => Ok(Field::Code),
919 "funding" => Ok(Field::Funding),
920 "guideline" => Ok(Field::Guideline),
921 "legalStatus" => Ok(Field::LegalStatus),
922 "medicineSystem" => Ok(Field::MedicineSystem),
923 "recognizingAuthority" => Ok(Field::RecognizingAuthority),
924 "relevantSpecialty" => Ok(Field::RelevantSpecialty),
925 "study" => Ok(Field::Study),
926 "additionalType" => Ok(Field::AdditionalType),
927 "alternateName" => Ok(Field::AlternateName),
928 "description" => Ok(Field::Description),
929 "disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
930 "identifier" => Ok(Field::Identifier),
931 "image" => Ok(Field::Image),
932 "mainEntityOfPage" => Ok(Field::MainEntityOfPage),
933 "name" => Ok(Field::Name),
934 "potentialAction" => Ok(Field::PotentialAction),
935 "sameAs" => Ok(Field::SameAs),
936 "subjectOf" => Ok(Field::SubjectOf),
937 "url" => Ok(Field::Url),
938 "id" | "type" => Ok(Field::Ignore),
939 _ => Err(de::Error::unknown_field(value, FIELDS)),
940 }
941 }
942 fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
943 where
944 E: de::Error,
945 {
946 match value {
947 b"arterialBranch" => Ok(Field::ArterialBranch),
948 b"supplyTo" => Ok(Field::SupplyTo),
949 b"associatedPathophysiology" => Ok(Field::AssociatedPathophysiology),
950 b"bodyLocation" => Ok(Field::BodyLocation),
951 b"connectedTo" => Ok(Field::ConnectedTo),
952 b"diagram" => Ok(Field::Diagram),
953 b"partOfSystem" => Ok(Field::PartOfSystem),
954 b"relatedCondition" => Ok(Field::RelatedCondition),
955 b"relatedTherapy" => Ok(Field::RelatedTherapy),
956 b"subStructure" => Ok(Field::SubStructure),
957 b"code" => Ok(Field::Code),
958 b"funding" => Ok(Field::Funding),
959 b"guideline" => Ok(Field::Guideline),
960 b"legalStatus" => Ok(Field::LegalStatus),
961 b"medicineSystem" => Ok(Field::MedicineSystem),
962 b"recognizingAuthority" => Ok(Field::RecognizingAuthority),
963 b"relevantSpecialty" => Ok(Field::RelevantSpecialty),
964 b"study" => Ok(Field::Study),
965 b"additionalType" => Ok(Field::AdditionalType),
966 b"alternateName" => Ok(Field::AlternateName),
967 b"description" => Ok(Field::Description),
968 b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
969 b"identifier" => Ok(Field::Identifier),
970 b"image" => Ok(Field::Image),
971 b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
972 b"name" => Ok(Field::Name),
973 b"potentialAction" => Ok(Field::PotentialAction),
974 b"sameAs" => Ok(Field::SameAs),
975 b"subjectOf" => Ok(Field::SubjectOf),
976 b"url" => Ok(Field::Url),
977 b"id" | b"type" => Ok(Field::Ignore),
978 _ => {
979 let value = &String::from_utf8_lossy(value);
980 Err(de::Error::unknown_field(value, FIELDS))
981 }
982 }
983 }
984 }
985 impl<'de> Deserialize<'de> for Field {
986 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
987 where
988 D: Deserializer<'de>,
989 {
990 deserializer.deserialize_identifier(FieldVisitor)
991 }
992 }
993 struct ClassVisitor;
994 impl<'de> Visitor<'de> for ClassVisitor {
995 type Value = Artery;
996 fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
997 formatter.write_str("schema.org schema Artery")
998 }
999 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
1000 where
1001 A: de::MapAccess<'de>,
1002 {
1003 let mut r#arterial_branch_property = None;
1004 let mut r#supply_to_property = None;
1005 let mut r#associated_pathophysiology_property = None;
1006 let mut r#body_location_property = None;
1007 let mut r#connected_to_property = None;
1008 let mut r#diagram_property = None;
1009 let mut r#part_of_system_property = None;
1010 let mut r#related_condition_property = None;
1011 let mut r#related_therapy_property = None;
1012 let mut r#sub_structure_property = None;
1013 let mut r#code_property = None;
1014 let mut r#funding_property = None;
1015 let mut r#guideline_property = None;
1016 let mut r#legal_status_property = None;
1017 let mut r#medicine_system_property = None;
1018 let mut r#recognizing_authority_property = None;
1019 let mut r#relevant_specialty_property = None;
1020 let mut r#study_property = None;
1021 let mut r#additional_type_property = None;
1022 let mut r#alternate_name_property = None;
1023 let mut r#description_property = None;
1024 let mut r#disambiguating_description_property = None;
1025 let mut r#identifier_property = None;
1026 let mut r#image_property = None;
1027 let mut r#main_entity_of_page_property = None;
1028 let mut r#name_property = None;
1029 let mut r#potential_action_property = None;
1030 let mut r#same_as_property = None;
1031 let mut r#subject_of_property = None;
1032 let mut r#url_property = None;
1033 while let Some(key) = map.next_key::<Field>()? {
1034 match key {
1035 Field::ArterialBranch => {
1036 if r#arterial_branch_property.is_some() {
1037 return Err(<A::Error as de::Error>::duplicate_field(
1038 "arterialBranch",
1039 ));
1040 }
1041 r#arterial_branch_property = Some({
1042 struct DeserializeWith(Vec<ArterialBranchProperty>);
1043 impl<'de> Deserialize<'de> for DeserializeWith {
1044 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1045 where
1046 D: Deserializer<'de>,
1047 {
1048 Ok(DeserializeWith(serde_with::As::<
1049 serde_with::OneOrMany<serde_with::Same>,
1050 >::deserialize(deserializer)?))
1051 }
1052 }
1053 match map.next_value::<DeserializeWith>() {
1054 Ok(deserialize_with) => deserialize_with.0,
1055 Err(err) => {
1056 return Err(err);
1057 }
1058 }
1059 });
1060 }
1061 Field::SupplyTo => {
1062 if r#supply_to_property.is_some() {
1063 return Err(<A::Error as de::Error>::duplicate_field(
1064 "supplyTo",
1065 ));
1066 }
1067 r#supply_to_property = Some({
1068 struct DeserializeWith(Vec<SupplyToProperty>);
1069 impl<'de> Deserialize<'de> for DeserializeWith {
1070 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1071 where
1072 D: Deserializer<'de>,
1073 {
1074 Ok(DeserializeWith(serde_with::As::<
1075 serde_with::OneOrMany<serde_with::Same>,
1076 >::deserialize(deserializer)?))
1077 }
1078 }
1079 match map.next_value::<DeserializeWith>() {
1080 Ok(deserialize_with) => deserialize_with.0,
1081 Err(err) => {
1082 return Err(err);
1083 }
1084 }
1085 });
1086 }
1087 Field::AssociatedPathophysiology => {
1088 if r#associated_pathophysiology_property.is_some() {
1089 return Err(<A::Error as de::Error>::duplicate_field(
1090 "associatedPathophysiology",
1091 ));
1092 }
1093 r#associated_pathophysiology_property = Some({
1094 struct DeserializeWith(Vec<AssociatedPathophysiologyProperty>);
1095 impl<'de> Deserialize<'de> for DeserializeWith {
1096 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1097 where
1098 D: Deserializer<'de>,
1099 {
1100 Ok(DeserializeWith(serde_with::As::<
1101 serde_with::OneOrMany<serde_with::Same>,
1102 >::deserialize(deserializer)?))
1103 }
1104 }
1105 match map.next_value::<DeserializeWith>() {
1106 Ok(deserialize_with) => deserialize_with.0,
1107 Err(err) => {
1108 return Err(err);
1109 }
1110 }
1111 });
1112 }
1113 Field::BodyLocation => {
1114 if r#body_location_property.is_some() {
1115 return Err(<A::Error as de::Error>::duplicate_field(
1116 "bodyLocation",
1117 ));
1118 }
1119 r#body_location_property = Some({
1120 struct DeserializeWith(Vec<BodyLocationProperty>);
1121 impl<'de> Deserialize<'de> for DeserializeWith {
1122 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1123 where
1124 D: Deserializer<'de>,
1125 {
1126 Ok(DeserializeWith(serde_with::As::<
1127 serde_with::OneOrMany<serde_with::Same>,
1128 >::deserialize(deserializer)?))
1129 }
1130 }
1131 match map.next_value::<DeserializeWith>() {
1132 Ok(deserialize_with) => deserialize_with.0,
1133 Err(err) => {
1134 return Err(err);
1135 }
1136 }
1137 });
1138 }
1139 Field::ConnectedTo => {
1140 if r#connected_to_property.is_some() {
1141 return Err(<A::Error as de::Error>::duplicate_field(
1142 "connectedTo",
1143 ));
1144 }
1145 r#connected_to_property = Some({
1146 struct DeserializeWith(Vec<ConnectedToProperty>);
1147 impl<'de> Deserialize<'de> for DeserializeWith {
1148 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1149 where
1150 D: Deserializer<'de>,
1151 {
1152 Ok(DeserializeWith(serde_with::As::<
1153 serde_with::OneOrMany<serde_with::Same>,
1154 >::deserialize(deserializer)?))
1155 }
1156 }
1157 match map.next_value::<DeserializeWith>() {
1158 Ok(deserialize_with) => deserialize_with.0,
1159 Err(err) => {
1160 return Err(err);
1161 }
1162 }
1163 });
1164 }
1165 Field::Diagram => {
1166 if r#diagram_property.is_some() {
1167 return Err(<A::Error as de::Error>::duplicate_field(
1168 "diagram",
1169 ));
1170 }
1171 r#diagram_property = Some({
1172 struct DeserializeWith(Vec<DiagramProperty>);
1173 impl<'de> Deserialize<'de> for DeserializeWith {
1174 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1175 where
1176 D: Deserializer<'de>,
1177 {
1178 Ok(DeserializeWith(serde_with::As::<
1179 serde_with::OneOrMany<serde_with::Same>,
1180 >::deserialize(deserializer)?))
1181 }
1182 }
1183 match map.next_value::<DeserializeWith>() {
1184 Ok(deserialize_with) => deserialize_with.0,
1185 Err(err) => {
1186 return Err(err);
1187 }
1188 }
1189 });
1190 }
1191 Field::PartOfSystem => {
1192 if r#part_of_system_property.is_some() {
1193 return Err(<A::Error as de::Error>::duplicate_field(
1194 "partOfSystem",
1195 ));
1196 }
1197 r#part_of_system_property = Some({
1198 struct DeserializeWith(Vec<PartOfSystemProperty>);
1199 impl<'de> Deserialize<'de> for DeserializeWith {
1200 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1201 where
1202 D: Deserializer<'de>,
1203 {
1204 Ok(DeserializeWith(serde_with::As::<
1205 serde_with::OneOrMany<serde_with::Same>,
1206 >::deserialize(deserializer)?))
1207 }
1208 }
1209 match map.next_value::<DeserializeWith>() {
1210 Ok(deserialize_with) => deserialize_with.0,
1211 Err(err) => {
1212 return Err(err);
1213 }
1214 }
1215 });
1216 }
1217 Field::RelatedCondition => {
1218 if r#related_condition_property.is_some() {
1219 return Err(<A::Error as de::Error>::duplicate_field(
1220 "relatedCondition",
1221 ));
1222 }
1223 r#related_condition_property = Some({
1224 struct DeserializeWith(Vec<RelatedConditionProperty>);
1225 impl<'de> Deserialize<'de> for DeserializeWith {
1226 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1227 where
1228 D: Deserializer<'de>,
1229 {
1230 Ok(DeserializeWith(serde_with::As::<
1231 serde_with::OneOrMany<serde_with::Same>,
1232 >::deserialize(deserializer)?))
1233 }
1234 }
1235 match map.next_value::<DeserializeWith>() {
1236 Ok(deserialize_with) => deserialize_with.0,
1237 Err(err) => {
1238 return Err(err);
1239 }
1240 }
1241 });
1242 }
1243 Field::RelatedTherapy => {
1244 if r#related_therapy_property.is_some() {
1245 return Err(<A::Error as de::Error>::duplicate_field(
1246 "relatedTherapy",
1247 ));
1248 }
1249 r#related_therapy_property = Some({
1250 struct DeserializeWith(Vec<RelatedTherapyProperty>);
1251 impl<'de> Deserialize<'de> for DeserializeWith {
1252 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1253 where
1254 D: Deserializer<'de>,
1255 {
1256 Ok(DeserializeWith(serde_with::As::<
1257 serde_with::OneOrMany<serde_with::Same>,
1258 >::deserialize(deserializer)?))
1259 }
1260 }
1261 match map.next_value::<DeserializeWith>() {
1262 Ok(deserialize_with) => deserialize_with.0,
1263 Err(err) => {
1264 return Err(err);
1265 }
1266 }
1267 });
1268 }
1269 Field::SubStructure => {
1270 if r#sub_structure_property.is_some() {
1271 return Err(<A::Error as de::Error>::duplicate_field(
1272 "subStructure",
1273 ));
1274 }
1275 r#sub_structure_property = Some({
1276 struct DeserializeWith(Vec<SubStructureProperty>);
1277 impl<'de> Deserialize<'de> for DeserializeWith {
1278 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1279 where
1280 D: Deserializer<'de>,
1281 {
1282 Ok(DeserializeWith(serde_with::As::<
1283 serde_with::OneOrMany<serde_with::Same>,
1284 >::deserialize(deserializer)?))
1285 }
1286 }
1287 match map.next_value::<DeserializeWith>() {
1288 Ok(deserialize_with) => deserialize_with.0,
1289 Err(err) => {
1290 return Err(err);
1291 }
1292 }
1293 });
1294 }
1295 Field::Code => {
1296 if r#code_property.is_some() {
1297 return Err(<A::Error as de::Error>::duplicate_field("code"));
1298 }
1299 r#code_property = Some({
1300 struct DeserializeWith(Vec<CodeProperty>);
1301 impl<'de> Deserialize<'de> for DeserializeWith {
1302 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1303 where
1304 D: Deserializer<'de>,
1305 {
1306 Ok(DeserializeWith(serde_with::As::<
1307 serde_with::OneOrMany<serde_with::Same>,
1308 >::deserialize(deserializer)?))
1309 }
1310 }
1311 match map.next_value::<DeserializeWith>() {
1312 Ok(deserialize_with) => deserialize_with.0,
1313 Err(err) => {
1314 return Err(err);
1315 }
1316 }
1317 });
1318 }
1319 Field::Funding => {
1320 if r#funding_property.is_some() {
1321 return Err(<A::Error as de::Error>::duplicate_field(
1322 "funding",
1323 ));
1324 }
1325 r#funding_property = Some({
1326 struct DeserializeWith(Vec<FundingProperty>);
1327 impl<'de> Deserialize<'de> for DeserializeWith {
1328 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1329 where
1330 D: Deserializer<'de>,
1331 {
1332 Ok(DeserializeWith(serde_with::As::<
1333 serde_with::OneOrMany<serde_with::Same>,
1334 >::deserialize(deserializer)?))
1335 }
1336 }
1337 match map.next_value::<DeserializeWith>() {
1338 Ok(deserialize_with) => deserialize_with.0,
1339 Err(err) => {
1340 return Err(err);
1341 }
1342 }
1343 });
1344 }
1345 Field::Guideline => {
1346 if r#guideline_property.is_some() {
1347 return Err(<A::Error as de::Error>::duplicate_field(
1348 "guideline",
1349 ));
1350 }
1351 r#guideline_property = Some({
1352 struct DeserializeWith(Vec<GuidelineProperty>);
1353 impl<'de> Deserialize<'de> for DeserializeWith {
1354 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1355 where
1356 D: Deserializer<'de>,
1357 {
1358 Ok(DeserializeWith(serde_with::As::<
1359 serde_with::OneOrMany<serde_with::Same>,
1360 >::deserialize(deserializer)?))
1361 }
1362 }
1363 match map.next_value::<DeserializeWith>() {
1364 Ok(deserialize_with) => deserialize_with.0,
1365 Err(err) => {
1366 return Err(err);
1367 }
1368 }
1369 });
1370 }
1371 Field::LegalStatus => {
1372 if r#legal_status_property.is_some() {
1373 return Err(<A::Error as de::Error>::duplicate_field(
1374 "legalStatus",
1375 ));
1376 }
1377 r#legal_status_property = Some({
1378 struct DeserializeWith(Vec<LegalStatusProperty>);
1379 impl<'de> Deserialize<'de> for DeserializeWith {
1380 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1381 where
1382 D: Deserializer<'de>,
1383 {
1384 Ok(DeserializeWith(serde_with::As::<
1385 serde_with::OneOrMany<serde_with::Same>,
1386 >::deserialize(deserializer)?))
1387 }
1388 }
1389 match map.next_value::<DeserializeWith>() {
1390 Ok(deserialize_with) => deserialize_with.0,
1391 Err(err) => {
1392 return Err(err);
1393 }
1394 }
1395 });
1396 }
1397 Field::MedicineSystem => {
1398 if r#medicine_system_property.is_some() {
1399 return Err(<A::Error as de::Error>::duplicate_field(
1400 "medicineSystem",
1401 ));
1402 }
1403 r#medicine_system_property = Some({
1404 struct DeserializeWith(Vec<MedicineSystemProperty>);
1405 impl<'de> Deserialize<'de> for DeserializeWith {
1406 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1407 where
1408 D: Deserializer<'de>,
1409 {
1410 Ok(DeserializeWith(serde_with::As::<
1411 serde_with::OneOrMany<serde_with::Same>,
1412 >::deserialize(deserializer)?))
1413 }
1414 }
1415 match map.next_value::<DeserializeWith>() {
1416 Ok(deserialize_with) => deserialize_with.0,
1417 Err(err) => {
1418 return Err(err);
1419 }
1420 }
1421 });
1422 }
1423 Field::RecognizingAuthority => {
1424 if r#recognizing_authority_property.is_some() {
1425 return Err(<A::Error as de::Error>::duplicate_field(
1426 "recognizingAuthority",
1427 ));
1428 }
1429 r#recognizing_authority_property = Some({
1430 struct DeserializeWith(Vec<RecognizingAuthorityProperty>);
1431 impl<'de> Deserialize<'de> for DeserializeWith {
1432 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1433 where
1434 D: Deserializer<'de>,
1435 {
1436 Ok(DeserializeWith(serde_with::As::<
1437 serde_with::OneOrMany<serde_with::Same>,
1438 >::deserialize(deserializer)?))
1439 }
1440 }
1441 match map.next_value::<DeserializeWith>() {
1442 Ok(deserialize_with) => deserialize_with.0,
1443 Err(err) => {
1444 return Err(err);
1445 }
1446 }
1447 });
1448 }
1449 Field::RelevantSpecialty => {
1450 if r#relevant_specialty_property.is_some() {
1451 return Err(<A::Error as de::Error>::duplicate_field(
1452 "relevantSpecialty",
1453 ));
1454 }
1455 r#relevant_specialty_property = Some({
1456 struct DeserializeWith(Vec<RelevantSpecialtyProperty>);
1457 impl<'de> Deserialize<'de> for DeserializeWith {
1458 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1459 where
1460 D: Deserializer<'de>,
1461 {
1462 Ok(DeserializeWith(serde_with::As::<
1463 serde_with::OneOrMany<serde_with::Same>,
1464 >::deserialize(deserializer)?))
1465 }
1466 }
1467 match map.next_value::<DeserializeWith>() {
1468 Ok(deserialize_with) => deserialize_with.0,
1469 Err(err) => {
1470 return Err(err);
1471 }
1472 }
1473 });
1474 }
1475 Field::Study => {
1476 if r#study_property.is_some() {
1477 return Err(<A::Error as de::Error>::duplicate_field("study"));
1478 }
1479 r#study_property = Some({
1480 struct DeserializeWith(Vec<StudyProperty>);
1481 impl<'de> Deserialize<'de> for DeserializeWith {
1482 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1483 where
1484 D: Deserializer<'de>,
1485 {
1486 Ok(DeserializeWith(serde_with::As::<
1487 serde_with::OneOrMany<serde_with::Same>,
1488 >::deserialize(deserializer)?))
1489 }
1490 }
1491 match map.next_value::<DeserializeWith>() {
1492 Ok(deserialize_with) => deserialize_with.0,
1493 Err(err) => {
1494 return Err(err);
1495 }
1496 }
1497 });
1498 }
1499 Field::AdditionalType => {
1500 if r#additional_type_property.is_some() {
1501 return Err(<A::Error as de::Error>::duplicate_field(
1502 "additionalType",
1503 ));
1504 }
1505 r#additional_type_property = Some({
1506 struct DeserializeWith(Vec<AdditionalTypeProperty>);
1507 impl<'de> Deserialize<'de> for DeserializeWith {
1508 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1509 where
1510 D: Deserializer<'de>,
1511 {
1512 Ok(DeserializeWith(serde_with::As::<
1513 serde_with::OneOrMany<serde_with::Same>,
1514 >::deserialize(deserializer)?))
1515 }
1516 }
1517 match map.next_value::<DeserializeWith>() {
1518 Ok(deserialize_with) => deserialize_with.0,
1519 Err(err) => {
1520 return Err(err);
1521 }
1522 }
1523 });
1524 }
1525 Field::AlternateName => {
1526 if r#alternate_name_property.is_some() {
1527 return Err(<A::Error as de::Error>::duplicate_field(
1528 "alternateName",
1529 ));
1530 }
1531 r#alternate_name_property = Some({
1532 struct DeserializeWith(Vec<AlternateNameProperty>);
1533 impl<'de> Deserialize<'de> for DeserializeWith {
1534 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1535 where
1536 D: Deserializer<'de>,
1537 {
1538 Ok(DeserializeWith(serde_with::As::<
1539 serde_with::OneOrMany<serde_with::Same>,
1540 >::deserialize(deserializer)?))
1541 }
1542 }
1543 match map.next_value::<DeserializeWith>() {
1544 Ok(deserialize_with) => deserialize_with.0,
1545 Err(err) => {
1546 return Err(err);
1547 }
1548 }
1549 });
1550 }
1551 Field::Description => {
1552 if r#description_property.is_some() {
1553 return Err(<A::Error as de::Error>::duplicate_field(
1554 "description",
1555 ));
1556 }
1557 r#description_property = Some({
1558 struct DeserializeWith(Vec<DescriptionProperty>);
1559 impl<'de> Deserialize<'de> for DeserializeWith {
1560 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1561 where
1562 D: Deserializer<'de>,
1563 {
1564 Ok(DeserializeWith(serde_with::As::<
1565 serde_with::OneOrMany<serde_with::Same>,
1566 >::deserialize(deserializer)?))
1567 }
1568 }
1569 match map.next_value::<DeserializeWith>() {
1570 Ok(deserialize_with) => deserialize_with.0,
1571 Err(err) => {
1572 return Err(err);
1573 }
1574 }
1575 });
1576 }
1577 Field::DisambiguatingDescription => {
1578 if r#disambiguating_description_property.is_some() {
1579 return Err(<A::Error as de::Error>::duplicate_field(
1580 "disambiguatingDescription",
1581 ));
1582 }
1583 r#disambiguating_description_property = Some({
1584 struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
1585 impl<'de> Deserialize<'de> for DeserializeWith {
1586 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1587 where
1588 D: Deserializer<'de>,
1589 {
1590 Ok(DeserializeWith(serde_with::As::<
1591 serde_with::OneOrMany<serde_with::Same>,
1592 >::deserialize(deserializer)?))
1593 }
1594 }
1595 match map.next_value::<DeserializeWith>() {
1596 Ok(deserialize_with) => deserialize_with.0,
1597 Err(err) => {
1598 return Err(err);
1599 }
1600 }
1601 });
1602 }
1603 Field::Identifier => {
1604 if r#identifier_property.is_some() {
1605 return Err(<A::Error as de::Error>::duplicate_field(
1606 "identifier",
1607 ));
1608 }
1609 r#identifier_property = Some({
1610 struct DeserializeWith(Vec<IdentifierProperty>);
1611 impl<'de> Deserialize<'de> for DeserializeWith {
1612 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1613 where
1614 D: Deserializer<'de>,
1615 {
1616 Ok(DeserializeWith(serde_with::As::<
1617 serde_with::OneOrMany<serde_with::Same>,
1618 >::deserialize(deserializer)?))
1619 }
1620 }
1621 match map.next_value::<DeserializeWith>() {
1622 Ok(deserialize_with) => deserialize_with.0,
1623 Err(err) => {
1624 return Err(err);
1625 }
1626 }
1627 });
1628 }
1629 Field::Image => {
1630 if r#image_property.is_some() {
1631 return Err(<A::Error as de::Error>::duplicate_field("image"));
1632 }
1633 r#image_property = Some({
1634 struct DeserializeWith(Vec<ImageProperty>);
1635 impl<'de> Deserialize<'de> for DeserializeWith {
1636 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1637 where
1638 D: Deserializer<'de>,
1639 {
1640 Ok(DeserializeWith(serde_with::As::<
1641 serde_with::OneOrMany<serde_with::Same>,
1642 >::deserialize(deserializer)?))
1643 }
1644 }
1645 match map.next_value::<DeserializeWith>() {
1646 Ok(deserialize_with) => deserialize_with.0,
1647 Err(err) => {
1648 return Err(err);
1649 }
1650 }
1651 });
1652 }
1653 Field::MainEntityOfPage => {
1654 if r#main_entity_of_page_property.is_some() {
1655 return Err(<A::Error as de::Error>::duplicate_field(
1656 "mainEntityOfPage",
1657 ));
1658 }
1659 r#main_entity_of_page_property = Some({
1660 struct DeserializeWith(Vec<MainEntityOfPageProperty>);
1661 impl<'de> Deserialize<'de> for DeserializeWith {
1662 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1663 where
1664 D: Deserializer<'de>,
1665 {
1666 Ok(DeserializeWith(serde_with::As::<
1667 serde_with::OneOrMany<serde_with::Same>,
1668 >::deserialize(deserializer)?))
1669 }
1670 }
1671 match map.next_value::<DeserializeWith>() {
1672 Ok(deserialize_with) => deserialize_with.0,
1673 Err(err) => {
1674 return Err(err);
1675 }
1676 }
1677 });
1678 }
1679 Field::Name => {
1680 if r#name_property.is_some() {
1681 return Err(<A::Error as de::Error>::duplicate_field("name"));
1682 }
1683 r#name_property = Some({
1684 struct DeserializeWith(Vec<NameProperty>);
1685 impl<'de> Deserialize<'de> for DeserializeWith {
1686 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1687 where
1688 D: Deserializer<'de>,
1689 {
1690 Ok(DeserializeWith(serde_with::As::<
1691 serde_with::OneOrMany<serde_with::Same>,
1692 >::deserialize(deserializer)?))
1693 }
1694 }
1695 match map.next_value::<DeserializeWith>() {
1696 Ok(deserialize_with) => deserialize_with.0,
1697 Err(err) => {
1698 return Err(err);
1699 }
1700 }
1701 });
1702 }
1703 Field::PotentialAction => {
1704 if r#potential_action_property.is_some() {
1705 return Err(<A::Error as de::Error>::duplicate_field(
1706 "potentialAction",
1707 ));
1708 }
1709 r#potential_action_property = Some({
1710 struct DeserializeWith(Vec<PotentialActionProperty>);
1711 impl<'de> Deserialize<'de> for DeserializeWith {
1712 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1713 where
1714 D: Deserializer<'de>,
1715 {
1716 Ok(DeserializeWith(serde_with::As::<
1717 serde_with::OneOrMany<serde_with::Same>,
1718 >::deserialize(deserializer)?))
1719 }
1720 }
1721 match map.next_value::<DeserializeWith>() {
1722 Ok(deserialize_with) => deserialize_with.0,
1723 Err(err) => {
1724 return Err(err);
1725 }
1726 }
1727 });
1728 }
1729 Field::SameAs => {
1730 if r#same_as_property.is_some() {
1731 return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
1732 }
1733 r#same_as_property = Some({
1734 struct DeserializeWith(Vec<SameAsProperty>);
1735 impl<'de> Deserialize<'de> for DeserializeWith {
1736 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1737 where
1738 D: Deserializer<'de>,
1739 {
1740 Ok(DeserializeWith(serde_with::As::<
1741 serde_with::OneOrMany<serde_with::Same>,
1742 >::deserialize(deserializer)?))
1743 }
1744 }
1745 match map.next_value::<DeserializeWith>() {
1746 Ok(deserialize_with) => deserialize_with.0,
1747 Err(err) => {
1748 return Err(err);
1749 }
1750 }
1751 });
1752 }
1753 Field::SubjectOf => {
1754 if r#subject_of_property.is_some() {
1755 return Err(<A::Error as de::Error>::duplicate_field(
1756 "subjectOf",
1757 ));
1758 }
1759 r#subject_of_property = Some({
1760 struct DeserializeWith(Vec<SubjectOfProperty>);
1761 impl<'de> Deserialize<'de> for DeserializeWith {
1762 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1763 where
1764 D: Deserializer<'de>,
1765 {
1766 Ok(DeserializeWith(serde_with::As::<
1767 serde_with::OneOrMany<serde_with::Same>,
1768 >::deserialize(deserializer)?))
1769 }
1770 }
1771 match map.next_value::<DeserializeWith>() {
1772 Ok(deserialize_with) => deserialize_with.0,
1773 Err(err) => {
1774 return Err(err);
1775 }
1776 }
1777 });
1778 }
1779 Field::Url => {
1780 if r#url_property.is_some() {
1781 return Err(<A::Error as de::Error>::duplicate_field("url"));
1782 }
1783 r#url_property = Some({
1784 struct DeserializeWith(Vec<UrlProperty>);
1785 impl<'de> Deserialize<'de> for DeserializeWith {
1786 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1787 where
1788 D: Deserializer<'de>,
1789 {
1790 Ok(DeserializeWith(serde_with::As::<
1791 serde_with::OneOrMany<serde_with::Same>,
1792 >::deserialize(deserializer)?))
1793 }
1794 }
1795 match map.next_value::<DeserializeWith>() {
1796 Ok(deserialize_with) => deserialize_with.0,
1797 Err(err) => {
1798 return Err(err);
1799 }
1800 }
1801 });
1802 }
1803 Field::Ignore => {
1804 let _ = map.next_value::<de::IgnoredAny>()?;
1805 }
1806 }
1807 }
1808 Ok(Artery {
1809 r#arterial_branch: r#arterial_branch_property.unwrap_or_default(),
1810 r#supply_to: r#supply_to_property.unwrap_or_default(),
1811 r#associated_pathophysiology: r#associated_pathophysiology_property
1812 .unwrap_or_default(),
1813 r#body_location: r#body_location_property.unwrap_or_default(),
1814 r#connected_to: r#connected_to_property.unwrap_or_default(),
1815 r#diagram: r#diagram_property.unwrap_or_default(),
1816 r#part_of_system: r#part_of_system_property.unwrap_or_default(),
1817 r#related_condition: r#related_condition_property.unwrap_or_default(),
1818 r#related_therapy: r#related_therapy_property.unwrap_or_default(),
1819 r#sub_structure: r#sub_structure_property.unwrap_or_default(),
1820 r#code: r#code_property.unwrap_or_default(),
1821 r#funding: r#funding_property.unwrap_or_default(),
1822 r#guideline: r#guideline_property.unwrap_or_default(),
1823 r#legal_status: r#legal_status_property.unwrap_or_default(),
1824 r#medicine_system: r#medicine_system_property.unwrap_or_default(),
1825 r#recognizing_authority: r#recognizing_authority_property
1826 .unwrap_or_default(),
1827 r#relevant_specialty: r#relevant_specialty_property.unwrap_or_default(),
1828 r#study: r#study_property.unwrap_or_default(),
1829 r#additional_type: r#additional_type_property.unwrap_or_default(),
1830 r#alternate_name: r#alternate_name_property.unwrap_or_default(),
1831 r#description: r#description_property.unwrap_or_default(),
1832 r#disambiguating_description: r#disambiguating_description_property
1833 .unwrap_or_default(),
1834 r#identifier: r#identifier_property.unwrap_or_default(),
1835 r#image: r#image_property.unwrap_or_default(),
1836 r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
1837 r#name: r#name_property.unwrap_or_default(),
1838 r#potential_action: r#potential_action_property.unwrap_or_default(),
1839 r#same_as: r#same_as_property.unwrap_or_default(),
1840 r#subject_of: r#subject_of_property.unwrap_or_default(),
1841 r#url: r#url_property.unwrap_or_default(),
1842 })
1843 }
1844 }
1845 const FIELDS: &[&str] = &[
1846 "arterialBranch",
1847 "supplyTo",
1848 "associatedPathophysiology",
1849 "bodyLocation",
1850 "connectedTo",
1851 "diagram",
1852 "partOfSystem",
1853 "relatedCondition",
1854 "relatedTherapy",
1855 "subStructure",
1856 "code",
1857 "funding",
1858 "guideline",
1859 "legalStatus",
1860 "medicineSystem",
1861 "recognizingAuthority",
1862 "relevantSpecialty",
1863 "study",
1864 "additionalType",
1865 "alternateName",
1866 "description",
1867 "disambiguatingDescription",
1868 "identifier",
1869 "image",
1870 "mainEntityOfPage",
1871 "name",
1872 "potentialAction",
1873 "sameAs",
1874 "subjectOf",
1875 "url",
1876 ];
1877 deserializer.deserialize_struct("Artery", FIELDS, ClassVisitor)
1878 }
1879 }
1880}