Struct serenity::client::ClientBuilder

pub struct ClientBuilder<'a> { /* fields omitted */ }

A builder implementing Future building a Client to interact with Discord.

Implementations

impl<'a> ClientBuilder<'a>

pub fn new(token: impl AsRef<str>) -> Self

Construct a new builder to call methods on for the client construction. The token will automatically be prefixed "Bot " if not already.

Panic: If you enabled the framework-feature (on by default), you must specify a framework via the framework or framework_arc method, otherwise awaiting the builder will cause a panic.

pub fn token(self, token: impl AsRef<str>) -> Self

Sets a token for the bot. If the token is not prefixed "Bot ", this method will automatically do so.

pub fn type_map(self, type_map: TypeMap) -> Self

Sets the entire TypeMap that will be available in Contexts. A TypeMap must not be constructed manually: [type_map_insert] can be used to insert one type at a time.

pub fn type_map_insert<T: TypeMapKey>(self, value: T::Value) -> Self

Insert a single value into the internal TypeMap that will be available in Context::data. This method can be called multiple times in order to populate the TypeMap with values.

pub fn cache_update_timeout(self, timeout: Duration) -> Self

Sets how long - if wanted to begin with - a cache update shall be attempted for. After the timeout ran out, the update will be skipped.

By default, a cache update will never timeout and potentially cause a deadlock. A timeout however, will invalidate the cache.

pub fn guild_subscriptions(self, is_enabled: bool) -> Self

Whether presence or typing events shall be received over the gateway.

Info: Prefer to use intents, as this may be replaced by them in the future.**

pub fn framework<F>(self, framework: F) -> Self where
    F: Framework + Send + Sync + 'static, 

Sets the command framework to be used. It will receive messages sent over the gateway and then consider - based on its settings - whether to dispatch a command.

Info: If a reference to the framework is required for manual dispatch, use the framework_arc-method instead.

pub fn framework_arc(
    self,
    framework: Arc<Box<dyn Framework + Send + Sync + 'static>>
) -> Self

This method allows to pass an Arc'ed framework - this step is done for you in the framework-method, if you don't need the extra control. You can provide a clone and keep the original to manually dispatch.

pub fn intents(self, intents: GatewayIntents) -> Self

Sets all intents directly, replacing already set intents.

See also: If visually preferred, you can use add_intent and chain it in order to add intent after intent.

Info: Intents are a bitflag, you can combine them by performing the |-operator.

pub fn add_intent(self, intent: GatewayIntents) -> Self

Adds a single intent, this method can be called repetitively to add multiple intents.

See also: If visually preferred, you can use intents and specify all intents at once. In theory you could also achieve the same result by passing the combined intents-bitflag to this method.

pub fn event_handler<H: EventHandler + 'static>(self, event_handler: H) -> Self

Sets an event handler with multiple methods for each possible event.

pub fn raw_event_handler<H: RawEventHandler + 'static>(
    self,
    raw_event_handler: H
) -> Self

Sets an event handler with a single method where all received gateway events will be dispatched.

Trait Implementations

impl<'a> Future for ClientBuilder<'a>

type Output = Result<Client>

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, ctx: &mut FutContext<'_>) -> Poll<Self::Output>

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.