Trait breadx::display::AsyncDisplayExt[−][src]

pub trait AsyncDisplayExt: AsyncDisplay {
    fn wait_async(&mut self) -> WaitFuture<'_, Self>ⓘ
Notable traits for WaitFuture<'a, D>
impl<'a, D: AsyncDisplay + ?Sized> Future for WaitFuture<'a, D>    type Output = Result;
;

    fn send_request_raw_async(
        &mut self, 
        req: RequestInfo
    ) -> SendRequestRawFuture<'_, Self>ⓘ
Notable traits for SendRequestRawFuture<'a, D>
impl<'a, D: AsyncDisplay + ?Sized> Future for SendRequestRawFuture<'a, D>    type Output = Result<u16>;
;

    fn send_request_async<R: Request>(
        &mut self, 
        request: R
    ) -> SendRequestFuture<'_, Self, R>ⓘ
Notable traits for SendRequestFuture<'a, D, R>
impl<'a, D: AsyncDisplay + ?Sized, R: Request + Unpin> Future for SendRequestFuture<'a, D, R>    type Output = Result<RequestCookie<R>>;
;

    fn resolve_request_async<R: Request>(
        &mut self, 
        token: RequestCookie<R>
    ) -> ResolveRequestFuture<'_, Self, R>ⓘ
Notable traits for ResolveRequestFuture<'a, D, R>
impl<'a, D: AsyncDisplay + ?Sized, R: Request> Future for ResolveRequestFuture<'a, D, R> where
    R::Reply: Default,     type Output = Result<R::Reply>;

    where
        R::Reply: Default;

    fn synchronize_async(&mut self) -> SynchronizeFuture<'_, Self>ⓘ
Notable traits for SynchronizeFuture<'a, D>
impl<'a, D: AsyncDisplay + ?Sized> Future for SynchronizeFuture<'a, D>    type Output = Result;
;

    fn resolve_request_raw_async(
        &mut self, 
        req_id: u16
    ) -> ResolveRequestRawFuture<'_, Self>;

    fn wait_for_event_async(&mut self) -> WaitForEventFuture<'_, Self>;

    fn wait_for_special_event_async(
        &mut self, 
        xid: XID
    ) -> WaitForSpecialEventFuture<'_, Self>;

    fn exchange_request_async<R: Request>(
        &mut self, 
        request: R
    ) -> ExchangeRequestFuture<'_, Self, R>ⓘ
Notable traits for ExchangeRequestFuture<'a, D, R>
impl<'a, D: AsyncDisplay + ?Sized, R: Request + Unpin + 'a> Future for ExchangeRequestFuture<'a, D, R> where
    R::Reply: Default + Unpin,     type Output = Result<R::Reply>;
;

    fn exchange_xid_async<R: Request, U: XidType + Unpin, F: FnOnce(U) -> R>(
        &mut self, 
        to_request: F
    ) -> ExchangeXidFuture<'_, Self, R, U, F>ⓘ
Notable traits for ExchangeXidFuture<'a, D, R, U, F>
impl<'a, D: AsyncDisplay + ?Sized, R: Request + Unpin + 'a, U: XidType + Unpin, F: FnOnce(U) -> R + Unpin> Future for ExchangeXidFuture<'a, D, R, U, F> where
    R::Reply: Default + Unpin,     type Output = Result<U>;
;
}
Expand description

Monomorphized methods we can’t put into the AsyncDisplay trait proper.

Required methods

Wait until we recieve data.

This future is essentially a wrapper around the poll_wait function, and is the asynchronous equivalent to the Display::wait function. See that function for more information on what this future is expected to return.

Send a raw request to the server.

This future is essentially a wrapper around the begin_send_request_raw and poll_send_request_raw functions, and is the asynchronous equivalent to the Display::send_request_raw function. See that function for more information on what it is expected to do and return.

Send a request to the server. This is the async equivalent of the DisplayExt::send_request function. See that function for more information on what this is expected to do.

Resolve a request that we sent to the server. This is the async equivalent of the DisplayExt::resolve_request function. See that function for more information on what this is expected to do.

Synchronize this display so that every request that has been sent is resolved. This is the async equivalent of the Display::synchronize function. See that function for more information on what this is expected to do.

Resolve for a raw request. This is the async equivalent of the Display::resolve_request_raw function. See that function for more information on what this is expected to do.

Wait for an event to be sent from the X server. This is the async equivalent of the Display::wait_for_event function. See that function for more information on what this is expected to do.

Wait for a special event to be sent from the X server. This is the async equivalent of the Display::wait_for_special_event function. See that function for more information on what this is expected to do.

Send a request and wait for a reply back. This is the async equivalent of the DisplayExt::exchange_request function. See that function for more information on what this is expected to do.

Send a no-op request to the server, but resolve for an XID. This is similar to exchange_request_async, but generates an XID before beginning the request send. This is largely a convenience wrapper.

Implementors