nominal-api 0.1239.0

#![allow(deprecated)]
use std::fmt;
use std::str;
/// Supported substances for REFPROP calculations
#[derive(
    Debug,
    Clone,
    PartialEq,
    Eq,
    PartialOrd,
    Ord,
    Hash,
    conjure_object::serde::Deserialize,
    conjure_object::serde::Serialize,
)]
#[serde(crate = "conjure_object::serde")]
pub enum RefpropSubstance {
    #[serde(rename = "NITROGEN")]
    Nitrogen,
    #[serde(rename = "OXYGEN")]
    Oxygen,
    #[serde(rename = "HELIUM")]
    Helium,
    #[serde(rename = "HYDROGEN")]
    Hydrogen,
    #[serde(rename = "METHANE")]
    Methane,
    #[serde(rename = "PROPANE")]
    Propane,
    #[serde(rename = "BUTANE")]
    Butane,
    #[serde(rename = "WATER")]
    Water,
    #[serde(rename = "XENON")]
    Xenon,
    #[serde(rename = "AIR")]
    Air,
    #[serde(rename = "CARBON_DIOXIDE")]
    CarbonDioxide,
    #[serde(rename = "ARGON")]
    Argon,
    #[serde(rename = "CARBON_MONOXIDE")]
    CarbonMonoxide,
    /// An unknown variant.
    #[serde(untagged)]
    Unknown(Unknown),
}
impl RefpropSubstance {
    /// Returns the string representation of the enum.
    #[inline]
    pub fn as_str(&self) -> &str {
        match self {
            RefpropSubstance::Nitrogen => "NITROGEN",
            RefpropSubstance::Oxygen => "OXYGEN",
            RefpropSubstance::Helium => "HELIUM",
            RefpropSubstance::Hydrogen => "HYDROGEN",
            RefpropSubstance::Methane => "METHANE",
            RefpropSubstance::Propane => "PROPANE",
            RefpropSubstance::Butane => "BUTANE",
            RefpropSubstance::Water => "WATER",
            RefpropSubstance::Xenon => "XENON",
            RefpropSubstance::Air => "AIR",
            RefpropSubstance::CarbonDioxide => "CARBON_DIOXIDE",
            RefpropSubstance::Argon => "ARGON",
            RefpropSubstance::CarbonMonoxide => "CARBON_MONOXIDE",
            RefpropSubstance::Unknown(v) => &*v,
        }
    }
}
impl fmt::Display for RefpropSubstance {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt::Display::fmt(self.as_str(), fmt)
    }
}
impl conjure_object::Plain for RefpropSubstance {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        conjure_object::Plain::fmt(self.as_str(), fmt)
    }
}
impl str::FromStr for RefpropSubstance {
    type Err = conjure_object::plain::ParseEnumError;
    #[inline]
    fn from_str(
        v: &str,
    ) -> Result<RefpropSubstance, conjure_object::plain::ParseEnumError> {
        match v {
            "NITROGEN" => Ok(RefpropSubstance::Nitrogen),
            "OXYGEN" => Ok(RefpropSubstance::Oxygen),
            "HELIUM" => Ok(RefpropSubstance::Helium),
            "HYDROGEN" => Ok(RefpropSubstance::Hydrogen),
            "METHANE" => Ok(RefpropSubstance::Methane),
            "PROPANE" => Ok(RefpropSubstance::Propane),
            "BUTANE" => Ok(RefpropSubstance::Butane),
            "WATER" => Ok(RefpropSubstance::Water),
            "XENON" => Ok(RefpropSubstance::Xenon),
            "AIR" => Ok(RefpropSubstance::Air),
            "CARBON_DIOXIDE" => Ok(RefpropSubstance::CarbonDioxide),
            "ARGON" => Ok(RefpropSubstance::Argon),
            "CARBON_MONOXIDE" => Ok(RefpropSubstance::CarbonMonoxide),
            v => v.parse().map(|v| RefpropSubstance::Unknown(Unknown(v))),
        }
    }
}
impl conjure_object::FromPlain for RefpropSubstance {
    type Err = conjure_object::plain::ParseEnumError;
    #[inline]
    fn from_plain(
        v: &str,
    ) -> Result<RefpropSubstance, conjure_object::plain::ParseEnumError> {
        v.parse()
    }
}
///An unknown variant of the RefpropSubstance enum.
#[derive(
    Debug,
    Clone,
    PartialEq,
    Eq,
    PartialOrd,
    Ord,
    Hash,
    conjure_object::serde::Deserialize,
    conjure_object::serde::Serialize,
)]
#[serde(crate = "conjure_object::serde", transparent)]
pub struct Unknown(conjure_object::private::Variant);
impl std::ops::Deref for Unknown {
    type Target = str;
    #[inline]
    fn deref(&self) -> &str {
        &self.0
    }
}
impl fmt::Display for Unknown {
    #[inline]
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Display::fmt(&self.0, fmt)
    }
}