Struct Intersect 

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

An intersection of SAF file readers.

The intersection takes an arbitrary number of readers and returns data where all readers contain data for the same contig and position. It is assumed that contigs are sorted in the same order in each file, and that positions are sorted numerically within each contig.

Implementations

impl<R, V> Intersect<R, V>

where R: BufRead + Seek, V: Version,

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

Returns a new collection of records suitable for use in reading.

Examples found in repository

examples/saf_v3_intersect.rs (line 23)

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 intersect(self, reader: Reader<R, V>) -> Self

Creates a new intersecting reader with an additional reader, consuming self.

Since self is consumed, rather than mutated, this can be chained to build intersections of multiple readers. See also the Reader::intersect method for a way to start create the initial intersecting reader.

pub fn get_readers(&self) -> &[Reader<R, V>]

Returns the inner readers.

Examples found in repository

examples/saf_v3_intersect.rs (line 25)

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 get_readers_mut(&mut self) -> &mut [Reader<R, V>]

Returns a mutable reference to the inner readers.

pub fn into_readers(self) -> Vec<Reader<R, V>>

Returns the inner readers, consuming self.

pub fn new(readers: Vec<Reader<R, V>>) -> Self

Creates a new intersecting reader from a collection of readers.

Panics

Panics if readers is empty.

Examples found in repository

examples/saf_v3_intersect.rs (line 18)

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 read_records( &mut self, bufs: &mut [Record<Id, V::Item>], ) -> Result<ReadStatus>

Reads a set of intersecting records, one from each contained reader.

If successful, a record from each inner reader will be read into the corresponding buffer such that all resulting records will be on the same contig and the same position.

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

Examples found in repository

examples/saf_v3_intersect.rs (line 24)

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