Struct Reader

pub struct Reader<R> { /* private fields */ }

A GTF reader.

Implementations

impl<R> Reader<R>

pub fn get_ref(&self) -> &R

Returns a reference to the underlying reader.

Examples

use noodles_gtf as gtf;
let reader = gtf::io::Reader::new(io::empty());
let _ = reader.get_ref();

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

Returns a mutable reference to the underlying reader.

Examples

use noodles_gtf as gtf;
let mut reader = gtf::io::Reader::new(io::empty());
let _ = reader.get_mut();

pub fn into_inner(self) -> R

Unwraps and returns the underlying reader.

Examples

use noodles_gtf as gtf;
let reader = gtf::io::Reader::new(io::empty());
let _ = reader.into_inner();

impl<R> Reader<R>

where R: BufRead,

pub fn new(inner: R) -> Self

Creates a GTF reader.

Examples

use noodles_gtf as gtf;
let data = [];
let reader = gtf::io::Reader::new(&data[..]);

pub fn read_line(&mut self, line: &mut Line) -> Result<usize>

Reads a GTF line.

Examples

use noodles_gtf as gtf;

let src = b"##format: gtf\nsq0\tNOODLES\tgene\t8\t13\t.\t+\t.\tid 0;\n";
let mut reader = gtf::io::Reader::new(&src[..]);

let mut line = gtf::Line::default();

reader.read_line(&mut line)?;
assert_eq!(line.kind(), gtf::line::Kind::Comment);

reader.read_line(&mut line)?;
assert_eq!(line.kind(), gtf::line::Kind::Record);

assert_eq!(reader.read_line(&mut line)?, 0);

Examples found in repository

examples/gtf_count.rs (line 23)

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

    let mut reader = File::open(src)
        .map(BufReader::new)
        .map(gtf::io::Reader::new)?;

    let mut line = gtf::Line::default();
    let mut n = 0;

    while reader.read_line(&mut line)? != 0 {
        if line.as_record().is_some() {
            n += 1;
        }
    }

    println!("{n}");

    Ok(())
}

examples/gtf_view.rs (line 25)

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

    let mut reader = File::open(src)
        .map(BufReader::new)
        .map(gtf::io::Reader::new)?;

    let stdout = io::stdout().lock();
    let mut writer = gtf::io::Writer::new(BufWriter::new(stdout));

    let mut line = gtf::Line::default();

    while reader.read_line(&mut line)? != 0 {
        if let Some(result) = line.as_record() {
            let record = result?;
            writer.write_feature_record(&record)?;
        }
    }

    Ok(())
}

pub fn lines(&mut self) -> impl Iterator<Item = Result<Line>> + '_

Returns an iterator over lines starting from the current stream position.

Examples

use noodles_gtf as gtf;

let src = b"##format: gtf\nsq0\tNOODLES\tgene\t8\t13\t.\t+\t.\tid 0;\n";
let mut reader = gtf::io::Reader::new(&src[..]);

let mut lines = reader.lines();

let line = lines.next().transpose()?;
assert_eq!(line.map(|l| l.kind()), Some(gtf::line::Kind::Comment));

let line = lines.next().transpose()?;
assert_eq!(line.map(|l| l.kind()), Some(gtf::line::Kind::Record));

assert!(lines.next().is_none());

pub fn line_bufs(&mut self) -> impl Iterator<Item = Result<LineBuf>> + '_

Returns an iterator over line buffers starting from the current stream position.

Examples

use bstr::BString;
use noodles_gtf as gtf;

let data = b"##format: gtf
sq0\tNOODLES\tgene\t8\t13\t.\t+\t.\tgene_id \"g0\"; transcript_id \"t0\";
";
let mut reader = gtf::io::Reader::new(&data[..]);

let mut lines = reader.line_bufs();

let line = lines.next().transpose()?;
assert_eq!(line, Some(gtf::LineBuf::Comment(BString::from("#format: gtf"))));

let line = lines.next().transpose()?;
assert!(matches!(line, Some(gtf::LineBuf::Record(_))));

assert!(lines.next().is_none());

pub fn record_bufs(&mut self) -> impl Iterator<Item = Result<RecordBuf>> + '_

Returns an iterator over record buffers starting from the current stream position.

Examples

use noodles_core::Position;
use noodles_gtf as gtf;

let src = b"##format: gtf
sq0\tNOODLES\tgene\t8\t13\t.\t+\t.\tgene_id \"g0\"; transcript_id \"t0\";
";
let mut reader = gtf::io::Reader::new(&src[..]);

let mut record_bufs = reader.record_bufs();

let record = record_bufs.next().transpose()?;
assert_eq!(record.map(|r| r.start()), Position::new(8));
// ...

assert!(record_bufs.next().is_none());

impl<R> Reader<Reader<R>>

where R: Read + Seek,

pub fn query<'r, I>( &'r mut self, index: &I, region: &'r Region, ) -> Result<impl Iterator<Item = Result<RecordBuf>> + 'r>

where I: BinningIndex,

Returns an iterator over records that intersects the given region.

Examples found in repository

examples/gtf_query.rs (line 25)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut args = env::args().skip(1);
    let src = args.next().expect("missing src");
    let region = args.next().expect("missing region").parse()?;

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

    let mut reader = File::open(src)
        .map(bgzf::io::Reader::new)
        .map(gtf::io::Reader::new)?;

    let query = reader.query(&index, &region)?;

    let stdout = io::stdout().lock();
    let mut writer = gtf::io::Writer::new(stdout);

    for result in query {
        let record = result?;
        writer.write_record(&record)?;
    }

    Ok(())
}