breadx 3.1.0

Pure-Rust X11 connection implementation with a focus on adaptability
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

//               Copyright John Nunley, 2022.
// Distributed under the Boost Software License, Version 1.0.
//       (See accompanying file LICENSE or copy at
//         https://www.boost.org/LICENSE_1_0.txt)

use super::TryWithDyn;
use crate::{
    display::{AsyncDisplay, AsyncDisplayExt, AsyncStatus, RawReply},
    Result,
};
use alloc::boxed::Box;
use core::{
    future::Future,
    pin::Pin,
    task::{Context, Poll},
};
use futures_util::FutureExt;

/// The future returned by the `wait_for_reply_raw` function.
pub struct WaitForReplyRaw<'this, Dpy: ?Sized> {
    innards: TryWithDyn<'this, RawReply, Dpy>,
}

type FnTy = Box<
    dyn FnMut(&mut dyn AsyncDisplay, &mut Context<'_>) -> Result<AsyncStatus<RawReply>>
        + Send
        + 'static,
>;

impl<'this, Dpy: AsyncDisplay + ?Sized> WaitForReplyRaw<'this, Dpy> {
    pub(crate) fn polling(display: &'this mut Dpy, seq: u64) -> Self {
        // setup the function
        let mut flushed = false;
        let func: FnTy = Box::new(move |display, ctx| {
            if !flushed {
                match display.try_flush(ctx) {
                    Ok(AsyncStatus::Ready(())) => {
                        flushed = true;
                    }
                    Ok(status) => {
                        return Ok(status.map(|()| unreachable!()));
                    }
                    Err(e) => {
                        return Err(e);
                    }
                }
            }

            display.try_wait_for_reply_raw(seq, ctx)
        });

        let try_with = display.try_with(func);

        Self { innards: try_with }
    }

    pub(crate) fn cannibalize(self) -> &'this mut Dpy {
        self.innards.cannibalize()
    }
}

impl<'this, Dpy: AsyncDisplay + ?Sized> Future for WaitForReplyRaw<'this, Dpy> {
    type Output = Result<RawReply>;

    fn poll(self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<Result<RawReply>> {
        let this = self.get_mut();

        this.innards.poll_unpin(ctx)
    }
}