use serde::de::Error as DeError;
use serde::de::{Deserialize, Deserializer, Visitor};
use serde::ser::{Serialize, Serializer};
use std::convert::From;
use std::fmt;
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u64)]
pub enum EventKind {
Metadata,
TextNote,
RecommendRelay,
ContactList,
EncryptedDirectMessage,
EventDeletion,
Repost,
Reaction,
ChannelCreation,
ChannelMetadata,
ChannelMessage,
ChannelHideMessage,
ChannelMuteUser,
PublicChatReserved45,
PublicChatReserved46,
PublicChatReserved47,
PublicChatReserved48,
PublicChatReserved49,
RelaysList,
Auth,
Replaceable(u64),
Ephemeral(u64),
Other(u64),
}
impl EventKind {
#[allow(dead_code)]
pub(crate) fn mock() -> EventKind {
EventKind::TextNote
}
}
impl From<u64> for EventKind {
fn from(u: u64) -> Self {
use EventKind::*;
match u {
0 => Metadata,
1 => TextNote,
2 => RecommendRelay,
3 => ContactList,
4 => EncryptedDirectMessage,
5 => EventDeletion,
6 => Repost,
7 => Reaction,
40 => ChannelCreation,
41 => ChannelMetadata,
42 => ChannelMessage,
43 => ChannelHideMessage,
44 => ChannelMuteUser,
45 => PublicChatReserved45,
46 => PublicChatReserved46,
47 => PublicChatReserved47,
48 => PublicChatReserved48,
49 => PublicChatReserved49,
10001 => RelaysList,
22242 => Auth,
x if (10_000..20_000).contains(&x) => Replaceable(x),
x if (20_000..30_000).contains(&x) => Ephemeral(x),
x => Other(x),
}
}
}
impl From<EventKind> for u64 {
fn from(e: EventKind) -> u64 {
use EventKind::*;
match e {
Metadata => 0,
TextNote => 1,
RecommendRelay => 2,
ContactList => 3,
EncryptedDirectMessage => 4,
EventDeletion => 5,
Repost => 6,
Reaction => 7,
ChannelCreation => 40,
ChannelMetadata => 41,
ChannelMessage => 42,
ChannelHideMessage => 43,
ChannelMuteUser => 44,
PublicChatReserved45 => 45,
PublicChatReserved46 => 46,
PublicChatReserved47 => 47,
PublicChatReserved48 => 48,
PublicChatReserved49 => 49,
RelaysList => 10001,
Auth => 22242,
Replaceable(u) => u,
Ephemeral(u) => u,
Other(u) => u,
}
}
}
impl Serialize for EventKind {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let u: u64 = From::from(*self);
serializer.serialize_u64(u)
}
}
impl<'de> Deserialize<'de> for EventKind {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_u64(EventKindVisitor)
}
}
struct EventKindVisitor;
impl Visitor<'_> for EventKindVisitor {
type Value = EventKind;
fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "an unsigned number that matches a known EventKind")
}
fn visit_u64<E>(self, v: u64) -> Result<EventKind, E>
where
E: DeError,
{
Ok(From::<u64>::from(v))
}
}
#[cfg(test)]
mod test {
use super::*;
test_serde! {EventKind, test_event_kind_serde}
}