Struct async_imap::extensions::idle::Handle

pub struct Handle<T: Read + Write + Unpin + Debug> { /* private fields */ }

Handle allows a client to block waiting for changes to the remote mailbox.

The handle blocks using the IDLE command specificed in RFC 2177 until the underlying server state changes in some way. While idling does inform the client what changes happened on the server, this implementation will currently just block until anything changes, and then notify the

Note that the server MAY consider a client inactive if it has an IDLE command running, and if such a server has an inactivity timeout it MAY log the client off implicitly at the end of its timeout period. Because of that, clients using IDLE are advised to terminate the IDLE and re-issue it at least every 29 minutes to avoid being logged off. Handle::wait does this. This still allows a client to receive immediate mailbox updates even though it need only “poll” at half hour intervals.

As long as a Handle is active, the mailbox cannot be otherwise accessed.

Implementations

impl<T: Read + Write + Unpin + Debug + Send> Handle<T>

pub fn wait( &mut self ) -> (impl Future<Output = Result<IdleResponse>> + '_, StopSource)

Start listening to the server side responses. Must be called after Handle::init.

pub fn wait_with_timeout( &mut self, dur: Duration ) -> (impl Future<Output = Result<IdleResponse>> + '_, StopSource)

Start listening to the server side responses.

Stops after the passed in timeout without any response from the server. Timeout is reset by any response, including * OK Still here keepalives.

Must be called after Handle::init.

pub async fn init(&mut self) -> Result<()>

Initialise the idle connection by sending the IDLE command to the server.

pub async fn done(self) -> Result<Session<T>>

Signal that we want to exit the idle connection, by sending the DONE command to the server.

Trait Implementations

impl<T: Read + Write + Unpin + Debug> AsMut<T> for Handle<T>

fn as_mut(&mut self) -> &mut T

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T: Debug + Read + Write + Unpin + Debug> Debug for Handle<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Read + Write + Unpin + Debug + Send> Stream for Handle<T>

type Item = Result<ResponseData, 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.

impl<T: Read + Write + Unpin + Debug> Unpin for Handle<T>