use serde::Deserialize;
use serde::Serialize;
use {
diesel::backend::Backend,
diesel::deserialize::FromSql,
diesel::pg::Pg,
diesel::serialize::{IsNull, Output, ToSql},
diesel::sql_types::Varchar,
diesel::{deserialize, not_none, serialize},
std::io::Write,
diesel::{AsExpression, FromSqlRow},
};
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Eq, Ord, PartialOrd, AsExpression, FromSqlRow)]
#[sql_type = "Varchar"]
pub enum MarkType {
A,
A_,
AB,
B,
B_,
C,
C_,
F,
P,
D,
E,
HD,
S,
F1,
F2,
NGP,
P1,
P2,
N,
CR,
PC,
Cr,
#[allow(non_camel_case_types)]
g2,
#[allow(non_camel_case_types)]
g3,
#[allow(non_camel_case_types)]
g4,
#[allow(non_camel_case_types)]
g1,
#[allow(non_camel_case_types)]
g6,
#[allow(non_camel_case_types)]
g7,
#[allow(non_camel_case_types)]
g8,
#[allow(non_camel_case_types)]
g9,
#[allow(non_camel_case_types)]
g10,
#[allow(non_camel_case_types)]
g1_1,
#[allow(non_camel_case_types)]
g1_2,
#[allow(non_camel_case_types)]
g1_3,
#[allow(non_camel_case_types)]
g1_4,
#[allow(non_camel_case_types)]
g1_5,
#[allow(non_camel_case_types)]
g2_1,
#[allow(non_camel_case_types)]
g2_2,
#[allow(non_camel_case_types)]
g2_3,
#[allow(non_camel_case_types)]
g2_4,
#[allow(non_camel_case_types)]
g2_5,
#[allow(non_camel_case_types)]
g3_1,
#[allow(non_camel_case_types)]
g3_2,
#[allow(non_camel_case_types)]
g3_3,
#[allow(non_camel_case_types)]
g3_4,
#[allow(non_camel_case_types)]
g3_5,
#[allow(non_camel_case_types)]
g4_1,
#[allow(non_camel_case_types)]
g4_2,
#[allow(non_camel_case_types)]
g4_3,
#[allow(non_camel_case_types)]
g4_4,
#[allow(non_camel_case_types)]
g4_5,
#[allow(non_camel_case_types)]
g5,
#[allow(non_camel_case_types)]
g5_1,
#[allow(non_camel_case_types)]
g5_2,
#[allow(non_camel_case_types)]
g5_3,
#[allow(non_camel_case_types)]
g5_4,
#[allow(non_camel_case_types)]
g5_5,
#[allow(non_camel_case_types)]
absent,
#[allow(non_camel_case_types)]
noMark,
#[allow(non_camel_case_types)]
acceptableExcuse,
#[allow(non_camel_case_types)]
noAcceptableExcuse,
}
impl ToSql<Varchar, Pg> for MarkType {
fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> serialize::Result {
match *self {
MarkType::A => out.write_all(b"A")?,
MarkType::A_ => out.write_all(b"A_")?,
MarkType::AB => out.write_all(b"AB")?,
MarkType::B => out.write_all(b"B")?,
MarkType::B_ => out.write_all(b"B_")?,
MarkType::C => out.write_all(b"C")?,
MarkType::C_ => out.write_all(b"C_")?,
MarkType::F => out.write_all(b"F")?,
MarkType::P => out.write_all(b"P")?,
MarkType::D => out.write_all(b"D")?,
MarkType::E => out.write_all(b"E")?,
MarkType::HD => out.write_all(b"HD")?,
MarkType::S => out.write_all(b"S")?,
MarkType::F1 => out.write_all(b"F1")?,
MarkType::F2 => out.write_all(b"F2")?,
MarkType::NGP => out.write_all(b"NGP")?,
MarkType::P1 => out.write_all(b"P1")?,
MarkType::P2 => out.write_all(b"P2")?,
MarkType::N => out.write_all(b"N")?,
MarkType::CR => out.write_all(b"CR")?,
MarkType::PC => out.write_all(b"PC")?,
MarkType::Cr => out.write_all(b"Cr")?,
MarkType::g2 => out.write_all(b"g2")?,
MarkType::g3 => out.write_all(b"g3")?,
MarkType::g4 => out.write_all(b"g4")?,
MarkType::g1 => out.write_all(b"g1")?,
MarkType::g6 => out.write_all(b"g6")?,
MarkType::g7 => out.write_all(b"g7")?,
MarkType::g8 => out.write_all(b"g8")?,
MarkType::g9 => out.write_all(b"g9")?,
MarkType::g10 => out.write_all(b"g10")?,
MarkType::g1_1 => out.write_all(b"g1_1")?,
MarkType::g1_2 => out.write_all(b"g1_2")?,
MarkType::g1_3 => out.write_all(b"g1_3")?,
MarkType::g1_4 => out.write_all(b"g1_4")?,
MarkType::g1_5 => out.write_all(b"g1_5")?,
MarkType::g2_1 => out.write_all(b"g2_1")?,
MarkType::g2_2 => out.write_all(b"g2_2")?,
MarkType::g2_3 => out.write_all(b"g2_3")?,
MarkType::g2_4 => out.write_all(b"g2_4")?,
MarkType::g2_5 => out.write_all(b"g2_5")?,
MarkType::g3_1 => out.write_all(b"g3_1")?,
MarkType::g3_2 => out.write_all(b"g3_2")?,
MarkType::g3_3 => out.write_all(b"g3_3")?,
MarkType::g3_4 => out.write_all(b"g3_4")?,
MarkType::g3_5 => out.write_all(b"g3_5")?,
MarkType::g4_1 => out.write_all(b"g4_1")?,
MarkType::g4_2 => out.write_all(b"g4_2")?,
MarkType::g4_3 => out.write_all(b"g4_3")?,
MarkType::g4_4 => out.write_all(b"g4_4")?,
MarkType::g4_5 => out.write_all(b"g4_5")?,
MarkType::g5 => out.write_all(b"g5")?,
MarkType::g5_1 => out.write_all(b"g5_1")?,
MarkType::g5_2 => out.write_all(b"g5_2")?,
MarkType::g5_3 => out.write_all(b"g5_3")?,
MarkType::g5_4 => out.write_all(b"g5_4")?,
MarkType::g5_5 => out.write_all(b"g5_5")?,
MarkType::absent => out.write_all(b"absent")?,
MarkType::noMark => out.write_all(b"noMark")?,
MarkType::acceptableExcuse => out.write_all(b"acceptableExcuse")?,
MarkType::noAcceptableExcuse => out.write_all(b"noAcceptableExcuse")?,
}
Ok(IsNull::No)
}
}
impl FromSql<Varchar, Pg> for MarkType {
fn from_sql(bytes: Option<&<Pg as Backend>::RawValue>) -> deserialize::Result<Self> {
match not_none!(bytes) {
b"A" => Ok(MarkType::A),
b"A_" => Ok(MarkType::A_),
b"AB" => Ok(MarkType::AB),
b"B" => Ok(MarkType::B),
b"B_" => Ok(MarkType::B_),
b"C" => Ok(MarkType::C),
b"C_" => Ok(MarkType::C_),
b"F" => Ok(MarkType::F),
b"P" => Ok(MarkType::P),
b"D" => Ok(MarkType::D),
b"E" => Ok(MarkType::E),
b"HD" => Ok(MarkType::HD),
b"S" => Ok(MarkType::S),
b"F1" => Ok(MarkType::F1),
b"F2" => Ok(MarkType::F2),
b"NGP" => Ok(MarkType::NGP),
b"P1" => Ok(MarkType::P1),
b"P2" => Ok(MarkType::P2),
b"N" => Ok(MarkType::N),
b"CR" => Ok(MarkType::CR),
b"PC" => Ok(MarkType::PC),
b"Cr" => Ok(MarkType::Cr),
b"g2" => Ok(MarkType::g2),
b"g3" => Ok(MarkType::g3),
b"g4" => Ok(MarkType::g4),
b"g1" => Ok(MarkType::g1),
b"g6" => Ok(MarkType::g6),
b"g7" => Ok(MarkType::g7),
b"g8" => Ok(MarkType::g8),
b"g9" => Ok(MarkType::g9),
b"g10" => Ok(MarkType::g10),
b"g1_1" => Ok(MarkType::g1_1),
b"g1_2" => Ok(MarkType::g1_2),
b"g1_3" => Ok(MarkType::g1_3),
b"g1_4" => Ok(MarkType::g1_4),
b"g1_5" => Ok(MarkType::g1_5),
b"g2_1" => Ok(MarkType::g2_1),
b"g2_2" => Ok(MarkType::g2_2),
b"g2_3" => Ok(MarkType::g2_3),
b"g2_4" => Ok(MarkType::g2_4),
b"g2_5" => Ok(MarkType::g2_5),
b"g3_1" => Ok(MarkType::g3_1),
b"g3_2" => Ok(MarkType::g3_2),
b"g3_3" => Ok(MarkType::g3_3),
b"g3_4" => Ok(MarkType::g3_4),
b"g3_5" => Ok(MarkType::g3_5),
b"g4_1" => Ok(MarkType::g4_1),
b"g4_2" => Ok(MarkType::g4_2),
b"g4_3" => Ok(MarkType::g4_3),
b"g4_4" => Ok(MarkType::g4_4),
b"g4_5" => Ok(MarkType::g4_5),
b"g5" => Ok(MarkType::g5),
b"g5_1" => Ok(MarkType::g5_1),
b"g5_2" => Ok(MarkType::g5_2),
b"g5_3" => Ok(MarkType::g5_3),
b"g5_4" => Ok(MarkType::g5_4),
b"g5_5" => Ok(MarkType::g5_5),
b"absent" => Ok(MarkType::absent),
b"noMark" => Ok(MarkType::noMark),
b"acceptableExcuse" => Ok(MarkType::acceptableExcuse),
b"noAcceptableExcuse" => Ok(MarkType::noAcceptableExcuse),
_ => Err("Unrecognized enum variant".into()),
}
}
}
impl MarkType {
pub fn from_str(input: &str) -> MarkType {
match input {
"A" => MarkType::A,
"A_" => MarkType::A_,
"AB" => MarkType::AB,
"B" => MarkType::B,
"B_" => MarkType::B_,
"C" => MarkType::C,
"C_" => MarkType::C_,
"F" => MarkType::F,
"P" => MarkType::P,
"D" => MarkType::D,
"E" => MarkType::E,
"HD" => MarkType::HD,
"S" => MarkType::S,
"F1" => MarkType::F1,
"F2" => MarkType::F2,
"NGP" => MarkType::NGP,
"P1" => MarkType::P1,
"P2" => MarkType::P2,
"N" => MarkType::N,
"CR" => MarkType::CR,
"PC" => MarkType::PC,
"Cr" => MarkType::Cr,
"g2" => MarkType::g2,
"g3" => MarkType::g3,
"g4" => MarkType::g4,
"g1" => MarkType::g1,
"g6" => MarkType::g6,
"g7" => MarkType::g7,
"g8" => MarkType::g8,
"g9" => MarkType::g9,
"g10" => MarkType::g10,
"g1_1" => MarkType::g1_1,
"g1_2" => MarkType::g1_2,
"g1_3" => MarkType::g1_3,
"g1_4" => MarkType::g1_4,
"g1_5" => MarkType::g1_5,
"g2_1" => MarkType::g2_1,
"g2_2" => MarkType::g2_2,
"g2_3" => MarkType::g2_3,
"g2_4" => MarkType::g2_4,
"g2_5" => MarkType::g2_5,
"g3_1" => MarkType::g3_1,
"g3_2" => MarkType::g3_2,
"g3_3" => MarkType::g3_3,
"g3_4" => MarkType::g3_4,
"g3_5" => MarkType::g3_5,
"g4_1" => MarkType::g4_1,
"g4_2" => MarkType::g4_2,
"g4_3" => MarkType::g4_3,
"g4_4" => MarkType::g4_4,
"g4_5" => MarkType::g4_5,
"g5" => MarkType::g5,
"g5_1" => MarkType::g5_1,
"g5_2" => MarkType::g5_2,
"g5_3" => MarkType::g5_3,
"g5_4" => MarkType::g5_4,
"g5_5" => MarkType::g5_5,
"absent" => MarkType::absent,
"noMark" => MarkType::noMark,
"acceptableExcuse" => MarkType::acceptableExcuse,
"noAcceptableExcuse" => MarkType::noAcceptableExcuse,
_ => MarkType::noMark,
}
}
}