secded 1.1.0

Single Error Correction, Double Error Detection Codes for Everyone
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

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */

use crate::{SecDed128, SecDed64, SecDedCodec};

#[no_mangle]
pub unsafe fn SECDED_64_new(encodable_size: usize) -> SecDed64 {
    crate::SecDed64::new(encodable_size)
}

#[no_mangle]
pub unsafe fn SECDED_64_encode(secded: *const SecDed64, data: *mut [u8; 8]) {
    (*secded).encode(&mut *data);
}

#[no_mangle]
pub unsafe fn SECDED_64_decode(secded: *const SecDed64, data: *mut [u8; 8]) -> bool {
    match (*secded).decode(&mut *data) {
        Err(()) => false,
        Ok(()) => true,
    }
}

#[no_mangle]
pub unsafe fn SECDED_64_code_size(secded: *const SecDed64) -> usize {
    (*secded).code_size()
}

#[no_mangle]
pub unsafe fn SECDED_64_encodable_size(secded: *const SecDed64) -> usize {
    (*secded).encodable_size()
}

#[no_mangle]
pub unsafe fn SECDED_128_new(encodable_size: usize) -> SecDed128 {
    crate::SecDed128::new(encodable_size)
}

#[no_mangle]
pub unsafe fn SECDED_128_encode(secded: *const SecDed128, data: *mut [u8; 16]) {
    (*secded).encode(&mut *data);
}

#[no_mangle]
pub unsafe fn SECDED_128_decode(secded: *const SecDed128, data: *mut [u8; 16]) -> bool {
    match (*secded).decode(&mut *data) {
        Err(()) => false,
        Ok(()) => true,
    }
}

#[no_mangle]
pub unsafe fn SECDED_128_code_size(secded: *const SecDed128) -> usize {
    (*secded).code_size()
}

#[no_mangle]
pub unsafe fn SECDED_128_encodable_size(secded: *const SecDed128) -> usize {
    (*secded).encodable_size()
}

#[test]
fn hamming_both() {
    unsafe {
        let secded = SECDED_64_new(57);
        let expected = [0, 0, 0, 0, 5, 0, 0];
        let mut buffer = [0u8; 8];
        buffer[..7].clone_from_slice(&expected);
        SECDED_64_encode(&secded, buffer.as_mut_ptr() as *mut [u8; 8]);
        assert!(SECDED_64_decode(
            &secded,
            buffer.as_mut_ptr() as *mut [u8; 8]
        ));
        assert_eq!(expected, buffer[..7]);
    }
}

#[cfg(feature = "dyn")]
pub mod dynamic {
    use crate::SecDedCodec;
    #[repr(C)]
    pub struct SECDED_DYN {}

    #[no_mangle]
    pub unsafe fn SECDED_DYN_new(encodable_size: usize) -> *const SECDED_DYN {
        Box::into_raw(Box::new(crate::SecDedDynamic::new(encodable_size))) as *const SECDED_DYN
    }
    #[no_mangle]
    pub unsafe fn SECDED_DYN_free(secded: *const SECDED_DYN) {
        Box::from_raw(secded as *mut crate::SecDedDynamic);
    }

    #[no_mangle]
    pub unsafe fn SECDED_DYN_encode(secded: *const SECDED_DYN, data: *mut u8, size: usize) {
        let slice = std::slice::from_raw_parts_mut(data, size);
        (*(secded as *const crate::SecDedDynamic)).encode(slice);
    }

    #[no_mangle]
    pub unsafe fn SECDED_DYN_decode(secded: *const SECDED_DYN, data: *mut u8, size: usize) -> bool {
        let slice = std::slice::from_raw_parts_mut(data, size);
        match (*(secded as *const crate::SecDedDynamic)).decode(slice) {
            Err(()) => false,
            Ok(()) => true,
        }
    }

    #[no_mangle]
    pub unsafe fn SECDED_DYN_code_size(secded: *const SECDED_DYN) -> usize {
        (*(secded as *mut crate::SecDedDynamic)).code_size()
    }

    #[no_mangle]
    pub unsafe fn SECDED_DYN_encodable_size(secded: *const SECDED_DYN) -> usize {
        (*(secded as *mut crate::SecDedDynamic)).encodable_size()
    }
}