fastqrab-steps 0.9.1

Pipeline building blocks for fastqrab: read transformations, filters, reports, and demultiplexing
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

use fastqrab_dna::dna::TagColumn;
use fastqrab_io::io::{FastQBlocksCombined, WrappedFastQRead};

mod base_content;
mod complexity;
mod convert_to_rate;
mod expected_error;
mod kmers;
mod length;
mod n_content;
mod qualified_bases;

mod gc_content;
mod worst_quality;

pub use base_content::{BaseContent, PartialBaseContent};
pub use complexity::{Complexity, PartialComplexity};
pub use convert_to_rate::{ConvertToRate, PartialConvertToRate};
pub use expected_error::{ExpectedError, PartialExpectedError};
use fastqrab_config::{
    TagLabel,
    segments::{SegmentIndex, SegmentIndexOrAll},
};
pub use gc_content::{GCContent, PartialGCContent};
pub use kmers::{Kmers, PartialKmers};
pub use length::{Length, PartialLength};
pub use n_content::{NContent, PartialNContent};
pub use qualified_bases::{PartialQualifiedBases, QualifiedBases};
pub use worst_quality::{PartialWorstQuality, WorstQuality};

pub(crate) fn extract_numeric_tags<F>(
    segment: SegmentIndex,
    label: &TagLabel,
    mut extractor: F,
    block: &mut FastQBlocksCombined,
) where
    F: FnMut(&WrappedFastQRead) -> f64,
{
    let mut values = Vec::with_capacity(block.segments[segment.as_index()].len()); //7% speed up
    let f = |read: &mut WrappedFastQRead| {
        values.push(extractor(read));
    };

    block.segments[segment.as_index()].apply(f);
    block.tags.insert(label.clone(), TagColumn::Numeric(values));
}

pub(crate) fn extract_numeric_tags_plus_all<F>(
    segment: SegmentIndexOrAll,
    label: &TagLabel,
    extractor_single: F,
    mut extractor_all: impl FnMut(&Vec<WrappedFastQRead>) -> f64,
    block: &mut FastQBlocksCombined,
) where
    F: FnMut(&WrappedFastQRead) -> f64,
{
    if let Ok(target) = segment.try_into() as Result<SegmentIndex, _> {
        // Handle single target case
        extract_numeric_tags(target, label, extractor_single, block);
    } else {
        // Handle "All" target case
        let mut values = Vec::with_capacity(block.segments[0].len());
        let mut block_iter = block.get_pseudo_iter();
        while let Some(molecule) = block_iter.pseudo_next() {
            let value = extractor_all(&molecule.segments);
            values.push(value);
        }
        block.tags.insert(label.clone(), TagColumn::Numeric(values));
    }
}