1use super::*;
2#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct MolecularEntity {
6 pub r#chemical_role: Vec<ChemicalRoleProperty>,
8 pub r#in_ch_i: Vec<InChIProperty>,
10 pub r#in_ch_i_key: Vec<InChIKeyProperty>,
12 pub r#iupac_name: Vec<IupacNameProperty>,
14 pub r#molecular_formula: Vec<MolecularFormulaProperty>,
16 pub r#molecular_weight: Vec<MolecularWeightProperty>,
18 pub r#monoisotopic_molecular_weight: Vec<MonoisotopicMolecularWeightProperty>,
20 pub r#potential_use: Vec<PotentialUseProperty>,
22 pub r#smiles: Vec<SmilesProperty>,
24 pub r#associated_disease: Vec<AssociatedDiseaseProperty>,
26 pub r#bio_chem_interaction: Vec<BioChemInteractionProperty>,
28 pub r#bio_chem_similarity: Vec<BioChemSimilarityProperty>,
30 pub r#biological_role: Vec<BiologicalRoleProperty>,
32 pub r#funding: Vec<FundingProperty>,
34 pub r#has_bio_chem_entity_part: Vec<HasBioChemEntityPartProperty>,
36 pub r#has_molecular_function: Vec<HasMolecularFunctionProperty>,
38 pub r#has_representation: Vec<HasRepresentationProperty>,
40 pub r#is_encoded_by_bio_chem_entity: Vec<IsEncodedByBioChemEntityProperty>,
42 pub r#is_involved_in_biological_process: Vec<IsInvolvedInBiologicalProcessProperty>,
44 pub r#is_located_in_subcellular_location: Vec<IsLocatedInSubcellularLocationProperty>,
46 pub r#is_part_of_bio_chem_entity: Vec<IsPartOfBioChemEntityProperty>,
48 pub r#taxonomic_range: Vec<TaxonomicRangeProperty>,
50 pub r#additional_type: Vec<AdditionalTypeProperty>,
52 pub r#alternate_name: Vec<AlternateNameProperty>,
54 pub r#description: Vec<DescriptionProperty>,
56 pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
58 pub r#identifier: Vec<IdentifierProperty>,
60 pub r#image: Vec<ImageProperty>,
62 pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
64 pub r#name: Vec<NameProperty>,
66 pub r#potential_action: Vec<PotentialActionProperty>,
68 pub r#same_as: Vec<SameAsProperty>,
70 pub r#subject_of: Vec<SubjectOfProperty>,
72 pub r#url: Vec<UrlProperty>,
74}
75pub trait MolecularEntityTrait {
77 fn get_chemical_role(&self) -> &[ChemicalRoleProperty];
79 fn take_chemical_role(&mut self) -> Vec<ChemicalRoleProperty>;
81 fn get_in_ch_i(&self) -> &[InChIProperty];
83 fn take_in_ch_i(&mut self) -> Vec<InChIProperty>;
85 fn get_in_ch_i_key(&self) -> &[InChIKeyProperty];
87 fn take_in_ch_i_key(&mut self) -> Vec<InChIKeyProperty>;
89 fn get_iupac_name(&self) -> &[IupacNameProperty];
91 fn take_iupac_name(&mut self) -> Vec<IupacNameProperty>;
93 fn get_molecular_formula(&self) -> &[MolecularFormulaProperty];
95 fn take_molecular_formula(&mut self) -> Vec<MolecularFormulaProperty>;
97 fn get_molecular_weight(&self) -> &[MolecularWeightProperty];
99 fn take_molecular_weight(&mut self) -> Vec<MolecularWeightProperty>;
101 fn get_monoisotopic_molecular_weight(&self) -> &[MonoisotopicMolecularWeightProperty];
103 fn take_monoisotopic_molecular_weight(&mut self) -> Vec<MonoisotopicMolecularWeightProperty>;
105 fn get_potential_use(&self) -> &[PotentialUseProperty];
107 fn take_potential_use(&mut self) -> Vec<PotentialUseProperty>;
109 fn get_smiles(&self) -> &[SmilesProperty];
111 fn take_smiles(&mut self) -> Vec<SmilesProperty>;
113}
114impl MolecularEntityTrait for MolecularEntity {
115 fn get_chemical_role(&self) -> &[ChemicalRoleProperty] {
116 self.r#chemical_role.as_slice()
117 }
118 fn take_chemical_role(&mut self) -> Vec<ChemicalRoleProperty> {
119 std::mem::take(&mut self.r#chemical_role)
120 }
121 fn get_in_ch_i(&self) -> &[InChIProperty] {
122 self.r#in_ch_i.as_slice()
123 }
124 fn take_in_ch_i(&mut self) -> Vec<InChIProperty> {
125 std::mem::take(&mut self.r#in_ch_i)
126 }
127 fn get_in_ch_i_key(&self) -> &[InChIKeyProperty] {
128 self.r#in_ch_i_key.as_slice()
129 }
130 fn take_in_ch_i_key(&mut self) -> Vec<InChIKeyProperty> {
131 std::mem::take(&mut self.r#in_ch_i_key)
132 }
133 fn get_iupac_name(&self) -> &[IupacNameProperty] {
134 self.r#iupac_name.as_slice()
135 }
136 fn take_iupac_name(&mut self) -> Vec<IupacNameProperty> {
137 std::mem::take(&mut self.r#iupac_name)
138 }
139 fn get_molecular_formula(&self) -> &[MolecularFormulaProperty] {
140 self.r#molecular_formula.as_slice()
141 }
142 fn take_molecular_formula(&mut self) -> Vec<MolecularFormulaProperty> {
143 std::mem::take(&mut self.r#molecular_formula)
144 }
145 fn get_molecular_weight(&self) -> &[MolecularWeightProperty] {
146 self.r#molecular_weight.as_slice()
147 }
148 fn take_molecular_weight(&mut self) -> Vec<MolecularWeightProperty> {
149 std::mem::take(&mut self.r#molecular_weight)
150 }
151 fn get_monoisotopic_molecular_weight(&self) -> &[MonoisotopicMolecularWeightProperty] {
152 self.r#monoisotopic_molecular_weight.as_slice()
153 }
154 fn take_monoisotopic_molecular_weight(&mut self) -> Vec<MonoisotopicMolecularWeightProperty> {
155 std::mem::take(&mut self.r#monoisotopic_molecular_weight)
156 }
157 fn get_potential_use(&self) -> &[PotentialUseProperty] {
158 self.r#potential_use.as_slice()
159 }
160 fn take_potential_use(&mut self) -> Vec<PotentialUseProperty> {
161 std::mem::take(&mut self.r#potential_use)
162 }
163 fn get_smiles(&self) -> &[SmilesProperty] {
164 self.r#smiles.as_slice()
165 }
166 fn take_smiles(&mut self) -> Vec<SmilesProperty> {
167 std::mem::take(&mut self.r#smiles)
168 }
169}
170impl BioChemEntityTrait for MolecularEntity {
171 fn get_associated_disease(&self) -> &[AssociatedDiseaseProperty] {
172 self.r#associated_disease.as_slice()
173 }
174 fn take_associated_disease(&mut self) -> Vec<AssociatedDiseaseProperty> {
175 std::mem::take(&mut self.r#associated_disease)
176 }
177 fn get_bio_chem_interaction(&self) -> &[BioChemInteractionProperty] {
178 self.r#bio_chem_interaction.as_slice()
179 }
180 fn take_bio_chem_interaction(&mut self) -> Vec<BioChemInteractionProperty> {
181 std::mem::take(&mut self.r#bio_chem_interaction)
182 }
183 fn get_bio_chem_similarity(&self) -> &[BioChemSimilarityProperty] {
184 self.r#bio_chem_similarity.as_slice()
185 }
186 fn take_bio_chem_similarity(&mut self) -> Vec<BioChemSimilarityProperty> {
187 std::mem::take(&mut self.r#bio_chem_similarity)
188 }
189 fn get_biological_role(&self) -> &[BiologicalRoleProperty] {
190 self.r#biological_role.as_slice()
191 }
192 fn take_biological_role(&mut self) -> Vec<BiologicalRoleProperty> {
193 std::mem::take(&mut self.r#biological_role)
194 }
195 fn get_funding(&self) -> &[FundingProperty] {
196 self.r#funding.as_slice()
197 }
198 fn take_funding(&mut self) -> Vec<FundingProperty> {
199 std::mem::take(&mut self.r#funding)
200 }
201 fn get_has_bio_chem_entity_part(&self) -> &[HasBioChemEntityPartProperty] {
202 self.r#has_bio_chem_entity_part.as_slice()
203 }
204 fn take_has_bio_chem_entity_part(&mut self) -> Vec<HasBioChemEntityPartProperty> {
205 std::mem::take(&mut self.r#has_bio_chem_entity_part)
206 }
207 fn get_has_molecular_function(&self) -> &[HasMolecularFunctionProperty] {
208 self.r#has_molecular_function.as_slice()
209 }
210 fn take_has_molecular_function(&mut self) -> Vec<HasMolecularFunctionProperty> {
211 std::mem::take(&mut self.r#has_molecular_function)
212 }
213 fn get_has_representation(&self) -> &[HasRepresentationProperty] {
214 self.r#has_representation.as_slice()
215 }
216 fn take_has_representation(&mut self) -> Vec<HasRepresentationProperty> {
217 std::mem::take(&mut self.r#has_representation)
218 }
219 fn get_is_encoded_by_bio_chem_entity(&self) -> &[IsEncodedByBioChemEntityProperty] {
220 self.r#is_encoded_by_bio_chem_entity.as_slice()
221 }
222 fn take_is_encoded_by_bio_chem_entity(&mut self) -> Vec<IsEncodedByBioChemEntityProperty> {
223 std::mem::take(&mut self.r#is_encoded_by_bio_chem_entity)
224 }
225 fn get_is_involved_in_biological_process(&self) -> &[IsInvolvedInBiologicalProcessProperty] {
226 self.r#is_involved_in_biological_process.as_slice()
227 }
228 fn take_is_involved_in_biological_process(
229 &mut self,
230 ) -> Vec<IsInvolvedInBiologicalProcessProperty> {
231 std::mem::take(&mut self.r#is_involved_in_biological_process)
232 }
233 fn get_is_located_in_subcellular_location(&self) -> &[IsLocatedInSubcellularLocationProperty] {
234 self.r#is_located_in_subcellular_location.as_slice()
235 }
236 fn take_is_located_in_subcellular_location(
237 &mut self,
238 ) -> Vec<IsLocatedInSubcellularLocationProperty> {
239 std::mem::take(&mut self.r#is_located_in_subcellular_location)
240 }
241 fn get_is_part_of_bio_chem_entity(&self) -> &[IsPartOfBioChemEntityProperty] {
242 self.r#is_part_of_bio_chem_entity.as_slice()
243 }
244 fn take_is_part_of_bio_chem_entity(&mut self) -> Vec<IsPartOfBioChemEntityProperty> {
245 std::mem::take(&mut self.r#is_part_of_bio_chem_entity)
246 }
247 fn get_taxonomic_range(&self) -> &[TaxonomicRangeProperty] {
248 self.r#taxonomic_range.as_slice()
249 }
250 fn take_taxonomic_range(&mut self) -> Vec<TaxonomicRangeProperty> {
251 std::mem::take(&mut self.r#taxonomic_range)
252 }
253}
254impl ThingTrait for MolecularEntity {
255 fn get_additional_type(&self) -> &[AdditionalTypeProperty] {
256 self.r#additional_type.as_slice()
257 }
258 fn take_additional_type(&mut self) -> Vec<AdditionalTypeProperty> {
259 std::mem::take(&mut self.r#additional_type)
260 }
261 fn get_alternate_name(&self) -> &[AlternateNameProperty] {
262 self.r#alternate_name.as_slice()
263 }
264 fn take_alternate_name(&mut self) -> Vec<AlternateNameProperty> {
265 std::mem::take(&mut self.r#alternate_name)
266 }
267 fn get_description(&self) -> &[DescriptionProperty] {
268 self.r#description.as_slice()
269 }
270 fn take_description(&mut self) -> Vec<DescriptionProperty> {
271 std::mem::take(&mut self.r#description)
272 }
273 fn get_disambiguating_description(&self) -> &[DisambiguatingDescriptionProperty] {
274 self.r#disambiguating_description.as_slice()
275 }
276 fn take_disambiguating_description(&mut self) -> Vec<DisambiguatingDescriptionProperty> {
277 std::mem::take(&mut self.r#disambiguating_description)
278 }
279 fn get_identifier(&self) -> &[IdentifierProperty] {
280 self.r#identifier.as_slice()
281 }
282 fn take_identifier(&mut self) -> Vec<IdentifierProperty> {
283 std::mem::take(&mut self.r#identifier)
284 }
285 fn get_image(&self) -> &[ImageProperty] {
286 self.r#image.as_slice()
287 }
288 fn take_image(&mut self) -> Vec<ImageProperty> {
289 std::mem::take(&mut self.r#image)
290 }
291 fn get_main_entity_of_page(&self) -> &[MainEntityOfPageProperty] {
292 self.r#main_entity_of_page.as_slice()
293 }
294 fn take_main_entity_of_page(&mut self) -> Vec<MainEntityOfPageProperty> {
295 std::mem::take(&mut self.r#main_entity_of_page)
296 }
297 fn get_name(&self) -> &[NameProperty] {
298 self.r#name.as_slice()
299 }
300 fn take_name(&mut self) -> Vec<NameProperty> {
301 std::mem::take(&mut self.r#name)
302 }
303 fn get_potential_action(&self) -> &[PotentialActionProperty] {
304 self.r#potential_action.as_slice()
305 }
306 fn take_potential_action(&mut self) -> Vec<PotentialActionProperty> {
307 std::mem::take(&mut self.r#potential_action)
308 }
309 fn get_same_as(&self) -> &[SameAsProperty] {
310 self.r#same_as.as_slice()
311 }
312 fn take_same_as(&mut self) -> Vec<SameAsProperty> {
313 std::mem::take(&mut self.r#same_as)
314 }
315 fn get_subject_of(&self) -> &[SubjectOfProperty] {
316 self.r#subject_of.as_slice()
317 }
318 fn take_subject_of(&mut self) -> Vec<SubjectOfProperty> {
319 std::mem::take(&mut self.r#subject_of)
320 }
321 fn get_url(&self) -> &[UrlProperty] {
322 self.r#url.as_slice()
323 }
324 fn take_url(&mut self) -> Vec<UrlProperty> {
325 std::mem::take(&mut self.r#url)
326 }
327}
328#[cfg(feature = "serde")]
329mod serde {
330 use std::{fmt, fmt::Formatter};
331
332 use ::serde::{
333 de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
334 };
335
336 use super::*;
337 impl Serialize for MolecularEntity {
338 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
339 where
340 S: Serializer,
341 {
342 let len: usize = [
343 !Vec::is_empty(&self.r#chemical_role) as usize,
344 !Vec::is_empty(&self.r#in_ch_i) as usize,
345 !Vec::is_empty(&self.r#in_ch_i_key) as usize,
346 !Vec::is_empty(&self.r#iupac_name) as usize,
347 !Vec::is_empty(&self.r#molecular_formula) as usize,
348 !Vec::is_empty(&self.r#molecular_weight) as usize,
349 !Vec::is_empty(&self.r#monoisotopic_molecular_weight) as usize,
350 !Vec::is_empty(&self.r#potential_use) as usize,
351 !Vec::is_empty(&self.r#smiles) as usize,
352 !Vec::is_empty(&self.r#associated_disease) as usize,
353 !Vec::is_empty(&self.r#bio_chem_interaction) as usize,
354 !Vec::is_empty(&self.r#bio_chem_similarity) as usize,
355 !Vec::is_empty(&self.r#biological_role) as usize,
356 !Vec::is_empty(&self.r#funding) as usize,
357 !Vec::is_empty(&self.r#has_bio_chem_entity_part) as usize,
358 !Vec::is_empty(&self.r#has_molecular_function) as usize,
359 !Vec::is_empty(&self.r#has_representation) as usize,
360 !Vec::is_empty(&self.r#is_encoded_by_bio_chem_entity) as usize,
361 !Vec::is_empty(&self.r#is_involved_in_biological_process) as usize,
362 !Vec::is_empty(&self.r#is_located_in_subcellular_location) as usize,
363 !Vec::is_empty(&self.r#is_part_of_bio_chem_entity) as usize,
364 !Vec::is_empty(&self.r#taxonomic_range) as usize,
365 !Vec::is_empty(&self.r#additional_type) as usize,
366 !Vec::is_empty(&self.r#alternate_name) as usize,
367 !Vec::is_empty(&self.r#description) as usize,
368 !Vec::is_empty(&self.r#disambiguating_description) as usize,
369 !Vec::is_empty(&self.r#identifier) as usize,
370 !Vec::is_empty(&self.r#image) as usize,
371 !Vec::is_empty(&self.r#main_entity_of_page) as usize,
372 !Vec::is_empty(&self.r#name) as usize,
373 !Vec::is_empty(&self.r#potential_action) as usize,
374 !Vec::is_empty(&self.r#same_as) as usize,
375 !Vec::is_empty(&self.r#subject_of) as usize,
376 !Vec::is_empty(&self.r#url) as usize,
377 ]
378 .iter()
379 .sum();
380 let mut serialize_struct =
381 Serializer::serialize_struct(serializer, "MolecularEntity", len)?;
382 if !Vec::is_empty(&self.r#chemical_role) {
383 serialize_struct.serialize_field("chemicalRole", {
384 struct SerializeWith<'a>(&'a Vec<ChemicalRoleProperty>);
385 impl<'a> Serialize for SerializeWith<'a> {
386 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
387 where
388 S: Serializer,
389 {
390 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
391 self.0, serializer,
392 )
393 }
394 }
395 &SerializeWith(&self.r#chemical_role)
396 })?;
397 } else {
398 serialize_struct.skip_field("chemicalRole")?;
399 }
400 if !Vec::is_empty(&self.r#in_ch_i) {
401 serialize_struct.serialize_field("inChI", {
402 struct SerializeWith<'a>(&'a Vec<InChIProperty>);
403 impl<'a> Serialize for SerializeWith<'a> {
404 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
405 where
406 S: Serializer,
407 {
408 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
409 self.0, serializer,
410 )
411 }
412 }
413 &SerializeWith(&self.r#in_ch_i)
414 })?;
415 } else {
416 serialize_struct.skip_field("inChI")?;
417 }
418 if !Vec::is_empty(&self.r#in_ch_i_key) {
419 serialize_struct.serialize_field("inChIKey", {
420 struct SerializeWith<'a>(&'a Vec<InChIKeyProperty>);
421 impl<'a> Serialize for SerializeWith<'a> {
422 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
423 where
424 S: Serializer,
425 {
426 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
427 self.0, serializer,
428 )
429 }
430 }
431 &SerializeWith(&self.r#in_ch_i_key)
432 })?;
433 } else {
434 serialize_struct.skip_field("inChIKey")?;
435 }
436 if !Vec::is_empty(&self.r#iupac_name) {
437 serialize_struct.serialize_field("iupacName", {
438 struct SerializeWith<'a>(&'a Vec<IupacNameProperty>);
439 impl<'a> Serialize for SerializeWith<'a> {
440 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
441 where
442 S: Serializer,
443 {
444 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
445 self.0, serializer,
446 )
447 }
448 }
449 &SerializeWith(&self.r#iupac_name)
450 })?;
451 } else {
452 serialize_struct.skip_field("iupacName")?;
453 }
454 if !Vec::is_empty(&self.r#molecular_formula) {
455 serialize_struct.serialize_field("molecularFormula", {
456 struct SerializeWith<'a>(&'a Vec<MolecularFormulaProperty>);
457 impl<'a> Serialize for SerializeWith<'a> {
458 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
459 where
460 S: Serializer,
461 {
462 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
463 self.0, serializer,
464 )
465 }
466 }
467 &SerializeWith(&self.r#molecular_formula)
468 })?;
469 } else {
470 serialize_struct.skip_field("molecularFormula")?;
471 }
472 if !Vec::is_empty(&self.r#molecular_weight) {
473 serialize_struct.serialize_field("molecularWeight", {
474 struct SerializeWith<'a>(&'a Vec<MolecularWeightProperty>);
475 impl<'a> Serialize for SerializeWith<'a> {
476 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
477 where
478 S: Serializer,
479 {
480 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
481 self.0, serializer,
482 )
483 }
484 }
485 &SerializeWith(&self.r#molecular_weight)
486 })?;
487 } else {
488 serialize_struct.skip_field("molecularWeight")?;
489 }
490 if !Vec::is_empty(&self.r#monoisotopic_molecular_weight) {
491 serialize_struct.serialize_field("monoisotopicMolecularWeight", {
492 struct SerializeWith<'a>(&'a Vec<MonoisotopicMolecularWeightProperty>);
493 impl<'a> Serialize for SerializeWith<'a> {
494 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
495 where
496 S: Serializer,
497 {
498 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
499 self.0, serializer,
500 )
501 }
502 }
503 &SerializeWith(&self.r#monoisotopic_molecular_weight)
504 })?;
505 } else {
506 serialize_struct.skip_field("monoisotopicMolecularWeight")?;
507 }
508 if !Vec::is_empty(&self.r#potential_use) {
509 serialize_struct.serialize_field("potentialUse", {
510 struct SerializeWith<'a>(&'a Vec<PotentialUseProperty>);
511 impl<'a> Serialize for SerializeWith<'a> {
512 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
513 where
514 S: Serializer,
515 {
516 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
517 self.0, serializer,
518 )
519 }
520 }
521 &SerializeWith(&self.r#potential_use)
522 })?;
523 } else {
524 serialize_struct.skip_field("potentialUse")?;
525 }
526 if !Vec::is_empty(&self.r#smiles) {
527 serialize_struct.serialize_field("smiles", {
528 struct SerializeWith<'a>(&'a Vec<SmilesProperty>);
529 impl<'a> Serialize for SerializeWith<'a> {
530 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
531 where
532 S: Serializer,
533 {
534 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
535 self.0, serializer,
536 )
537 }
538 }
539 &SerializeWith(&self.r#smiles)
540 })?;
541 } else {
542 serialize_struct.skip_field("smiles")?;
543 }
544 if !Vec::is_empty(&self.r#associated_disease) {
545 serialize_struct.serialize_field("associatedDisease", {
546 struct SerializeWith<'a>(&'a Vec<AssociatedDiseaseProperty>);
547 impl<'a> Serialize for SerializeWith<'a> {
548 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
549 where
550 S: Serializer,
551 {
552 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
553 self.0, serializer,
554 )
555 }
556 }
557 &SerializeWith(&self.r#associated_disease)
558 })?;
559 } else {
560 serialize_struct.skip_field("associatedDisease")?;
561 }
562 if !Vec::is_empty(&self.r#bio_chem_interaction) {
563 serialize_struct.serialize_field("bioChemInteraction", {
564 struct SerializeWith<'a>(&'a Vec<BioChemInteractionProperty>);
565 impl<'a> Serialize for SerializeWith<'a> {
566 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
567 where
568 S: Serializer,
569 {
570 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
571 self.0, serializer,
572 )
573 }
574 }
575 &SerializeWith(&self.r#bio_chem_interaction)
576 })?;
577 } else {
578 serialize_struct.skip_field("bioChemInteraction")?;
579 }
580 if !Vec::is_empty(&self.r#bio_chem_similarity) {
581 serialize_struct.serialize_field("bioChemSimilarity", {
582 struct SerializeWith<'a>(&'a Vec<BioChemSimilarityProperty>);
583 impl<'a> Serialize for SerializeWith<'a> {
584 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
585 where
586 S: Serializer,
587 {
588 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
589 self.0, serializer,
590 )
591 }
592 }
593 &SerializeWith(&self.r#bio_chem_similarity)
594 })?;
595 } else {
596 serialize_struct.skip_field("bioChemSimilarity")?;
597 }
598 if !Vec::is_empty(&self.r#biological_role) {
599 serialize_struct.serialize_field("biologicalRole", {
600 struct SerializeWith<'a>(&'a Vec<BiologicalRoleProperty>);
601 impl<'a> Serialize for SerializeWith<'a> {
602 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
603 where
604 S: Serializer,
605 {
606 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
607 self.0, serializer,
608 )
609 }
610 }
611 &SerializeWith(&self.r#biological_role)
612 })?;
613 } else {
614 serialize_struct.skip_field("biologicalRole")?;
615 }
616 if !Vec::is_empty(&self.r#funding) {
617 serialize_struct.serialize_field("funding", {
618 struct SerializeWith<'a>(&'a Vec<FundingProperty>);
619 impl<'a> Serialize for SerializeWith<'a> {
620 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
621 where
622 S: Serializer,
623 {
624 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
625 self.0, serializer,
626 )
627 }
628 }
629 &SerializeWith(&self.r#funding)
630 })?;
631 } else {
632 serialize_struct.skip_field("funding")?;
633 }
634 if !Vec::is_empty(&self.r#has_bio_chem_entity_part) {
635 serialize_struct.serialize_field("hasBioChemEntityPart", {
636 struct SerializeWith<'a>(&'a Vec<HasBioChemEntityPartProperty>);
637 impl<'a> Serialize for SerializeWith<'a> {
638 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
639 where
640 S: Serializer,
641 {
642 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
643 self.0, serializer,
644 )
645 }
646 }
647 &SerializeWith(&self.r#has_bio_chem_entity_part)
648 })?;
649 } else {
650 serialize_struct.skip_field("hasBioChemEntityPart")?;
651 }
652 if !Vec::is_empty(&self.r#has_molecular_function) {
653 serialize_struct.serialize_field("hasMolecularFunction", {
654 struct SerializeWith<'a>(&'a Vec<HasMolecularFunctionProperty>);
655 impl<'a> Serialize for SerializeWith<'a> {
656 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
657 where
658 S: Serializer,
659 {
660 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
661 self.0, serializer,
662 )
663 }
664 }
665 &SerializeWith(&self.r#has_molecular_function)
666 })?;
667 } else {
668 serialize_struct.skip_field("hasMolecularFunction")?;
669 }
670 if !Vec::is_empty(&self.r#has_representation) {
671 serialize_struct.serialize_field("hasRepresentation", {
672 struct SerializeWith<'a>(&'a Vec<HasRepresentationProperty>);
673 impl<'a> Serialize for SerializeWith<'a> {
674 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
675 where
676 S: Serializer,
677 {
678 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
679 self.0, serializer,
680 )
681 }
682 }
683 &SerializeWith(&self.r#has_representation)
684 })?;
685 } else {
686 serialize_struct.skip_field("hasRepresentation")?;
687 }
688 if !Vec::is_empty(&self.r#is_encoded_by_bio_chem_entity) {
689 serialize_struct.serialize_field("isEncodedByBioChemEntity", {
690 struct SerializeWith<'a>(&'a Vec<IsEncodedByBioChemEntityProperty>);
691 impl<'a> Serialize for SerializeWith<'a> {
692 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
693 where
694 S: Serializer,
695 {
696 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
697 self.0, serializer,
698 )
699 }
700 }
701 &SerializeWith(&self.r#is_encoded_by_bio_chem_entity)
702 })?;
703 } else {
704 serialize_struct.skip_field("isEncodedByBioChemEntity")?;
705 }
706 if !Vec::is_empty(&self.r#is_involved_in_biological_process) {
707 serialize_struct.serialize_field("isInvolvedInBiologicalProcess", {
708 struct SerializeWith<'a>(&'a Vec<IsInvolvedInBiologicalProcessProperty>);
709 impl<'a> Serialize for SerializeWith<'a> {
710 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
711 where
712 S: Serializer,
713 {
714 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
715 self.0, serializer,
716 )
717 }
718 }
719 &SerializeWith(&self.r#is_involved_in_biological_process)
720 })?;
721 } else {
722 serialize_struct.skip_field("isInvolvedInBiologicalProcess")?;
723 }
724 if !Vec::is_empty(&self.r#is_located_in_subcellular_location) {
725 serialize_struct.serialize_field("isLocatedInSubcellularLocation", {
726 struct SerializeWith<'a>(&'a Vec<IsLocatedInSubcellularLocationProperty>);
727 impl<'a> Serialize for SerializeWith<'a> {
728 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
729 where
730 S: Serializer,
731 {
732 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
733 self.0, serializer,
734 )
735 }
736 }
737 &SerializeWith(&self.r#is_located_in_subcellular_location)
738 })?;
739 } else {
740 serialize_struct.skip_field("isLocatedInSubcellularLocation")?;
741 }
742 if !Vec::is_empty(&self.r#is_part_of_bio_chem_entity) {
743 serialize_struct.serialize_field("isPartOfBioChemEntity", {
744 struct SerializeWith<'a>(&'a Vec<IsPartOfBioChemEntityProperty>);
745 impl<'a> Serialize for SerializeWith<'a> {
746 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
747 where
748 S: Serializer,
749 {
750 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
751 self.0, serializer,
752 )
753 }
754 }
755 &SerializeWith(&self.r#is_part_of_bio_chem_entity)
756 })?;
757 } else {
758 serialize_struct.skip_field("isPartOfBioChemEntity")?;
759 }
760 if !Vec::is_empty(&self.r#taxonomic_range) {
761 serialize_struct.serialize_field("taxonomicRange", {
762 struct SerializeWith<'a>(&'a Vec<TaxonomicRangeProperty>);
763 impl<'a> Serialize for SerializeWith<'a> {
764 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
765 where
766 S: Serializer,
767 {
768 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
769 self.0, serializer,
770 )
771 }
772 }
773 &SerializeWith(&self.r#taxonomic_range)
774 })?;
775 } else {
776 serialize_struct.skip_field("taxonomicRange")?;
777 }
778 if !Vec::is_empty(&self.r#additional_type) {
779 serialize_struct.serialize_field("additionalType", {
780 struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
781 impl<'a> Serialize for SerializeWith<'a> {
782 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
783 where
784 S: Serializer,
785 {
786 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
787 self.0, serializer,
788 )
789 }
790 }
791 &SerializeWith(&self.r#additional_type)
792 })?;
793 } else {
794 serialize_struct.skip_field("additionalType")?;
795 }
796 if !Vec::is_empty(&self.r#alternate_name) {
797 serialize_struct.serialize_field("alternateName", {
798 struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
799 impl<'a> Serialize for SerializeWith<'a> {
800 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
801 where
802 S: Serializer,
803 {
804 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
805 self.0, serializer,
806 )
807 }
808 }
809 &SerializeWith(&self.r#alternate_name)
810 })?;
811 } else {
812 serialize_struct.skip_field("alternateName")?;
813 }
814 if !Vec::is_empty(&self.r#description) {
815 serialize_struct.serialize_field("description", {
816 struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
817 impl<'a> Serialize for SerializeWith<'a> {
818 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
819 where
820 S: Serializer,
821 {
822 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
823 self.0, serializer,
824 )
825 }
826 }
827 &SerializeWith(&self.r#description)
828 })?;
829 } else {
830 serialize_struct.skip_field("description")?;
831 }
832 if !Vec::is_empty(&self.r#disambiguating_description) {
833 serialize_struct.serialize_field("disambiguatingDescription", {
834 struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
835 impl<'a> Serialize for SerializeWith<'a> {
836 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
837 where
838 S: Serializer,
839 {
840 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
841 self.0, serializer,
842 )
843 }
844 }
845 &SerializeWith(&self.r#disambiguating_description)
846 })?;
847 } else {
848 serialize_struct.skip_field("disambiguatingDescription")?;
849 }
850 if !Vec::is_empty(&self.r#identifier) {
851 serialize_struct.serialize_field("identifier", {
852 struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
853 impl<'a> Serialize for SerializeWith<'a> {
854 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
855 where
856 S: Serializer,
857 {
858 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
859 self.0, serializer,
860 )
861 }
862 }
863 &SerializeWith(&self.r#identifier)
864 })?;
865 } else {
866 serialize_struct.skip_field("identifier")?;
867 }
868 if !Vec::is_empty(&self.r#image) {
869 serialize_struct.serialize_field("image", {
870 struct SerializeWith<'a>(&'a Vec<ImageProperty>);
871 impl<'a> Serialize for SerializeWith<'a> {
872 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
873 where
874 S: Serializer,
875 {
876 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
877 self.0, serializer,
878 )
879 }
880 }
881 &SerializeWith(&self.r#image)
882 })?;
883 } else {
884 serialize_struct.skip_field("image")?;
885 }
886 if !Vec::is_empty(&self.r#main_entity_of_page) {
887 serialize_struct.serialize_field("mainEntityOfPage", {
888 struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
889 impl<'a> Serialize for SerializeWith<'a> {
890 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
891 where
892 S: Serializer,
893 {
894 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
895 self.0, serializer,
896 )
897 }
898 }
899 &SerializeWith(&self.r#main_entity_of_page)
900 })?;
901 } else {
902 serialize_struct.skip_field("mainEntityOfPage")?;
903 }
904 if !Vec::is_empty(&self.r#name) {
905 serialize_struct.serialize_field("name", {
906 struct SerializeWith<'a>(&'a Vec<NameProperty>);
907 impl<'a> Serialize for SerializeWith<'a> {
908 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
909 where
910 S: Serializer,
911 {
912 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
913 self.0, serializer,
914 )
915 }
916 }
917 &SerializeWith(&self.r#name)
918 })?;
919 } else {
920 serialize_struct.skip_field("name")?;
921 }
922 if !Vec::is_empty(&self.r#potential_action) {
923 serialize_struct.serialize_field("potentialAction", {
924 struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
925 impl<'a> Serialize for SerializeWith<'a> {
926 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
927 where
928 S: Serializer,
929 {
930 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
931 self.0, serializer,
932 )
933 }
934 }
935 &SerializeWith(&self.r#potential_action)
936 })?;
937 } else {
938 serialize_struct.skip_field("potentialAction")?;
939 }
940 if !Vec::is_empty(&self.r#same_as) {
941 serialize_struct.serialize_field("sameAs", {
942 struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
943 impl<'a> Serialize for SerializeWith<'a> {
944 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
945 where
946 S: Serializer,
947 {
948 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
949 self.0, serializer,
950 )
951 }
952 }
953 &SerializeWith(&self.r#same_as)
954 })?;
955 } else {
956 serialize_struct.skip_field("sameAs")?;
957 }
958 if !Vec::is_empty(&self.r#subject_of) {
959 serialize_struct.serialize_field("subjectOf", {
960 struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
961 impl<'a> Serialize for SerializeWith<'a> {
962 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
963 where
964 S: Serializer,
965 {
966 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
967 self.0, serializer,
968 )
969 }
970 }
971 &SerializeWith(&self.r#subject_of)
972 })?;
973 } else {
974 serialize_struct.skip_field("subjectOf")?;
975 }
976 if !Vec::is_empty(&self.r#url) {
977 serialize_struct.serialize_field("url", {
978 struct SerializeWith<'a>(&'a Vec<UrlProperty>);
979 impl<'a> Serialize for SerializeWith<'a> {
980 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
981 where
982 S: Serializer,
983 {
984 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
985 self.0, serializer,
986 )
987 }
988 }
989 &SerializeWith(&self.r#url)
990 })?;
991 } else {
992 serialize_struct.skip_field("url")?;
993 }
994 serialize_struct.end()
995 }
996 }
997 impl<'de> Deserialize<'de> for MolecularEntity {
998 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
999 where
1000 D: Deserializer<'de>,
1001 {
1002 enum Field {
1003 ChemicalRole,
1004 InChI,
1005 InChIKey,
1006 IupacName,
1007 MolecularFormula,
1008 MolecularWeight,
1009 MonoisotopicMolecularWeight,
1010 PotentialUse,
1011 Smiles,
1012 AssociatedDisease,
1013 BioChemInteraction,
1014 BioChemSimilarity,
1015 BiologicalRole,
1016 Funding,
1017 HasBioChemEntityPart,
1018 HasMolecularFunction,
1019 HasRepresentation,
1020 IsEncodedByBioChemEntity,
1021 IsInvolvedInBiologicalProcess,
1022 IsLocatedInSubcellularLocation,
1023 IsPartOfBioChemEntity,
1024 TaxonomicRange,
1025 AdditionalType,
1026 AlternateName,
1027 Description,
1028 DisambiguatingDescription,
1029 Identifier,
1030 Image,
1031 MainEntityOfPage,
1032 Name,
1033 PotentialAction,
1034 SameAs,
1035 SubjectOf,
1036 Url,
1037 Ignore,
1038 }
1039 struct FieldVisitor;
1040 impl<'de> Visitor<'de> for FieldVisitor {
1041 type Value = Field;
1042 fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
1043 formatter.write_str("field identifier")
1044 }
1045 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
1046 where
1047 E: de::Error,
1048 {
1049 match value {
1050 "chemicalRole" => Ok(Field::ChemicalRole),
1051 "inChI" => Ok(Field::InChI),
1052 "inChIKey" => Ok(Field::InChIKey),
1053 "iupacName" => Ok(Field::IupacName),
1054 "molecularFormula" => Ok(Field::MolecularFormula),
1055 "molecularWeight" => Ok(Field::MolecularWeight),
1056 "monoisotopicMolecularWeight" => Ok(Field::MonoisotopicMolecularWeight),
1057 "potentialUse" => Ok(Field::PotentialUse),
1058 "smiles" => Ok(Field::Smiles),
1059 "associatedDisease" => Ok(Field::AssociatedDisease),
1060 "bioChemInteraction" => Ok(Field::BioChemInteraction),
1061 "bioChemSimilarity" => Ok(Field::BioChemSimilarity),
1062 "biologicalRole" => Ok(Field::BiologicalRole),
1063 "funding" => Ok(Field::Funding),
1064 "hasBioChemEntityPart" => Ok(Field::HasBioChemEntityPart),
1065 "hasMolecularFunction" => Ok(Field::HasMolecularFunction),
1066 "hasRepresentation" => Ok(Field::HasRepresentation),
1067 "isEncodedByBioChemEntity" => Ok(Field::IsEncodedByBioChemEntity),
1068 "isInvolvedInBiologicalProcess" => Ok(Field::IsInvolvedInBiologicalProcess),
1069 "isLocatedInSubcellularLocation" => {
1070 Ok(Field::IsLocatedInSubcellularLocation)
1071 }
1072 "isPartOfBioChemEntity" => Ok(Field::IsPartOfBioChemEntity),
1073 "taxonomicRange" => Ok(Field::TaxonomicRange),
1074 "additionalType" => Ok(Field::AdditionalType),
1075 "alternateName" => Ok(Field::AlternateName),
1076 "description" => Ok(Field::Description),
1077 "disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
1078 "identifier" => Ok(Field::Identifier),
1079 "image" => Ok(Field::Image),
1080 "mainEntityOfPage" => Ok(Field::MainEntityOfPage),
1081 "name" => Ok(Field::Name),
1082 "potentialAction" => Ok(Field::PotentialAction),
1083 "sameAs" => Ok(Field::SameAs),
1084 "subjectOf" => Ok(Field::SubjectOf),
1085 "url" => Ok(Field::Url),
1086 "id" | "type" => Ok(Field::Ignore),
1087 _ => Err(de::Error::unknown_field(value, FIELDS)),
1088 }
1089 }
1090 fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
1091 where
1092 E: de::Error,
1093 {
1094 match value {
1095 b"chemicalRole" => Ok(Field::ChemicalRole),
1096 b"inChI" => Ok(Field::InChI),
1097 b"inChIKey" => Ok(Field::InChIKey),
1098 b"iupacName" => Ok(Field::IupacName),
1099 b"molecularFormula" => Ok(Field::MolecularFormula),
1100 b"molecularWeight" => Ok(Field::MolecularWeight),
1101 b"monoisotopicMolecularWeight" => Ok(Field::MonoisotopicMolecularWeight),
1102 b"potentialUse" => Ok(Field::PotentialUse),
1103 b"smiles" => Ok(Field::Smiles),
1104 b"associatedDisease" => Ok(Field::AssociatedDisease),
1105 b"bioChemInteraction" => Ok(Field::BioChemInteraction),
1106 b"bioChemSimilarity" => Ok(Field::BioChemSimilarity),
1107 b"biologicalRole" => Ok(Field::BiologicalRole),
1108 b"funding" => Ok(Field::Funding),
1109 b"hasBioChemEntityPart" => Ok(Field::HasBioChemEntityPart),
1110 b"hasMolecularFunction" => Ok(Field::HasMolecularFunction),
1111 b"hasRepresentation" => Ok(Field::HasRepresentation),
1112 b"isEncodedByBioChemEntity" => Ok(Field::IsEncodedByBioChemEntity),
1113 b"isInvolvedInBiologicalProcess" => {
1114 Ok(Field::IsInvolvedInBiologicalProcess)
1115 }
1116 b"isLocatedInSubcellularLocation" => {
1117 Ok(Field::IsLocatedInSubcellularLocation)
1118 }
1119 b"isPartOfBioChemEntity" => Ok(Field::IsPartOfBioChemEntity),
1120 b"taxonomicRange" => Ok(Field::TaxonomicRange),
1121 b"additionalType" => Ok(Field::AdditionalType),
1122 b"alternateName" => Ok(Field::AlternateName),
1123 b"description" => Ok(Field::Description),
1124 b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
1125 b"identifier" => Ok(Field::Identifier),
1126 b"image" => Ok(Field::Image),
1127 b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
1128 b"name" => Ok(Field::Name),
1129 b"potentialAction" => Ok(Field::PotentialAction),
1130 b"sameAs" => Ok(Field::SameAs),
1131 b"subjectOf" => Ok(Field::SubjectOf),
1132 b"url" => Ok(Field::Url),
1133 b"id" | b"type" => Ok(Field::Ignore),
1134 _ => {
1135 let value = &String::from_utf8_lossy(value);
1136 Err(de::Error::unknown_field(value, FIELDS))
1137 }
1138 }
1139 }
1140 }
1141 impl<'de> Deserialize<'de> for Field {
1142 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1143 where
1144 D: Deserializer<'de>,
1145 {
1146 deserializer.deserialize_identifier(FieldVisitor)
1147 }
1148 }
1149 struct ClassVisitor;
1150 impl<'de> Visitor<'de> for ClassVisitor {
1151 type Value = MolecularEntity;
1152 fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
1153 formatter.write_str("schema.org schema MolecularEntity")
1154 }
1155 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
1156 where
1157 A: de::MapAccess<'de>,
1158 {
1159 let mut r#chemical_role_property = None;
1160 let mut r#in_ch_i_property = None;
1161 let mut r#in_ch_i_key_property = None;
1162 let mut r#iupac_name_property = None;
1163 let mut r#molecular_formula_property = None;
1164 let mut r#molecular_weight_property = None;
1165 let mut r#monoisotopic_molecular_weight_property = None;
1166 let mut r#potential_use_property = None;
1167 let mut r#smiles_property = None;
1168 let mut r#associated_disease_property = None;
1169 let mut r#bio_chem_interaction_property = None;
1170 let mut r#bio_chem_similarity_property = None;
1171 let mut r#biological_role_property = None;
1172 let mut r#funding_property = None;
1173 let mut r#has_bio_chem_entity_part_property = None;
1174 let mut r#has_molecular_function_property = None;
1175 let mut r#has_representation_property = None;
1176 let mut r#is_encoded_by_bio_chem_entity_property = None;
1177 let mut r#is_involved_in_biological_process_property = None;
1178 let mut r#is_located_in_subcellular_location_property = None;
1179 let mut r#is_part_of_bio_chem_entity_property = None;
1180 let mut r#taxonomic_range_property = None;
1181 let mut r#additional_type_property = None;
1182 let mut r#alternate_name_property = None;
1183 let mut r#description_property = None;
1184 let mut r#disambiguating_description_property = None;
1185 let mut r#identifier_property = None;
1186 let mut r#image_property = None;
1187 let mut r#main_entity_of_page_property = None;
1188 let mut r#name_property = None;
1189 let mut r#potential_action_property = None;
1190 let mut r#same_as_property = None;
1191 let mut r#subject_of_property = None;
1192 let mut r#url_property = None;
1193 while let Some(key) = map.next_key::<Field>()? {
1194 match key {
1195 Field::ChemicalRole => {
1196 if r#chemical_role_property.is_some() {
1197 return Err(<A::Error as de::Error>::duplicate_field(
1198 "chemicalRole",
1199 ));
1200 }
1201 r#chemical_role_property = Some({
1202 struct DeserializeWith(Vec<ChemicalRoleProperty>);
1203 impl<'de> Deserialize<'de> for DeserializeWith {
1204 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1205 where
1206 D: Deserializer<'de>,
1207 {
1208 Ok(DeserializeWith(serde_with::As::<
1209 serde_with::OneOrMany<serde_with::Same>,
1210 >::deserialize(deserializer)?))
1211 }
1212 }
1213 match map.next_value::<DeserializeWith>() {
1214 Ok(deserialize_with) => deserialize_with.0,
1215 Err(err) => {
1216 return Err(err);
1217 }
1218 }
1219 });
1220 }
1221 Field::InChI => {
1222 if r#in_ch_i_property.is_some() {
1223 return Err(<A::Error as de::Error>::duplicate_field("inChI"));
1224 }
1225 r#in_ch_i_property = Some({
1226 struct DeserializeWith(Vec<InChIProperty>);
1227 impl<'de> Deserialize<'de> for DeserializeWith {
1228 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1229 where
1230 D: Deserializer<'de>,
1231 {
1232 Ok(DeserializeWith(serde_with::As::<
1233 serde_with::OneOrMany<serde_with::Same>,
1234 >::deserialize(deserializer)?))
1235 }
1236 }
1237 match map.next_value::<DeserializeWith>() {
1238 Ok(deserialize_with) => deserialize_with.0,
1239 Err(err) => {
1240 return Err(err);
1241 }
1242 }
1243 });
1244 }
1245 Field::InChIKey => {
1246 if r#in_ch_i_key_property.is_some() {
1247 return Err(<A::Error as de::Error>::duplicate_field(
1248 "inChIKey",
1249 ));
1250 }
1251 r#in_ch_i_key_property = Some({
1252 struct DeserializeWith(Vec<InChIKeyProperty>);
1253 impl<'de> Deserialize<'de> for DeserializeWith {
1254 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1255 where
1256 D: Deserializer<'de>,
1257 {
1258 Ok(DeserializeWith(serde_with::As::<
1259 serde_with::OneOrMany<serde_with::Same>,
1260 >::deserialize(deserializer)?))
1261 }
1262 }
1263 match map.next_value::<DeserializeWith>() {
1264 Ok(deserialize_with) => deserialize_with.0,
1265 Err(err) => {
1266 return Err(err);
1267 }
1268 }
1269 });
1270 }
1271 Field::IupacName => {
1272 if r#iupac_name_property.is_some() {
1273 return Err(<A::Error as de::Error>::duplicate_field(
1274 "iupacName",
1275 ));
1276 }
1277 r#iupac_name_property = Some({
1278 struct DeserializeWith(Vec<IupacNameProperty>);
1279 impl<'de> Deserialize<'de> for DeserializeWith {
1280 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1281 where
1282 D: Deserializer<'de>,
1283 {
1284 Ok(DeserializeWith(serde_with::As::<
1285 serde_with::OneOrMany<serde_with::Same>,
1286 >::deserialize(deserializer)?))
1287 }
1288 }
1289 match map.next_value::<DeserializeWith>() {
1290 Ok(deserialize_with) => deserialize_with.0,
1291 Err(err) => {
1292 return Err(err);
1293 }
1294 }
1295 });
1296 }
1297 Field::MolecularFormula => {
1298 if r#molecular_formula_property.is_some() {
1299 return Err(<A::Error as de::Error>::duplicate_field(
1300 "molecularFormula",
1301 ));
1302 }
1303 r#molecular_formula_property = Some({
1304 struct DeserializeWith(Vec<MolecularFormulaProperty>);
1305 impl<'de> Deserialize<'de> for DeserializeWith {
1306 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1307 where
1308 D: Deserializer<'de>,
1309 {
1310 Ok(DeserializeWith(serde_with::As::<
1311 serde_with::OneOrMany<serde_with::Same>,
1312 >::deserialize(deserializer)?))
1313 }
1314 }
1315 match map.next_value::<DeserializeWith>() {
1316 Ok(deserialize_with) => deserialize_with.0,
1317 Err(err) => {
1318 return Err(err);
1319 }
1320 }
1321 });
1322 }
1323 Field::MolecularWeight => {
1324 if r#molecular_weight_property.is_some() {
1325 return Err(<A::Error as de::Error>::duplicate_field(
1326 "molecularWeight",
1327 ));
1328 }
1329 r#molecular_weight_property = Some({
1330 struct DeserializeWith(Vec<MolecularWeightProperty>);
1331 impl<'de> Deserialize<'de> for DeserializeWith {
1332 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1333 where
1334 D: Deserializer<'de>,
1335 {
1336 Ok(DeserializeWith(serde_with::As::<
1337 serde_with::OneOrMany<serde_with::Same>,
1338 >::deserialize(deserializer)?))
1339 }
1340 }
1341 match map.next_value::<DeserializeWith>() {
1342 Ok(deserialize_with) => deserialize_with.0,
1343 Err(err) => {
1344 return Err(err);
1345 }
1346 }
1347 });
1348 }
1349 Field::MonoisotopicMolecularWeight => {
1350 if r#monoisotopic_molecular_weight_property.is_some() {
1351 return Err(<A::Error as de::Error>::duplicate_field(
1352 "monoisotopicMolecularWeight",
1353 ));
1354 }
1355 r#monoisotopic_molecular_weight_property = Some({
1356 struct DeserializeWith(
1357 Vec<MonoisotopicMolecularWeightProperty>,
1358 );
1359 impl<'de> Deserialize<'de> for DeserializeWith {
1360 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1361 where
1362 D: Deserializer<'de>,
1363 {
1364 Ok(DeserializeWith(serde_with::As::<
1365 serde_with::OneOrMany<serde_with::Same>,
1366 >::deserialize(deserializer)?))
1367 }
1368 }
1369 match map.next_value::<DeserializeWith>() {
1370 Ok(deserialize_with) => deserialize_with.0,
1371 Err(err) => {
1372 return Err(err);
1373 }
1374 }
1375 });
1376 }
1377 Field::PotentialUse => {
1378 if r#potential_use_property.is_some() {
1379 return Err(<A::Error as de::Error>::duplicate_field(
1380 "potentialUse",
1381 ));
1382 }
1383 r#potential_use_property = Some({
1384 struct DeserializeWith(Vec<PotentialUseProperty>);
1385 impl<'de> Deserialize<'de> for DeserializeWith {
1386 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1387 where
1388 D: Deserializer<'de>,
1389 {
1390 Ok(DeserializeWith(serde_with::As::<
1391 serde_with::OneOrMany<serde_with::Same>,
1392 >::deserialize(deserializer)?))
1393 }
1394 }
1395 match map.next_value::<DeserializeWith>() {
1396 Ok(deserialize_with) => deserialize_with.0,
1397 Err(err) => {
1398 return Err(err);
1399 }
1400 }
1401 });
1402 }
1403 Field::Smiles => {
1404 if r#smiles_property.is_some() {
1405 return Err(<A::Error as de::Error>::duplicate_field("smiles"));
1406 }
1407 r#smiles_property = Some({
1408 struct DeserializeWith(Vec<SmilesProperty>);
1409 impl<'de> Deserialize<'de> for DeserializeWith {
1410 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1411 where
1412 D: Deserializer<'de>,
1413 {
1414 Ok(DeserializeWith(serde_with::As::<
1415 serde_with::OneOrMany<serde_with::Same>,
1416 >::deserialize(deserializer)?))
1417 }
1418 }
1419 match map.next_value::<DeserializeWith>() {
1420 Ok(deserialize_with) => deserialize_with.0,
1421 Err(err) => {
1422 return Err(err);
1423 }
1424 }
1425 });
1426 }
1427 Field::AssociatedDisease => {
1428 if r#associated_disease_property.is_some() {
1429 return Err(<A::Error as de::Error>::duplicate_field(
1430 "associatedDisease",
1431 ));
1432 }
1433 r#associated_disease_property = Some({
1434 struct DeserializeWith(Vec<AssociatedDiseaseProperty>);
1435 impl<'de> Deserialize<'de> for DeserializeWith {
1436 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1437 where
1438 D: Deserializer<'de>,
1439 {
1440 Ok(DeserializeWith(serde_with::As::<
1441 serde_with::OneOrMany<serde_with::Same>,
1442 >::deserialize(deserializer)?))
1443 }
1444 }
1445 match map.next_value::<DeserializeWith>() {
1446 Ok(deserialize_with) => deserialize_with.0,
1447 Err(err) => {
1448 return Err(err);
1449 }
1450 }
1451 });
1452 }
1453 Field::BioChemInteraction => {
1454 if r#bio_chem_interaction_property.is_some() {
1455 return Err(<A::Error as de::Error>::duplicate_field(
1456 "bioChemInteraction",
1457 ));
1458 }
1459 r#bio_chem_interaction_property = Some({
1460 struct DeserializeWith(Vec<BioChemInteractionProperty>);
1461 impl<'de> Deserialize<'de> for DeserializeWith {
1462 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1463 where
1464 D: Deserializer<'de>,
1465 {
1466 Ok(DeserializeWith(serde_with::As::<
1467 serde_with::OneOrMany<serde_with::Same>,
1468 >::deserialize(deserializer)?))
1469 }
1470 }
1471 match map.next_value::<DeserializeWith>() {
1472 Ok(deserialize_with) => deserialize_with.0,
1473 Err(err) => {
1474 return Err(err);
1475 }
1476 }
1477 });
1478 }
1479 Field::BioChemSimilarity => {
1480 if r#bio_chem_similarity_property.is_some() {
1481 return Err(<A::Error as de::Error>::duplicate_field(
1482 "bioChemSimilarity",
1483 ));
1484 }
1485 r#bio_chem_similarity_property = Some({
1486 struct DeserializeWith(Vec<BioChemSimilarityProperty>);
1487 impl<'de> Deserialize<'de> for DeserializeWith {
1488 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1489 where
1490 D: Deserializer<'de>,
1491 {
1492 Ok(DeserializeWith(serde_with::As::<
1493 serde_with::OneOrMany<serde_with::Same>,
1494 >::deserialize(deserializer)?))
1495 }
1496 }
1497 match map.next_value::<DeserializeWith>() {
1498 Ok(deserialize_with) => deserialize_with.0,
1499 Err(err) => {
1500 return Err(err);
1501 }
1502 }
1503 });
1504 }
1505 Field::BiologicalRole => {
1506 if r#biological_role_property.is_some() {
1507 return Err(<A::Error as de::Error>::duplicate_field(
1508 "biologicalRole",
1509 ));
1510 }
1511 r#biological_role_property = Some({
1512 struct DeserializeWith(Vec<BiologicalRoleProperty>);
1513 impl<'de> Deserialize<'de> for DeserializeWith {
1514 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1515 where
1516 D: Deserializer<'de>,
1517 {
1518 Ok(DeserializeWith(serde_with::As::<
1519 serde_with::OneOrMany<serde_with::Same>,
1520 >::deserialize(deserializer)?))
1521 }
1522 }
1523 match map.next_value::<DeserializeWith>() {
1524 Ok(deserialize_with) => deserialize_with.0,
1525 Err(err) => {
1526 return Err(err);
1527 }
1528 }
1529 });
1530 }
1531 Field::Funding => {
1532 if r#funding_property.is_some() {
1533 return Err(<A::Error as de::Error>::duplicate_field(
1534 "funding",
1535 ));
1536 }
1537 r#funding_property = Some({
1538 struct DeserializeWith(Vec<FundingProperty>);
1539 impl<'de> Deserialize<'de> for DeserializeWith {
1540 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1541 where
1542 D: Deserializer<'de>,
1543 {
1544 Ok(DeserializeWith(serde_with::As::<
1545 serde_with::OneOrMany<serde_with::Same>,
1546 >::deserialize(deserializer)?))
1547 }
1548 }
1549 match map.next_value::<DeserializeWith>() {
1550 Ok(deserialize_with) => deserialize_with.0,
1551 Err(err) => {
1552 return Err(err);
1553 }
1554 }
1555 });
1556 }
1557 Field::HasBioChemEntityPart => {
1558 if r#has_bio_chem_entity_part_property.is_some() {
1559 return Err(<A::Error as de::Error>::duplicate_field(
1560 "hasBioChemEntityPart",
1561 ));
1562 }
1563 r#has_bio_chem_entity_part_property = Some({
1564 struct DeserializeWith(Vec<HasBioChemEntityPartProperty>);
1565 impl<'de> Deserialize<'de> for DeserializeWith {
1566 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1567 where
1568 D: Deserializer<'de>,
1569 {
1570 Ok(DeserializeWith(serde_with::As::<
1571 serde_with::OneOrMany<serde_with::Same>,
1572 >::deserialize(deserializer)?))
1573 }
1574 }
1575 match map.next_value::<DeserializeWith>() {
1576 Ok(deserialize_with) => deserialize_with.0,
1577 Err(err) => {
1578 return Err(err);
1579 }
1580 }
1581 });
1582 }
1583 Field::HasMolecularFunction => {
1584 if r#has_molecular_function_property.is_some() {
1585 return Err(<A::Error as de::Error>::duplicate_field(
1586 "hasMolecularFunction",
1587 ));
1588 }
1589 r#has_molecular_function_property = Some({
1590 struct DeserializeWith(Vec<HasMolecularFunctionProperty>);
1591 impl<'de> Deserialize<'de> for DeserializeWith {
1592 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1593 where
1594 D: Deserializer<'de>,
1595 {
1596 Ok(DeserializeWith(serde_with::As::<
1597 serde_with::OneOrMany<serde_with::Same>,
1598 >::deserialize(deserializer)?))
1599 }
1600 }
1601 match map.next_value::<DeserializeWith>() {
1602 Ok(deserialize_with) => deserialize_with.0,
1603 Err(err) => {
1604 return Err(err);
1605 }
1606 }
1607 });
1608 }
1609 Field::HasRepresentation => {
1610 if r#has_representation_property.is_some() {
1611 return Err(<A::Error as de::Error>::duplicate_field(
1612 "hasRepresentation",
1613 ));
1614 }
1615 r#has_representation_property = Some({
1616 struct DeserializeWith(Vec<HasRepresentationProperty>);
1617 impl<'de> Deserialize<'de> for DeserializeWith {
1618 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1619 where
1620 D: Deserializer<'de>,
1621 {
1622 Ok(DeserializeWith(serde_with::As::<
1623 serde_with::OneOrMany<serde_with::Same>,
1624 >::deserialize(deserializer)?))
1625 }
1626 }
1627 match map.next_value::<DeserializeWith>() {
1628 Ok(deserialize_with) => deserialize_with.0,
1629 Err(err) => {
1630 return Err(err);
1631 }
1632 }
1633 });
1634 }
1635 Field::IsEncodedByBioChemEntity => {
1636 if r#is_encoded_by_bio_chem_entity_property.is_some() {
1637 return Err(<A::Error as de::Error>::duplicate_field(
1638 "isEncodedByBioChemEntity",
1639 ));
1640 }
1641 r#is_encoded_by_bio_chem_entity_property = Some({
1642 struct DeserializeWith(Vec<IsEncodedByBioChemEntityProperty>);
1643 impl<'de> Deserialize<'de> for DeserializeWith {
1644 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1645 where
1646 D: Deserializer<'de>,
1647 {
1648 Ok(DeserializeWith(serde_with::As::<
1649 serde_with::OneOrMany<serde_with::Same>,
1650 >::deserialize(deserializer)?))
1651 }
1652 }
1653 match map.next_value::<DeserializeWith>() {
1654 Ok(deserialize_with) => deserialize_with.0,
1655 Err(err) => {
1656 return Err(err);
1657 }
1658 }
1659 });
1660 }
1661 Field::IsInvolvedInBiologicalProcess => {
1662 if r#is_involved_in_biological_process_property.is_some() {
1663 return Err(<A::Error as de::Error>::duplicate_field(
1664 "isInvolvedInBiologicalProcess",
1665 ));
1666 }
1667 r#is_involved_in_biological_process_property = Some({
1668 struct DeserializeWith(
1669 Vec<IsInvolvedInBiologicalProcessProperty>,
1670 );
1671 impl<'de> Deserialize<'de> for DeserializeWith {
1672 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1673 where
1674 D: Deserializer<'de>,
1675 {
1676 Ok(DeserializeWith(serde_with::As::<
1677 serde_with::OneOrMany<serde_with::Same>,
1678 >::deserialize(deserializer)?))
1679 }
1680 }
1681 match map.next_value::<DeserializeWith>() {
1682 Ok(deserialize_with) => deserialize_with.0,
1683 Err(err) => {
1684 return Err(err);
1685 }
1686 }
1687 });
1688 }
1689 Field::IsLocatedInSubcellularLocation => {
1690 if r#is_located_in_subcellular_location_property.is_some() {
1691 return Err(<A::Error as de::Error>::duplicate_field(
1692 "isLocatedInSubcellularLocation",
1693 ));
1694 }
1695 r#is_located_in_subcellular_location_property = Some({
1696 struct DeserializeWith(
1697 Vec<IsLocatedInSubcellularLocationProperty>,
1698 );
1699 impl<'de> Deserialize<'de> for DeserializeWith {
1700 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1701 where
1702 D: Deserializer<'de>,
1703 {
1704 Ok(DeserializeWith(serde_with::As::<
1705 serde_with::OneOrMany<serde_with::Same>,
1706 >::deserialize(deserializer)?))
1707 }
1708 }
1709 match map.next_value::<DeserializeWith>() {
1710 Ok(deserialize_with) => deserialize_with.0,
1711 Err(err) => {
1712 return Err(err);
1713 }
1714 }
1715 });
1716 }
1717 Field::IsPartOfBioChemEntity => {
1718 if r#is_part_of_bio_chem_entity_property.is_some() {
1719 return Err(<A::Error as de::Error>::duplicate_field(
1720 "isPartOfBioChemEntity",
1721 ));
1722 }
1723 r#is_part_of_bio_chem_entity_property = Some({
1724 struct DeserializeWith(Vec<IsPartOfBioChemEntityProperty>);
1725 impl<'de> Deserialize<'de> for DeserializeWith {
1726 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1727 where
1728 D: Deserializer<'de>,
1729 {
1730 Ok(DeserializeWith(serde_with::As::<
1731 serde_with::OneOrMany<serde_with::Same>,
1732 >::deserialize(deserializer)?))
1733 }
1734 }
1735 match map.next_value::<DeserializeWith>() {
1736 Ok(deserialize_with) => deserialize_with.0,
1737 Err(err) => {
1738 return Err(err);
1739 }
1740 }
1741 });
1742 }
1743 Field::TaxonomicRange => {
1744 if r#taxonomic_range_property.is_some() {
1745 return Err(<A::Error as de::Error>::duplicate_field(
1746 "taxonomicRange",
1747 ));
1748 }
1749 r#taxonomic_range_property = Some({
1750 struct DeserializeWith(Vec<TaxonomicRangeProperty>);
1751 impl<'de> Deserialize<'de> for DeserializeWith {
1752 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1753 where
1754 D: Deserializer<'de>,
1755 {
1756 Ok(DeserializeWith(serde_with::As::<
1757 serde_with::OneOrMany<serde_with::Same>,
1758 >::deserialize(deserializer)?))
1759 }
1760 }
1761 match map.next_value::<DeserializeWith>() {
1762 Ok(deserialize_with) => deserialize_with.0,
1763 Err(err) => {
1764 return Err(err);
1765 }
1766 }
1767 });
1768 }
1769 Field::AdditionalType => {
1770 if r#additional_type_property.is_some() {
1771 return Err(<A::Error as de::Error>::duplicate_field(
1772 "additionalType",
1773 ));
1774 }
1775 r#additional_type_property = Some({
1776 struct DeserializeWith(Vec<AdditionalTypeProperty>);
1777 impl<'de> Deserialize<'de> for DeserializeWith {
1778 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1779 where
1780 D: Deserializer<'de>,
1781 {
1782 Ok(DeserializeWith(serde_with::As::<
1783 serde_with::OneOrMany<serde_with::Same>,
1784 >::deserialize(deserializer)?))
1785 }
1786 }
1787 match map.next_value::<DeserializeWith>() {
1788 Ok(deserialize_with) => deserialize_with.0,
1789 Err(err) => {
1790 return Err(err);
1791 }
1792 }
1793 });
1794 }
1795 Field::AlternateName => {
1796 if r#alternate_name_property.is_some() {
1797 return Err(<A::Error as de::Error>::duplicate_field(
1798 "alternateName",
1799 ));
1800 }
1801 r#alternate_name_property = Some({
1802 struct DeserializeWith(Vec<AlternateNameProperty>);
1803 impl<'de> Deserialize<'de> for DeserializeWith {
1804 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1805 where
1806 D: Deserializer<'de>,
1807 {
1808 Ok(DeserializeWith(serde_with::As::<
1809 serde_with::OneOrMany<serde_with::Same>,
1810 >::deserialize(deserializer)?))
1811 }
1812 }
1813 match map.next_value::<DeserializeWith>() {
1814 Ok(deserialize_with) => deserialize_with.0,
1815 Err(err) => {
1816 return Err(err);
1817 }
1818 }
1819 });
1820 }
1821 Field::Description => {
1822 if r#description_property.is_some() {
1823 return Err(<A::Error as de::Error>::duplicate_field(
1824 "description",
1825 ));
1826 }
1827 r#description_property = Some({
1828 struct DeserializeWith(Vec<DescriptionProperty>);
1829 impl<'de> Deserialize<'de> for DeserializeWith {
1830 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1831 where
1832 D: Deserializer<'de>,
1833 {
1834 Ok(DeserializeWith(serde_with::As::<
1835 serde_with::OneOrMany<serde_with::Same>,
1836 >::deserialize(deserializer)?))
1837 }
1838 }
1839 match map.next_value::<DeserializeWith>() {
1840 Ok(deserialize_with) => deserialize_with.0,
1841 Err(err) => {
1842 return Err(err);
1843 }
1844 }
1845 });
1846 }
1847 Field::DisambiguatingDescription => {
1848 if r#disambiguating_description_property.is_some() {
1849 return Err(<A::Error as de::Error>::duplicate_field(
1850 "disambiguatingDescription",
1851 ));
1852 }
1853 r#disambiguating_description_property = Some({
1854 struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
1855 impl<'de> Deserialize<'de> for DeserializeWith {
1856 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1857 where
1858 D: Deserializer<'de>,
1859 {
1860 Ok(DeserializeWith(serde_with::As::<
1861 serde_with::OneOrMany<serde_with::Same>,
1862 >::deserialize(deserializer)?))
1863 }
1864 }
1865 match map.next_value::<DeserializeWith>() {
1866 Ok(deserialize_with) => deserialize_with.0,
1867 Err(err) => {
1868 return Err(err);
1869 }
1870 }
1871 });
1872 }
1873 Field::Identifier => {
1874 if r#identifier_property.is_some() {
1875 return Err(<A::Error as de::Error>::duplicate_field(
1876 "identifier",
1877 ));
1878 }
1879 r#identifier_property = Some({
1880 struct DeserializeWith(Vec<IdentifierProperty>);
1881 impl<'de> Deserialize<'de> for DeserializeWith {
1882 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1883 where
1884 D: Deserializer<'de>,
1885 {
1886 Ok(DeserializeWith(serde_with::As::<
1887 serde_with::OneOrMany<serde_with::Same>,
1888 >::deserialize(deserializer)?))
1889 }
1890 }
1891 match map.next_value::<DeserializeWith>() {
1892 Ok(deserialize_with) => deserialize_with.0,
1893 Err(err) => {
1894 return Err(err);
1895 }
1896 }
1897 });
1898 }
1899 Field::Image => {
1900 if r#image_property.is_some() {
1901 return Err(<A::Error as de::Error>::duplicate_field("image"));
1902 }
1903 r#image_property = Some({
1904 struct DeserializeWith(Vec<ImageProperty>);
1905 impl<'de> Deserialize<'de> for DeserializeWith {
1906 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1907 where
1908 D: Deserializer<'de>,
1909 {
1910 Ok(DeserializeWith(serde_with::As::<
1911 serde_with::OneOrMany<serde_with::Same>,
1912 >::deserialize(deserializer)?))
1913 }
1914 }
1915 match map.next_value::<DeserializeWith>() {
1916 Ok(deserialize_with) => deserialize_with.0,
1917 Err(err) => {
1918 return Err(err);
1919 }
1920 }
1921 });
1922 }
1923 Field::MainEntityOfPage => {
1924 if r#main_entity_of_page_property.is_some() {
1925 return Err(<A::Error as de::Error>::duplicate_field(
1926 "mainEntityOfPage",
1927 ));
1928 }
1929 r#main_entity_of_page_property = Some({
1930 struct DeserializeWith(Vec<MainEntityOfPageProperty>);
1931 impl<'de> Deserialize<'de> for DeserializeWith {
1932 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1933 where
1934 D: Deserializer<'de>,
1935 {
1936 Ok(DeserializeWith(serde_with::As::<
1937 serde_with::OneOrMany<serde_with::Same>,
1938 >::deserialize(deserializer)?))
1939 }
1940 }
1941 match map.next_value::<DeserializeWith>() {
1942 Ok(deserialize_with) => deserialize_with.0,
1943 Err(err) => {
1944 return Err(err);
1945 }
1946 }
1947 });
1948 }
1949 Field::Name => {
1950 if r#name_property.is_some() {
1951 return Err(<A::Error as de::Error>::duplicate_field("name"));
1952 }
1953 r#name_property = Some({
1954 struct DeserializeWith(Vec<NameProperty>);
1955 impl<'de> Deserialize<'de> for DeserializeWith {
1956 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1957 where
1958 D: Deserializer<'de>,
1959 {
1960 Ok(DeserializeWith(serde_with::As::<
1961 serde_with::OneOrMany<serde_with::Same>,
1962 >::deserialize(deserializer)?))
1963 }
1964 }
1965 match map.next_value::<DeserializeWith>() {
1966 Ok(deserialize_with) => deserialize_with.0,
1967 Err(err) => {
1968 return Err(err);
1969 }
1970 }
1971 });
1972 }
1973 Field::PotentialAction => {
1974 if r#potential_action_property.is_some() {
1975 return Err(<A::Error as de::Error>::duplicate_field(
1976 "potentialAction",
1977 ));
1978 }
1979 r#potential_action_property = Some({
1980 struct DeserializeWith(Vec<PotentialActionProperty>);
1981 impl<'de> Deserialize<'de> for DeserializeWith {
1982 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1983 where
1984 D: Deserializer<'de>,
1985 {
1986 Ok(DeserializeWith(serde_with::As::<
1987 serde_with::OneOrMany<serde_with::Same>,
1988 >::deserialize(deserializer)?))
1989 }
1990 }
1991 match map.next_value::<DeserializeWith>() {
1992 Ok(deserialize_with) => deserialize_with.0,
1993 Err(err) => {
1994 return Err(err);
1995 }
1996 }
1997 });
1998 }
1999 Field::SameAs => {
2000 if r#same_as_property.is_some() {
2001 return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
2002 }
2003 r#same_as_property = Some({
2004 struct DeserializeWith(Vec<SameAsProperty>);
2005 impl<'de> Deserialize<'de> for DeserializeWith {
2006 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2007 where
2008 D: Deserializer<'de>,
2009 {
2010 Ok(DeserializeWith(serde_with::As::<
2011 serde_with::OneOrMany<serde_with::Same>,
2012 >::deserialize(deserializer)?))
2013 }
2014 }
2015 match map.next_value::<DeserializeWith>() {
2016 Ok(deserialize_with) => deserialize_with.0,
2017 Err(err) => {
2018 return Err(err);
2019 }
2020 }
2021 });
2022 }
2023 Field::SubjectOf => {
2024 if r#subject_of_property.is_some() {
2025 return Err(<A::Error as de::Error>::duplicate_field(
2026 "subjectOf",
2027 ));
2028 }
2029 r#subject_of_property = Some({
2030 struct DeserializeWith(Vec<SubjectOfProperty>);
2031 impl<'de> Deserialize<'de> for DeserializeWith {
2032 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2033 where
2034 D: Deserializer<'de>,
2035 {
2036 Ok(DeserializeWith(serde_with::As::<
2037 serde_with::OneOrMany<serde_with::Same>,
2038 >::deserialize(deserializer)?))
2039 }
2040 }
2041 match map.next_value::<DeserializeWith>() {
2042 Ok(deserialize_with) => deserialize_with.0,
2043 Err(err) => {
2044 return Err(err);
2045 }
2046 }
2047 });
2048 }
2049 Field::Url => {
2050 if r#url_property.is_some() {
2051 return Err(<A::Error as de::Error>::duplicate_field("url"));
2052 }
2053 r#url_property = Some({
2054 struct DeserializeWith(Vec<UrlProperty>);
2055 impl<'de> Deserialize<'de> for DeserializeWith {
2056 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2057 where
2058 D: Deserializer<'de>,
2059 {
2060 Ok(DeserializeWith(serde_with::As::<
2061 serde_with::OneOrMany<serde_with::Same>,
2062 >::deserialize(deserializer)?))
2063 }
2064 }
2065 match map.next_value::<DeserializeWith>() {
2066 Ok(deserialize_with) => deserialize_with.0,
2067 Err(err) => {
2068 return Err(err);
2069 }
2070 }
2071 });
2072 }
2073 Field::Ignore => {
2074 let _ = map.next_value::<de::IgnoredAny>()?;
2075 }
2076 }
2077 }
2078 Ok(MolecularEntity {
2079 r#chemical_role: r#chemical_role_property.unwrap_or_default(),
2080 r#in_ch_i: r#in_ch_i_property.unwrap_or_default(),
2081 r#in_ch_i_key: r#in_ch_i_key_property.unwrap_or_default(),
2082 r#iupac_name: r#iupac_name_property.unwrap_or_default(),
2083 r#molecular_formula: r#molecular_formula_property.unwrap_or_default(),
2084 r#molecular_weight: r#molecular_weight_property.unwrap_or_default(),
2085 r#monoisotopic_molecular_weight: r#monoisotopic_molecular_weight_property
2086 .unwrap_or_default(),
2087 r#potential_use: r#potential_use_property.unwrap_or_default(),
2088 r#smiles: r#smiles_property.unwrap_or_default(),
2089 r#associated_disease: r#associated_disease_property.unwrap_or_default(),
2090 r#bio_chem_interaction: r#bio_chem_interaction_property.unwrap_or_default(),
2091 r#bio_chem_similarity: r#bio_chem_similarity_property.unwrap_or_default(),
2092 r#biological_role: r#biological_role_property.unwrap_or_default(),
2093 r#funding: r#funding_property.unwrap_or_default(),
2094 r#has_bio_chem_entity_part: r#has_bio_chem_entity_part_property
2095 .unwrap_or_default(),
2096 r#has_molecular_function: r#has_molecular_function_property
2097 .unwrap_or_default(),
2098 r#has_representation: r#has_representation_property.unwrap_or_default(),
2099 r#is_encoded_by_bio_chem_entity: r#is_encoded_by_bio_chem_entity_property
2100 .unwrap_or_default(),
2101 r#is_involved_in_biological_process:
2102 r#is_involved_in_biological_process_property.unwrap_or_default(),
2103 r#is_located_in_subcellular_location:
2104 r#is_located_in_subcellular_location_property.unwrap_or_default(),
2105 r#is_part_of_bio_chem_entity: r#is_part_of_bio_chem_entity_property
2106 .unwrap_or_default(),
2107 r#taxonomic_range: r#taxonomic_range_property.unwrap_or_default(),
2108 r#additional_type: r#additional_type_property.unwrap_or_default(),
2109 r#alternate_name: r#alternate_name_property.unwrap_or_default(),
2110 r#description: r#description_property.unwrap_or_default(),
2111 r#disambiguating_description: r#disambiguating_description_property
2112 .unwrap_or_default(),
2113 r#identifier: r#identifier_property.unwrap_or_default(),
2114 r#image: r#image_property.unwrap_or_default(),
2115 r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
2116 r#name: r#name_property.unwrap_or_default(),
2117 r#potential_action: r#potential_action_property.unwrap_or_default(),
2118 r#same_as: r#same_as_property.unwrap_or_default(),
2119 r#subject_of: r#subject_of_property.unwrap_or_default(),
2120 r#url: r#url_property.unwrap_or_default(),
2121 })
2122 }
2123 }
2124 const FIELDS: &[&str] = &[
2125 "chemicalRole",
2126 "inChI",
2127 "inChIKey",
2128 "iupacName",
2129 "molecularFormula",
2130 "molecularWeight",
2131 "monoisotopicMolecularWeight",
2132 "potentialUse",
2133 "smiles",
2134 "associatedDisease",
2135 "bioChemInteraction",
2136 "bioChemSimilarity",
2137 "biologicalRole",
2138 "funding",
2139 "hasBioChemEntityPart",
2140 "hasMolecularFunction",
2141 "hasRepresentation",
2142 "isEncodedByBioChemEntity",
2143 "isInvolvedInBiologicalProcess",
2144 "isLocatedInSubcellularLocation",
2145 "isPartOfBioChemEntity",
2146 "taxonomicRange",
2147 "additionalType",
2148 "alternateName",
2149 "description",
2150 "disambiguatingDescription",
2151 "identifier",
2152 "image",
2153 "mainEntityOfPage",
2154 "name",
2155 "potentialAction",
2156 "sameAs",
2157 "subjectOf",
2158 "url",
2159 ];
2160 deserializer.deserialize_struct("MolecularEntity", FIELDS, ClassVisitor)
2161 }
2162 }
2163}