cbfr 0.1.6

A buffer that run on stack, focusing on performance and speed
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

use crate::errors::NotEnoughCapacity;


/// helper function for Display trait implementation
#[doc = "hidden"]
pub fn fmt(len: &usize, arr: &[u8], f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    let contain_values = &arr[0..arr.len()];
    let text: &str;
    unsafe {
        text = std::str::from_utf8_unchecked(contain_values);
    }
    write!(f, "{}", &text[0..*len])
}

/// helper function for From trait implementation
// #[doc = "hidden"]
// pub fn from(value: &str, arr: &mut [u8]) {
//     assert!(value.len() <= arr.len(), "Not enough capacity!");
//     unsafe {
//         std::ptr::copy(value.as_ptr(), arr.as_mut_ptr(), value.len());
//     }
//     //NOTE: old slow code
//     // if value.len() <= arr.len() {
//     //     for (i, &v) in value.as_bytes().iter().enumerate() {
//     //         arr[i] = v
//     //     };
//     // } else {
//     //     panic!("{}", NotEnoughCapacity::throw(arr.len(), value.len()));
//     // }
// } 

#[doc = "hidden"]
pub fn from_slice(value: &[u8], arr: &mut [u8]) {
    assert!(value.len() <= arr.len(), "Not enough capacity!");
    unsafe {
        std::ptr::copy(value.as_ptr(), arr.as_mut_ptr(), value.len())
    }
    //NOTE: old code (slower code, takes O(n))
    // if value.len() <= arr.len() {
    //     for (i, &v) in value.iter().enumerate() {
    //         arr[i] = v;
    //     }
    // } else {
    //     panic!("{}", NotEnoughCapacity::throw(arr.len(), value.len()));
    // }
} 

#[doc = "hidden"]
pub fn from_slice2(value: &[u8], arr: &mut [u8]) -> usize {
    // let mut len = 0;
    if value.len() <= arr.len() {
        // for (i, &v) in value.iter().enumerate() {
        //     arr[i] = v;
        //     len = i;
        // }
        // len + 1
        unsafe {
            std::ptr::copy(value.as_ptr(), arr.as_mut_ptr(), value.len());
            value.len()
        }
    } else {
        unsafe {
            std::ptr::copy(value.as_ptr(), arr.as_mut_ptr(), arr.len());
            arr.len()
        }
        // for (i, v) in arr.iter_mut().enumerate() {
        //     *v = value[i];
        //     len = i
        // }
        // len + 1
    }
} 

#[doc = "hidden"]
/// helper function for partialEQ trait implementation
pub fn eq(lena: &usize, arra: &[u8], lenb: &usize, arrb: &[u8]) -> bool {
    if lena != lenb {
        return false;
    } else {
        for (i, c) in arra.iter().enumerate() {
            if *c != arrb[i] {
                return false;
            }
        }
    }
    true
}

#[doc = "hidden"]
pub fn ne(lena: &usize, arra: &[u8], lenb: &usize, arrb: &[u8]) -> bool {
    if lena != lenb {
        return true;
    } else {
        for (i, c) in arra.iter().enumerate() {
            if *c != arrb[i] {
                return true;
            }
        }
    }
    false
}

#[doc = "hidden"]
pub fn append_ch_unchecked(len: &mut usize, arr: &mut [u8], c: char) {
    arr[*len] = c as u8;
    *len += 1;
} 

#[doc = "hidden"]
pub fn append_ch(len: &mut usize, arr: &mut [u8], c: char) -> Result<(), NotEnoughCapacity> {
    let total_len = *len + c.len_utf8();
    if total_len < arr.len() {
        for i in 0..c.len_utf8() {
            arr[*len+i] = c as u8;
        }
        *len += c.len_utf8();
        Ok(())
    } else {
        Err(NotEnoughCapacity::throw(arr.len(), total_len))
    }
}

#[doc = "hidden"]
pub fn checksum(arr: &[u8]) -> usize {
    let mut result = 0;
    for i in arr.iter() {
        result += *i as usize;
    }
    result
}