wl-data-control-protocol-evt 1.0.0

Implementation of ext-data-control Wayland protocol, pollable and event based
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

use rustix::{
    fs::{OFlags, fcntl_getfl, fcntl_setfl},
    io::Errno,
};
use std::{
    io::ErrorKind,
    os::fd::{AsFd, AsRawFd, OwnedFd},
};

pub struct Writer {
    fd: OwnedFd,
    buf: Vec<u8>,
    pos: usize,
}

pub enum WriteResult {
    Done,
    Pending,
}

fn set_nonblocking(fd: impl AsFd) -> Result<(), Errno> {
    let mut flags = fcntl_getfl(&fd)?;
    flags.insert(OFlags::NONBLOCK);
    fcntl_setfl(fd, flags)?;
    Ok(())
}

#[expect(clippy::indexing_slicing, clippy::arithmetic_side_effects)]
impl Writer {
    pub(crate) fn new(fd: OwnedFd, text: String) -> Result<Self, Errno> {
        set_nonblocking(&fd)?;

        Ok(Self {
            fd,
            buf: text.into_bytes(),
            pos: 0,
        })
    }

    pub(crate) fn write(&mut self) -> Result<WriteResult, Errno> {
        match rustix::io::write(&self.fd, &self.buf[self.pos..]) {
            Ok(bytes_written) => {
                self.pos += bytes_written;
                if self.pos == self.buf.len() {
                    Ok(WriteResult::Done)
                } else {
                    Ok(WriteResult::Pending)
                }
            }
            Err(err) if err.kind() == ErrorKind::WouldBlock => Ok(WriteResult::Pending),
            Err(err) => Err(err),
        }
    }
}

impl AsFd for Writer {
    fn as_fd(&self) -> std::os::unix::prelude::BorrowedFd<'_> {
        self.fd.as_fd()
    }
}

impl AsRawFd for Writer {
    fn as_raw_fd(&self) -> std::os::unix::prelude::RawFd {
        self.fd.as_raw_fd()
    }
}