x11rb_protocol/protocol/
res.rs

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

x11rb_protocol/protocol/
res.rs
