mediclib/enums/
task_status.rs
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 TaskStatus {
Active,
Processing,
Completed,
Failed,
Undefined,
}
impl fmt::Display for TaskStatus {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
write!(f, "{:?}", self)
}
}
impl Default for TaskStatus {
fn default() -> Self {
TaskStatus::Undefined
}
}
#[cfg(feature = "diesel")]
impl ToSql<Varchar, Pg> for TaskStatus {
fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> serialize::Result {
match *self {
TaskStatus::Active => out.write_all(b"Active")?,
TaskStatus::Processing => out.write_all(b"Processing")?,
TaskStatus::Completed => out.write_all(b"Completed")?,
TaskStatus::Failed => out.write_all(b"Failed")?,
TaskStatus::Undefined => out.write_all(b"Undefined")?,
}
Ok(IsNull::No)
}
}
#[cfg(feature = "diesel")]
impl FromSql<Varchar, Pg> for TaskStatus {
fn from_sql(bytes: Option<&<Pg as Backend>::RawValue>) -> deserialize::Result<Self> {
match not_none!(bytes) {
b"Active" => Ok(TaskStatus::Active),
b"Processing" => Ok(TaskStatus::Processing),
b"Completed" => Ok(TaskStatus::Completed),
b"Failed" => Ok(TaskStatus::Failed),
b"Undefined" => Ok(TaskStatus::Undefined),
_ => Err("Unrecognized enum variant".into()),
}
}
}