byteorder_slice 3.0.0

Byteorder like crate for &[u8]
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

use byteorder::ByteOrder;

/// Extends &[u8] with methods for reading numbers and slices
pub trait ReadSlice<'a> {
    /// Try to read a u8 from self
    fn read_u8(&mut self) -> Option<u8>;

    /// Try to read a u16 from self
    fn read_u16<B: ByteOrder>(&mut self) -> Option<u16>;

    /// Try to read a u32 from self
    fn read_u32<B: ByteOrder>(&mut self) -> Option<u32>;

    /// Try to read a u64 from self
    fn read_u64<B: ByteOrder>(&mut self) -> Option<u64>;

    /// Try to read a u128 from self
    fn read_u128<B: ByteOrder>(&mut self) -> Option<u128>;

    /// Try to read an unsigned n-bytes integer from self
    fn read_uint32<B: ByteOrder>(&mut self, nb_bytes: usize) -> Option<u32>;

    /// Try to read an unsigned n-bytes integer from self
    fn read_uint64<B: ByteOrder>(&mut self, nb_bytes: usize) -> Option<u64>;

    /// Try to read an unsigned n-bytes integer from self
    fn read_uint128<B: ByteOrder>(&mut self, nb_bytes: usize) -> Option<u128>;

    /// Try to read a i8 from self
    fn read_i8(&mut self) -> Option<i8>;

    /// Try to read a i16 from self
    fn read_i16<B: ByteOrder>(&mut self) -> Option<i16>;

    /// Try to read a i32 from self
    fn read_i32<B: ByteOrder>(&mut self) -> Option<i32>;

    /// Try to read a i64 from self
    fn read_i64<B: ByteOrder>(&mut self) -> Option<i64>;

    /// Try to read a i128 from self
    fn read_i128<B: ByteOrder>(&mut self) -> Option<i128>;

    /// Try to read a signed n-bytes integer from self
    fn read_int32<B: ByteOrder>(&mut self, nb_bytes: usize) -> Option<i32>;

    /// Try to read a signed n-bytes integer from self
    fn read_int64<B: ByteOrder>(&mut self, nb_bytes: usize) -> Option<i64>;

    /// Try to read a signed n-bytes integer from self
    fn read_int128<B: ByteOrder>(&mut self, nb_bytes: usize) -> Option<i128>;

    /// Try to read a f32 from self
    fn read_f32<B: ByteOrder>(&mut self) -> Option<f32>;

    /// Try to read a f64 from self
    fn read_f64<B: ByteOrder>(&mut self) -> Option<f64>;

    /// Try to read a slice from self
    fn read_slice(&mut self, nb_bytes: usize) -> Option<&'a [u8]>;

    /// Read a slice from start to end of self
    fn read_slice_to_end(&mut self) -> &'a [u8];

    /// Try to move forward in self
    #[must_use]
    fn move_forward(&mut self, nb_bytes: usize) -> Option<()>;
}