Struct xmpp::agent::TokioXmppClient

pub struct TokioXmppClient<C>
where
    C: ServerConnector,
{ /* private fields */ }

XMPP client connection and state

It is able to reconnect. TODO: implement session management.

This implements the futures crate’s Stream and Sink traits.

Implementations

impl Client<ServerConfig>

pub fn new<J, P>(jid: J, password: P) -> Client<ServerConfig>

where J: Into<Jid>, P: Into<String>,

Start a new XMPP client

Start polling the returned instance so that it will connect and yield events.

impl<C> Client<C>

where C: ServerConnector,

pub fn new_with_config(config: Config<C>) -> Client<C>

Start a new client given that the JID is already parsed.

pub fn set_reconnect(&mut self, reconnect: bool) -> &mut Client<C>

Set whether to reconnect (true) or let the stream end (false) when a connection to the server has ended.

pub fn bound_jid(&self) -> Option<&Jid>

Get the client’s bound JID (the one reported by the XMPP server).

pub async fn send_stanza(&mut self, stanza: Element) -> Result<(), Error>

Send stanza

pub fn get_stream_features(&self) -> Option<&StreamFeatures>

Get the stream features (<stream:features/>) of the underlying stream

pub async fn send_end(&mut self) -> Result<(), Error>

End connection by sending </stream:stream>

You may expect the server to respond with the same. This client will then drop its connection.

Make sure to disable reconnect.

Trait Implementations

impl<C> Sink<Packet> for Client<C>

where C: ServerConnector,

Outgoing XMPP packets

See send_stanza() for an async fn

type Error = Error

The type of value produced by the sink when an error occurs.

fn start_send( self: Pin<&mut Client<C>>, item: Packet, ) -> Result<(), <Client<C> as Sink<Packet>>::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

fn poll_ready( self: Pin<&mut Client<C>>, cx: &mut Context<'_>, ) -> Poll<Result<(), <Client<C> as Sink<Packet>>::Error>>

Attempts to prepare the Sink to receive a value.

fn poll_flush( self: Pin<&mut Client<C>>, cx: &mut Context<'_>, ) -> Poll<Result<(), <Client<C> as Sink<Packet>>::Error>>

Flush any remaining output from this sink.

fn poll_close( self: Pin<&mut Client<C>>, cx: &mut Context<'_>, ) -> Poll<Result<(), <Client<C> as Sink<Packet>>::Error>>

Flush any remaining output and close this sink, if necessary.

impl<C> Stream for Client<C>

where C: ServerConnector,

Incoming XMPP events

In an async fn you may want to use this with use futures::stream::StreamExt;

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

Low-level read on the XMPP stream, allowing the underlying machinery to:

• connect,
• starttls,
• authenticate,
• bind a session, and finally
• receive stanzas

…for your client

type Item = Event

Values yielded by the stream.

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

Returns the bounds on the remaining length of the stream.