[][src]Struct serenity::client::Context

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

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<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.

http: Arc<Http>cache: CacheRwLock

Methods

impl Context[src]

pub fn online(&self)[src]

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;

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)[src]

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;

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)[src]

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;

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)[src]

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;

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)[src]

"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;

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_activity(&self, activity: Activity)[src]

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;

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_activity(Activity::playing(*unsafe { args.get_unchecked(1) }));
    }
}

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

client.start().unwrap();

pub fn set_presence(&self, activity: Option<Activity>, status: OnlineStatus)[src]

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;

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:

This example is not tested
struct Handler;

impl EventHandler for Handler {
    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::new("token", Handler).unwrap();

client.start().unwrap();

Trait Implementations

impl AsRef<CacheRwLock> for Context[src]

impl AsRef<Http> for Context[src]

impl CacheHttp for Context[src]

impl<'_> CacheHttp for &'_ Context[src]

impl<'_> CacheHttp for &'_ mut Context[src]

impl Clone for Context[src]

Auto Trait Implementations

impl !RefUnwindSafe for Context

impl Send for Context

impl !Sync for Context

impl Unpin for Context

impl !UnwindSafe for Context

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> CloneAny for T where
    T: Clone + Any
[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> Same<T> for T

type Output = T

Should always be Self

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> UnsafeAny for T where
    T: Any

impl<V, T> VZip<V> for T where
    V: MultiLane<T>,