x11rb_protocol/protocol/
record.rs

1// This file contains generated code. Do not edit directly.
2// To regenerate this, run 'make'.
3
4//! Bindings to the `Record` X11 extension.
5
6#![allow(clippy::too_many_arguments)]
7// The code generator is simpler if it can always use conversions
8#![allow(clippy::useless_conversion)]
9
10#[allow(unused_imports)]
11use alloc::borrow::Cow;
12#[allow(unused_imports)]
13use core::convert::TryInto;
14use alloc::vec;
15use alloc::vec::Vec;
16use core::convert::TryFrom;
17use crate::errors::ParseError;
18#[allow(unused_imports)]
19use crate::x11_utils::TryIntoUSize;
20use crate::BufWithFds;
21#[allow(unused_imports)]
22use crate::utils::{RawFdContainer, pretty_print_bitmask, pretty_print_enum};
23#[allow(unused_imports)]
24use crate::x11_utils::{Request, RequestHeader, Serialize, TryParse, TryParseFd};
25
26/// The X11 name of the extension for QueryExtension
27pub const X11_EXTENSION_NAME: &str = "RECORD";
28
29/// The version number of this extension that this client library supports.
30///
31/// This constant contains the version number of this extension that is supported
32/// by this build of x11rb. For most things, it does not make sense to use this
33/// information. If you need to send a `QueryVersion`, it is recommended to instead
34/// send the maximum version of the extension that you need.
35pub const X11_XML_VERSION: (u32, u32) = (1, 13);
36
37pub type Context = u32;
38
39#[derive(Clone, Copy, Default)]
40#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
41#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
42pub struct Range8 {
43    pub first: u8,
44    pub last: u8,
45}
46impl_debug_if_no_extra_traits!(Range8, "Range8");
47impl TryParse for Range8 {
48    fn try_parse(remaining: &[u8]) -> Result<(Self, &[u8]), ParseError> {
49        let (first, remaining) = u8::try_parse(remaining)?;
50        let (last, remaining) = u8::try_parse(remaining)?;
51        let result = Range8 { first, last };
52        Ok((result, remaining))
53    }
54}
55impl Serialize for Range8 {
56    type Bytes = [u8; 2];
57    fn serialize(&self) -> [u8; 2] {
58        let first_bytes = self.first.serialize();
59        let last_bytes = self.last.serialize();
60        [
61            first_bytes[0],
62            last_bytes[0],
63        ]
64    }
65    fn serialize_into(&self, bytes: &mut Vec<u8>) {
66        bytes.reserve(2);
67        self.first.serialize_into(bytes);
68        self.last.serialize_into(bytes);
69    }
70}
71
72#[derive(Clone, Copy, Default)]
73#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
74#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
75pub struct Range16 {
76    pub first: u16,
77    pub last: u16,
78}
79impl_debug_if_no_extra_traits!(Range16, "Range16");
80impl TryParse for Range16 {
81    fn try_parse(remaining: &[u8]) -> Result<(Self, &[u8]), ParseError> {
82        let (first, remaining) = u16::try_parse(remaining)?;
83        let (last, remaining) = u16::try_parse(remaining)?;
84        let result = Range16 { first, last };
85        Ok((result, remaining))
86    }
87}
88impl Serialize for Range16 {
89    type Bytes = [u8; 4];
90    fn serialize(&self) -> [u8; 4] {
91        let first_bytes = self.first.serialize();
92        let last_bytes = self.last.serialize();
93        [
94            first_bytes[0],
95            first_bytes[1],
96            last_bytes[0],
97            last_bytes[1],
98        ]
99    }
100    fn serialize_into(&self, bytes: &mut Vec<u8>) {
101        bytes.reserve(4);
102        self.first.serialize_into(bytes);
103        self.last.serialize_into(bytes);
104    }
105}
106
107#[derive(Clone, Copy, Default)]
108#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
109#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
110pub struct ExtRange {
111    pub major: Range8,
112    pub minor: Range16,
113}
114impl_debug_if_no_extra_traits!(ExtRange, "ExtRange");
115impl TryParse for ExtRange {
116    fn try_parse(remaining: &[u8]) -> Result<(Self, &[u8]), ParseError> {
117        let (major, remaining) = Range8::try_parse(remaining)?;
118        let (minor, remaining) = Range16::try_parse(remaining)?;
119        let result = ExtRange { major, minor };
120        Ok((result, remaining))
121    }
122}
123impl Serialize for ExtRange {
124    type Bytes = [u8; 6];
125    fn serialize(&self) -> [u8; 6] {
126        let major_bytes = self.major.serialize();
127        let minor_bytes = self.minor.serialize();
128        [
129            major_bytes[0],
130            major_bytes[1],
131            minor_bytes[0],
132            minor_bytes[1],
133            minor_bytes[2],
134            minor_bytes[3],
135        ]
136    }
137    fn serialize_into(&self, bytes: &mut Vec<u8>) {
138        bytes.reserve(6);
139        self.major.serialize_into(bytes);
140        self.minor.serialize_into(bytes);
141    }
142}
143
144#[derive(Clone, Copy, Default)]
145#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
146#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
147pub struct Range {
148    pub core_requests: Range8,
149    pub core_replies: Range8,
150    pub ext_requests: ExtRange,
151    pub ext_replies: ExtRange,
152    pub delivered_events: Range8,
153    pub device_events: Range8,
154    pub errors: Range8,
155    pub client_started: bool,
156    pub client_died: bool,
157}
158impl_debug_if_no_extra_traits!(Range, "Range");
159impl TryParse for Range {
160    fn try_parse(remaining: &[u8]) -> Result<(Self, &[u8]), ParseError> {
161        let (core_requests, remaining) = Range8::try_parse(remaining)?;
162        let (core_replies, remaining) = Range8::try_parse(remaining)?;
163        let (ext_requests, remaining) = ExtRange::try_parse(remaining)?;
164        let (ext_replies, remaining) = ExtRange::try_parse(remaining)?;
165        let (delivered_events, remaining) = Range8::try_parse(remaining)?;
166        let (device_events, remaining) = Range8::try_parse(remaining)?;
167        let (errors, remaining) = Range8::try_parse(remaining)?;
168        let (client_started, remaining) = bool::try_parse(remaining)?;
169        let (client_died, remaining) = bool::try_parse(remaining)?;
170        let result = Range { core_requests, core_replies, ext_requests, ext_replies, delivered_events, device_events, errors, client_started, client_died };
171        Ok((result, remaining))
172    }
173}
174impl Serialize for Range {
175    type Bytes = [u8; 24];
176    fn serialize(&self) -> [u8; 24] {
177        let core_requests_bytes = self.core_requests.serialize();
178        let core_replies_bytes = self.core_replies.serialize();
179        let ext_requests_bytes = self.ext_requests.serialize();
180        let ext_replies_bytes = self.ext_replies.serialize();
181        let delivered_events_bytes = self.delivered_events.serialize();
182        let device_events_bytes = self.device_events.serialize();
183        let errors_bytes = self.errors.serialize();
184        let client_started_bytes = self.client_started.serialize();
185        let client_died_bytes = self.client_died.serialize();
186        [
187            core_requests_bytes[0],
188            core_requests_bytes[1],
189            core_replies_bytes[0],
190            core_replies_bytes[1],
191            ext_requests_bytes[0],
192            ext_requests_bytes[1],
193            ext_requests_bytes[2],
194            ext_requests_bytes[3],
195            ext_requests_bytes[4],
196            ext_requests_bytes[5],
197            ext_replies_bytes[0],
198            ext_replies_bytes[1],
199            ext_replies_bytes[2],
200            ext_replies_bytes[3],
201            ext_replies_bytes[4],
202            ext_replies_bytes[5],
203            delivered_events_bytes[0],
204            delivered_events_bytes[1],
205            device_events_bytes[0],
206            device_events_bytes[1],
207            errors_bytes[0],
208            errors_bytes[1],
209            client_started_bytes[0],
210            client_died_bytes[0],
211        ]
212    }
213    fn serialize_into(&self, bytes: &mut Vec<u8>) {
214        bytes.reserve(24);
215        self.core_requests.serialize_into(bytes);
216        self.core_replies.serialize_into(bytes);
217        self.ext_requests.serialize_into(bytes);
218        self.ext_replies.serialize_into(bytes);
219        self.delivered_events.serialize_into(bytes);
220        self.device_events.serialize_into(bytes);
221        self.errors.serialize_into(bytes);
222        self.client_started.serialize_into(bytes);
223        self.client_died.serialize_into(bytes);
224    }
225}
226
227pub type ElementHeader = u8;
228
229#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
230#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
231pub struct HType(u8);
232impl HType {
233    pub const FROM_SERVER_TIME: Self = Self(1 << 0);
234    pub const FROM_CLIENT_TIME: Self = Self(1 << 1);
235    pub const FROM_CLIENT_SEQUENCE: Self = Self(1 << 2);
236}
237impl From<HType> for u8 {
238    #[inline]
239    fn from(input: HType) -> Self {
240        input.0
241    }
242}
243impl From<HType> for Option<u8> {
244    #[inline]
245    fn from(input: HType) -> Self {
246        Some(input.0)
247    }
248}
249impl From<HType> for u16 {
250    #[inline]
251    fn from(input: HType) -> Self {
252        u16::from(input.0)
253    }
254}
255impl From<HType> for Option<u16> {
256    #[inline]
257    fn from(input: HType) -> Self {
258        Some(u16::from(input.0))
259    }
260}
261impl From<HType> for u32 {
262    #[inline]
263    fn from(input: HType) -> Self {
264        u32::from(input.0)
265    }
266}
267impl From<HType> for Option<u32> {
268    #[inline]
269    fn from(input: HType) -> Self {
270        Some(u32::from(input.0))
271    }
272}
273impl From<u8> for HType {
274    #[inline]
275    fn from(value: u8) -> Self {
276        Self(value)
277    }
278}
279impl core::fmt::Debug for HType  {
280    fn fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
281        let variants = [
282            (Self::FROM_SERVER_TIME.0.into(), "FROM_SERVER_TIME", "FromServerTime"),
283            (Self::FROM_CLIENT_TIME.0.into(), "FROM_CLIENT_TIME", "FromClientTime"),
284            (Self::FROM_CLIENT_SEQUENCE.0.into(), "FROM_CLIENT_SEQUENCE", "FromClientSequence"),
285        ];
286        pretty_print_bitmask(fmt, self.0.into(), &variants)
287    }
288}
289bitmask_binop!(HType, u8);
290
291pub type ClientSpec = u32;
292
293#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
294#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
295pub struct CS(u8);
296impl CS {
297    pub const CURRENT_CLIENTS: Self = Self(1);
298    pub const FUTURE_CLIENTS: Self = Self(2);
299    pub const ALL_CLIENTS: Self = Self(3);
300}
301impl From<CS> for u8 {
302    #[inline]
303    fn from(input: CS) -> Self {
304        input.0
305    }
306}
307impl From<CS> for Option<u8> {
308    #[inline]
309    fn from(input: CS) -> Self {
310        Some(input.0)
311    }
312}
313impl From<CS> for u16 {
314    #[inline]
315    fn from(input: CS) -> Self {
316        u16::from(input.0)
317    }
318}
319impl From<CS> for Option<u16> {
320    #[inline]
321    fn from(input: CS) -> Self {
322        Some(u16::from(input.0))
323    }
324}
325impl From<CS> for u32 {
326    #[inline]
327    fn from(input: CS) -> Self {
328        u32::from(input.0)
329    }
330}
331impl From<CS> for Option<u32> {
332    #[inline]
333    fn from(input: CS) -> Self {
334        Some(u32::from(input.0))
335    }
336}
337impl From<u8> for CS {
338    #[inline]
339    fn from(value: u8) -> Self {
340        Self(value)
341    }
342}
343impl core::fmt::Debug for CS  {
344    fn fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
345        let variants = [
346            (Self::CURRENT_CLIENTS.0.into(), "CURRENT_CLIENTS", "CurrentClients"),
347            (Self::FUTURE_CLIENTS.0.into(), "FUTURE_CLIENTS", "FutureClients"),
348            (Self::ALL_CLIENTS.0.into(), "ALL_CLIENTS", "AllClients"),
349        ];
350        pretty_print_enum(fmt, self.0.into(), &variants)
351    }
352}
353
354#[derive(Clone, Default)]
355#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
356#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
357pub struct ClientInfo {
358    pub client_resource: ClientSpec,
359    pub ranges: Vec<Range>,
360}
361impl_debug_if_no_extra_traits!(ClientInfo, "ClientInfo");
362impl TryParse for ClientInfo {
363    fn try_parse(remaining: &[u8]) -> Result<(Self, &[u8]), ParseError> {
364        let (client_resource, remaining) = ClientSpec::try_parse(remaining)?;
365        let (num_ranges, remaining) = u32::try_parse(remaining)?;
366        let (ranges, remaining) = crate::x11_utils::parse_list::<Range>(remaining, num_ranges.try_to_usize()?)?;
367        let result = ClientInfo { client_resource, ranges };
368        Ok((result, remaining))
369    }
370}
371impl Serialize for ClientInfo {
372    type Bytes = Vec<u8>;
373    fn serialize(&self) -> Vec<u8> {
374        let mut result = Vec::new();
375        self.serialize_into(&mut result);
376        result
377    }
378    fn serialize_into(&self, bytes: &mut Vec<u8>) {
379        bytes.reserve(8);
380        self.client_resource.serialize_into(bytes);
381        let num_ranges = u32::try_from(self.ranges.len()).expect("`ranges` has too many elements");
382        num_ranges.serialize_into(bytes);
383        self.ranges.serialize_into(bytes);
384    }
385}
386impl ClientInfo {
387    /// Get the value of the `num_ranges` field.
388    ///
389    /// The `num_ranges` field is used as the length field of the `ranges` field.
390    /// This function computes the field's value again based on the length of the list.
391    ///
392    /// # Panics
393    ///
394    /// Panics if the value cannot be represented in the target type. This
395    /// cannot happen with values of the struct received from the X11 server.
396    pub fn num_ranges(&self) -> u32 {
397        self.ranges.len()
398            .try_into().unwrap()
399    }
400}
401
402/// Opcode for the BadContext error
403pub const BAD_CONTEXT_ERROR: u8 = 0;
404
405/// Opcode for the QueryVersion request
406pub const QUERY_VERSION_REQUEST: u8 = 0;
407#[derive(Clone, Copy, Default)]
408#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
409#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
410pub struct QueryVersionRequest {
411    pub major_version: u16,
412    pub minor_version: u16,
413}
414impl_debug_if_no_extra_traits!(QueryVersionRequest, "QueryVersionRequest");
415impl QueryVersionRequest {
416    /// Serialize this request into bytes for the provided connection
417    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
418        let length_so_far = 0;
419        let major_version_bytes = self.major_version.serialize();
420        let minor_version_bytes = self.minor_version.serialize();
421        let mut request0 = vec![
422            major_opcode,
423            QUERY_VERSION_REQUEST,
424            0,
425            0,
426            major_version_bytes[0],
427            major_version_bytes[1],
428            minor_version_bytes[0],
429            minor_version_bytes[1],
430        ];
431        let length_so_far = length_so_far + request0.len();
432        assert_eq!(length_so_far % 4, 0);
433        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
434        request0[2..4].copy_from_slice(&length.to_ne_bytes());
435        ([request0.into()], vec![])
436    }
437    /// Parse this request given its header, its body, and any fds that go along with it
438    #[cfg(feature = "request-parsing")]
439    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
440        if header.minor_opcode != QUERY_VERSION_REQUEST {
441            return Err(ParseError::InvalidValue);
442        }
443        let (major_version, remaining) = u16::try_parse(value)?;
444        let (minor_version, remaining) = u16::try_parse(remaining)?;
445        let _ = remaining;
446        Ok(QueryVersionRequest {
447            major_version,
448            minor_version,
449        })
450    }
451}
452impl Request for QueryVersionRequest {
453    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
454
455    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
456        let (bufs, fds) = self.serialize(major_opcode);
457        // Flatten the buffers into a single vector
458        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
459        (buf, fds)
460    }
461}
462impl crate::x11_utils::ReplyRequest for QueryVersionRequest {
463    type Reply = QueryVersionReply;
464}
465
466#[derive(Clone, Copy, Default)]
467#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
468#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
469pub struct QueryVersionReply {
470    pub sequence: u16,
471    pub length: u32,
472    pub major_version: u16,
473    pub minor_version: u16,
474}
475impl_debug_if_no_extra_traits!(QueryVersionReply, "QueryVersionReply");
476impl TryParse for QueryVersionReply {
477    fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
478        let remaining = initial_value;
479        let (response_type, remaining) = u8::try_parse(remaining)?;
480        let remaining = remaining.get(1..).ok_or(ParseError::InsufficientData)?;
481        let (sequence, remaining) = u16::try_parse(remaining)?;
482        let (length, remaining) = u32::try_parse(remaining)?;
483        let (major_version, remaining) = u16::try_parse(remaining)?;
484        let (minor_version, remaining) = u16::try_parse(remaining)?;
485        if response_type != 1 {
486            return Err(ParseError::InvalidValue);
487        }
488        let result = QueryVersionReply { sequence, length, major_version, minor_version };
489        let _ = remaining;
490        let remaining = initial_value.get(32 + length as usize * 4..)
491            .ok_or(ParseError::InsufficientData)?;
492        Ok((result, remaining))
493    }
494}
495impl Serialize for QueryVersionReply {
496    type Bytes = [u8; 12];
497    fn serialize(&self) -> [u8; 12] {
498        let response_type_bytes = &[1];
499        let sequence_bytes = self.sequence.serialize();
500        let length_bytes = self.length.serialize();
501        let major_version_bytes = self.major_version.serialize();
502        let minor_version_bytes = self.minor_version.serialize();
503        [
504            response_type_bytes[0],
505            0,
506            sequence_bytes[0],
507            sequence_bytes[1],
508            length_bytes[0],
509            length_bytes[1],
510            length_bytes[2],
511            length_bytes[3],
512            major_version_bytes[0],
513            major_version_bytes[1],
514            minor_version_bytes[0],
515            minor_version_bytes[1],
516        ]
517    }
518    fn serialize_into(&self, bytes: &mut Vec<u8>) {
519        bytes.reserve(12);
520        let response_type_bytes = &[1];
521        bytes.push(response_type_bytes[0]);
522        bytes.extend_from_slice(&[0; 1]);
523        self.sequence.serialize_into(bytes);
524        self.length.serialize_into(bytes);
525        self.major_version.serialize_into(bytes);
526        self.minor_version.serialize_into(bytes);
527    }
528}
529
530/// Opcode for the CreateContext request
531pub const CREATE_CONTEXT_REQUEST: u8 = 1;
532#[derive(Clone, Default)]
533#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
534#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
535pub struct CreateContextRequest<'input> {
536    pub context: Context,
537    pub element_header: ElementHeader,
538    pub client_specs: Cow<'input, [ClientSpec]>,
539    pub ranges: Cow<'input, [Range]>,
540}
541impl_debug_if_no_extra_traits!(CreateContextRequest<'_>, "CreateContextRequest");
542impl<'input> CreateContextRequest<'input> {
543    /// Serialize this request into bytes for the provided connection
544    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'input, [u8]>; 4]> {
545        let length_so_far = 0;
546        let context_bytes = self.context.serialize();
547        let element_header_bytes = self.element_header.serialize();
548        let num_client_specs = u32::try_from(self.client_specs.len()).expect("`client_specs` has too many elements");
549        let num_client_specs_bytes = num_client_specs.serialize();
550        let num_ranges = u32::try_from(self.ranges.len()).expect("`ranges` has too many elements");
551        let num_ranges_bytes = num_ranges.serialize();
552        let mut request0 = vec![
553            major_opcode,
554            CREATE_CONTEXT_REQUEST,
555            0,
556            0,
557            context_bytes[0],
558            context_bytes[1],
559            context_bytes[2],
560            context_bytes[3],
561            element_header_bytes[0],
562            0,
563            0,
564            0,
565            num_client_specs_bytes[0],
566            num_client_specs_bytes[1],
567            num_client_specs_bytes[2],
568            num_client_specs_bytes[3],
569            num_ranges_bytes[0],
570            num_ranges_bytes[1],
571            num_ranges_bytes[2],
572            num_ranges_bytes[3],
573        ];
574        let length_so_far = length_so_far + request0.len();
575        let client_specs_bytes = self.client_specs.serialize();
576        let length_so_far = length_so_far + client_specs_bytes.len();
577        let ranges_bytes = self.ranges.serialize();
578        let length_so_far = length_so_far + ranges_bytes.len();
579        let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4];
580        let length_so_far = length_so_far + padding0.len();
581        assert_eq!(length_so_far % 4, 0);
582        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
583        request0[2..4].copy_from_slice(&length.to_ne_bytes());
584        ([request0.into(), client_specs_bytes.into(), ranges_bytes.into(), padding0.into()], vec![])
585    }
586    /// Parse this request given its header, its body, and any fds that go along with it
587    #[cfg(feature = "request-parsing")]
588    pub fn try_parse_request(header: RequestHeader, value: &'input [u8]) -> Result<Self, ParseError> {
589        if header.minor_opcode != CREATE_CONTEXT_REQUEST {
590            return Err(ParseError::InvalidValue);
591        }
592        let (context, remaining) = Context::try_parse(value)?;
593        let (element_header, remaining) = ElementHeader::try_parse(remaining)?;
594        let remaining = remaining.get(3..).ok_or(ParseError::InsufficientData)?;
595        let (num_client_specs, remaining) = u32::try_parse(remaining)?;
596        let (num_ranges, remaining) = u32::try_parse(remaining)?;
597        let (client_specs, remaining) = crate::x11_utils::parse_list::<ClientSpec>(remaining, num_client_specs.try_to_usize()?)?;
598        let (ranges, remaining) = crate::x11_utils::parse_list::<Range>(remaining, num_ranges.try_to_usize()?)?;
599        let _ = remaining;
600        Ok(CreateContextRequest {
601            context,
602            element_header,
603            client_specs: Cow::Owned(client_specs),
604            ranges: Cow::Owned(ranges),
605        })
606    }
607    /// Clone all borrowed data in this CreateContextRequest.
608    pub fn into_owned(self) -> CreateContextRequest<'static> {
609        CreateContextRequest {
610            context: self.context,
611            element_header: self.element_header,
612            client_specs: Cow::Owned(self.client_specs.into_owned()),
613            ranges: Cow::Owned(self.ranges.into_owned()),
614        }
615    }
616}
617impl<'input> Request for CreateContextRequest<'input> {
618    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
619
620    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
621        let (bufs, fds) = self.serialize(major_opcode);
622        // Flatten the buffers into a single vector
623        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
624        (buf, fds)
625    }
626}
627impl<'input> crate::x11_utils::VoidRequest for CreateContextRequest<'input> {
628}
629
630/// Opcode for the RegisterClients request
631pub const REGISTER_CLIENTS_REQUEST: u8 = 2;
632#[derive(Clone, Default)]
633#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
634#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
635pub struct RegisterClientsRequest<'input> {
636    pub context: Context,
637    pub element_header: ElementHeader,
638    pub client_specs: Cow<'input, [ClientSpec]>,
639    pub ranges: Cow<'input, [Range]>,
640}
641impl_debug_if_no_extra_traits!(RegisterClientsRequest<'_>, "RegisterClientsRequest");
642impl<'input> RegisterClientsRequest<'input> {
643    /// Serialize this request into bytes for the provided connection
644    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'input, [u8]>; 4]> {
645        let length_so_far = 0;
646        let context_bytes = self.context.serialize();
647        let element_header_bytes = self.element_header.serialize();
648        let num_client_specs = u32::try_from(self.client_specs.len()).expect("`client_specs` has too many elements");
649        let num_client_specs_bytes = num_client_specs.serialize();
650        let num_ranges = u32::try_from(self.ranges.len()).expect("`ranges` has too many elements");
651        let num_ranges_bytes = num_ranges.serialize();
652        let mut request0 = vec![
653            major_opcode,
654            REGISTER_CLIENTS_REQUEST,
655            0,
656            0,
657            context_bytes[0],
658            context_bytes[1],
659            context_bytes[2],
660            context_bytes[3],
661            element_header_bytes[0],
662            0,
663            0,
664            0,
665            num_client_specs_bytes[0],
666            num_client_specs_bytes[1],
667            num_client_specs_bytes[2],
668            num_client_specs_bytes[3],
669            num_ranges_bytes[0],
670            num_ranges_bytes[1],
671            num_ranges_bytes[2],
672            num_ranges_bytes[3],
673        ];
674        let length_so_far = length_so_far + request0.len();
675        let client_specs_bytes = self.client_specs.serialize();
676        let length_so_far = length_so_far + client_specs_bytes.len();
677        let ranges_bytes = self.ranges.serialize();
678        let length_so_far = length_so_far + ranges_bytes.len();
679        let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4];
680        let length_so_far = length_so_far + padding0.len();
681        assert_eq!(length_so_far % 4, 0);
682        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
683        request0[2..4].copy_from_slice(&length.to_ne_bytes());
684        ([request0.into(), client_specs_bytes.into(), ranges_bytes.into(), padding0.into()], vec![])
685    }
686    /// Parse this request given its header, its body, and any fds that go along with it
687    #[cfg(feature = "request-parsing")]
688    pub fn try_parse_request(header: RequestHeader, value: &'input [u8]) -> Result<Self, ParseError> {
689        if header.minor_opcode != REGISTER_CLIENTS_REQUEST {
690            return Err(ParseError::InvalidValue);
691        }
692        let (context, remaining) = Context::try_parse(value)?;
693        let (element_header, remaining) = ElementHeader::try_parse(remaining)?;
694        let remaining = remaining.get(3..).ok_or(ParseError::InsufficientData)?;
695        let (num_client_specs, remaining) = u32::try_parse(remaining)?;
696        let (num_ranges, remaining) = u32::try_parse(remaining)?;
697        let (client_specs, remaining) = crate::x11_utils::parse_list::<ClientSpec>(remaining, num_client_specs.try_to_usize()?)?;
698        let (ranges, remaining) = crate::x11_utils::parse_list::<Range>(remaining, num_ranges.try_to_usize()?)?;
699        let _ = remaining;
700        Ok(RegisterClientsRequest {
701            context,
702            element_header,
703            client_specs: Cow::Owned(client_specs),
704            ranges: Cow::Owned(ranges),
705        })
706    }
707    /// Clone all borrowed data in this RegisterClientsRequest.
708    pub fn into_owned(self) -> RegisterClientsRequest<'static> {
709        RegisterClientsRequest {
710            context: self.context,
711            element_header: self.element_header,
712            client_specs: Cow::Owned(self.client_specs.into_owned()),
713            ranges: Cow::Owned(self.ranges.into_owned()),
714        }
715    }
716}
717impl<'input> Request for RegisterClientsRequest<'input> {
718    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
719
720    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
721        let (bufs, fds) = self.serialize(major_opcode);
722        // Flatten the buffers into a single vector
723        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
724        (buf, fds)
725    }
726}
727impl<'input> crate::x11_utils::VoidRequest for RegisterClientsRequest<'input> {
728}
729
730/// Opcode for the UnregisterClients request
731pub const UNREGISTER_CLIENTS_REQUEST: u8 = 3;
732#[derive(Clone, Default)]
733#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
734#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
735pub struct UnregisterClientsRequest<'input> {
736    pub context: Context,
737    pub client_specs: Cow<'input, [ClientSpec]>,
738}
739impl_debug_if_no_extra_traits!(UnregisterClientsRequest<'_>, "UnregisterClientsRequest");
740impl<'input> UnregisterClientsRequest<'input> {
741    /// Serialize this request into bytes for the provided connection
742    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'input, [u8]>; 3]> {
743        let length_so_far = 0;
744        let context_bytes = self.context.serialize();
745        let num_client_specs = u32::try_from(self.client_specs.len()).expect("`client_specs` has too many elements");
746        let num_client_specs_bytes = num_client_specs.serialize();
747        let mut request0 = vec![
748            major_opcode,
749            UNREGISTER_CLIENTS_REQUEST,
750            0,
751            0,
752            context_bytes[0],
753            context_bytes[1],
754            context_bytes[2],
755            context_bytes[3],
756            num_client_specs_bytes[0],
757            num_client_specs_bytes[1],
758            num_client_specs_bytes[2],
759            num_client_specs_bytes[3],
760        ];
761        let length_so_far = length_so_far + request0.len();
762        let client_specs_bytes = self.client_specs.serialize();
763        let length_so_far = length_so_far + client_specs_bytes.len();
764        let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4];
765        let length_so_far = length_so_far + padding0.len();
766        assert_eq!(length_so_far % 4, 0);
767        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
768        request0[2..4].copy_from_slice(&length.to_ne_bytes());
769        ([request0.into(), client_specs_bytes.into(), padding0.into()], vec![])
770    }
771    /// Parse this request given its header, its body, and any fds that go along with it
772    #[cfg(feature = "request-parsing")]
773    pub fn try_parse_request(header: RequestHeader, value: &'input [u8]) -> Result<Self, ParseError> {
774        if header.minor_opcode != UNREGISTER_CLIENTS_REQUEST {
775            return Err(ParseError::InvalidValue);
776        }
777        let (context, remaining) = Context::try_parse(value)?;
778        let (num_client_specs, remaining) = u32::try_parse(remaining)?;
779        let (client_specs, remaining) = crate::x11_utils::parse_list::<ClientSpec>(remaining, num_client_specs.try_to_usize()?)?;
780        let _ = remaining;
781        Ok(UnregisterClientsRequest {
782            context,
783            client_specs: Cow::Owned(client_specs),
784        })
785    }
786    /// Clone all borrowed data in this UnregisterClientsRequest.
787    pub fn into_owned(self) -> UnregisterClientsRequest<'static> {
788        UnregisterClientsRequest {
789            context: self.context,
790            client_specs: Cow::Owned(self.client_specs.into_owned()),
791        }
792    }
793}
794impl<'input> Request for UnregisterClientsRequest<'input> {
795    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
796
797    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
798        let (bufs, fds) = self.serialize(major_opcode);
799        // Flatten the buffers into a single vector
800        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
801        (buf, fds)
802    }
803}
804impl<'input> crate::x11_utils::VoidRequest for UnregisterClientsRequest<'input> {
805}
806
807/// Opcode for the GetContext request
808pub const GET_CONTEXT_REQUEST: u8 = 4;
809#[derive(Clone, Copy, Default)]
810#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
811#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
812pub struct GetContextRequest {
813    pub context: Context,
814}
815impl_debug_if_no_extra_traits!(GetContextRequest, "GetContextRequest");
816impl GetContextRequest {
817    /// Serialize this request into bytes for the provided connection
818    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
819        let length_so_far = 0;
820        let context_bytes = self.context.serialize();
821        let mut request0 = vec![
822            major_opcode,
823            GET_CONTEXT_REQUEST,
824            0,
825            0,
826            context_bytes[0],
827            context_bytes[1],
828            context_bytes[2],
829            context_bytes[3],
830        ];
831        let length_so_far = length_so_far + request0.len();
832        assert_eq!(length_so_far % 4, 0);
833        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
834        request0[2..4].copy_from_slice(&length.to_ne_bytes());
835        ([request0.into()], vec![])
836    }
837    /// Parse this request given its header, its body, and any fds that go along with it
838    #[cfg(feature = "request-parsing")]
839    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
840        if header.minor_opcode != GET_CONTEXT_REQUEST {
841            return Err(ParseError::InvalidValue);
842        }
843        let (context, remaining) = Context::try_parse(value)?;
844        let _ = remaining;
845        Ok(GetContextRequest {
846            context,
847        })
848    }
849}
850impl Request for GetContextRequest {
851    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
852
853    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
854        let (bufs, fds) = self.serialize(major_opcode);
855        // Flatten the buffers into a single vector
856        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
857        (buf, fds)
858    }
859}
860impl crate::x11_utils::ReplyRequest for GetContextRequest {
861    type Reply = GetContextReply;
862}
863
864#[derive(Clone, Default)]
865#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
866#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
867pub struct GetContextReply {
868    pub enabled: bool,
869    pub sequence: u16,
870    pub length: u32,
871    pub element_header: ElementHeader,
872    pub intercepted_clients: Vec<ClientInfo>,
873}
874impl_debug_if_no_extra_traits!(GetContextReply, "GetContextReply");
875impl TryParse for GetContextReply {
876    fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
877        let remaining = initial_value;
878        let (response_type, remaining) = u8::try_parse(remaining)?;
879        let (enabled, remaining) = bool::try_parse(remaining)?;
880        let (sequence, remaining) = u16::try_parse(remaining)?;
881        let (length, remaining) = u32::try_parse(remaining)?;
882        let (element_header, remaining) = ElementHeader::try_parse(remaining)?;
883        let remaining = remaining.get(3..).ok_or(ParseError::InsufficientData)?;
884        let (num_intercepted_clients, remaining) = u32::try_parse(remaining)?;
885        let remaining = remaining.get(16..).ok_or(ParseError::InsufficientData)?;
886        let (intercepted_clients, remaining) = crate::x11_utils::parse_list::<ClientInfo>(remaining, num_intercepted_clients.try_to_usize()?)?;
887        if response_type != 1 {
888            return Err(ParseError::InvalidValue);
889        }
890        let result = GetContextReply { enabled, sequence, length, element_header, intercepted_clients };
891        let _ = remaining;
892        let remaining = initial_value.get(32 + length as usize * 4..)
893            .ok_or(ParseError::InsufficientData)?;
894        Ok((result, remaining))
895    }
896}
897impl Serialize for GetContextReply {
898    type Bytes = Vec<u8>;
899    fn serialize(&self) -> Vec<u8> {
900        let mut result = Vec::new();
901        self.serialize_into(&mut result);
902        result
903    }
904    fn serialize_into(&self, bytes: &mut Vec<u8>) {
905        bytes.reserve(32);
906        let response_type_bytes = &[1];
907        bytes.push(response_type_bytes[0]);
908        self.enabled.serialize_into(bytes);
909        self.sequence.serialize_into(bytes);
910        self.length.serialize_into(bytes);
911        self.element_header.serialize_into(bytes);
912        bytes.extend_from_slice(&[0; 3]);
913        let num_intercepted_clients = u32::try_from(self.intercepted_clients.len()).expect("`intercepted_clients` has too many elements");
914        num_intercepted_clients.serialize_into(bytes);
915        bytes.extend_from_slice(&[0; 16]);
916        self.intercepted_clients.serialize_into(bytes);
917    }
918}
919impl GetContextReply {
920    /// Get the value of the `num_intercepted_clients` field.
921    ///
922    /// The `num_intercepted_clients` field is used as the length field of the `intercepted_clients` field.
923    /// This function computes the field's value again based on the length of the list.
924    ///
925    /// # Panics
926    ///
927    /// Panics if the value cannot be represented in the target type. This
928    /// cannot happen with values of the struct received from the X11 server.
929    pub fn num_intercepted_clients(&self) -> u32 {
930        self.intercepted_clients.len()
931            .try_into().unwrap()
932    }
933}
934
935/// Opcode for the EnableContext request
936pub const ENABLE_CONTEXT_REQUEST: u8 = 5;
937#[derive(Clone, Copy, Default)]
938#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
939#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
940pub struct EnableContextRequest {
941    pub context: Context,
942}
943impl_debug_if_no_extra_traits!(EnableContextRequest, "EnableContextRequest");
944impl EnableContextRequest {
945    /// Serialize this request into bytes for the provided connection
946    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
947        let length_so_far = 0;
948        let context_bytes = self.context.serialize();
949        let mut request0 = vec![
950            major_opcode,
951            ENABLE_CONTEXT_REQUEST,
952            0,
953            0,
954            context_bytes[0],
955            context_bytes[1],
956            context_bytes[2],
957            context_bytes[3],
958        ];
959        let length_so_far = length_so_far + request0.len();
960        assert_eq!(length_so_far % 4, 0);
961        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
962        request0[2..4].copy_from_slice(&length.to_ne_bytes());
963        ([request0.into()], vec![])
964    }
965    /// Parse this request given its header, its body, and any fds that go along with it
966    #[cfg(feature = "request-parsing")]
967    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
968        if header.minor_opcode != ENABLE_CONTEXT_REQUEST {
969            return Err(ParseError::InvalidValue);
970        }
971        let (context, remaining) = Context::try_parse(value)?;
972        let _ = remaining;
973        Ok(EnableContextRequest {
974            context,
975        })
976    }
977}
978impl Request for EnableContextRequest {
979    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
980
981    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
982        let (bufs, fds) = self.serialize(major_opcode);
983        // Flatten the buffers into a single vector
984        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
985        (buf, fds)
986    }
987}
988impl crate::x11_utils::ReplyRequest for EnableContextRequest {
989    type Reply = EnableContextReply;
990}
991
992#[derive(Clone, Default)]
993#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
994#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
995pub struct EnableContextReply {
996    pub category: u8,
997    pub sequence: u16,
998    pub element_header: ElementHeader,
999    pub client_swapped: bool,
1000    pub xid_base: u32,
1001    pub server_time: u32,
1002    pub rec_sequence_num: u32,
1003    pub data: Vec<u8>,
1004}
1005impl_debug_if_no_extra_traits!(EnableContextReply, "EnableContextReply");
1006impl TryParse for EnableContextReply {
1007    fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
1008        let remaining = initial_value;
1009        let (response_type, remaining) = u8::try_parse(remaining)?;
1010        let (category, remaining) = u8::try_parse(remaining)?;
1011        let (sequence, remaining) = u16::try_parse(remaining)?;
1012        let (length, remaining) = u32::try_parse(remaining)?;
1013        let (element_header, remaining) = ElementHeader::try_parse(remaining)?;
1014        let (client_swapped, remaining) = bool::try_parse(remaining)?;
1015        let remaining = remaining.get(2..).ok_or(ParseError::InsufficientData)?;
1016        let (xid_base, remaining) = u32::try_parse(remaining)?;
1017        let (server_time, remaining) = u32::try_parse(remaining)?;
1018        let (rec_sequence_num, remaining) = u32::try_parse(remaining)?;
1019        let remaining = remaining.get(8..).ok_or(ParseError::InsufficientData)?;
1020        let (data, remaining) = crate::x11_utils::parse_u8_list(remaining, u32::from(length).checked_mul(4u32).ok_or(ParseError::InvalidExpression)?.try_to_usize()?)?;
1021        let data = data.to_vec();
1022        if response_type != 1 {
1023            return Err(ParseError::InvalidValue);
1024        }
1025        let result = EnableContextReply { category, sequence, element_header, client_swapped, xid_base, server_time, rec_sequence_num, data };
1026        let _ = remaining;
1027        let remaining = initial_value.get(32 + length as usize * 4..)
1028            .ok_or(ParseError::InsufficientData)?;
1029        Ok((result, remaining))
1030    }
1031}
1032impl Serialize for EnableContextReply {
1033    type Bytes = Vec<u8>;
1034    fn serialize(&self) -> Vec<u8> {
1035        let mut result = Vec::new();
1036        self.serialize_into(&mut result);
1037        result
1038    }
1039    fn serialize_into(&self, bytes: &mut Vec<u8>) {
1040        bytes.reserve(32);
1041        let response_type_bytes = &[1];
1042        bytes.push(response_type_bytes[0]);
1043        self.category.serialize_into(bytes);
1044        self.sequence.serialize_into(bytes);
1045        assert_eq!(self.data.len() % 4, 0, "`data` has an incorrect length, must be a multiple of 4");
1046        let length = u32::try_from(self.data.len() / 4).expect("`data` has too many elements");
1047        length.serialize_into(bytes);
1048        self.element_header.serialize_into(bytes);
1049        self.client_swapped.serialize_into(bytes);
1050        bytes.extend_from_slice(&[0; 2]);
1051        self.xid_base.serialize_into(bytes);
1052        self.server_time.serialize_into(bytes);
1053        self.rec_sequence_num.serialize_into(bytes);
1054        bytes.extend_from_slice(&[0; 8]);
1055        bytes.extend_from_slice(&self.data);
1056    }
1057}
1058impl EnableContextReply {
1059    /// Get the value of the `length` field.
1060    ///
1061    /// The `length` field is used as the length field of the `data` field.
1062    /// This function computes the field's value again based on the length of the list.
1063    ///
1064    /// # Panics
1065    ///
1066    /// Panics if the value cannot be represented in the target type. This
1067    /// cannot happen with values of the struct received from the X11 server.
1068    pub fn length(&self) -> u32 {
1069        self.data.len()
1070            .checked_div(4).unwrap()
1071            .try_into().unwrap()
1072    }
1073}
1074
1075/// Opcode for the DisableContext request
1076pub const DISABLE_CONTEXT_REQUEST: u8 = 6;
1077#[derive(Clone, Copy, Default)]
1078#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
1079#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1080pub struct DisableContextRequest {
1081    pub context: Context,
1082}
1083impl_debug_if_no_extra_traits!(DisableContextRequest, "DisableContextRequest");
1084impl DisableContextRequest {
1085    /// Serialize this request into bytes for the provided connection
1086    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
1087        let length_so_far = 0;
1088        let context_bytes = self.context.serialize();
1089        let mut request0 = vec![
1090            major_opcode,
1091            DISABLE_CONTEXT_REQUEST,
1092            0,
1093            0,
1094            context_bytes[0],
1095            context_bytes[1],
1096            context_bytes[2],
1097            context_bytes[3],
1098        ];
1099        let length_so_far = length_so_far + request0.len();
1100        assert_eq!(length_so_far % 4, 0);
1101        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
1102        request0[2..4].copy_from_slice(&length.to_ne_bytes());
1103        ([request0.into()], vec![])
1104    }
1105    /// Parse this request given its header, its body, and any fds that go along with it
1106    #[cfg(feature = "request-parsing")]
1107    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
1108        if header.minor_opcode != DISABLE_CONTEXT_REQUEST {
1109            return Err(ParseError::InvalidValue);
1110        }
1111        let (context, remaining) = Context::try_parse(value)?;
1112        let _ = remaining;
1113        Ok(DisableContextRequest {
1114            context,
1115        })
1116    }
1117}
1118impl Request for DisableContextRequest {
1119    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
1120
1121    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
1122        let (bufs, fds) = self.serialize(major_opcode);
1123        // Flatten the buffers into a single vector
1124        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
1125        (buf, fds)
1126    }
1127}
1128impl crate::x11_utils::VoidRequest for DisableContextRequest {
1129}
1130
1131/// Opcode for the FreeContext request
1132pub const FREE_CONTEXT_REQUEST: u8 = 7;
1133#[derive(Clone, Copy, Default)]
1134#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
1135#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1136pub struct FreeContextRequest {
1137    pub context: Context,
1138}
1139impl_debug_if_no_extra_traits!(FreeContextRequest, "FreeContextRequest");
1140impl FreeContextRequest {
1141    /// Serialize this request into bytes for the provided connection
1142    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
1143        let length_so_far = 0;
1144        let context_bytes = self.context.serialize();
1145        let mut request0 = vec![
1146            major_opcode,
1147            FREE_CONTEXT_REQUEST,
1148            0,
1149            0,
1150            context_bytes[0],
1151            context_bytes[1],
1152            context_bytes[2],
1153            context_bytes[3],
1154        ];
1155        let length_so_far = length_so_far + request0.len();
1156        assert_eq!(length_so_far % 4, 0);
1157        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
1158        request0[2..4].copy_from_slice(&length.to_ne_bytes());
1159        ([request0.into()], vec![])
1160    }
1161    /// Parse this request given its header, its body, and any fds that go along with it
1162    #[cfg(feature = "request-parsing")]
1163    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
1164        if header.minor_opcode != FREE_CONTEXT_REQUEST {
1165            return Err(ParseError::InvalidValue);
1166        }
1167        let (context, remaining) = Context::try_parse(value)?;
1168        let _ = remaining;
1169        Ok(FreeContextRequest {
1170            context,
1171        })
1172    }
1173}
1174impl Request for FreeContextRequest {
1175    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
1176
1177    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
1178        let (bufs, fds) = self.serialize(major_opcode);
1179        // Flatten the buffers into a single vector
1180        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
1181        (buf, fds)
1182    }
1183}
1184impl crate::x11_utils::VoidRequest for FreeContextRequest {
1185}
1186
x11rb_protocol/protocol/record.rs

x11rb_protocol/protocol/
record.rs
