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());

Examples found in repository

examples/bed_query.rs (line 32)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut args = env::args().skip(1);

    let src = args.next().expect("missing src");
    let region: Region = args.next().expect("missing region").parse()?;

    let index_src = format!("{src}.tbi");
    let index = tabix::fs::read(index_src)?;

    let header = index.header().expect("missing tabix header");
    let reference_sequence_id = header
        .reference_sequence_names()
        .get_index_of(region.name())
        .expect("invalid reference sequence name");

    let mut decoder = File::open(src).map(bgzf::io::Reader::new)?;
    let chunks = index.query(reference_sequence_id, region.interval())?;
    let query = csi::io::Query::new(&mut decoder, chunks);

    let mut reader = bed::io::Reader::<3, _>::new(query);
    let mut record = bed::Record::default();

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

    while reader.read_record(&mut record)? != 0 {
        let start = record.feature_start()?;
        let end = record.feature_end().expect("missing feature end")?;
        let interval = (start..=end).into();

        if !region.interval().intersects(interval) {
            continue;
        }

        writer.write_record(&record)?;
    }

    Ok(())
}

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 21)

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

    let mut reader = File::open(src)
        .map(BufReader::new)
        .map(bed::io::Reader::<3, _>::new)?;

    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 23)

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

    let mut reader = File::open(src)
        .map(BufReader::new)
        .map(bed::io::Reader::<3, _>::new)?;

    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(())
}

examples/bed_query.rs (line 38)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut args = env::args().skip(1);

    let src = args.next().expect("missing src");
    let region: Region = args.next().expect("missing region").parse()?;

    let index_src = format!("{src}.tbi");
    let index = tabix::fs::read(index_src)?;

    let header = index.header().expect("missing tabix header");
    let reference_sequence_id = header
        .reference_sequence_names()
        .get_index_of(region.name())
        .expect("invalid reference sequence name");

    let mut decoder = File::open(src).map(bgzf::io::Reader::new)?;
    let chunks = index.query(reference_sequence_id, region.interval())?;
    let query = csi::io::Query::new(&mut decoder, chunks);

    let mut reader = bed::io::Reader::<3, _>::new(query);
    let mut record = bed::Record::default();

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

    while reader.read_record(&mut record)? != 0 {
        let start = record.feature_start()?;
        let end = record.feature_end().expect("missing feature end")?;
        let interval = (start..=end).into();

        if !region.interval().intersects(interval) {
            continue;
        }

        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)?;