use std::path::Path;
use std::sync::mpsc::{SyncSender, sync_channel};
use std::thread::JoinHandle;
use noodles_sam::alignment::record::data::field::Tag;
use noodles_sam::{self as sam};
use crate::filter::DropReason;
use crate::io::Format;
pub(crate) const REASON_TAG: Tag = Tag::new(b'w', b'r');
const QUEUE_PER_WORKER: usize = 4;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum Reason {
TagFilter,
TrimmedToNothing,
Dropped(DropReason),
}
impl Reason {
pub(crate) fn label(self) -> &'static str {
match self {
Reason::TagFilter => "tag_filter",
Reason::TrimmedToNothing => "trimmed_to_nothing",
Reason::Dropped(DropReason::TooShort) => "too_short",
Reason::Dropped(DropReason::TooLong) => "too_long",
Reason::Dropped(DropReason::LowQuality) => "low_quality",
Reason::Dropped(DropReason::HighQuality) => "high_quality",
Reason::Dropped(DropReason::ExpectedErrors) => "expected_errors",
Reason::Dropped(DropReason::Gc) => "gc",
}
}
}
pub(crate) fn push_fastq_tag(out: &mut Vec<u8>, reason: Reason) {
out.extend_from_slice(b"\twr:Z:");
out.extend_from_slice(reason.label().as_bytes());
}
pub(crate) enum RejectItem {
Bam(Vec<u8>),
Fastq(Vec<u8>),
End,
}
#[derive(Clone)]
pub(crate) struct Rejects {
tx: SyncSender<RejectItem>,
}
impl Rejects {
pub(crate) fn send(&self, item: RejectItem) -> anyhow::Result<()> {
self.tx
.send(item)
.map_err(|_| anyhow::anyhow!("the rejected-record writer stopped"))
}
}
pub(crate) struct RejectWriter {
tx: SyncSender<RejectItem>,
handle: JoinHandle<anyhow::Result<()>>,
}
impl RejectWriter {
pub(crate) fn start(
path: &Path,
format: Format,
level: u8,
header: Option<sam::Header>,
workers: usize,
) -> anyhow::Result<(Rejects, RejectWriter)> {
let (tx, rx) = sync_channel::<RejectItem>((workers * QUEUE_PER_WORKER).max(4));
let handle = match format {
Format::Bam => {
let header = header.expect("BAM rejected output is given its header");
let mut sink = crate::io::bam::writer(Some(path), &header, false, level)?;
std::thread::Builder::new()
.name("rejected-writer".into())
.spawn(move || {
for item in rx.iter() {
match item {
RejectItem::Bam(rec) => sink.write_record_bytes(&header, &rec)?,
RejectItem::Fastq(_) => {
anyhow::bail!("a FASTQ record reached the BAM rejected output")
},
RejectItem::End => break,
}
}
sink.finish()
})?
},
Format::Fastq | Format::FastqGz | Format::FastqBgzf => {
let mut sink = crate::io::fastq::writer_to(Some(path), format, level, false)?;
std::thread::Builder::new()
.name("rejected-writer".into())
.spawn(move || {
use std::io::Write;
for item in rx.iter() {
match item {
RejectItem::Fastq(bytes) => sink.write_all(&bytes)?,
RejectItem::Bam(_) => {
anyhow::bail!("a BAM record reached the FASTQ rejected output")
},
RejectItem::End => break,
}
}
sink.finish()
})?
},
};
Ok((Rejects { tx: tx.clone() }, RejectWriter { tx, handle }))
}
pub(crate) fn finish(self) -> anyhow::Result<()> {
let _ = self.tx.send(RejectItem::End);
self.handle
.join()
.map_err(|_| anyhow::anyhow!("the rejected-record writer panicked"))?
}
}
pub(crate) fn resolve_format(path: &Path, out_fmt: Format) -> anyhow::Result<Format> {
let format = crate::io::resolve_output(Some(path), out_fmt);
if format.family() != out_fmt.family() {
anyhow::bail!(
"--rejected-output {} is {} but the output is {}; rejected records are written in the \
output's format family",
path.display(),
format.family(),
out_fmt.family()
);
}
Ok(format)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn reasons_have_stable_labels() {
assert_eq!(Reason::TagFilter.label(), "tag_filter");
assert_eq!(Reason::TrimmedToNothing.label(), "trimmed_to_nothing");
assert_eq!(Reason::Dropped(DropReason::TooShort).label(), "too_short");
assert_eq!(Reason::Dropped(DropReason::Gc).label(), "gc");
assert_eq!(
Reason::Dropped(DropReason::ExpectedErrors).label(),
"expected_errors"
);
}
#[test]
fn rejected_format_follows_the_output_family() {
assert_eq!(
resolve_format(Path::new("r.fastq.gz"), Format::Fastq).unwrap(),
Format::FastqGz
);
assert_eq!(
resolve_format(Path::new("r.bam"), Format::Bam).unwrap(),
Format::Bam
);
assert!(resolve_format(Path::new("r.bam"), Format::Fastq).is_err());
assert!(resolve_format(Path::new("r.fastq"), Format::Bam).is_err());
}
#[test]
fn fastq_tag_names_the_reason() {
let mut out = b"@r1".to_vec();
push_fastq_tag(&mut out, Reason::TagFilter);
assert_eq!(out, b"@r1\twr:Z:tag_filter");
}
}