songbird 0.6.0

An async Rust library for the Discord voice API.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

//! Newtypes around Discord IDs for library cross-compatibility.

#[cfg(feature = "driver")]
use crate::model::id::{GuildId as DriverGuild, UserId as DriverUser};
#[cfg(feature = "serenity")]
use serenity::model::id::{
    ChannelId as SerenityChannel,
    GuildId as SerenityGuild,
    UserId as SerenityUser,
};
use std::{
    fmt::{Display, Formatter, Result as FmtResult},
    num::NonZeroU64,
};
#[cfg(feature = "twilight")]
use twilight_model::id::{
    marker::{ChannelMarker, GuildMarker, UserMarker},
    Id as TwilightId,
};

/// ID of a Discord voice/text channel.
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub struct ChannelId(pub NonZeroU64);

/// ID of a Discord guild (colloquially, "server").
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub struct GuildId(pub NonZeroU64);

/// ID of a Discord user.
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub struct UserId(pub NonZeroU64);

impl Display for ChannelId {
    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
        Display::fmt(&self.0, f)
    }
}

impl From<NonZeroU64> for ChannelId {
    fn from(id: NonZeroU64) -> Self {
        Self(id)
    }
}

#[cfg(feature = "serenity")]
impl From<SerenityChannel> for ChannelId {
    fn from(id: SerenityChannel) -> Self {
        Self(NonZeroU64::new(id.get()).unwrap())
    }
}

#[cfg(feature = "twilight")]
impl From<TwilightId<ChannelMarker>> for ChannelId {
    fn from(id: TwilightId<ChannelMarker>) -> Self {
        Self(id.into_nonzero())
    }
}

impl Display for GuildId {
    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
        Display::fmt(&self.0, f)
    }
}

impl From<NonZeroU64> for GuildId {
    fn from(id: NonZeroU64) -> Self {
        Self(id)
    }
}

#[cfg(feature = "serenity")]
impl From<SerenityGuild> for GuildId {
    fn from(id: SerenityGuild) -> Self {
        Self(NonZeroU64::new(id.get()).unwrap())
    }
}

#[cfg(feature = "driver")]
impl From<GuildId> for DriverGuild {
    fn from(id: GuildId) -> Self {
        Self(id.0.get())
    }
}

#[cfg(feature = "twilight")]
impl From<TwilightId<GuildMarker>> for GuildId {
    fn from(id: TwilightId<GuildMarker>) -> Self {
        Self(id.into_nonzero())
    }
}

impl Display for UserId {
    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
        Display::fmt(&self.0, f)
    }
}

impl From<NonZeroU64> for UserId {
    fn from(id: NonZeroU64) -> Self {
        Self(id)
    }
}

#[cfg(feature = "serenity")]
impl From<SerenityUser> for UserId {
    fn from(id: SerenityUser) -> Self {
        Self(NonZeroU64::new(id.get()).unwrap())
    }
}

#[cfg(feature = "driver")]
impl From<UserId> for DriverUser {
    fn from(id: UserId) -> Self {
        Self(id.0.get())
    }
}

#[cfg(feature = "twilight")]
impl From<TwilightId<UserMarker>> for UserId {
    fn from(id: TwilightId<UserMarker>) -> Self {
        Self(id.into_nonzero())
    }
}