bio-seq 0.14.8

Bit packed and well-typed biological sequences
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

use core::fmt;
use core::result;

#[derive(Debug, PartialEq)]
pub enum ParseBioError {
    UnrecognisedBase(u8),
    MismatchedLength(usize, usize),
    SequenceTooLong(usize, usize),
}

pub type Result<T> = result::Result<T, ParseBioError>;

impl fmt::Display for ParseBioError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ParseBioError::UnrecognisedBase(byte) => {
                if byte.is_ascii_alphanumeric() {
                    write!(
                        f,
                        "Unrecognised character: '{}' ({byte:#04X?})",
                        *byte as char,
                    )
                } else {
                    write!(f, "Unrecognised character: {byte:#04X?}")
                }
            }

            ParseBioError::MismatchedLength(got, expected) => {
                write!(f, "Expected length {expected}, got {got}")
            }

            ParseBioError::SequenceTooLong(got, expected) => {
                write!(f, "Expected length <= {expected}, got {got}")
            }
        }
    }
}

impl From<ParseBioError> for std::io::Error {
    fn from(err: ParseBioError) -> Self {
        std::io::Error::other(err)
    }
}

// #![feature(error_in_core)
impl std::error::Error for ParseBioError {}

#[cfg(test)]
mod tests {
    use crate::prelude::*;

    #[test]
    fn test_parse_error() {
        let seq = Seq::<Dna>::from_str("ACGTx").unwrap_err();
        assert_eq!(
            format!("{seq}"),
            "Unrecognised character: 'x' (0x78)".to_string()
        );

        let seq = Seq::<Dna>::from_str("ACGT\n").unwrap_err();
        assert_eq!(format!("{seq}"), "Unrecognised character: 0x0A".to_string());

        let err: std::io::Error = seq.into();
        assert_eq!(err.kind(), std::io::ErrorKind::Other);

        let seq = Seq::<Dna>::from_str("ACGTT");
        assert!(seq.is_ok());
    }

    #[test]
    fn test_mismatched_length() {
        let seq: &SeqSlice<Dna> = dna!("ACGTGAT");
        let kmer = Kmer::<Dna, 14>::try_from(seq).unwrap_err();
        assert_eq!(format!("{kmer}"), "Expected length 7, got 14".to_string());

        let kmer = Kmer::<Dna, 6>::try_from(seq).unwrap_err();
        assert_eq!(format!("{kmer}"), "Expected length 7, got 6".to_string());

        let kmer = Kmer::<Dna, 7>::try_from(seq);
        assert!(kmer.is_ok());
    }

    #[test]
    fn test_size_error() {
        let seq = dna!("ACGTACGTACGTACGTACGTACGTACGTACGTA");
        let int = TryInto::<usize>::try_into(seq).unwrap_err();

        let expected_size = usize::BITS / Dna::BITS as u32;

        assert_eq!(
            format!("{int}"),
            format!("Expected length <= {expected_size}, got 33")
        );

        let good = TryInto::<usize>::try_into(&seq[..expected_size as usize]);
        assert!(good.is_ok());
    }
}