Struct Client 

pub struct Client<H> {
    pub state: GlobalCache,
    pub handler: Arc<H>,
    pub http: HttpClient,
    pub waiters: Notifiers,
    pub events: Option<Events>,
}

Stoat Client

Entrypoint for connecting to the Stoat API.

Create a client via Self::new or Self::new_with_api_url if you are connecting to a 3rd party instance. Clients require an implementation of EventHandler which contains all the event methods.

Example

While it may seem like setting up a client requires a lot, the boilerplate required here pays off in larger projects ensuring everything works smoothly together.

#[derive(Debug, Clone)]
pub enum Error {
    StoatError(stoat::Error),
}

impl From<stoat::Error> for Error {
    fn from(value: stoat::Error) -> Self {
        Self::StoatError(value)
    }
}

#[derive(Clone)]
struct Events;

#[async_trait]
impl EventHandler for Events {
    type Error = Error;

    async fn ready(&self, _context: Context) -> Result<(), Self::Error> {
        println!("Ready!");
        Ok(())
    }
}

#[tokio::main]
async fn main() -> Result<(), Error> {
    Client::new(Events).await?.run("TOKEN HERE").await
}

Fields

state: GlobalCache

handler: Arc<H>

http: HttpClient

waiters: Notifiers

events: Option<Events>

Implementations

impl<H: EventHandler + Clone + Send + Sync + 'static> Client<H>

pub async fn new(handler: H) -> Result<Self, H::Error>

Constructs a client with the official instance.

Use the new_with_* functions to customise the creation.

Examples found in repository

examples/simple.rs (line 33)

async fn main() -> Result<(), Error> {
    Client::new(Events).await?.run("TOKEN HERE").await
}

examples/groups/main.rs (line 40)

async fn main() -> Result<(), Error> {
    let commands = CommandHandler::new(commands::Commands, ()).register(commands::commands());

    let events = Events(commands);

    Client::new(events).await?.run("TOKEN HERE").await
}

examples/commands.rs (line 71)

async fn main() -> Result<(), Error> {
    let commands = CommandHandler::new(Commands, ())
        .register(vec![Command::new("ping", ping).description("Pong")]);

    let events = Events(commands);

    Client::new(events).await?.run("TOKEN HERE").await
}

pub async fn new_with_config( handler: H, config: CacheConfig, ) -> Result<Self, H::Error>

Constructs a client with a custom cache config.

pub async fn new_with_api_url( handler: H, config: CacheConfig, base_url: impl Into<String>, ) -> Result<Self, H::Error>

Constructs a client with a custom Stoat instance.

pub async fn start(&mut self, token: impl Into<String>) -> Result<(), H::Error>

Connects to the api and sets the current user.

You will usually not need to call this directly as Self::run handles this.

pub async fn run(&mut self, token: impl Into<String>) -> Result<(), H::Error>

Connects and starts the bot, this connects to the websocket to receive events, this is the main entry point for starting the bot.

Reconnects are handled automatically.

Examples found in repository

examples/simple.rs (line 33)

async fn main() -> Result<(), Error> {
    Client::new(Events).await?.run("TOKEN HERE").await
}

examples/groups/main.rs (line 40)

async fn main() -> Result<(), Error> {
    let commands = CommandHandler::new(commands::Commands, ()).register(commands::commands());

    let events = Events(commands);

    Client::new(events).await?.run("TOKEN HERE").await
}

examples/commands.rs (line 71)

async fn main() -> Result<(), Error> {
    let commands = CommandHandler::new(Commands, ())
        .register(vec![Command::new("ping", ping).description("Pong")]);

    let events = Events(commands);

    Client::new(events).await?.run("TOKEN HERE").await
}

pub async fn cleanup(&mut self)

Clears the internal cache.

pub async fn handle_event(&self, event: EventV1)

Handles a Stoat event with updating the local state, invoking notifiers and calling the event callbacks.

You shouldn’t need to call this yourself unless your mocking events or debugging.

Trait Implementations

impl<H: Clone> Clone for Client<H>

fn clone(&self) -> Client<H>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<H> StoatExt for Client<H>

fn fetch_user<'life0, 'life1, 'async_trait>( &'life0 self, user_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<User>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn upload_file<'life0, 'async_trait>( &'life0 self, tag: Tag, file: LocalFile, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

fn fetch_server<'life0, 'life1, 'async_trait>( &'life0 self, server_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Server>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn fetch_server_with_channels<'life0, 'life1, 'async_trait>( &'life0 self, server_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(Server, Vec<Channel>)>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn fetch_dms<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<Channel>>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

fn fetch_self<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<User>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,