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