breadx 1.1.0

Implementation of the X Window System Protocol
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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

// MIT/Apache2 License

use super::{ResolveRequestRawFuture, SynchronizeFuture};
use crate::{
    display::{decode_reply, AsyncDisplay, PendingReply, RequestCookie},
    util::take_mut,
    Request,
};
use core::{
    future::Future,
    marker::PhantomData,
    mem,
    pin::Pin,
    task::{Context, Poll},
};
use futures_lite::prelude::*;

/// The future returned by `AsyncDisplayExt::resolve_request_async`.
#[derive(Debug)]
#[must_use = "futures do nothing unless you poll or .await them"]
pub enum ResolveRequestFuture<'a, D: ?Sized, R: Request> {
    /// We can fast-path to the answer, since we aren't checked.
    #[doc(hidden)]
    FastPath { display: &'a mut D },
    /// The reply type is zero sized, and the display is currently synchronizing.
    #[doc(hidden)]
    Synchronizing {
        sf: SynchronizeFuture<'a, D>,
        tok: RequestCookie<R>,
    },
    /// The reply type is not zero typed, so we are calling the raw function.
    #[doc(hidden)]
    Resolving {
        rrrf: ResolveRequestRawFuture<'a, D>,
    },
    /// We've completed.
    #[doc(hidden)]
    Complete { display: &'a mut D },
    #[doc(hidden)]
    Hole,
}

impl<'a, D: ?Sized, R: Request> Default for ResolveRequestFuture<'a, D, R> {
    #[inline]
    fn default() -> Self {
        Self::Hole
    }
}
impl<'a, D: ?Sized, R: Request> Unpin for ResolveRequestFuture<'a, D, R> {}

impl<'a, D: AsyncDisplay + ?Sized, R: Request> ResolveRequestFuture<'a, D, R> {
    #[inline]
    pub(crate) fn run(display: &'a mut D, tok: RequestCookie<R>) -> Self {
        log::info!(
            "Resolving for a {} from the server",
            core::any::type_name::<R>()
        );

        match (mem::size_of::<R::Reply>(), display.checked()) {
            (0, false) => ResolveRequestFuture::FastPath { display },
            (0, true) => ResolveRequestFuture::Synchronizing {
                sf: SynchronizeFuture::run(display),
                tok,
            },
            _ => ResolveRequestFuture::Resolving {
                rrrf: ResolveRequestRawFuture::run(display, tok.sequence()),
            },
        }
    }

    #[inline]
    pub(crate) fn cannibalize(self) -> &'a mut D {
        match self {
            ResolveRequestFuture::FastPath { display } => display,
            ResolveRequestFuture::Complete { display } => display,
            ResolveRequestFuture::Synchronizing { sf, .. } => sf.cannibalize(),
            ResolveRequestFuture::Resolving { rrrf } => rrrf.cannibalize(),
            ResolveRequestFuture::Hole => panic!("Cannot cannibalize an empty hole"),
        }
    }
}

impl<'a, D: AsyncDisplay + ?Sized, R: Request> Future for ResolveRequestFuture<'a, D, R>
where
    R::Reply: Default,
{
    type Output = crate::Result<R::Reply>;

    #[inline]
    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<crate::Result<R::Reply>> {
        let mut result = Poll::Pending;
        take_mut(&mut *self, |this| match this {
            ResolveRequestFuture::FastPath { display } => {
                result = Poll::Ready(Ok(R::Reply::default()));
                ResolveRequestFuture::Complete { display }
            }
            ResolveRequestFuture::Synchronizing { mut sf, tok } => match sf.poll(cx) {
                Poll::Pending => ResolveRequestFuture::Synchronizing { sf, tok },
                Poll::Ready(Err(e)) => {
                    result = Poll::Ready(Err(e));
                    ResolveRequestFuture::Complete {
                        display: sf.cannibalize(),
                    }
                }
                Poll::Ready(Ok(())) => {
                    let seq = tok.sequence();
                    let display = sf.cannibalize();
                    display.take_pending_request(seq);
                    result = match display.check_for_pending_error(seq) {
                        Ok(()) => Poll::Ready(Ok(R::Reply::default())),
                        Err(e) => Poll::Ready(Err(e)),
                    };

                    ResolveRequestFuture::Complete { display }
                }
            },
            ResolveRequestFuture::Resolving { mut rrrf } => match rrrf.poll(cx) {
                Poll::Pending => ResolveRequestFuture::Resolving { rrrf },
                Poll::Ready(Err(e)) => {
                    result = Poll::Ready(Err(e));
                    ResolveRequestFuture::Complete {
                        display: rrrf.cannibalize(),
                    }
                }
                Poll::Ready(Ok(PendingReply { data, fds })) => {
                    result = Poll::Ready(decode_reply::<R>(&data, fds));
                    ResolveRequestFuture::Complete {
                        display: rrrf.cannibalize(),
                    }
                }
            },
            ResolveRequestFuture::Complete { .. } => {
                panic!("Attempted to poll future past completion")
            }
            ResolveRequestFuture::Hole => panic!("Cannot pole an empty hole"),
        });
        result
    }
}