Struct Bi

pub struct Bi { /* private fields */ }

Bi

This struct helps with controlling multiple tasks reading data into memory.

For examples, your program parses files. Naturally it scans for files on the system, then reads them into memory, and does the job. Now, if you want to limit total memory it uses at a time to 256 MiB, you can do this:

use {
    core::time::Duration,
    std::{
        io::{self, Read},
        sync::Arc,
        thread,
    },

    bi::{Bi, Options},
};

let bi = Arc::new(Bi::from(Options {
    limit: 1024 * 1024 * 256,
    buf_size: 1024 * 64,
    wait_timeout: Duration::from_secs(10),
}));

let threads = (0..100).map(|_| {
    let bi = bi.clone();
    thread::spawn(move || {
        // For demonstration, we use io::repeat()
        let bytes = bi.read(&mut io::repeat(0).take(100), 100)?;

        // Do something with bytes...

        io::Result::Ok(())
    })
}).collect::<Vec<_>>();

for t in threads {
    if let Err(err) = t.join().unwrap() {
        eprintln!("{}", err);
    }
}

Implementations

impl Bi

pub fn read<R>(&self, src: &mut R, capacity: usize) -> IoResult<Bytes>

where R: Read,

Reads into new Bytes

Capacity is used to request memory upfront. It would help if you provide a good value. If capacity is lower than real data, the function will request more memory.

pub fn move<B>(&self, src: B) -> Result<Bytes, Vec<u8>>

where B: Into<Vec<u8>>,

Moves src into new Bytes

On failure, source will be returned.

Trait Implementations

impl Debug for Bi

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

Formats the value using the given formatter.

impl From<Options> for Bi

fn from(options: Options) -> Self

Converts to this type from the input type.