Struct Reader

pub struct Reader<const N: usize, R> { /* private fields */ }

A BED reader.

Implementations

impl<R, const N: usize> Reader<N, R>

pub fn get_ref(&self) -> &R

Returns a reference to the underlying reader.

Examples

use noodles_bed as bed;
let reader = bed::io::Reader::<3, _>::new(io::empty());
let _inner = reader.get_ref();

pub fn get_mut(&mut self) -> &mut R

Returns a mutable reference to the underlying reader.

Examples

use noodles_bed as bed;
let mut reader = bed::io::Reader::<3, _>::new(io::empty());
let _inner = reader.get_mut();

pub fn into_inner(self) -> R

Returns the underlying reader.

Examples

use noodles_bed as bed;
let reader = bed::io::Reader::<3, _>::new(io::empty());
let _inner = reader.into_inner();

impl<const N: usize, R> Reader<N, R>

where R: BufRead,

pub fn new(inner: R) -> Self

Creates a BED reader.

Examples

use noodles_bed as bed;
let reader = bed::io::Reader::<3, _>::new(io::empty());

impl<R> Reader<3, R>

where R: BufRead,

pub fn read_record(&mut self, record: &mut Record<3>) -> Result<usize>

Reads a BED3+ record.

Examples

use noodles_bed as bed;
let mut reader = bed::io::Reader::<3, _>::new(io::empty());
let mut record = bed::Record::default();
reader.read_record(&mut record)?;

Examples found in repository

examples/bed_count.rs (line 15)

fn main() -> io::Result<()> {
    let src = env::args().nth(1).expect("missing src");

    let mut reader = bed::io::reader::Builder::<3>.build_from_path(src)?;

    let mut record = bed::Record::default();
    let mut n = 0;

    while reader.read_record(&mut record)? != 0 {
        n += 1;
    }

    println!("{n}");

    Ok(())
}

examples/bed_view.rs (line 17)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let src = env::args().nth(1).expect("missing src");

    let mut reader = bed::io::reader::Builder::<3>.build_from_path(src)?;

    let stdout = io::stdout().lock();
    let mut writer = bed::io::Writer::<3, _>::new(stdout);

    let mut record = bed::Record::default();

    while reader.read_record(&mut record)? != 0 {
        writer.write_record(&record)?;
    }

    Ok(())
}

impl<R> Reader<4, R>

where R: BufRead,

pub fn read_record(&mut self, record: &mut Record<4>) -> Result<usize>

Reads a BED4+ record.

Examples

use noodles_bed as bed;
let mut reader = bed::io::Reader::<4, _>::new(io::empty());
let mut record = bed::Record::default();
reader.read_record(&mut record)?;

impl<R> Reader<5, R>

where R: BufRead,

pub fn read_record(&mut self, record: &mut Record<5>) -> Result<usize>

Reads a BED5+ record.

Examples

use noodles_bed as bed;
let mut reader = bed::io::Reader::<5, _>::new(io::empty());
let mut record = bed::Record::default();
reader.read_record(&mut record)?;

impl<R> Reader<6, R>

where R: BufRead,

pub fn read_record(&mut self, record: &mut Record<6>) -> Result<usize>

Reads a BED6+ record.

Examples

use noodles_bed as bed;
let mut reader = bed::io::Reader::<6, _>::new(io::empty());
let mut record = bed::Record::default();
reader.read_record(&mut record)?;