ps-ecc 0.1.0-9

Generates Reed-Solomon error correction codes.
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use crate::ReedSolomon;

impl ReedSolomon {
    /// Applies XOR corrections to a detached `(parity, data)` pair.
    ///
    /// The `corrections` slice is laid out parity-first, matching the
    /// `parity || data` codeword layout: its first `parity.len()` bytes are
    /// `XORed` onto `parity`, and the remaining bytes onto `data`.
    ///
    /// Like [`ReedSolomon::apply_corrections`], this method uses truncating
    /// zip semantics. If `corrections` holds fewer bytes than `parity` and
    /// `data` combined, the uncovered tail is left unmodified; excess
    /// correction bytes are ignored.
    pub fn apply_corrections_detached(
        parity: &mut [u8],
        data: &mut [u8],
        corrections: impl AsRef<[u8]>,
    ) {
        let corrections = corrections.as_ref();
        let split = corrections.len().min(parity.len());
        let (parity_corrections, data_corrections) = corrections.split_at(split);

        Self::apply_corrections(parity, parity_corrections);
        Self::apply_corrections(data, data_corrections);
    }
}

#[cfg(test)]
#[allow(clippy::decimal_bitwise_operands)]
mod tests {
    use ps_buffer::Buffer;

    use crate::ReedSolomon;

    type TestError = Box<dyn std::error::Error>;

    #[test]
    fn test_apply_corrections_detached() -> Result<(), TestError> {
        let mut parity = Buffer::from_slice([10, 20])?;
        let mut data = Buffer::from_slice([30, 40, 50])?;
        let corrections = [1, 2, 3, 4, 5];

        ReedSolomon::apply_corrections_detached(&mut parity, &mut data, corrections);

        assert_eq!(parity.as_slice(), &[10 ^ 1, 20 ^ 2]);
        assert_eq!(data.as_slice(), &[30 ^ 3, 40 ^ 4, 50 ^ 5]);

        Ok(())
    }

    #[test]
    fn test_apply_corrections_detached_empty() -> Result<(), TestError> {
        let mut parity = Buffer::from_slice([])?;
        let mut data = Buffer::from_slice([])?;
        let corrections = [];

        ReedSolomon::apply_corrections_detached(&mut parity, &mut data, corrections);

        assert_eq!(parity.as_slice(), &[]);
        assert_eq!(data.as_slice(), &[]);

        Ok(())
    }

    #[test]
    fn test_corrections_shorter_than_parity() -> Result<(), TestError> {
        // Previously panicked on `corrections[..parity.len()]`; now the
        // uncovered parity tail and all of `data` are left unmodified.
        let mut parity = Buffer::from_slice([10, 20, 30])?;
        let mut data = Buffer::from_slice([40, 50])?;
        let corrections = [1];

        ReedSolomon::apply_corrections_detached(&mut parity, &mut data, corrections);

        assert_eq!(parity.as_slice(), &[10 ^ 1, 20, 30]);
        assert_eq!(data.as_slice(), &[40, 50]);

        Ok(())
    }

    #[test]
    fn test_corrections_cover_parity_only() -> Result<(), TestError> {
        let mut parity = Buffer::from_slice([10, 20])?;
        let mut data = Buffer::from_slice([30, 40])?;
        let corrections = [1, 2];

        ReedSolomon::apply_corrections_detached(&mut parity, &mut data, corrections);

        assert_eq!(parity.as_slice(), &[10 ^ 1, 20 ^ 2]);
        assert_eq!(data.as_slice(), &[30, 40]);

        Ok(())
    }

    #[test]
    fn test_corrections_cover_parity_and_partial_data() -> Result<(), TestError> {
        let mut parity = Buffer::from_slice([10, 20])?;
        let mut data = Buffer::from_slice([30, 40, 50])?;
        let corrections = [1, 2, 3];

        ReedSolomon::apply_corrections_detached(&mut parity, &mut data, corrections);

        assert_eq!(parity.as_slice(), &[10 ^ 1, 20 ^ 2]);
        assert_eq!(data.as_slice(), &[30 ^ 3, 40, 50]);

        Ok(())
    }

    #[test]
    fn test_corrections_longer_than_codeword() -> Result<(), TestError> {
        let mut parity = Buffer::from_slice([10])?;
        let mut data = Buffer::from_slice([20])?;
        let corrections = [1, 2, 3, 4];

        ReedSolomon::apply_corrections_detached(&mut parity, &mut data, corrections);

        assert_eq!(parity.as_slice(), &[10 ^ 1]);
        assert_eq!(data.as_slice(), &[20 ^ 2]);

        Ok(())
    }

    #[test]
    fn test_empty_parity_with_corrections() -> Result<(), TestError> {
        let mut parity = Buffer::from_slice([])?;
        let mut data = Buffer::from_slice([30, 40])?;
        let corrections = [1, 2];

        ReedSolomon::apply_corrections_detached(&mut parity, &mut data, corrections);

        assert_eq!(parity.as_slice(), &[]);
        assert_eq!(data.as_slice(), &[30 ^ 1, 40 ^ 2]);

        Ok(())
    }
}