pub mod catalog;
pub mod detect;
pub mod infer;
pub mod preset;
pub mod resolve;
pub mod search;
use std::cell::RefCell;
use std::collections::BTreeMap;
use std::sync::OnceLock;
use search::{
AmbiguousSearcher, EncodedAdapterBatch, Hit, MAX_TILED_PATTERN_LEN, PlainSearcher, Strands,
encode_patterns, encoded_pattern_hits, for_each_hit, for_each_hit_in_texts, is_plain_acgt,
iupac_bases, new_ambiguous_searcher, new_overhang_searcher, new_searcher,
};
mod budget;
mod hits;
mod index;
mod passes;
mod refine;
pub(crate) use budget::*;
use hits::*;
pub(crate) use index::*;
pub(crate) use passes::*;
thread_local! {
static STATE: RefCell<ThreadState> = RefCell::new(ThreadState::new());
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Role {
Adapter,
Primer,
Barcode,
}
impl Role {
pub fn label(self) -> &'static str {
match self {
Role::Adapter => "adapter",
Role::Primer => "primer",
Role::Barcode => "barcode",
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Adapter {
pub name: String,
pub seq: Vec<u8>,
pub role: Role,
}
#[derive(Debug, Clone)]
pub struct AdapterConfig {
pub adapters: Vec<Adapter>,
pub error_rate: f64,
pub end_size: usize,
pub split: bool,
pub min_piece: usize,
pub(crate) candidate_index: OnceLock<CandidateIndex>,
pub amplicon: bool,
}
impl AdapterConfig {
pub(crate) fn replace_adapters(&mut self, adapters: Vec<Adapter>) {
self.adapters = adapters;
self.candidate_index = OnceLock::new();
}
pub(crate) fn set_amplicon(&mut self, amplicon: bool) {
self.amplicon = amplicon;
self.candidate_index = OnceLock::new();
}
pub(crate) fn barcode_span_verified(
&self,
seq: &[u8],
start: usize,
end: usize,
call: Option<&[u8]>,
) -> bool {
let lo = start.saturating_sub(BARCODE_SPAN_SLACK);
let hi = end.saturating_add(BARCODE_SPAN_SLACK).min(seq.len());
if hi <= lo {
return false;
}
let text = seq[lo..hi].to_ascii_uppercase();
let number = call.and_then(barcode_number);
let named = catalog_barcodes().iter().filter(|entry| {
number.is_some_and(|n| barcode_number(entry.name.as_bytes()) == Some(n))
});
let mut searcher = search::new_ambiguous_searcher();
self.adapters
.iter()
.filter(|entry| entry.role == Role::Barcode)
.chain(named)
.filter(|entry| entry.seq.len() >= MIN_PATTERN_LEN)
.any(|entry| {
let pattern = entry.seq.to_ascii_uppercase();
let k = edit_budget(self.error_rate, pattern.len());
!search::hits(&mut searcher, &pattern, &text, k).is_empty()
})
}
}
const BARCODE_SPAN_SLACK: usize = 3;
fn catalog_barcodes() -> &'static [Adapter] {
static ENTRIES: OnceLock<Vec<Adapter>> = OnceLock::new();
ENTRIES.get_or_init(|| {
preset::preset(preset::Kit::ALL)
.into_iter()
.filter(|entry| entry.role == Role::Barcode)
.collect()
})
}
fn barcode_number(name: &[u8]) -> Option<u32> {
let digits = name.iter().rev().take_while(|b| b.is_ascii_digit()).count();
(digits > 0)
.then(|| {
std::str::from_utf8(&name[name.len() - digits..])
.ok()?
.parse()
.ok()
})
.flatten()
}
fn complement(base: u8) -> u8 {
let upper = match base.to_ascii_uppercase() {
b'A' => b'T',
b'T' => b'A',
b'C' => b'G',
b'G' => b'C',
b'R' => b'Y',
b'Y' => b'R',
b'K' => b'M',
b'M' => b'K',
b'B' => b'V',
b'V' => b'B',
b'D' => b'H',
b'H' => b'D',
other => other,
};
if base.is_ascii_lowercase() {
upper.to_ascii_lowercase()
} else {
upper
}
}
pub(crate) fn reverse_complement(seq: &[u8]) -> Vec<u8> {
seq.iter().rev().map(|&b| complement(b)).collect()
}
pub const MIN_PATTERN_LEN: usize = 11;
pub const MIN_OVERLAP: usize = 10;
const FLANK_SLACK: usize = MIN_PATTERN_LEN;
pub fn adapter_segments(window: &[u8], cfg: &AdapterConfig) -> Vec<(usize, usize)> {
segments_tallied(window, cfg, None)
}
pub(crate) fn adapter_segments_tallied(
window: &[u8],
cfg: &AdapterConfig,
acted: &mut [bool],
) -> Vec<(usize, usize)> {
segments_tallied(window, cfg, Some(acted))
}
#[cfg(test)]
mod segment_tests;