timesheetlib/enums/
bonus_type.rs

Help
use std::fmt;
use std::fmt::Formatter;
use std::str;

use serde::Deserialize;
use serde::Serialize;

#[cfg(feature = "diesel")]
use {
    diesel::{deserialize, not_none, serialize},
    diesel::{AsExpression, FromSqlRow},
    diesel::backend::Backend,
    diesel::deserialize::FromSql,
    diesel::pg::Pg,
    diesel::serialize::{IsNull, Output, ToSql},
    diesel::types::Varchar,
    std::io::Write,
};

#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
#[cfg_attr(
feature = "diesel",
derive(AsExpression, FromSqlRow),
sql_type = "Varchar"
)]

pub enum BonusType {
    Performance,
    Scheduled,
    Other,
    Undefined,

}
impl fmt::Display for BonusType {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        write!(f, "{:?}", self)
    }
}
impl Default for BonusType {
    fn default() -> Self {
        BonusType::Undefined
    }
}


#[cfg(feature = "diesel")]
impl ToSql<Varchar, Pg> for BonusType {
    fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> serialize::Result {
        match *self {
            BonusType::Performance => out.write_all(b"Performance")?,
            BonusType::Scheduled => out.write_all(b"Scheduled")?,
            BonusType::Other => out.write_all(b"Other")?,
            BonusType::Undefined => out.write_all(b"Undefined")?,

        }
        Ok(IsNull::No)
    }
}


#[cfg(feature = "diesel")]
impl FromSql<Varchar, Pg> for BonusType {
    fn from_sql(bytes: Option<&<Pg as Backend>::RawValue>) -> deserialize::Result<Self> {
        match not_none!(bytes) {

            b"Performance" => Ok(BonusType::Performance),
            b"Scheduled" => Ok(BonusType::Scheduled),
            b"Other" => Ok(BonusType::Other),
            b"Undefined" => Ok(BonusType::Undefined),

            _ => Err("Unrecognized enum variant".into()),
        }
    }
}
timesheetlib/enums/bonus_type.rs

timesheetlib/enums/
bonus_type.rs
