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

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]) {
    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]) {
    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"]
/// 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
}