Struct Writer 

pub struct Writer<T> { /* private fields */ }

Writer of a Cueue.

See examples/ for usage.

Implementations

impl<T> Writer<T>

pub fn capacity(&self) -> usize

Maximum number of elements the referenced cueue can hold.

pub fn write_chunk(&mut self) -> &mut [T]

Get a writable slice of maximum available size.

The elements in the returned slice are either default initialized (never written yet) or are the result of previous writes. The writer is free to overwrite or reuse them.

After write, commit must be called, to make the written elements available for reading.

Examples found in repository

examples/ipc_write.rs (line 27)

fn main() -> std::io::Result<()> {
    let path = CString::new("cueue_ipc").unwrap();
    let mode = (libc::S_IRUSR | libc::S_IWUSR) as Mode;
    let f = unsafe { libc::shm_open(path.as_ptr(), libc::O_RDWR | libc::O_CREAT, mode) };
    if f < 0 {
        return Err(std::io::Error::last_os_error());
    }

    let (mut w, _) = cueue::cueue_in_fd(f, Some(1 << 20))?;

    loop {
        print!("> ");
        std::io::stdout().flush()?;
        let buf = w.write_chunk();
        match std::io::stdin().read(buf) {
            Ok(0) | Err(_) => break,
            Ok(n) => {
                w.commit(n);
            }
        }
    }

    unsafe {
        libc::shm_unlink(path.as_ptr());
    }

    Ok(())
}

examples/basics.rs (line 11)

fn main() {
    // Create a cueue with capacity at least 1M.
    // (The actual capacity will be rounded up to match system requirements, if needed)
    // w and r are the write and read handles of the cueue, respectively.
    // These handles can be sent between threads, but cannot be duplicated.
    let (mut w, mut r) = cueue::cueue(1 << 20).unwrap();

    // To write a cueue, first we need to get a writable slice from it:
    let buf = w.write_chunk();

    // Check if there are 9 bytes free for writing in the cueue.
    if buf.len() >= 3 + 3 + 3 {
        // If yes, write whatever we want
        buf[..9].copy_from_slice(b"foobarbaz");

        // When done, make the written are available for reading.
        // Without this, the reader will not see the written but not committed changes.
        w.commit(9);
    }

    // Now read whatever is in the queue
    let read_result = r.read_chunk();
    assert_eq!(read_result, b"foobarbaz");
    println!("Read {}", String::from_utf8_lossy(read_result));
    // Mark the previously returned slice consumed, making it available for writing.
    r.commit();
}

pub fn commit(&mut self, n: usize) -> usize

Make n number of elements, written to the slice returned by write_chunk available for reading.

n is checked: if too large, gets truncated to the maximum committable size.

Returns the number of committed elements.

Examples found in repository

examples/ipc_write.rs (line 31)

fn main() -> std::io::Result<()> {
    let path = CString::new("cueue_ipc").unwrap();
    let mode = (libc::S_IRUSR | libc::S_IWUSR) as Mode;
    let f = unsafe { libc::shm_open(path.as_ptr(), libc::O_RDWR | libc::O_CREAT, mode) };
    if f < 0 {
        return Err(std::io::Error::last_os_error());
    }

    let (mut w, _) = cueue::cueue_in_fd(f, Some(1 << 20))?;

    loop {
        print!("> ");
        std::io::stdout().flush()?;
        let buf = w.write_chunk();
        match std::io::stdin().read(buf) {
            Ok(0) | Err(_) => break,
            Ok(n) => {
                w.commit(n);
            }
        }
    }

    unsafe {
        libc::shm_unlink(path.as_ptr());
    }

    Ok(())
}

examples/basics.rs (line 20)

fn main() {
    // Create a cueue with capacity at least 1M.
    // (The actual capacity will be rounded up to match system requirements, if needed)
    // w and r are the write and read handles of the cueue, respectively.
    // These handles can be sent between threads, but cannot be duplicated.
    let (mut w, mut r) = cueue::cueue(1 << 20).unwrap();

    // To write a cueue, first we need to get a writable slice from it:
    let buf = w.write_chunk();

    // Check if there are 9 bytes free for writing in the cueue.
    if buf.len() >= 3 + 3 + 3 {
        // If yes, write whatever we want
        buf[..9].copy_from_slice(b"foobarbaz");

        // When done, make the written are available for reading.
        // Without this, the reader will not see the written but not committed changes.
        w.commit(9);
    }

    // Now read whatever is in the queue
    let read_result = r.read_chunk();
    assert_eq!(read_result, b"foobarbaz");
    println!("Read {}", String::from_utf8_lossy(read_result));
    // Mark the previously returned slice consumed, making it available for writing.
    r.commit();
}

pub fn is_abandoned(&self) -> bool

Returns true, if the Reader counterpart was dropped.

pub fn push(&mut self, t: T) -> Result<(), T>

Write and commit a single element, or return it if the queue was full.

Trait Implementations

impl<T: Send> Send for Writer<T>