Struct telexide_fork::client::UpdatesStream

pub struct UpdatesStream { /* private fields */ }

The stream of incoming updates, created by long polling the telegram API using their getUpdates endpoint.

In most use-cases, this will be handled for you by the Client and the new updates then dispatched to your eventhandlers.

Example

use futures::StreamExt;
use telexide_fork::{
    api::APIClient,
    client::UpdatesStream
};

#[tokio::main]
async fn main() {
    let token = String::from("test token");

    let mut stream = UpdatesStream::new(
        Arc::new(
            Box::new(
                APIClient::new_default(&token)
            )
        )
    );

    while let Some(poll) = stream.next().await {
        match poll {
            Ok(update) => {
                println!("ID of the update received: {}", update.update_id);
            },
            Err(err) => return,
        }
    }
}

Implementations

impl UpdatesStream

pub fn new(api: Arc<Box<dyn API + Send>>) -> Self

creates a new update stream using the provided API

pub fn set_limit(&mut self, limit: usize) -> &mut Self

Sets the maximum amount of updates retrieved in one API call

pub fn set_timout(&mut self, timeout: usize) -> &mut Self

Set the timeout in seconds for long polling. Defaults to 5. Should be positive, short polling should be used for testing purposes only.

pub fn set_allowed_updates(&mut self, allowed: Vec<UpdateType>) -> &mut Self

Set which update types you want to receive

pub fn add_allowed_updates(&mut self, allowed: UpdateType) -> &mut Self

Add an update type to the list of update types you want to receive

pub fn remove_allowed_updates(&mut self, to_remove: &UpdateType) -> &mut Self

Remove an update type from the list of update types you want to receive

Trait Implementations

impl Stream for UpdatesStream

type Item = Result<Update, Error>

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_> ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.