Struct BufferedSocket

pub struct BufferedSocket { /* private fields */ }

An adapter around a raw Socket that directly handles buffering and conversion from/to wayland messages

Implementations

impl BufferedSocket

pub fn new(socket: Socket) -> BufferedSocket

Wrap a Socket into a Buffered Socket

Examples found in repository

examples/manual_global_list.rs (line 18)

fn main() {
    let xdg_dir = env::var_os("XDG_RUNTIME_DIR").unwrap();
    let mut path: PathBuf = xdg_dir.into();
    path.push("wayland-0");

    let socket = UnixStream::connect(path).unwrap();
    let mut socket = BufferedSocket::new(unsafe { Socket::from_raw_fd(socket.into_raw_fd()) });

    socket
        .write_message(&Message {
            sender_id: 1, // wl_display
            opcode: 1,    // get registry
            args: smallvec![
                Argument::NewId(2), // id of the created registry
            ],
        })
        .unwrap();

    socket.flush().unwrap();

    ::std::thread::sleep(::std::time::Duration::from_millis(500)); // sleep 0.5 seconds

    let ret = socket.read_messages(
        |id, opcode| match (id, opcode) {
            (2, 0) => Some(&GLOBAL_EVENT.signature),
            _ => None,
        },
        |msg| {
            println!("{:?}", msg);
            true
        },
    );
    println!("{:?}", ret);
}

pub fn get_socket(&mut self) -> &mut Socket

Get direct access to the underlying socket

pub fn into_socket(self) -> Socket

Retrieve ownership of the underlying Socket

Any leftover content in the internal buffers will be lost

pub fn flush(&mut self) -> NixResult<()>

Flush the contents of the outgoing buffer into the socket

Examples found in repository

examples/manual_global_list.rs (line 30)

fn main() {
    let xdg_dir = env::var_os("XDG_RUNTIME_DIR").unwrap();
    let mut path: PathBuf = xdg_dir.into();
    path.push("wayland-0");

    let socket = UnixStream::connect(path).unwrap();
    let mut socket = BufferedSocket::new(unsafe { Socket::from_raw_fd(socket.into_raw_fd()) });

    socket
        .write_message(&Message {
            sender_id: 1, // wl_display
            opcode: 1,    // get registry
            args: smallvec![
                Argument::NewId(2), // id of the created registry
            ],
        })
        .unwrap();

    socket.flush().unwrap();

    ::std::thread::sleep(::std::time::Duration::from_millis(500)); // sleep 0.5 seconds

    let ret = socket.read_messages(
        |id, opcode| match (id, opcode) {
            (2, 0) => Some(&GLOBAL_EVENT.signature),
            _ => None,
        },
        |msg| {
            println!("{:?}", msg);
            true
        },
    );
    println!("{:?}", ret);
}

pub fn write_message(&mut self, msg: &Message) -> NixResult<()>

Write a message to the outgoing buffer

This method may flush the internal buffer if necessary (if it is full).

If the message is too big to fit in the buffer, the error Error::Sys(E2BIG) will be returned.

Examples found in repository

examples/manual_global_list.rs (lines 21-27)

fn main() {
    let xdg_dir = env::var_os("XDG_RUNTIME_DIR").unwrap();
    let mut path: PathBuf = xdg_dir.into();
    path.push("wayland-0");

    let socket = UnixStream::connect(path).unwrap();
    let mut socket = BufferedSocket::new(unsafe { Socket::from_raw_fd(socket.into_raw_fd()) });

    socket
        .write_message(&Message {
            sender_id: 1, // wl_display
            opcode: 1,    // get registry
            args: smallvec![
                Argument::NewId(2), // id of the created registry
            ],
        })
        .unwrap();

    socket.flush().unwrap();

    ::std::thread::sleep(::std::time::Duration::from_millis(500)); // sleep 0.5 seconds

    let ret = socket.read_messages(
        |id, opcode| match (id, opcode) {
            (2, 0) => Some(&GLOBAL_EVENT.signature),
            _ => None,
        },
        |msg| {
            println!("{:?}", msg);
            true
        },
    );
    println!("{:?}", ret);
}

pub fn fill_incoming_buffers(&mut self) -> NixResult<()>

Try to fill the incoming buffers of this socket, to prepare a new round of parsing.

pub fn read_one_message<F>( &mut self, signature: F, ) -> Result<Message, MessageParseError>

where F: FnMut(u32, u16) -> Option<&'static [ArgumentType]>,

Read and deserialize a single message from the incoming buffers socket

This method requires one closure that given an object id and an opcode, must provide the signature of the associated request/event, in the form of a &'static [ArgumentType]. If it returns None, meaning that the couple object/opcode does not exist, an error will be returned.

There are 3 possibilities of return value:

• Ok(Ok(msg)): no error occurred, this is the message
• Ok(Err(e)): either a malformed message was encountered or we need more data, in the latter case you need to try calling fill_incoming_buffers().
• Err(e): an I/O error occurred reading from the socked, details are in e (this can be a “wouldblock” error, which just means that no message is available to read)

pub fn read_messages<F1, F2>( &mut self, signature: F1, callback: F2, ) -> NixResult<Result<usize, MessageParseError>>

where F1: FnMut(u32, u16) -> Option<&'static [ArgumentType]>, F2: FnMut(Message) -> bool,

Read and deserialize messages from the socket

This method requires two closures:

• The first one, given an object id and an opcode, must provide the signature of the associated request/event, in the form of a &'static [ArgumentType]. If it returns None, meaning that the couple object/opcode does not exist, the parsing will be prematurely interrupted and this method will return a MessageParseError::Malformed error.
• The second closure is charged to process the parsed message. If it returns false, the iteration will be prematurely stopped.

In both cases of early stopping, the remaining unused data will be left in the buffers, and will start to be processed at the next call of this method.

There are 3 possibilities of return value:

• Ok(Ok(n)): no error occurred, n messages where processed
• Ok(Err(MessageParseError::Malformed)): a malformed message was encountered (this is a protocol error and is supposed to be fatal to the connection).
• Err(e): an I/O error occurred reading from the socked, details are in e (this can be a “wouldblock” error, which just means that no message is available to read)

Examples found in repository

examples/manual_global_list.rs (lines 34-43)

fn main() {
    let xdg_dir = env::var_os("XDG_RUNTIME_DIR").unwrap();
    let mut path: PathBuf = xdg_dir.into();
    path.push("wayland-0");

    let socket = UnixStream::connect(path).unwrap();
    let mut socket = BufferedSocket::new(unsafe { Socket::from_raw_fd(socket.into_raw_fd()) });

    socket
        .write_message(&Message {
            sender_id: 1, // wl_display
            opcode: 1,    // get registry
            args: smallvec![
                Argument::NewId(2), // id of the created registry
            ],
        })
        .unwrap();

    socket.flush().unwrap();

    ::std::thread::sleep(::std::time::Duration::from_millis(500)); // sleep 0.5 seconds

    let ret = socket.read_messages(
        |id, opcode| match (id, opcode) {
            (2, 0) => Some(&GLOBAL_EVENT.signature),
            _ => None,
        },
        |msg| {
            println!("{:?}", msg);
            true
        },
    );
    println!("{:?}", ret);
}

Trait Implementations

impl Debug for BufferedSocket

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.