Struct bam_builder::ReadPairSpecBuilder

pub struct ReadPairSpecBuilder { /* private fields */ }

Builder for ReadPairSpec.

Implementations

impl ReadPairSpecBuilder

pub fn name(&mut self, value: String) -> &mut Self

Name of the reads, will be filled in by BamBuilder::next_name by default.

pub fn bases1(&mut self, value: String) -> &mut Self

Sequence bases, will be filled in by BamBuilder::random_bases by default.

Examples found in repository

examples/ex1.rs (line 23)

fn main() {
    // Create a builder with all defaults except the read_len is 100
    let mut builder = BamBuilder::new(
        100,
        30,
        "Pair".to_owned(),
        None,
        BamSortOrder::Unsorted,
        None,
        None,
    );

    // Create a builder for read pair spec
    let records = builder
        .pair_builder()
        .contig(0)
        .start1(0)
        .start2(200)
        .unmapped1(false)
        .unmapped2(false)
        .bases1("A".repeat(100))
        .bases2("C".repeat(100))
        .build()
        .unwrap();
    println!("{:?}", records);

    // Add the pair to bam builder
    builder.add_pair(records);
    println!("{:?}", builder);
    // Write records to a file
    builder
        .to_path(std::path::Path::new(&String::from("./test.bam")))
        .unwrap();
}

pub fn bases2(&mut self, value: String) -> &mut Self

Sequence bases, will be filled in by BamBuilder::random_bases by default.

Examples found in repository

examples/ex1.rs (line 24)

fn main() {
    // Create a builder with all defaults except the read_len is 100
    let mut builder = BamBuilder::new(
        100,
        30,
        "Pair".to_owned(),
        None,
        BamSortOrder::Unsorted,
        None,
        None,
    );

    // Create a builder for read pair spec
    let records = builder
        .pair_builder()
        .contig(0)
        .start1(0)
        .start2(200)
        .unmapped1(false)
        .unmapped2(false)
        .bases1("A".repeat(100))
        .bases2("C".repeat(100))
        .build()
        .unwrap();
    println!("{:?}", records);

    // Add the pair to bam builder
    builder.add_pair(records);
    println!("{:?}", builder);
    // Write records to a file
    builder
        .to_path(std::path::Path::new(&String::from("./test.bam")))
        .unwrap();
}

pub fn quals1(&mut self, value: String) -> &mut Self

Quality string, will be based on the BamBuilder::base_quality by default.

pub fn quals2(&mut self, value: String) -> &mut Self

Quality string, will be based on the BamBuilder::base_quality by default.

pub fn contig(&mut self, value: i32) -> &mut Self

Reference contig if mapped, defaults to unmapped.

Examples found in repository

examples/ex1.rs (line 18)

fn main() {
    // Create a builder with all defaults except the read_len is 100
    let mut builder = BamBuilder::new(
        100,
        30,
        "Pair".to_owned(),
        None,
        BamSortOrder::Unsorted,
        None,
        None,
    );

    // Create a builder for read pair spec
    let records = builder
        .pair_builder()
        .contig(0)
        .start1(0)
        .start2(200)
        .unmapped1(false)
        .unmapped2(false)
        .bases1("A".repeat(100))
        .bases2("C".repeat(100))
        .build()
        .unwrap();
    println!("{:?}", records);

    // Add the pair to bam builder
    builder.add_pair(records);
    println!("{:?}", builder);
    // Write records to a file
    builder
        .to_path(std::path::Path::new(&String::from("./test.bam")))
        .unwrap();
}

pub fn start1(&mut self, value: i64) -> &mut Self

0-based location on reference contig if mapped. defaults to unmapped.

Examples found in repository

examples/ex1.rs (line 19)

fn main() {
    // Create a builder with all defaults except the read_len is 100
    let mut builder = BamBuilder::new(
        100,
        30,
        "Pair".to_owned(),
        None,
        BamSortOrder::Unsorted,
        None,
        None,
    );

    // Create a builder for read pair spec
    let records = builder
        .pair_builder()
        .contig(0)
        .start1(0)
        .start2(200)
        .unmapped1(false)
        .unmapped2(false)
        .bases1("A".repeat(100))
        .bases2("C".repeat(100))
        .build()
        .unwrap();
    println!("{:?}", records);

    // Add the pair to bam builder
    builder.add_pair(records);
    println!("{:?}", builder);
    // Write records to a file
    builder
        .to_path(std::path::Path::new(&String::from("./test.bam")))
        .unwrap();
}

pub fn start2(&mut self, value: i64) -> &mut Self

0-based location on reference contig if mapped. defaults to unmapped.

Examples found in repository

examples/ex1.rs (line 20)

fn main() {
    // Create a builder with all defaults except the read_len is 100
    let mut builder = BamBuilder::new(
        100,
        30,
        "Pair".to_owned(),
        None,
        BamSortOrder::Unsorted,
        None,
        None,
    );

    // Create a builder for read pair spec
    let records = builder
        .pair_builder()
        .contig(0)
        .start1(0)
        .start2(200)
        .unmapped1(false)
        .unmapped2(false)
        .bases1("A".repeat(100))
        .bases2("C".repeat(100))
        .build()
        .unwrap();
    println!("{:?}", records);

    // Add the pair to bam builder
    builder.add_pair(records);
    println!("{:?}", builder);
    // Write records to a file
    builder
        .to_path(std::path::Path::new(&String::from("./test.bam")))
        .unwrap();
}

pub fn unmapped1(&mut self, value: bool) -> &mut Self

true if unmapped, defaults to true.

Examples found in repository

examples/ex1.rs (line 21)

fn main() {
    // Create a builder with all defaults except the read_len is 100
    let mut builder = BamBuilder::new(
        100,
        30,
        "Pair".to_owned(),
        None,
        BamSortOrder::Unsorted,
        None,
        None,
    );

    // Create a builder for read pair spec
    let records = builder
        .pair_builder()
        .contig(0)
        .start1(0)
        .start2(200)
        .unmapped1(false)
        .unmapped2(false)
        .bases1("A".repeat(100))
        .bases2("C".repeat(100))
        .build()
        .unwrap();
    println!("{:?}", records);

    // Add the pair to bam builder
    builder.add_pair(records);
    println!("{:?}", builder);
    // Write records to a file
    builder
        .to_path(std::path::Path::new(&String::from("./test.bam")))
        .unwrap();
}

pub fn unmapped2(&mut self, value: bool) -> &mut Self

true if unmapped, defaults to true.

Examples found in repository

examples/ex1.rs (line 22)

fn main() {
    // Create a builder with all defaults except the read_len is 100
    let mut builder = BamBuilder::new(
        100,
        30,
        "Pair".to_owned(),
        None,
        BamSortOrder::Unsorted,
        None,
        None,
    );

    // Create a builder for read pair spec
    let records = builder
        .pair_builder()
        .contig(0)
        .start1(0)
        .start2(200)
        .unmapped1(false)
        .unmapped2(false)
        .bases1("A".repeat(100))
        .bases2("C".repeat(100))
        .build()
        .unwrap();
    println!("{:?}", records);

    // Add the pair to bam builder
    builder.add_pair(records);
    println!("{:?}", builder);
    // Write records to a file
    builder
        .to_path(std::path::Path::new(&String::from("./test.bam")))
        .unwrap();
}

pub fn cigar1(&mut self, value: String) -> &mut Self

Alignment, defaults to all M if mapped or * if unmapped.

pub fn cigar2(&mut self, value: String) -> &mut Self

Alignment, defaults to all M if mapped or * if unmapped.

pub fn mapq1(&mut self, value: u8) -> &mut Self

map quality of the read, defaults to 60 if mapped, * if unmapped.

pub fn mapq2(&mut self, value: u8) -> &mut Self

map quality of the read, defaults to 60 if mapped, * if unmapped.

pub fn strand1(&mut self, value: Strand) -> &mut Self

Strand the read maps to, defaults to wrappers::Strand::Plus.

pub fn strand2(&mut self, value: Strand) -> &mut Self

Strand the read maps to, defaults to wrappers::Strand::Minus.

pub fn attrs(&mut self, value: HashMap<String, AuxType>) -> &mut Self

Tags for the reads, mate tags will be filled in by default.

pub fn build(&self) -> Result<ReadPairSpec, ReadPairSpecBuilderError>

Builds a new ReadPairSpec.

Errors

If a required field has not been initialized.

Examples found in repository

examples/ex1.rs (line 25)

fn main() {
    // Create a builder with all defaults except the read_len is 100
    let mut builder = BamBuilder::new(
        100,
        30,
        "Pair".to_owned(),
        None,
        BamSortOrder::Unsorted,
        None,
        None,
    );

    // Create a builder for read pair spec
    let records = builder
        .pair_builder()
        .contig(0)
        .start1(0)
        .start2(200)
        .unmapped1(false)
        .unmapped2(false)
        .bases1("A".repeat(100))
        .bases2("C".repeat(100))
        .build()
        .unwrap();
    println!("{:?}", records);

    // Add the pair to bam builder
    builder.add_pair(records);
    println!("{:?}", builder);
    // Write records to a file
    builder
        .to_path(std::path::Path::new(&String::from("./test.bam")))
        .unwrap();
}

Trait Implementations

impl Clone for ReadPairSpecBuilder

fn clone(&self) -> ReadPairSpecBuilder

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for ReadPairSpecBuilder

fn default() -> Self

Returns the “default value” for a type.