Enum serenity::model::channel::Channel

#[non_exhaustive]
pub enum Channel {
    Guild(GuildChannel),
    Private(PrivateChannel),
    Category(ChannelCategory),
}

A container for any channel.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Guild(GuildChannel)

Tuple Fields

0: GuildChannel

A text, voice, or stage channel within a Guild.

Private(PrivateChannel)

Tuple Fields

0: PrivateChannel

A private channel to another User. No other users may access the channel. For multi-user “private channels”, use a group.

Category(ChannelCategory)

Tuple Fields

0: ChannelCategory

A category of GuildChannels

Implementations

impl Channel

pub fn guild(self) -> Option<GuildChannel>

Converts from Channel to Option<GuildChannel>.

Converts self into an Option<GuildChannel>, consuming self, and discarding a PrivateChannel, or ChannelCategory, if any.

Examples

Basic usage:

match channel.guild() {
    Some(guild_channel) => {
        println!("It's a guild channel named {}!", guild_channel.name);
    },
    None => {
        println!("It's not in a guild!");
    },
}

pub fn private(self) -> Option<PrivateChannel>

Converts from Channel to Option<PrivateChannel>.

Converts self into an Option<PrivateChannel>, consuming self, and discarding a GuildChannel, or ChannelCategory, if any.

Examples

Basic usage:

match channel.private() {
    Some(private) => {
        println!("It's a private channel with {}!", &private.recipient);
    },
    None => {
        println!("It's not a private channel!");
    },
}

pub fn category(self) -> Option<ChannelCategory>

Converts from Channel to Option<ChannelCategory>.

Converts self into an Option<ChannelCategory>, consuming self, and discarding a GuildChannel, or PrivateChannel, if any.

Examples

Basic usage:

match channel.category() {
    Some(category) => {
        println!("It's a category named {}!", category.name);
    },
    None => {
        println!("It's not a category!");
    },
}

pub async fn delete(&self, cache_http: impl CacheHttp) -> Result<()>

Deletes the inner channel.

Errors

If the cache is enabled, returns ModelError::InvalidPermissions, if the current user lacks permission.

Otherwise will return Error::Http if the current user does not have permission.

pub fn is_nsfw(&self) -> bool

Determines if the channel is NSFW.

pub fn id(&self) -> ChannelId

Retrieves the Id of the inner GuildChannel, or PrivateChannel.

pub fn position(&self) -> Option<i64>

Retrieves the position of the inner GuildChannel or ChannelCategory.

If other channel types are used it will return None.

Trait Implementations

impl ArgumentConvert for Channel

Look up a Channel by a string case-insensitively.

Lookup are done via local guild. If in DMs, the global cache is used instead.

The cache feature needs to be enabled.

The lookup strategy is as follows (in order):

1. Lookup by ID.
2. Lookup by mention.
3. Lookup by name.

type Err = ChannelParseError

The associated error which can be returned from parsing.

fn convert<'life0, 'life1, 'async_trait>(
    ctx: &'life0 Context,
    guild_id: Option<GuildId>,
    _channel_id: Option<ChannelId>,
    s: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<Self, Self::Err>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Parses a string s as a command parameter of this type.

impl Clone for Channel

fn clone(&self) -> Channel

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Channel

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Channel

fn deserialize<D: Deserializer<'de>>(
    deserializer: D
) -> StdResult<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Display for Channel

fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult

Formats the channel into a “mentioned” string.

This will return a different format for each type of channel:

• PrivateChannels: the recipient’s name;
• GuildChannels: a string mentioning the channel that users who can see the channel can click on.

impl From<&'_ Channel> for Mention

fn from(value: &Channel) -> Self

Performs the conversion.

impl<'a> From<&'a Channel> for ChannelId

fn from(channel: &Channel) -> ChannelId

Gets the Id of a Channel.

impl From<Channel> for ChannelId

fn from(channel: Channel) -> ChannelId

Gets the Id of a Channel.

impl FromStrAndCache for Channel

type Err = ChannelParseError

fn from_str<'life0, 'async_trait, C>(
    cache: C,
    s: &'life0 str
) -> Pin<Box<dyn Future<Output = StdResult<Self, Self::Err>> + Send + 'async_trait>> where
    C: AsRef<Cache> + Send + Sync,
    C: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl Mentionable for Channel

fn mention(&self) -> Mention

Creates a Mention that will be able to notify or create a link to the item.

impl Serialize for Channel

fn serialize<S>(&self, serializer: S) -> StdResult<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.