paraseq 0.4.10

A minimal-copy parser for FASTA and FASTQ files built for paired parallel processing.
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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use std::error::Error as StdError;
use std::fmt;

use crossbeam_channel::SendError;
use thiserror::Error;

#[cfg(feature = "htslib")]
use crate::htslib::ParallelHtslibError;
#[cfg(feature = "htslib")]
use rust_htslib::errors::Error as HtslibError;

// Convenience Result type alias
pub type Result<T> = std::result::Result<T, ProcessError>;

/// Error type for parallel processing operations
#[derive(Error, Debug)]
pub enum ProcessError {
    /// Error occurred during parallel processing
    #[error("Processing error: {0}")]
    Process(Box<dyn StdError + Send + Sync>),

    /// Invalid number of threads specified
    #[error("Invalid thread count specified")]
    InvalidThreadCount,

    #[error(
        "Collection size mismatch, expected multiple of {} found {}",
        arity,
        found
    )]
    CollectionSizeMismatch { arity: usize, found: usize },

    /// Incompatible readers specified
    #[error("Incompatible readers specified, expected both readers to be the same input format")]
    IncompatibleReaders,

    #[error("Incompatible record set sizes: {0} != {1}")]
    IncompatibleRecordSetSizes(usize, usize),

    #[error("Incompatible interleaved set size - expected an even number: {0}")]
    IncompatibleInterleavedSetSize(usize),

    /// Record synchronization error between paired files
    #[error("Record synchronization error between paired files. {0} has less records.")]
    PairedRecordMismatch(RecordPair),

    /// Record synchronization error between paired files
    #[error(
        "Record synchronization error between multiple files. (at least) File {0} has fewer records."
    )]
    MultiRecordMismatch(usize),

    #[error("Record set length ({0}) must be divisible by {1}")]
    MultiRecordSetSizeMismatch(usize, usize),

    /// Error sending data between threads
    #[error("Channel error: {0}")]
    SendError(#[from] SendError<Option<usize>>),

    /// Error joining threads
    #[error("Thread join error.")]
    JoinError,

    /// Error reading from input
    #[error("I/O error: {0}")]
    IoError(#[from] std::io::Error),

    /// Error from FASTX processing
    #[error("FASTX error: {0}")]
    FastxError(#[from] crate::Error),

    /// Error from HTSlib
    #[cfg(feature = "htslib")]
    #[error("HTSlib error: {0}")]
    HtslibError(#[from] HtslibError),

    /// Error for parallel processing of HTSlib files
    #[cfg(feature = "htslib")]
    #[error("Parallel HTSlib error: {0}")]
    ParallelHtslibError(#[from] ParallelHtslibError),
}

/// Enum for identifying record pairs
#[derive(Debug)]
pub enum RecordPair {
    R1,
    R2,
}
impl fmt::Display for RecordPair {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            RecordPair::R1 => write!(f, "R1"),
            RecordPair::R2 => write!(f, "R2"),
        }
    }
}

/// Trait for converting arbitrary errors into `ProcessError`
pub trait IntoProcessError {
    fn into_process_error(self) -> ProcessError;
}

// Implement conversion for Box<dyn Error>
impl<E> IntoProcessError for E
where
    E: StdError + Send + Sync + 'static,
{
    fn into_process_error(self) -> ProcessError {
        ProcessError::Process(Box::new(self))
    }
}

// Feature-gated anyhow support
#[cfg(feature = "anyhow")]
impl From<anyhow::Error> for ProcessError {
    fn from(err: anyhow::Error) -> Self {
        ProcessError::Process(err.into())
    }
}