pub struct Client {
pub api_client: Arc<Box<dyn API + Send>>,
pub data: Arc<RwLock<TypeMap>>,
pub allowed_updates: Vec<UpdateType>,
/* private fields */
}
Expand description
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::prelude::*;
#[prepare_listener]
async fn event_listener(ctx: Context, update: Update) {
println!("received an update!")
}
#[tokio::main]
async fn main() -> telexide::Result<()> {
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<TypeMap>>
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 TypeMap 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§
source§impl Client
impl Client
sourcepub fn new(token: impl ToString) -> Self
pub fn new(token: impl ToString) -> Self
Creates a Client object with default values and no framework
sourcepub fn with_framework(fr: Arc<Framework>, token: impl ToString) -> Self
pub fn with_framework(fr: Arc<Framework>, token: impl ToString) -> Self
Creates a Client object with default values, but with a Framework
sourcepub fn builder() -> ClientBuilder
pub fn builder() -> ClientBuilder
Returns a new ClientBuilder
sourcepub async fn start(&self) -> Result<()>
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
sourcepub async fn start_with_stream(&self, stream: &mut UpdatesStream) -> Result<()>
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
sourcepub async fn start_with_webhook(&self, opts: &WebhookOptions) -> Result<()>
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
sourcepub fn subscribe_handler_func(&mut self, handler: EventHandlerFunc)
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
sourcepub fn subscribe_raw_handler(&mut self, handler: RawEventHandlerFunc)
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