Struct serenity::prelude::Context

pub struct Context {
    pub data: Arc<Mutex<ShareMap>>,
    pub shard: ShardMessenger,
    pub shard_id: u64,
}

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_game 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<Mutex<ShareMap>>

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.

Methods

impl Context

pub fn edit_profile<F: FnOnce(EditProfile) -> EditProfile>(
    &self,
    f: F
) -> Result<CurrentUser>

Deprecated since 0.5.6:

Use the http module instead.

Edits the current user's profile settings.

Refer to EditProfile's documentation for its methods.

Examples

Change the current user's username:

struct Handler;

impl EventHandler for Handler {
    fn message(&self, ctx: Context, msg: Message) {
        if msg.content == "!changename" {
            ctx.edit_profile(|e| e.username("Edward Elric"));
        }
    }
}
let mut client = Client::new("token", Handler).unwrap();

client.start().unwrap();

pub fn online(&self)

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

Examples

Set the current user to being online on the shard:

struct Handler;

impl EventHandler for Handler {
    fn message(&self, ctx: Context, msg: Message) {
        if msg.content == "!online" {
            ctx.online();
        }
    }
}

let mut client = Client::new("token", Handler).unwrap();

client.start().unwrap();

pub fn idle(&self)

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

Examples

Set the current user to being idle on the shard:

struct Handler;

impl EventHandler for Handler {
    fn message(&self, ctx: Context, msg: Message) {
        if msg.content == "!idle" {
            ctx.idle();
        }
    }
}
let mut client = Client::new("token", Handler).unwrap();

client.start().unwrap();

pub fn dnd(&self)

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

Examples

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

struct Handler;

impl EventHandler for Handler {
    fn message(&self, ctx: Context, msg: Message) {
        if msg.content == "!dnd" {
            ctx.dnd();
        }
    }
}
let mut client = Client::new("token", Handler).unwrap();

client.start().unwrap();

pub fn invisible(&self)

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

Examples

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

struct Handler;

impl EventHandler for Handler {
    fn ready(&self, ctx: Context, _: Ready) {
        ctx.invisible();
    }
}

let mut client = Client::new("token", Handler).unwrap();

client.start().unwrap();

pub fn reset_presence(&self)

"Resets" the current user's presence, by setting the game 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;

impl EventHandler for Handler {
    fn resume(&self, ctx: Context, _: ResumedEvent) {
        ctx.reset_presence();
    }
}

let mut client = Client::new("token", Handler).unwrap();

client.start().unwrap();

pub fn set_game<T: Into<Game>>(&self, game: T)

Sets the current game, 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::Game;

struct Handler;

impl EventHandler for Handler {
    fn message(&self, ctx: Context, msg: Message) {
        let args = msg.content.splitn(2, ' ').collect::<Vec<&str>>();

        if args.len() < 2 || *unsafe { args.get_unchecked(0) } != "~setgame" {
            return;
        }

        ctx.set_game(Game::playing(*unsafe { args.get_unchecked(1) }));
    }
}

let mut client = Client::new("token", Handler).unwrap();

client.start().unwrap();

pub fn set_game_name<T: Into<String>>(&self, game_name: T)

Deprecated since 0.5.5:

Use Context::set_game

Sets the current game, passing in only its name. This will automatically set the current user's OnlineStatus to Online, and its GameType as Playing.

Use reset_presence to clear the current game, or set_presence for more fine-grained control.

Note: Maximum length is 128.

Examples

When an Event::Ready is received, set the game name to "test":

struct Handler;

impl EventHandler for Handler {
    fn ready(&self, ctx: Context, _: Ready) {
        ctx.set_game_name("test");
    }
}

let mut client = Client::new("token", Handler).unwrap();
client.start().unwrap();

pub fn set_presence(&self, game: Option<Game>, status: OnlineStatus)

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

Examples

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

struct Handler;

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

        ctx.set_presence(None, OnlineStatus::Idle);
    }
}
let mut client = Client::new("token", Handler).unwrap();

client.start().unwrap();

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

struct Handler;

impl EventHandler for Handler {
    fn ready(&self, context: Context, _: Ready) {
        use serenity::model::gateway::Game;
        use serenity::model::user::OnlineStatus;

        let game = Game::playing("Heroes of the Storm");
        let status = OnlineStatus::DoNotDisturb;

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

let mut client = Client::new("token", Handler).unwrap();

client.start().unwrap();

pub fn quit(&self)

Disconnects the shard from the websocket, essentially "quiting" it. Note however that this will only exit the one which the Context was given. If it's just one shard that's on, then serenity will stop any further actions until Client::start and vice versa are called again.

Trait Implementations

impl Clone for Context

fn clone(&self) -> Context

Returns a copy of the value.

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

Performs copy-assignment from source.