Struct Reader 

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

A SAF reader.

The reader is generic over the inner reader type and over the SAF Version being read. Version-specific aliases ReaderV3 and ReaderV4 are provided for convenience.

Implementations

impl<R, V> Reader<R, V>

where R: BufRead, V: Version,

pub fn create_record_buf(&self) -> Record<Id, V::Item>

Returns a new record suitable for use in reading.

Examples found in repository

examples/saf_v3_read.rs (line 19)

fn main() -> io::Result<()> {
    let path = env::args().nth(1).expect("missing path to SAF member file");
    let mut reader = saf::reader::Builder::v3().build_from_member_path(path)?;

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

    write!(writer, "{}", reader.index())?;

    let mut record = reader.create_record_buf();
    while reader.read_record(&mut record)?.is_not_done() {
        writeln!(writer, "{record:.2}")?;
    }

    Ok(())
}

examples/saf_v4_read.rs (line 19)

fn main() -> io::Result<()> {
    let path = env::args().nth(1).expect("missing path to SAF member file");
    let mut reader = saf::reader::Builder::v4().build_from_member_path(path)?;

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

    write!(writer, "{}", reader.index())?;

    let mut record = reader.create_record_buf();
    while reader.read_record(&mut record)?.is_not_done() {
        writeln!(writer, "{record:.2}")?;
    }

    Ok(())
}

pub fn from_bgzf( index: Index<V>, position_reader: Reader<R>, item_reader: Reader<R>, ) -> Option<Self>

Creates a new reader from its raw parts.

A Builder will typically be a more ergonimic way to create a reader.

Returns None if index contains no records.

pub fn index(&self) -> &Index<V>

Returns the index.

Examples found in repository

examples/saf_v3_read.rs (line 17)

fn main() -> io::Result<()> {
    let path = env::args().nth(1).expect("missing path to SAF member file");
    let mut reader = saf::reader::Builder::v3().build_from_member_path(path)?;

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

    write!(writer, "{}", reader.index())?;

    let mut record = reader.create_record_buf();
    while reader.read_record(&mut record)?.is_not_done() {
        writeln!(writer, "{record:.2}")?;
    }

    Ok(())
}

examples/saf_v4_read.rs (line 17)

fn main() -> io::Result<()> {
    let path = env::args().nth(1).expect("missing path to SAF member file");
    let mut reader = saf::reader::Builder::v4().build_from_member_path(path)?;

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

    write!(writer, "{}", reader.index())?;

    let mut record = reader.create_record_buf();
    while reader.read_record(&mut record)?.is_not_done() {
        writeln!(writer, "{record:.2}")?;
    }

    Ok(())
}

examples/saf_v3_intersect.rs (line 26)

fn main() -> io::Result<()> {
    let readers = env::args()
        .skip(1)
        .map(|p| saf::reader::Builder::v3().build_from_member_path(p))
        .collect::<io::Result<Vec<_>>>()?;

    // Note also the [`Reader::intersect`] and [`Intersect::intersect`] methods to construct
    // intersecting reader when the number of readers are statically known.
    let mut intersect = saf::Intersect::new(readers);

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

    let mut bufs = intersect.create_record_bufs();
    while intersect.read_records(&mut bufs)?.is_not_done() {
        for (reader, buf) in intersect.get_readers().iter().zip(bufs.iter()) {
            let contig = reader.index().records()[*buf.contig_id()].name();
            let position = buf.position();
            write!(writer, "{contig}\t{position}")?;

            for v in buf.item().iter() {
                write!(writer, "\t{v:.2}")?;
            }

            writeln!(writer)?;
        }
    }

    Ok(())
}

pub fn index_mut(&mut self) -> &mut Index<V>

Returns a mutable reference to the index.

pub fn into_parts(self) -> (Index<V>, Reader<R>, Reader<R>)

Returns the inner index, position reader, and item reader, consuming self.

pub fn item_reader(&self) -> &Reader<R>

Returns the inner item reader.

pub fn item_reader_mut(&mut self) -> &mut Reader<R>

Returns a mutable reference to the inner item reader.

pub fn position_reader(&self) -> &Reader<R>

Returns the inner position reader.

pub fn position_reader_mut(&mut self) -> &mut Reader<R>

Returns a mutable reference to the inner position reader.

pub fn read_item(&mut self, buf: &mut V::Item) -> Result<ReadStatus>

Reads a single item from the item reader into the provided buffer.

Note that this will bring the item and position readers out of sync. Use Self::read_record instead unless you wish to manually re-sync the underlying readers.

pub fn read_magic(&mut self) -> Result<()>

Reads and checks the magic numbers.

Assumes the streams are positioned at the beginning of the files.

pub fn read_position(&mut self) -> Result<Option<u32>>

Reads a single position from the position reader.

Note that this will bring the item and position readers out of sync. Use Self::read_record instead unless you wish to manually re-sync the underlying readers.

pub fn read_record( &mut self, record: &mut Record<Id, V::Item>, ) -> Result<ReadStatus>

Reads a single record.

Note that the record buffer needs to be correctly set up. Use Self::create_record_buf for a correctly initialised record buffer to use for reading.

Examples found in repository

examples/saf_v3_read.rs (line 20)

fn main() -> io::Result<()> {
    let path = env::args().nth(1).expect("missing path to SAF member file");
    let mut reader = saf::reader::Builder::v3().build_from_member_path(path)?;

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

    write!(writer, "{}", reader.index())?;

    let mut record = reader.create_record_buf();
    while reader.read_record(&mut record)?.is_not_done() {
        writeln!(writer, "{record:.2}")?;
    }

    Ok(())
}

examples/saf_v4_read.rs (line 20)

fn main() -> io::Result<()> {
    let path = env::args().nth(1).expect("missing path to SAF member file");
    let mut reader = saf::reader::Builder::v4().build_from_member_path(path)?;

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

    write!(writer, "{}", reader.index())?;

    let mut record = reader.create_record_buf();
    while reader.read_record(&mut record)?.is_not_done() {
        writeln!(writer, "{record:.2}")?;
    }

    Ok(())
}

impl<R, V> Reader<R, V>

where R: BufRead + Seek, V: Version,

pub fn intersect(self, other: Self) -> Intersect<R, V>

Creates an intersection of two readers.

The resulting intersecting readers will read only records that lie on the same contigs and the same positions. Further readers can be added to the resulting intersecting reader by chaining the Intersect::intersect method.

pub fn seek(&mut self, contig_id: usize) -> Result<()>

Seeks to start of contig.

The contig_id refers to the position of records in the index.

Panics

Panics if contig_id is larger than the number of records defined in the index.

pub fn seek_by_name(&mut self, name: &str) -> Result<()>

Seeks to start of contig by name.

Note that this requires a linear search of names in the index with worst time complexity linear in the index size.. If the index is large, and the contig ID is known, prefer Self::seek is more efficient.

Panics

Panics if sequence name is not defined in index.