x11rb/connection/
impls.rs

Help
1//! Implement RequestConnection for wrappers around other connection types, e.g.
2//! `Box<Connection>`.
3
4use std::io::IoSlice;
5
6use x11rb_protocol::x11_utils::{ReplyFDsRequest, ReplyRequest, VoidRequest};
7use x11rb_protocol::{DiscardMode, RawEventAndSeqNumber, SequenceNumber};
8
9use crate::connection::{
10    BufWithFds, Connection, EventAndSeqNumber, ReplyOrError, RequestConnection, RequestKind,
11};
12use crate::cookie::{Cookie, CookieWithFds, VoidCookie};
13use crate::errors::{ConnectionError, ParseError, ReplyError, ReplyOrIdError};
14use crate::protocol::xproto::Setup;
15use crate::protocol::Event;
16use crate::utils::RawFdContainer;
17use crate::x11_utils::{ExtensionInformation, TryParse, TryParseFd, X11Error};
18
19macro_rules! impl_deref_request_connection_inner {
20    () => {
21        type Buf = C::Buf;
22
23        fn send_request_with_reply<R>(
24            &self,
25            bufs: &[IoSlice<'_>],
26            fds: Vec<RawFdContainer>,
27        ) -> Result<Cookie<'_, Self, R>, ConnectionError>
28        where
29            R: TryParse,
30        {
31            (**self)
32                .send_request_with_reply(bufs, fds)
33                .map(|cookie| cookie.replace_connection(self))
34        }
35
36        fn send_trait_request_with_reply<R>(
37            &self,
38            request: R,
39        ) -> Result<Cookie<'_, Self, <R as ReplyRequest>::Reply>, ConnectionError>
40        where
41            R: ReplyRequest,
42        {
43            (**self)
44                .send_trait_request_with_reply(request)
45                .map(|cookie| cookie.replace_connection(self))
46        }
47
48        fn send_request_with_reply_with_fds<R>(
49            &self,
50            bufs: &[IoSlice<'_>],
51            fds: Vec<RawFdContainer>,
52        ) -> Result<CookieWithFds<'_, Self, R>, ConnectionError>
53        where
54            R: TryParseFd,
55        {
56            (**self)
57                .send_request_with_reply_with_fds(bufs, fds)
58                .map(|cookie| cookie.replace_connection(self))
59        }
60
61        fn send_trait_request_with_reply_with_fds<R>(
62            &self,
63            request: R,
64        ) -> Result<CookieWithFds<'_, Self, R::Reply>, ConnectionError>
65        where
66            R: ReplyFDsRequest,
67        {
68            (**self)
69                .send_trait_request_with_reply_with_fds(request)
70                .map(|cookie| cookie.replace_connection(self))
71        }
72
73        fn send_request_without_reply(
74            &self,
75            bufs: &[IoSlice<'_>],
76            fds: Vec<RawFdContainer>,
77        ) -> Result<VoidCookie<'_, Self>, ConnectionError> {
78            (**self)
79                .send_request_without_reply(bufs, fds)
80                .map(|cookie| cookie.replace_connection(self))
81        }
82
83        fn send_trait_request_without_reply<R>(
84            &self,
85            request: R,
86        ) -> Result<VoidCookie<'_, Self>, ConnectionError>
87        where
88            R: VoidRequest,
89        {
90            (**self)
91                .send_trait_request_without_reply(request)
92                .map(|cookie| cookie.replace_connection(self))
93        }
94
95        fn discard_reply(&self, sequence: SequenceNumber, kind: RequestKind, mode: DiscardMode) {
96            (**self).discard_reply(sequence, kind, mode)
97        }
98
99        fn prefetch_extension_information(
100            &self,
101            extension_name: &'static str,
102        ) -> Result<(), ConnectionError> {
103            (**self).prefetch_extension_information(extension_name)
104        }
105
106        fn extension_information(
107            &self,
108            extension_name: &'static str,
109        ) -> Result<Option<ExtensionInformation>, ConnectionError> {
110            (**self).extension_information(extension_name)
111        }
112
113        fn wait_for_reply_or_error(
114            &self,
115            sequence: SequenceNumber,
116        ) -> Result<Self::Buf, ReplyError> {
117            (**self).wait_for_reply_or_error(sequence)
118        }
119
120        fn wait_for_reply_or_raw_error(
121            &self,
122            sequence: SequenceNumber,
123        ) -> Result<ReplyOrError<Self::Buf>, ConnectionError> {
124            (**self).wait_for_reply_or_raw_error(sequence)
125        }
126
127        fn wait_for_reply(
128            &self,
129            sequence: SequenceNumber,
130        ) -> Result<Option<Self::Buf>, ConnectionError> {
131            (**self).wait_for_reply(sequence)
132        }
133
134        fn wait_for_reply_with_fds(
135            &self,
136            sequence: SequenceNumber,
137        ) -> Result<BufWithFds<Self::Buf>, ReplyError> {
138            (**self).wait_for_reply_with_fds(sequence)
139        }
140
141        fn wait_for_reply_with_fds_raw(
142            &self,
143            sequence: SequenceNumber,
144        ) -> Result<ReplyOrError<BufWithFds<Self::Buf>, Self::Buf>, ConnectionError> {
145            (**self).wait_for_reply_with_fds_raw(sequence)
146        }
147
148        fn check_for_error(&self, sequence: SequenceNumber) -> Result<(), ReplyError> {
149            (**self).check_for_error(sequence)
150        }
151
152        fn check_for_raw_error(
153            &self,
154            sequence: SequenceNumber,
155        ) -> Result<Option<Self::Buf>, ConnectionError> {
156            (**self).check_for_raw_error(sequence)
157        }
158
159        fn prefetch_maximum_request_bytes(&self) {
160            (**self).prefetch_maximum_request_bytes()
161        }
162
163        fn maximum_request_bytes(&self) -> usize {
164            (**self).maximum_request_bytes()
165        }
166
167        fn parse_error(&self, error: &[u8]) -> Result<X11Error, ParseError> {
168            (**self).parse_error(error)
169        }
170
171        fn parse_event(&self, event: &[u8]) -> Result<Event, ParseError> {
172            (**self).parse_event(event)
173        }
174    };
175}
176
177macro_rules! impl_deref_connection_inner {
178    () => {
179        fn wait_for_event(&self) -> Result<Event, ConnectionError> {
180            (**self).wait_for_event()
181        }
182
183        fn wait_for_raw_event(&self) -> Result<Self::Buf, ConnectionError> {
184            (**self).wait_for_raw_event()
185        }
186
187        fn wait_for_event_with_sequence(&self) -> Result<EventAndSeqNumber, ConnectionError> {
188            (**self).wait_for_event_with_sequence()
189        }
190
191        fn wait_for_raw_event_with_sequence(
192            &self,
193        ) -> Result<RawEventAndSeqNumber<Self::Buf>, ConnectionError> {
194            (**self).wait_for_raw_event_with_sequence()
195        }
196
197        fn poll_for_event(&self) -> Result<Option<Event>, ConnectionError> {
198            (**self).poll_for_event()
199        }
200
201        fn poll_for_raw_event(&self) -> Result<Option<Self::Buf>, ConnectionError> {
202            (**self).poll_for_raw_event()
203        }
204
205        fn poll_for_event_with_sequence(
206            &self,
207        ) -> Result<Option<EventAndSeqNumber>, ConnectionError> {
208            (**self).poll_for_event_with_sequence()
209        }
210
211        fn poll_for_raw_event_with_sequence(
212            &self,
213        ) -> Result<Option<RawEventAndSeqNumber<Self::Buf>>, ConnectionError> {
214            (**self).poll_for_raw_event_with_sequence()
215        }
216
217        fn flush(&self) -> Result<(), ConnectionError> {
218            (**self).flush()
219        }
220
221        fn setup(&self) -> &Setup {
222            (**self).setup()
223        }
224
225        fn generate_id(&self) -> Result<u32, ReplyOrIdError> {
226            (**self).generate_id()
227        }
228    };
229}
230
231macro_rules! impl_deref_connection {
232    ($type:ty) => {
233        impl<C: RequestConnection + ?Sized> RequestConnection for $type {
234            impl_deref_request_connection_inner!();
235        }
236        impl<C: Connection + ?Sized> Connection for $type {
237            impl_deref_connection_inner!();
238        }
239    };
240}
241
242impl_deref_connection!(&C);
243impl_deref_connection!(&mut C);
244impl_deref_connection!(Box<C>);
245impl_deref_connection!(std::sync::Arc<C>);
246impl_deref_connection!(std::rc::Rc<C>);
247
248impl<C: RequestConnection + ToOwned + ?Sized> RequestConnection for std::borrow::Cow<'_, C> {
249    impl_deref_request_connection_inner!();
250}
251impl<C: Connection + ToOwned + ?Sized> Connection for std::borrow::Cow<'_, C> {
252    impl_deref_connection_inner!();
253}
x11rb/connection/impls.rs

x11rb/connection/
impls.rs
