#[allow(missing_docs)] #[non_exhaustive]
#[derive(
::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::Ord, ::std::cmp::PartialEq, ::std::cmp::PartialOrd, ::std::fmt::Debug, ::std::hash::Hash,
)]
pub enum BlockType {
#[allow(missing_docs)] Cell,
#[allow(missing_docs)] KeyValueSet,
#[allow(missing_docs)] LayoutFigure,
#[allow(missing_docs)] LayoutFooter,
#[allow(missing_docs)] LayoutHeader,
#[allow(missing_docs)] LayoutKeyValue,
#[allow(missing_docs)] LayoutList,
#[allow(missing_docs)] LayoutPageNumber,
#[allow(missing_docs)] LayoutSectionHeader,
#[allow(missing_docs)] LayoutTable,
#[allow(missing_docs)] LayoutText,
#[allow(missing_docs)] LayoutTitle,
#[allow(missing_docs)] Line,
#[allow(missing_docs)] MergedCell,
#[allow(missing_docs)] Page,
#[allow(missing_docs)] Query,
#[allow(missing_docs)] QueryResult,
#[allow(missing_docs)] SelectionElement,
#[allow(missing_docs)] Signature,
#[allow(missing_docs)] Table,
#[allow(missing_docs)] TableFooter,
#[allow(missing_docs)] TableTitle,
#[allow(missing_docs)] Title,
#[allow(missing_docs)] Word,
#[deprecated(note = "Don't directly match on `Unknown`. See the docs on this enum for the correct way to handle unknown variants.")]
Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue),
}
impl ::std::convert::From<&str> for BlockType {
fn from(s: &str) -> Self {
match s {
"CELL" => BlockType::Cell,
"KEY_VALUE_SET" => BlockType::KeyValueSet,
"LAYOUT_FIGURE" => BlockType::LayoutFigure,
"LAYOUT_FOOTER" => BlockType::LayoutFooter,
"LAYOUT_HEADER" => BlockType::LayoutHeader,
"LAYOUT_KEY_VALUE" => BlockType::LayoutKeyValue,
"LAYOUT_LIST" => BlockType::LayoutList,
"LAYOUT_PAGE_NUMBER" => BlockType::LayoutPageNumber,
"LAYOUT_SECTION_HEADER" => BlockType::LayoutSectionHeader,
"LAYOUT_TABLE" => BlockType::LayoutTable,
"LAYOUT_TEXT" => BlockType::LayoutText,
"LAYOUT_TITLE" => BlockType::LayoutTitle,
"LINE" => BlockType::Line,
"MERGED_CELL" => BlockType::MergedCell,
"PAGE" => BlockType::Page,
"QUERY" => BlockType::Query,
"QUERY_RESULT" => BlockType::QueryResult,
"SELECTION_ELEMENT" => BlockType::SelectionElement,
"SIGNATURE" => BlockType::Signature,
"TABLE" => BlockType::Table,
"TABLE_FOOTER" => BlockType::TableFooter,
"TABLE_TITLE" => BlockType::TableTitle,
"TITLE" => BlockType::Title,
"WORD" => BlockType::Word,
other => BlockType::Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue(other.to_owned())),
}
}
}
impl ::std::str::FromStr for BlockType {
type Err = ::std::convert::Infallible;
fn from_str(s: &str) -> ::std::result::Result<Self, <Self as ::std::str::FromStr>::Err> {
::std::result::Result::Ok(BlockType::from(s))
}
}
impl BlockType {
pub fn as_str(&self) -> &str {
match self {
BlockType::Cell => "CELL",
BlockType::KeyValueSet => "KEY_VALUE_SET",
BlockType::LayoutFigure => "LAYOUT_FIGURE",
BlockType::LayoutFooter => "LAYOUT_FOOTER",
BlockType::LayoutHeader => "LAYOUT_HEADER",
BlockType::LayoutKeyValue => "LAYOUT_KEY_VALUE",
BlockType::LayoutList => "LAYOUT_LIST",
BlockType::LayoutPageNumber => "LAYOUT_PAGE_NUMBER",
BlockType::LayoutSectionHeader => "LAYOUT_SECTION_HEADER",
BlockType::LayoutTable => "LAYOUT_TABLE",
BlockType::LayoutText => "LAYOUT_TEXT",
BlockType::LayoutTitle => "LAYOUT_TITLE",
BlockType::Line => "LINE",
BlockType::MergedCell => "MERGED_CELL",
BlockType::Page => "PAGE",
BlockType::Query => "QUERY",
BlockType::QueryResult => "QUERY_RESULT",
BlockType::SelectionElement => "SELECTION_ELEMENT",
BlockType::Signature => "SIGNATURE",
BlockType::Table => "TABLE",
BlockType::TableFooter => "TABLE_FOOTER",
BlockType::TableTitle => "TABLE_TITLE",
BlockType::Title => "TITLE",
BlockType::Word => "WORD",
BlockType::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&[
"CELL",
"KEY_VALUE_SET",
"LAYOUT_FIGURE",
"LAYOUT_FOOTER",
"LAYOUT_HEADER",
"LAYOUT_KEY_VALUE",
"LAYOUT_LIST",
"LAYOUT_PAGE_NUMBER",
"LAYOUT_SECTION_HEADER",
"LAYOUT_TABLE",
"LAYOUT_TEXT",
"LAYOUT_TITLE",
"LINE",
"MERGED_CELL",
"PAGE",
"QUERY",
"QUERY_RESULT",
"SELECTION_ELEMENT",
"SIGNATURE",
"TABLE",
"TABLE_FOOTER",
"TABLE_TITLE",
"TITLE",
"WORD",
]
}
}
impl ::std::convert::AsRef<str> for BlockType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl BlockType {
pub fn try_parse(value: &str) -> ::std::result::Result<Self, crate::error::UnknownVariantError> {
match Self::from(value) {
#[allow(deprecated)]
Self::Unknown(_) => ::std::result::Result::Err(crate::error::UnknownVariantError::new(value)),
known => Ok(known),
}
}
}
impl ::std::fmt::Display for BlockType {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
match self {
BlockType::Cell => write!(f, "CELL"),
BlockType::KeyValueSet => write!(f, "KEY_VALUE_SET"),
BlockType::LayoutFigure => write!(f, "LAYOUT_FIGURE"),
BlockType::LayoutFooter => write!(f, "LAYOUT_FOOTER"),
BlockType::LayoutHeader => write!(f, "LAYOUT_HEADER"),
BlockType::LayoutKeyValue => write!(f, "LAYOUT_KEY_VALUE"),
BlockType::LayoutList => write!(f, "LAYOUT_LIST"),
BlockType::LayoutPageNumber => write!(f, "LAYOUT_PAGE_NUMBER"),
BlockType::LayoutSectionHeader => write!(f, "LAYOUT_SECTION_HEADER"),
BlockType::LayoutTable => write!(f, "LAYOUT_TABLE"),
BlockType::LayoutText => write!(f, "LAYOUT_TEXT"),
BlockType::LayoutTitle => write!(f, "LAYOUT_TITLE"),
BlockType::Line => write!(f, "LINE"),
BlockType::MergedCell => write!(f, "MERGED_CELL"),
BlockType::Page => write!(f, "PAGE"),
BlockType::Query => write!(f, "QUERY"),
BlockType::QueryResult => write!(f, "QUERY_RESULT"),
BlockType::SelectionElement => write!(f, "SELECTION_ELEMENT"),
BlockType::Signature => write!(f, "SIGNATURE"),
BlockType::Table => write!(f, "TABLE"),
BlockType::TableFooter => write!(f, "TABLE_FOOTER"),
BlockType::TableTitle => write!(f, "TABLE_TITLE"),
BlockType::Title => write!(f, "TITLE"),
BlockType::Word => write!(f, "WORD"),
BlockType::Unknown(value) => write!(f, "{}", value),
}
}
}