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

use std::fmt::Display;
use std::error::Error;

#[doc = "hidden"]
#[derive(Debug, Default)]
pub struct ErrorBase {
    buffer: usize,
    value: usize,
    len: usize,
    index: usize
}

#[doc = "hidden"]
#[derive(Debug)]
pub struct NotEnoughCapacity(pub ErrorBase);
impl Error for NotEnoughCapacity {}
impl Display for NotEnoughCapacity {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let err_msg = 
            format!("Capacity of buffer is {} but trying to store {}", 
                self.0.buffer, self.0.value);
        write!(f, "NotEnoughCapacity: \"{}\"", err_msg)
    }
}
impl NotEnoughCapacity {
    pub fn throw(buffer: usize, value: usize) -> Self {
        Self(ErrorBase { buffer, value, ..Default::default() })
    }
}

#[doc = "hidden"]
#[derive(Debug)]
pub struct InvalidIndex(ErrorBase);
impl Error for InvalidIndex {}
impl Display for InvalidIndex {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let err_msg = 
            format!("Buffer len is {} but trying to access index at {}", 
                self.0.len, self.0.index);
        write!(f, "InvalidIndex: \"{}\"", err_msg)
    }
}
impl InvalidIndex {
    pub fn throw(len: usize, index: usize) -> Self {
        Self(ErrorBase { len, index, ..Default::default() })
    }
}

impl From<InvalidIndex> for NotEnoughCapacity {
    fn from(value: InvalidIndex) -> Self {
        Self(ErrorBase { buffer: value.0.len, value: value.0.index, ..Default::default() })
    }
}
impl From<NotEnoughCapacity> for InvalidIndex {
    fn from(value: NotEnoughCapacity) -> Self {
        Self(ErrorBase { len: value.0.buffer, index: value.0.value, ..Default::default() })
    }
}