fgumi 0.1.3

High-performance tools for UMI-tagged sequencing data: extraction, grouping, and consensus calling
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

use std::{error, fmt};

use noodles::sam;

use super::num::write_i32_le;

const MAX_REFERENCE_SEQUENCE_ID: usize = i32::MAX as usize;

#[derive(Clone, Debug, Eq, PartialEq)]
pub enum EncodeError {
    OutOfRange(usize),
    MissingEntry { actual: usize, expected: usize },
}

impl error::Error for EncodeError {}

impl fmt::Display for EncodeError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::OutOfRange(actual) => {
                write!(f, "out of range: expected <= {MAX_REFERENCE_SEQUENCE_ID}, got {actual}")
            }
            Self::MissingEntry { actual, expected } => {
                write!(f, "missing entry: expected < {expected}, got {actual}")
            }
        }
    }
}

pub(super) fn write_reference_sequence_id(
    dst: &mut Vec<u8>,
    header: &sam::Header,
    reference_sequence_id: Option<usize>,
) -> Result<(), EncodeError> {
    const UNMAPPED: i32 = -1;

    let n = if let Some(id) = reference_sequence_id {
        if id < header.reference_sequences().len() {
            i32::try_from(id).map_err(|_| EncodeError::OutOfRange(id))?
        } else {
            return Err(EncodeError::MissingEntry {
                actual: id,
                expected: header.reference_sequences().len(),
            });
        }
    } else {
        UNMAPPED
    };

    write_i32_le(dst, n);

    Ok(())
}

#[cfg(test)]
mod tests {
    use std::num::NonZero;

    use super::*;

    #[test]
    fn test_write_reference_sequence_id() -> Result<(), EncodeError> {
        use sam::header::record::value::{Map, map::ReferenceSequence};

        fn t(
            buf: &mut Vec<u8>,
            header: &sam::Header,
            reference_sequence_id: Option<usize>,
            expected: &[u8],
        ) -> Result<(), EncodeError> {
            buf.clear();
            write_reference_sequence_id(buf, header, reference_sequence_id)?;
            assert_eq!(buf, expected);
            Ok(())
        }

        let mut buf = Vec::new();

        let header = sam::Header::default();
        let reference_sequence_id = None;
        t(&mut buf, &header, reference_sequence_id, &[0xff, 0xff, 0xff, 0xff])?;

        let header = sam::Header::builder()
            .add_reference_sequence(
                "sq0",
                Map::<ReferenceSequence>::new(const { NonZero::new(8).expect("non-zero value 8") }),
            )
            .build();
        let reference_sequence_id = Some(0);
        t(&mut buf, &header, reference_sequence_id, &[0x00, 0x00, 0x00, 0x00])?;

        buf.clear();
        let header = sam::Header::default();
        let reference_sequence_id = Some(0);
        assert_eq!(
            write_reference_sequence_id(&mut buf, &header, reference_sequence_id),
            Err(EncodeError::MissingEntry { actual: 0, expected: 0 })
        );

        Ok(())
    }
}