Struct ReadBatch 

pub struct ReadBatch { /* private fields */ }

A batch of paired-end reads to map.

All slices must have the same length (count). Sequences are ASCII DNA strings (ACGTN) and qualities are phred+33 ASCII strings.

Implementations

impl ReadBatch

pub fn new() -> Self

Create a new empty batch.

Examples found in repository

examples/align.rs (line 45)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    if args.len() < 2 {
        eprintln!("Usage: {} <index_prefix>", args[0]);
        std::process::exit(1);
    }
    let index_prefix = &args[1];

    // Configure the mapper.
    let options = MapperOptions {
        sensitivity: Sensitivity::Full,
        threads: 2,
        verbose: 1,
        ..Default::default()
    };

    // Open the index.
    eprintln!("Opening index: {index_prefix}");
    let mapper = YaraMapper::open(index_prefix, &options).unwrap_or_else(|e| {
        eprintln!("Failed to open index: {e}");
        std::process::exit(1);
    });

    eprintln!("Loaded {} contigs", mapper.contig_count());
    for (i, (name, len)) in mapper.contig_names().iter().zip(mapper.contig_lengths()).enumerate() {
        eprintln!("  contig {i}: {name} ({len} bp)");
        if i >= 5 {
            eprintln!("  ... ({} more)", mapper.contig_count() - i - 1);
            break;
        }
    }

    // Create a synthetic read pair (these won't align to anything real).
    let mut batch = ReadBatch::new();
    batch
        .push(
            "test_read_1",
            ReadEnd {
                seq: b"ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT",
                qual: b"IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII",
            },
            ReadEnd {
                seq: b"TGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCA",
                qual: b"IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII",
            },
        )
        .expect("failed to add read pair");

    // Map the reads.
    eprintln!("Mapping {} read pair(s)...", batch.len());
    match mapper.map_paired(&batch) {
        Ok(records) => {
            eprintln!("Got {} alignment record(s)", records.len());
            for rec in &records {
                println!(
                    "pair={} read1={} contig={} pos={} rev={} unmapped={} secondary={} mapq={} nm={} cigar={} flag={}",
                    rec.read_pair_index,
                    rec.is_read1,
                    rec.contig_id,
                    rec.pos,
                    rec.is_reverse,
                    rec.is_unmapped,
                    rec.is_secondary,
                    rec.mapq,
                    rec.nm,
                    rec.cigar_string(),
                    rec.flag,
                );
            }
        }
        Err(e) => {
            eprintln!("Mapping failed: {e}");
            std::process::exit(1);
        }
    }
}

pub fn with_capacity(n: usize) -> Self

Create a batch with pre-allocated capacity for n pairs.

pub fn push( &mut self, name: &str, r1: ReadEnd<'_>, r2: ReadEnd<'_>, ) -> Result<(), YaraError>

Add a read pair to the batch.

Errors

Returns YaraError::InvalidInput if any input contains a null byte or if sequence and quality lengths do not match.

Examples found in repository

examples/align.rs (lines 47-57)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    if args.len() < 2 {
        eprintln!("Usage: {} <index_prefix>", args[0]);
        std::process::exit(1);
    }
    let index_prefix = &args[1];

    // Configure the mapper.
    let options = MapperOptions {
        sensitivity: Sensitivity::Full,
        threads: 2,
        verbose: 1,
        ..Default::default()
    };

    // Open the index.
    eprintln!("Opening index: {index_prefix}");
    let mapper = YaraMapper::open(index_prefix, &options).unwrap_or_else(|e| {
        eprintln!("Failed to open index: {e}");
        std::process::exit(1);
    });

    eprintln!("Loaded {} contigs", mapper.contig_count());
    for (i, (name, len)) in mapper.contig_names().iter().zip(mapper.contig_lengths()).enumerate() {
        eprintln!("  contig {i}: {name} ({len} bp)");
        if i >= 5 {
            eprintln!("  ... ({} more)", mapper.contig_count() - i - 1);
            break;
        }
    }

    // Create a synthetic read pair (these won't align to anything real).
    let mut batch = ReadBatch::new();
    batch
        .push(
            "test_read_1",
            ReadEnd {
                seq: b"ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT",
                qual: b"IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII",
            },
            ReadEnd {
                seq: b"TGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCA",
                qual: b"IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII",
            },
        )
        .expect("failed to add read pair");

    // Map the reads.
    eprintln!("Mapping {} read pair(s)...", batch.len());
    match mapper.map_paired(&batch) {
        Ok(records) => {
            eprintln!("Got {} alignment record(s)", records.len());
            for rec in &records {
                println!(
                    "pair={} read1={} contig={} pos={} rev={} unmapped={} secondary={} mapq={} nm={} cigar={} flag={}",
                    rec.read_pair_index,
                    rec.is_read1,
                    rec.contig_id,
                    rec.pos,
                    rec.is_reverse,
                    rec.is_unmapped,
                    rec.is_secondary,
                    rec.mapq,
                    rec.nm,
                    rec.cigar_string(),
                    rec.flag,
                );
            }
        }
        Err(e) => {
            eprintln!("Mapping failed: {e}");
            std::process::exit(1);
        }
    }
}

pub fn len(&self) -> usize

Number of read pairs in the batch.

Examples found in repository

examples/align.rs (line 61)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    if args.len() < 2 {
        eprintln!("Usage: {} <index_prefix>", args[0]);
        std::process::exit(1);
    }
    let index_prefix = &args[1];

    // Configure the mapper.
    let options = MapperOptions {
        sensitivity: Sensitivity::Full,
        threads: 2,
        verbose: 1,
        ..Default::default()
    };

    // Open the index.
    eprintln!("Opening index: {index_prefix}");
    let mapper = YaraMapper::open(index_prefix, &options).unwrap_or_else(|e| {
        eprintln!("Failed to open index: {e}");
        std::process::exit(1);
    });

    eprintln!("Loaded {} contigs", mapper.contig_count());
    for (i, (name, len)) in mapper.contig_names().iter().zip(mapper.contig_lengths()).enumerate() {
        eprintln!("  contig {i}: {name} ({len} bp)");
        if i >= 5 {
            eprintln!("  ... ({} more)", mapper.contig_count() - i - 1);
            break;
        }
    }

    // Create a synthetic read pair (these won't align to anything real).
    let mut batch = ReadBatch::new();
    batch
        .push(
            "test_read_1",
            ReadEnd {
                seq: b"ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT",
                qual: b"IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII",
            },
            ReadEnd {
                seq: b"TGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCA",
                qual: b"IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII",
            },
        )
        .expect("failed to add read pair");

    // Map the reads.
    eprintln!("Mapping {} read pair(s)...", batch.len());
    match mapper.map_paired(&batch) {
        Ok(records) => {
            eprintln!("Got {} alignment record(s)", records.len());
            for rec in &records {
                println!(
                    "pair={} read1={} contig={} pos={} rev={} unmapped={} secondary={} mapq={} nm={} cigar={} flag={}",
                    rec.read_pair_index,
                    rec.is_read1,
                    rec.contig_id,
                    rec.pos,
                    rec.is_reverse,
                    rec.is_unmapped,
                    rec.is_secondary,
                    rec.mapq,
                    rec.nm,
                    rec.cigar_string(),
                    rec.flag,
                );
            }
        }
        Err(e) => {
            eprintln!("Mapping failed: {e}");
            std::process::exit(1);
        }
    }
}

pub fn is_empty(&self) -> bool

Whether the batch is empty.

Trait Implementations

impl Default for ReadBatch

fn default() -> ReadBatch

Returns the “default value” for a type.