Struct telexide_fork::Client

pub struct Client {
    pub api_client: Arc<Box<dyn API + Send>>,
    pub data: Arc<RwLock<ShareMap>>,
    pub allowed_updates: Vec<UpdateType>,
    // some fields omitted
}

The Client is the main object to manage your interaction with telegram.

It handles the incoming update objects from telegram and dispatches them to your event handlers and commands, providing those with access to shared data and easy access to the telegram API itself.

Event Handlers

Event handlers can be configured to be called upon every update that is received. (Later on support will be added for subscribing to more specific update events)

Note that you do not need to manually handle retrieving updates, as they are handled internally and then dispatched to your event handlers.

Examples

use telexide_fork::prelude::*;

#[prepare_listener]
async fn event_listener(ctx: Context, update: Update) {
    println!("received an update!")
}

#[tokio::main]
async fn main() -> telexide_fork::Result<()> {
    let token = String::from("test token");
    let mut client = Client::new(&token);
    client.subscribe_handler_func(event_listener);

    client.start().await
}

Fields

api_client: Arc<Box<dyn API + Send>>

The API client, it contains all the methods to talk to the telegram api, more documentation can be found over at the API docs

data: Arc<RwLock<ShareMap>>

Your custom data that you want to be shared amongst event handlers and commands.

The purpose of the data field is to be accessible and persistent across contexts; that is, data can be modified by one context, and will persist through the future and be accessible through other contexts. This is useful for anything that should “live” through the program: counters, database connections, custom user caches, etc. Therefore this ShareMap requires all types it will contain to be Send + Sync.

When using a Context, this data will be available as Context::data.

Refer to the repeat_image_bot example for an example on using the data field

allowed_updates: Vec<UpdateType>

The update types that you want to receive, see the documentation of UpdateType for more information

Implementations

impl Client

pub fn new<T: ToString>(token: &T) -> Self

Creates a Client object with default values and no framework

pub fn with_framework<T: ToString>(fr: Arc<Framework>, token: &T) -> Self

Creates a Client object with default values, but with a Framework

pub fn builder() -> ClientBuilder

Returns a new ClientBuilder

pub async fn start(&self) -> Result<()>

Starts the client and blocks until an error happens in the updates stream or the program exits (for example due to a panic). If using the framework, it will update your commands in telegram. If using a webhook, it will handle it, else it will use polling using a default UpdatesStream object

pub async fn start_with_stream(&self, stream: &mut UpdatesStream) -> Result<()>

Starts the client and blocks until an error happens in the updates stream or the program exits (for example due to a panic). If using the framework, it will update your commands in telegram You have to provide your own UpdatesStream object

pub async fn start_with_webhook(&self, opts: &WebhookOptions) -> Result<()>

Starts the client and blocks until an error happens in the webhook handling or the program exits (for example due to a panic). If using the framework, it will update your commands in telegram You have to provide your own WebhookOptions object

pub fn subscribe_handler_func(&mut self, handler: EventHandlerFunc)

Subscribes an update event handler function (EventHandlerFunc) to the client and will be ran whenever a new update is received

pub fn subscribe_raw_handler(&mut self, handler: RawEventHandlerFunc)

Subscribes a raw update event handler function (RawEventHandlerFunc) to the client and will be ran whenever a new update is received

Trait Implementations

impl Clone for Client

fn clone(&self) -> Client

Returns a copy of the value.

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

Performs copy-assignment from source.

impl From<Box<dyn API + Send + 'static, Global>> for Client

fn from(api: Box<dyn API + Send>) -> Self

Performs the conversion.