use super::*;
#[cfg_attr(feature = "derive-debug", derive(Debug))]
#[cfg_attr(feature = "derive-clone", derive(Clone))]
pub struct Protein {
pub r#additional_type: Vec<AdditionalTypeProperty>,
pub r#alternate_name: Vec<AlternateNameProperty>,
pub r#associated_disease: Vec<AssociatedDiseaseProperty>,
pub r#bio_chem_interaction: Vec<BioChemInteractionProperty>,
pub r#bio_chem_similarity: Vec<BioChemSimilarityProperty>,
pub r#biological_role: Vec<BiologicalRoleProperty>,
pub r#description: Vec<DescriptionProperty>,
pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
pub r#funding: Vec<FundingProperty>,
pub r#has_bio_chem_entity_part: Vec<HasBioChemEntityPartProperty>,
pub r#has_bio_polymer_sequence: Vec<HasBioPolymerSequenceProperty>,
pub r#has_molecular_function: Vec<HasMolecularFunctionProperty>,
pub r#has_representation: Vec<HasRepresentationProperty>,
pub r#identifier: Vec<IdentifierProperty>,
pub r#image: Vec<ImageProperty>,
pub r#is_encoded_by_bio_chem_entity: Vec<IsEncodedByBioChemEntityProperty>,
pub r#is_involved_in_biological_process: Vec<IsInvolvedInBiologicalProcessProperty>,
pub r#is_located_in_subcellular_location: Vec<IsLocatedInSubcellularLocationProperty>,
pub r#is_part_of_bio_chem_entity: Vec<IsPartOfBioChemEntityProperty>,
pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
pub r#name: Vec<NameProperty>,
pub r#potential_action: Vec<PotentialActionProperty>,
pub r#same_as: Vec<SameAsProperty>,
pub r#subject_of: Vec<SubjectOfProperty>,
pub r#taxonomic_range: Vec<TaxonomicRangeProperty>,
pub r#url: Vec<UrlProperty>,
}
#[cfg(feature = "serde")]
mod serde {
use std::{fmt, fmt::Formatter};
use ::serde::{
de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
};
use super::*;
impl Serialize for Protein {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let len: usize = [
!Vec::is_empty(&self.r#additional_type) as usize,
!Vec::is_empty(&self.r#alternate_name) as usize,
!Vec::is_empty(&self.r#associated_disease) as usize,
!Vec::is_empty(&self.r#bio_chem_interaction) as usize,
!Vec::is_empty(&self.r#bio_chem_similarity) as usize,
!Vec::is_empty(&self.r#biological_role) as usize,
!Vec::is_empty(&self.r#description) as usize,
!Vec::is_empty(&self.r#disambiguating_description) as usize,
!Vec::is_empty(&self.r#funding) as usize,
!Vec::is_empty(&self.r#has_bio_chem_entity_part) as usize,
!Vec::is_empty(&self.r#has_bio_polymer_sequence) as usize,
!Vec::is_empty(&self.r#has_molecular_function) as usize,
!Vec::is_empty(&self.r#has_representation) as usize,
!Vec::is_empty(&self.r#identifier) as usize,
!Vec::is_empty(&self.r#image) as usize,
!Vec::is_empty(&self.r#is_encoded_by_bio_chem_entity) as usize,
!Vec::is_empty(&self.r#is_involved_in_biological_process) as usize,
!Vec::is_empty(&self.r#is_located_in_subcellular_location) as usize,
!Vec::is_empty(&self.r#is_part_of_bio_chem_entity) as usize,
!Vec::is_empty(&self.r#main_entity_of_page) as usize,
!Vec::is_empty(&self.r#name) as usize,
!Vec::is_empty(&self.r#potential_action) as usize,
!Vec::is_empty(&self.r#same_as) as usize,
!Vec::is_empty(&self.r#subject_of) as usize,
!Vec::is_empty(&self.r#taxonomic_range) as usize,
!Vec::is_empty(&self.r#url) as usize,
]
.iter()
.sum();
let mut serialize_struct = Serializer::serialize_struct(serializer, "Protein", len)?;
if !Vec::is_empty(&self.r#additional_type) {
serialize_struct.serialize_field("additionalType", {
struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#additional_type)
})?;
} else {
serialize_struct.skip_field("additionalType")?;
}
if !Vec::is_empty(&self.r#alternate_name) {
serialize_struct.serialize_field("alternateName", {
struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#alternate_name)
})?;
} else {
serialize_struct.skip_field("alternateName")?;
}
if !Vec::is_empty(&self.r#associated_disease) {
serialize_struct.serialize_field("associatedDisease", {
struct SerializeWith<'a>(&'a Vec<AssociatedDiseaseProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#associated_disease)
})?;
} else {
serialize_struct.skip_field("associatedDisease")?;
}
if !Vec::is_empty(&self.r#bio_chem_interaction) {
serialize_struct.serialize_field("bioChemInteraction", {
struct SerializeWith<'a>(&'a Vec<BioChemInteractionProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#bio_chem_interaction)
})?;
} else {
serialize_struct.skip_field("bioChemInteraction")?;
}
if !Vec::is_empty(&self.r#bio_chem_similarity) {
serialize_struct.serialize_field("bioChemSimilarity", {
struct SerializeWith<'a>(&'a Vec<BioChemSimilarityProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#bio_chem_similarity)
})?;
} else {
serialize_struct.skip_field("bioChemSimilarity")?;
}
if !Vec::is_empty(&self.r#biological_role) {
serialize_struct.serialize_field("biologicalRole", {
struct SerializeWith<'a>(&'a Vec<BiologicalRoleProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#biological_role)
})?;
} else {
serialize_struct.skip_field("biologicalRole")?;
}
if !Vec::is_empty(&self.r#description) {
serialize_struct.serialize_field("description", {
struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#description)
})?;
} else {
serialize_struct.skip_field("description")?;
}
if !Vec::is_empty(&self.r#disambiguating_description) {
serialize_struct.serialize_field("disambiguatingDescription", {
struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#disambiguating_description)
})?;
} else {
serialize_struct.skip_field("disambiguatingDescription")?;
}
if !Vec::is_empty(&self.r#funding) {
serialize_struct.serialize_field("funding", {
struct SerializeWith<'a>(&'a Vec<FundingProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#funding)
})?;
} else {
serialize_struct.skip_field("funding")?;
}
if !Vec::is_empty(&self.r#has_bio_chem_entity_part) {
serialize_struct.serialize_field("hasBioChemEntityPart", {
struct SerializeWith<'a>(&'a Vec<HasBioChemEntityPartProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#has_bio_chem_entity_part)
})?;
} else {
serialize_struct.skip_field("hasBioChemEntityPart")?;
}
if !Vec::is_empty(&self.r#has_bio_polymer_sequence) {
serialize_struct.serialize_field("hasBioPolymerSequence", {
struct SerializeWith<'a>(&'a Vec<HasBioPolymerSequenceProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#has_bio_polymer_sequence)
})?;
} else {
serialize_struct.skip_field("hasBioPolymerSequence")?;
}
if !Vec::is_empty(&self.r#has_molecular_function) {
serialize_struct.serialize_field("hasMolecularFunction", {
struct SerializeWith<'a>(&'a Vec<HasMolecularFunctionProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#has_molecular_function)
})?;
} else {
serialize_struct.skip_field("hasMolecularFunction")?;
}
if !Vec::is_empty(&self.r#has_representation) {
serialize_struct.serialize_field("hasRepresentation", {
struct SerializeWith<'a>(&'a Vec<HasRepresentationProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#has_representation)
})?;
} else {
serialize_struct.skip_field("hasRepresentation")?;
}
if !Vec::is_empty(&self.r#identifier) {
serialize_struct.serialize_field("identifier", {
struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#identifier)
})?;
} else {
serialize_struct.skip_field("identifier")?;
}
if !Vec::is_empty(&self.r#image) {
serialize_struct.serialize_field("image", {
struct SerializeWith<'a>(&'a Vec<ImageProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#image)
})?;
} else {
serialize_struct.skip_field("image")?;
}
if !Vec::is_empty(&self.r#is_encoded_by_bio_chem_entity) {
serialize_struct.serialize_field("isEncodedByBioChemEntity", {
struct SerializeWith<'a>(&'a Vec<IsEncodedByBioChemEntityProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#is_encoded_by_bio_chem_entity)
})?;
} else {
serialize_struct.skip_field("isEncodedByBioChemEntity")?;
}
if !Vec::is_empty(&self.r#is_involved_in_biological_process) {
serialize_struct.serialize_field("isInvolvedInBiologicalProcess", {
struct SerializeWith<'a>(&'a Vec<IsInvolvedInBiologicalProcessProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#is_involved_in_biological_process)
})?;
} else {
serialize_struct.skip_field("isInvolvedInBiologicalProcess")?;
}
if !Vec::is_empty(&self.r#is_located_in_subcellular_location) {
serialize_struct.serialize_field("isLocatedInSubcellularLocation", {
struct SerializeWith<'a>(&'a Vec<IsLocatedInSubcellularLocationProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#is_located_in_subcellular_location)
})?;
} else {
serialize_struct.skip_field("isLocatedInSubcellularLocation")?;
}
if !Vec::is_empty(&self.r#is_part_of_bio_chem_entity) {
serialize_struct.serialize_field("isPartOfBioChemEntity", {
struct SerializeWith<'a>(&'a Vec<IsPartOfBioChemEntityProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#is_part_of_bio_chem_entity)
})?;
} else {
serialize_struct.skip_field("isPartOfBioChemEntity")?;
}
if !Vec::is_empty(&self.r#main_entity_of_page) {
serialize_struct.serialize_field("mainEntityOfPage", {
struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#main_entity_of_page)
})?;
} else {
serialize_struct.skip_field("mainEntityOfPage")?;
}
if !Vec::is_empty(&self.r#name) {
serialize_struct.serialize_field("name", {
struct SerializeWith<'a>(&'a Vec<NameProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#name)
})?;
} else {
serialize_struct.skip_field("name")?;
}
if !Vec::is_empty(&self.r#potential_action) {
serialize_struct.serialize_field("potentialAction", {
struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#potential_action)
})?;
} else {
serialize_struct.skip_field("potentialAction")?;
}
if !Vec::is_empty(&self.r#same_as) {
serialize_struct.serialize_field("sameAs", {
struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#same_as)
})?;
} else {
serialize_struct.skip_field("sameAs")?;
}
if !Vec::is_empty(&self.r#subject_of) {
serialize_struct.serialize_field("subjectOf", {
struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#subject_of)
})?;
} else {
serialize_struct.skip_field("subjectOf")?;
}
if !Vec::is_empty(&self.r#taxonomic_range) {
serialize_struct.serialize_field("taxonomicRange", {
struct SerializeWith<'a>(&'a Vec<TaxonomicRangeProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#taxonomic_range)
})?;
} else {
serialize_struct.skip_field("taxonomicRange")?;
}
if !Vec::is_empty(&self.r#url) {
serialize_struct.serialize_field("url", {
struct SerializeWith<'a>(&'a Vec<UrlProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#url)
})?;
} else {
serialize_struct.skip_field("url")?;
}
serialize_struct.end()
}
}
impl<'de> Deserialize<'de> for Protein {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
enum Field {
AdditionalType,
AlternateName,
AssociatedDisease,
BioChemInteraction,
BioChemSimilarity,
BiologicalRole,
Description,
DisambiguatingDescription,
Funding,
HasBioChemEntityPart,
HasBioPolymerSequence,
HasMolecularFunction,
HasRepresentation,
Identifier,
Image,
IsEncodedByBioChemEntity,
IsInvolvedInBiologicalProcess,
IsLocatedInSubcellularLocation,
IsPartOfBioChemEntity,
MainEntityOfPage,
Name,
PotentialAction,
SameAs,
SubjectOf,
TaxonomicRange,
Url,
Ignore,
}
struct FieldVisitor;
impl<'de> Visitor<'de> for FieldVisitor {
type Value = Field;
fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
formatter.write_str("field identifier")
}
fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
where
E: de::Error,
{
match value {
"additionalType" => Ok(Field::AdditionalType),
"alternateName" => Ok(Field::AlternateName),
"associatedDisease" => Ok(Field::AssociatedDisease),
"bioChemInteraction" => Ok(Field::BioChemInteraction),
"bioChemSimilarity" => Ok(Field::BioChemSimilarity),
"biologicalRole" => Ok(Field::BiologicalRole),
"description" => Ok(Field::Description),
"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
"funding" => Ok(Field::Funding),
"hasBioChemEntityPart" => Ok(Field::HasBioChemEntityPart),
"hasBioPolymerSequence" => Ok(Field::HasBioPolymerSequence),
"hasMolecularFunction" => Ok(Field::HasMolecularFunction),
"hasRepresentation" => Ok(Field::HasRepresentation),
"identifier" => Ok(Field::Identifier),
"image" => Ok(Field::Image),
"isEncodedByBioChemEntity" => Ok(Field::IsEncodedByBioChemEntity),
"isInvolvedInBiologicalProcess" => Ok(Field::IsInvolvedInBiologicalProcess),
"isLocatedInSubcellularLocation" => {
Ok(Field::IsLocatedInSubcellularLocation)
}
"isPartOfBioChemEntity" => Ok(Field::IsPartOfBioChemEntity),
"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
"name" => Ok(Field::Name),
"potentialAction" => Ok(Field::PotentialAction),
"sameAs" => Ok(Field::SameAs),
"subjectOf" => Ok(Field::SubjectOf),
"taxonomicRange" => Ok(Field::TaxonomicRange),
"url" => Ok(Field::Url),
_ => Ok(Field::Ignore),
}
}
fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
where
E: de::Error,
{
match value {
b"additionalType" => Ok(Field::AdditionalType),
b"alternateName" => Ok(Field::AlternateName),
b"associatedDisease" => Ok(Field::AssociatedDisease),
b"bioChemInteraction" => Ok(Field::BioChemInteraction),
b"bioChemSimilarity" => Ok(Field::BioChemSimilarity),
b"biologicalRole" => Ok(Field::BiologicalRole),
b"description" => Ok(Field::Description),
b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
b"funding" => Ok(Field::Funding),
b"hasBioChemEntityPart" => Ok(Field::HasBioChemEntityPart),
b"hasBioPolymerSequence" => Ok(Field::HasBioPolymerSequence),
b"hasMolecularFunction" => Ok(Field::HasMolecularFunction),
b"hasRepresentation" => Ok(Field::HasRepresentation),
b"identifier" => Ok(Field::Identifier),
b"image" => Ok(Field::Image),
b"isEncodedByBioChemEntity" => Ok(Field::IsEncodedByBioChemEntity),
b"isInvolvedInBiologicalProcess" => {
Ok(Field::IsInvolvedInBiologicalProcess)
}
b"isLocatedInSubcellularLocation" => {
Ok(Field::IsLocatedInSubcellularLocation)
}
b"isPartOfBioChemEntity" => Ok(Field::IsPartOfBioChemEntity),
b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
b"name" => Ok(Field::Name),
b"potentialAction" => Ok(Field::PotentialAction),
b"sameAs" => Ok(Field::SameAs),
b"subjectOf" => Ok(Field::SubjectOf),
b"taxonomicRange" => Ok(Field::TaxonomicRange),
b"url" => Ok(Field::Url),
_ => Ok(Field::Ignore),
}
}
}
impl<'de> Deserialize<'de> for Field {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_identifier(FieldVisitor)
}
}
struct ClassVisitor;
impl<'de> Visitor<'de> for ClassVisitor {
type Value = Protein;
fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
formatter.write_str("schema.org schema Protein")
}
fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
where
A: de::MapAccess<'de>,
{
let mut r#additional_type_property = None;
let mut r#alternate_name_property = None;
let mut r#associated_disease_property = None;
let mut r#bio_chem_interaction_property = None;
let mut r#bio_chem_similarity_property = None;
let mut r#biological_role_property = None;
let mut r#description_property = None;
let mut r#disambiguating_description_property = None;
let mut r#funding_property = None;
let mut r#has_bio_chem_entity_part_property = None;
let mut r#has_bio_polymer_sequence_property = None;
let mut r#has_molecular_function_property = None;
let mut r#has_representation_property = None;
let mut r#identifier_property = None;
let mut r#image_property = None;
let mut r#is_encoded_by_bio_chem_entity_property = None;
let mut r#is_involved_in_biological_process_property = None;
let mut r#is_located_in_subcellular_location_property = None;
let mut r#is_part_of_bio_chem_entity_property = None;
let mut r#main_entity_of_page_property = None;
let mut r#name_property = None;
let mut r#potential_action_property = None;
let mut r#same_as_property = None;
let mut r#subject_of_property = None;
let mut r#taxonomic_range_property = None;
let mut r#url_property = None;
while let Some(key) = map.next_key::<Field>()? {
match key {
Field::AdditionalType => {
if r#additional_type_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"additionalType",
));
}
r#additional_type_property = Some({
struct DeserializeWith(Vec<AdditionalTypeProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::AlternateName => {
if r#alternate_name_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"alternateName",
));
}
r#alternate_name_property = Some({
struct DeserializeWith(Vec<AlternateNameProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::AssociatedDisease => {
if r#associated_disease_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"associatedDisease",
));
}
r#associated_disease_property = Some({
struct DeserializeWith(Vec<AssociatedDiseaseProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::BioChemInteraction => {
if r#bio_chem_interaction_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"bioChemInteraction",
));
}
r#bio_chem_interaction_property = Some({
struct DeserializeWith(Vec<BioChemInteractionProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::BioChemSimilarity => {
if r#bio_chem_similarity_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"bioChemSimilarity",
));
}
r#bio_chem_similarity_property = Some({
struct DeserializeWith(Vec<BioChemSimilarityProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::BiologicalRole => {
if r#biological_role_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"biologicalRole",
));
}
r#biological_role_property = Some({
struct DeserializeWith(Vec<BiologicalRoleProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::Description => {
if r#description_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"description",
));
}
r#description_property = Some({
struct DeserializeWith(Vec<DescriptionProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::DisambiguatingDescription => {
if r#disambiguating_description_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"disambiguatingDescription",
));
}
r#disambiguating_description_property = Some({
struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::Funding => {
if r#funding_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"funding",
));
}
r#funding_property = Some({
struct DeserializeWith(Vec<FundingProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::HasBioChemEntityPart => {
if r#has_bio_chem_entity_part_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"hasBioChemEntityPart",
));
}
r#has_bio_chem_entity_part_property = Some({
struct DeserializeWith(Vec<HasBioChemEntityPartProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::HasBioPolymerSequence => {
if r#has_bio_polymer_sequence_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"hasBioPolymerSequence",
));
}
r#has_bio_polymer_sequence_property = Some({
struct DeserializeWith(Vec<HasBioPolymerSequenceProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::HasMolecularFunction => {
if r#has_molecular_function_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"hasMolecularFunction",
));
}
r#has_molecular_function_property = Some({
struct DeserializeWith(Vec<HasMolecularFunctionProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::HasRepresentation => {
if r#has_representation_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"hasRepresentation",
));
}
r#has_representation_property = Some({
struct DeserializeWith(Vec<HasRepresentationProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::Identifier => {
if r#identifier_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"identifier",
));
}
r#identifier_property = Some({
struct DeserializeWith(Vec<IdentifierProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::Image => {
if r#image_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field("image"));
}
r#image_property = Some({
struct DeserializeWith(Vec<ImageProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::IsEncodedByBioChemEntity => {
if r#is_encoded_by_bio_chem_entity_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"isEncodedByBioChemEntity",
));
}
r#is_encoded_by_bio_chem_entity_property = Some({
struct DeserializeWith(Vec<IsEncodedByBioChemEntityProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::IsInvolvedInBiologicalProcess => {
if r#is_involved_in_biological_process_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"isInvolvedInBiologicalProcess",
));
}
r#is_involved_in_biological_process_property = Some({
struct DeserializeWith(
Vec<IsInvolvedInBiologicalProcessProperty>,
);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::IsLocatedInSubcellularLocation => {
if r#is_located_in_subcellular_location_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"isLocatedInSubcellularLocation",
));
}
r#is_located_in_subcellular_location_property = Some({
struct DeserializeWith(
Vec<IsLocatedInSubcellularLocationProperty>,
);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::IsPartOfBioChemEntity => {
if r#is_part_of_bio_chem_entity_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"isPartOfBioChemEntity",
));
}
r#is_part_of_bio_chem_entity_property = Some({
struct DeserializeWith(Vec<IsPartOfBioChemEntityProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::MainEntityOfPage => {
if r#main_entity_of_page_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"mainEntityOfPage",
));
}
r#main_entity_of_page_property = Some({
struct DeserializeWith(Vec<MainEntityOfPageProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::Name => {
if r#name_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field("name"));
}
r#name_property = Some({
struct DeserializeWith(Vec<NameProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::PotentialAction => {
if r#potential_action_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"potentialAction",
));
}
r#potential_action_property = Some({
struct DeserializeWith(Vec<PotentialActionProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::SameAs => {
if r#same_as_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
}
r#same_as_property = Some({
struct DeserializeWith(Vec<SameAsProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::SubjectOf => {
if r#subject_of_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"subjectOf",
));
}
r#subject_of_property = Some({
struct DeserializeWith(Vec<SubjectOfProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::TaxonomicRange => {
if r#taxonomic_range_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"taxonomicRange",
));
}
r#taxonomic_range_property = Some({
struct DeserializeWith(Vec<TaxonomicRangeProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::Url => {
if r#url_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field("url"));
}
r#url_property = Some({
struct DeserializeWith(Vec<UrlProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
_ => {
let _ = map.next_value::<de::IgnoredAny>()?;
}
}
}
Ok(Protein {
r#additional_type: r#additional_type_property.unwrap_or_default(),
r#alternate_name: r#alternate_name_property.unwrap_or_default(),
r#associated_disease: r#associated_disease_property.unwrap_or_default(),
r#bio_chem_interaction: r#bio_chem_interaction_property.unwrap_or_default(),
r#bio_chem_similarity: r#bio_chem_similarity_property.unwrap_or_default(),
r#biological_role: r#biological_role_property.unwrap_or_default(),
r#description: r#description_property.unwrap_or_default(),
r#disambiguating_description: r#disambiguating_description_property
.unwrap_or_default(),
r#funding: r#funding_property.unwrap_or_default(),
r#has_bio_chem_entity_part: r#has_bio_chem_entity_part_property
.unwrap_or_default(),
r#has_bio_polymer_sequence: r#has_bio_polymer_sequence_property
.unwrap_or_default(),
r#has_molecular_function: r#has_molecular_function_property
.unwrap_or_default(),
r#has_representation: r#has_representation_property.unwrap_or_default(),
r#identifier: r#identifier_property.unwrap_or_default(),
r#image: r#image_property.unwrap_or_default(),
r#is_encoded_by_bio_chem_entity: r#is_encoded_by_bio_chem_entity_property
.unwrap_or_default(),
r#is_involved_in_biological_process:
r#is_involved_in_biological_process_property.unwrap_or_default(),
r#is_located_in_subcellular_location:
r#is_located_in_subcellular_location_property.unwrap_or_default(),
r#is_part_of_bio_chem_entity: r#is_part_of_bio_chem_entity_property
.unwrap_or_default(),
r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
r#name: r#name_property.unwrap_or_default(),
r#potential_action: r#potential_action_property.unwrap_or_default(),
r#same_as: r#same_as_property.unwrap_or_default(),
r#subject_of: r#subject_of_property.unwrap_or_default(),
r#taxonomic_range: r#taxonomic_range_property.unwrap_or_default(),
r#url: r#url_property.unwrap_or_default(),
})
}
}
const FIELDS: &[&str] = &[
"additionalType",
"alternateName",
"associatedDisease",
"bioChemInteraction",
"bioChemSimilarity",
"biologicalRole",
"description",
"disambiguatingDescription",
"funding",
"hasBioChemEntityPart",
"hasBioPolymerSequence",
"hasMolecularFunction",
"hasRepresentation",
"identifier",
"image",
"isEncodedByBioChemEntity",
"isInvolvedInBiologicalProcess",
"isLocatedInSubcellularLocation",
"isPartOfBioChemEntity",
"mainEntityOfPage",
"name",
"potentialAction",
"sameAs",
"subjectOf",
"taxonomicRange",
"url",
];
deserializer.deserialize_struct("Protein", FIELDS, ClassVisitor)
}
}
}