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