AppFlowy/shared-lib/folder-model/src/trash_rev.rs

use serde::de::Visitor;
use serde::{Deserialize, Serialize};
use serde_repr::*;
use std::fmt;
#[derive(Default, Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)]
pub struct TrashRevision {
  pub id: String,

  pub name: String,

  #[serde(default)]
  pub modified_time: i64,

  #[serde(default)]
  pub create_time: i64,

  pub ty: TrashTypeRevision,
}

#[derive(Eq, PartialEq, Debug, Clone, Hash, Serialize_repr)]
#[repr(u8)]
pub enum TrashTypeRevision {
  Unknown = 0,
  TrashView = 1,
  TrashApp = 2,
}
impl<'de> serde::Deserialize<'de> for TrashTypeRevision {
  fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
  where
    D: serde::Deserializer<'de>,
  {
    struct TrashTypeVisitor();

    impl<'de> Visitor<'de> for TrashTypeVisitor {
      type Value = TrashTypeRevision;

      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("expected enum TrashTypeRevision with type: u8")
      }

      fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
      where
        E: serde::de::Error,
      {
        self.visit_u8(v as u8)
      }

      fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
      where
        E: serde::de::Error,
      {
        self.visit_u8(v as u8)
      }

      fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
      where
        E: serde::de::Error,
      {
        self.visit_u8(v as u8)
      }

      fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
      where
        E: serde::de::Error,
      {
        self.visit_u8(v as u8)
      }

      fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
      where
        E: serde::de::Error,
      {
        let ty = match v {
          0 => TrashTypeRevision::Unknown,
          1 => TrashTypeRevision::TrashView,
          2 => TrashTypeRevision::TrashApp,
          _ => TrashTypeRevision::Unknown,
        };

        Ok(ty)
      }

      fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
      where
        E: serde::de::Error,
      {
        self.visit_u8(v as u8)
      }

      fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
      where
        E: serde::de::Error,
      {
        self.visit_u8(v as u8)
      }

      fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
      where
        E: serde::de::Error,
      {
        self.visit_u8(v as u8)
      }

      fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
      where
        E: serde::de::Error,
      {
        let value = match s {
          "Unknown" => TrashTypeRevision::Unknown,
          "TrashView" => TrashTypeRevision::TrashView,
          "TrashApp" => TrashTypeRevision::TrashApp,
          _ => TrashTypeRevision::Unknown,
        };
        Ok(value)
      }
    }

    deserializer.deserialize_any(TrashTypeVisitor())
  }
}
impl std::default::Default for TrashTypeRevision {
  fn default() -> Self {
    TrashTypeRevision::Unknown
  }
}

impl std::convert::From<TrashTypeRevision> for u8 {
  fn from(rev: TrashTypeRevision) -> Self {
    match rev {
      TrashTypeRevision::Unknown => 0,
      TrashTypeRevision::TrashView => 1,
      TrashTypeRevision::TrashApp => 2,
    }
  }
}