buff 0.1.0

Traits for buffer.
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

use core::mem::size_of;

macro_rules! get_v_buffer {
    ( $this:expr, $t:ty, $se:ident ) => ({
        const SIZE: usize = size_of::<$t>();
        assert!($this.remaining() >= SIZE);
        let mut b = [0u8; SIZE];
        $this.copy_to_slice(&mut b);
        return <$t>::$se(b);
    })
}

pub trait Buffer {

    /// Total length of buffer.
    /// This value is greater than or equal to the length of the slice returned by Rust `bytes`.
    fn length(&self) -> usize;

    /// Forward the internal cursor of `Buffer`
    fn forward(&mut self, cnt: usize);

    /// Backward the internal cursor of `Buffer`
    fn backward(&self, cnt: usize);

    /// Got current position.
    fn position(&self) -> usize;

    /// Return a slice.
    fn bytes(&self) -> &[u8];

    fn remaining(&self) -> usize {
        self.length() - self.position()
    }

    fn copy_to_slice(&mut self, dst: &mut [u8]) {
        assert!(self.remaining() >= dst.len());
        let b = self.bytes();
        dst.copy_from_slice(&b[..dst.len()]);
    }

    fn get_u8(&mut self) -> u8 {
        assert!(self.remaining() >= 1);
        let ret = self.bytes()[0];
        self.forward(1);
        ret
    }

    fn get_i8(&mut self) -> i8 {
        assert!(self.remaining() >= 1);
        let ret = self.bytes()[0] as i8;
        self.forward(1);
        ret
    }

    fn get_be_u16(&mut self) -> u16 {
        get_v_buffer!(self, u16, from_be_bytes)
    }

    fn get_le_u16(&mut self) -> u16 {
        get_v_buffer!(self, u16, from_le_bytes)
    }

    fn get_be_i16(&mut self) -> i16 {
        get_v_buffer!(self, i16, from_be_bytes)
    }

    fn get_le_i16(&mut self) -> i16 {
        get_v_buffer!(self, i16, from_le_bytes)
    }

    fn get_be_u32(&mut self) -> u32 {
        get_v_buffer!(self, u32, from_be_bytes)
    }

    fn get_le_u32(&mut self) -> u32 {
        get_v_buffer!(self, u32, from_le_bytes)
    }

    fn get_be_u64(&mut self) -> u64 {
        get_v_buffer!(self, u64, from_be_bytes)
    }

    fn get_le_u64(&mut self) -> u64 {
        get_v_buffer!(self, u64, from_le_bytes)
    }

    fn get_be_f32(&mut self) -> f32 {
        get_v_buffer!(self, f32, from_be_bytes)
    }

    fn get_le_f32(&mut self) -> f32 {
        get_v_buffer!(self, f32, from_le_bytes)
    }

    fn get_be_f64(&mut self) -> f64 {
        get_v_buffer!(self, f64, from_be_bytes)
    }

    fn get_le_f64(&mut self) -> f64 {
        get_v_buffer!(self, f64, from_le_bytes)
    }
}