Struct serenity::client::Context

pub struct Context {
    pub data: Arc<RwLock<TypeMap>>,
    pub shard: ShardMessenger,
    pub shard_id: u64,
    pub http: Arc<Http>,
    pub cache: Arc<Cache>,
}

The context is a general utility struct provided on event dispatches, which helps with dealing with the current "context" of the event dispatch. The context also acts as a general high-level interface over the associated Shard which received the event, or the low-level http module.

The context contains "shortcuts", like for interacting with the shard. Methods like set_activity will unlock the shard and perform an update for you to save a bit of work.

A context will only live for the event it was dispatched for. After the event handler finished, it is destroyed and will not be re-used.

Fields

data: Arc<RwLock<TypeMap>>

A clone of Client::data. Refer to its documentation for more information.

shard: ShardMessenger

The messenger to communicate with the shard runner.

shard_id: u64

The ID of the shard this context is related to.

http: Arc<Http>

cache: Arc<Cache>

Implementations

impl Context

pub async fn online<'_>(&'_ self)

Sets the current user as being Online. This maintains the current activity.

Examples

Set the current user to being online on the shard:

struct Handler;

#[serenity::async_trait]
impl EventHandler for Handler {
    async fn message(&self, ctx: Context, msg: Message) {
        if msg.content == "!online" {
            ctx.online().await;
        }
    }
}

let mut client = Client::builder("token").event_handler(Handler).await?;

client.start().await?;

pub async fn idle<'_>(&'_ self)

Sets the current user as being Idle. This maintains the current activity.

Examples

Set the current user to being idle on the shard:

struct Handler;

#[serenity::async_trait]
impl EventHandler for Handler {
    async fn message(&self, ctx: Context, msg: Message) {
        if msg.content == "!idle" {
            ctx.idle().await;
        }
    }
}

let mut client = Client::builder("token").event_handler(Handler).await?;

client.start().await?;

pub async fn dnd<'_>(&'_ self)

Sets the current user as being DoNotDisturb. This maintains the current activity.

Examples

Set the current user to being Do Not Disturb on the shard:

struct Handler;

#[serenity::async_trait]
impl EventHandler for Handler {
    async fn message(&self, ctx: Context, msg: Message) {
        if msg.content == "!dnd" {
            ctx.dnd().await;
        }
    }
}

let mut client = Client::builder("token").event_handler(Handler).await?;

client.start().await?;

pub async fn invisible<'_>(&'_ self)

Sets the current user as being Invisible. This maintains the current activity.

Examples

Set the current user to being invisible on the shard when an Event::Ready is received:

struct Handler;

#[serenity::async_trait]
impl EventHandler for Handler {
    async fn ready(&self, ctx: Context, _: Ready) {
        ctx.invisible().await;
    }
}

let mut client = Client::builder("token").event_handler(Handler).await?;

client.start().await?;

pub async fn reset_presence<'_>(&'_ self)

"Resets" the current user's presence, by setting the activity to None and the online status to Online.

Use set_presence for fine-grained control over individual details.

Examples

Reset the presence when an Event::Resumed is received:

struct Handler;

#[serenity::async_trait]
impl EventHandler for Handler {
    async fn resume(&self, ctx: Context, _: ResumedEvent) {
        ctx.reset_presence().await;
    }
}

let mut client = Client::builder("token").event_handler(Handler).await?;

client.start().await?;

pub async fn set_activity<'_>(&'_ self, activity: Activity)

Sets the current activity, defaulting to an online status of Online.

Examples

Create a command named ~setgame that accepts a name of a game to be playing:

use serenity::model::gateway::Activity;

struct Handler;

#[serenity::async_trait]
impl EventHandler for Handler {
    async fn message(&self, ctx: Context, msg: Message) {
        let mut args = msg.content.splitn(2, ' ');

        if let (Some("~setgame"), Some(game)) = (args.next(), args.next()) {
            ctx.set_activity(Activity::playing(game)).await;
        }
    }
}

let mut client = Client::builder("token").event_handler(Handler).await?;

client.start().await?;

pub async fn set_presence<'_>(
    &'_ self,
    activity: Option<Activity>,
    status: OnlineStatus
)

Sets the current user's presence, providing all fields to be passed.

Examples

Setting the current user as having no activity and being Idle:

struct Handler;

#[serenity::async_trait]
impl EventHandler for Handler {
    async fn ready(&self, ctx: Context, _: Ready) {
        use serenity::model::user::OnlineStatus;

        ctx.set_presence(None, OnlineStatus::Idle);
    }
}

let mut client = Client::builder("token").event_handler(Handler).await?;

client.start().await?;

Setting the current user as playing "Heroes of the Storm", while being DoNotDisturb:

struct Handler;

#[serenity::async_trait]
impl EventHandler for Handler {
    async fn ready(&self, context: Context, _: Ready) {
        use serenity::model::gateway::Activity;
        use serenity::model::user::OnlineStatus;

        let activity = Activity::playing("Heroes of the Storm");
        let status = OnlineStatus::DoNotDisturb;

        context.set_presence(Some(activity), status);
    }
}

let mut client = Client::builder("token").event_handler(Handler).await?;

client.start().await?;

pub async fn set_message_filter<'_>(&'_ self, filter: MessageFilter)

Sets a new filter for the shard to check if a message event shall be sent back to filter's paired receiver.

pub async fn set_reaction_filter<'_>(&'_ self, filter: ReactionFilter)

Sets a new filter for the shard to check if a reaction event shall be sent back to filter's paired receiver.

Trait Implementations

impl AsRef<Arc<Cache>> for Context

pub fn as_ref(&self) -> &Arc<Cache>

Performs the conversion.

impl AsRef<Arc<Http>> for Context

pub fn as_ref(&self) -> &Arc<Http>

Performs the conversion.

impl AsRef<Cache> for Context

pub fn as_ref(&self) -> &Cache

Performs the conversion.

impl AsRef<Http> for Context

pub fn as_ref(&self) -> &Http

Performs the conversion.

impl AsRef<ShardMessenger> for Context

pub fn as_ref(&self) -> &ShardMessenger

Performs the conversion.

impl CacheHttp for Context

pub fn http(&self) -> &Http

pub fn cache(&self) -> Option<&Arc<Cache>>

impl Clone for Context

pub fn clone(&self) -> Context

Returns a copy of the value.

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

Performs copy-assignment from source.