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

//!Slice accessors
//!
//!Provides traits to access integers as byte slices.
//!
//!# Usage
//!
//!```rust
//!use lazy_bytes_cast::slice::{
//!   ByteSlice,
//!   ByteIndex
//!};
//!
//!fn main() {
//!    let some_int = 666;
//!
//!    for (idx, byte) in some_int.byte_slice().iter().enumerate() {
//!        assert_eq!(some_int.byte(idx).unwrap(), *byte);
//!        println!("bytes[{}]={}", idx, byte);
//!    }
//!}
//!```

use core::mem;
use core::slice as std_slice;

/// Slice Accessor.
///
/// Note that one must be careful when impl this trait for own types.
pub unsafe trait ByteSlice: Sized {
    /// Returns read-only slice over integer bytes
    fn byte_slice<'a>(&'a self) -> &'a [u8] {
        unsafe {
            std_slice::from_raw_parts(self as *const _ as *const _, mem::size_of::<Self>())
        }
    }
    /// Returns mutable slice over integer bytes
    fn byte_mut_slice<'a>(&'a mut self) -> &'a mut [u8] {
        unsafe {
            std_slice::from_raw_parts_mut(self as *mut _ as *mut _, mem::size_of::<Self>())
        }
    }
}

/// Indexing Accessor.
pub unsafe trait ByteIndex : ByteSlice {
    /// Returns byte from integer by index.
    ///
    ///# Parameters:
    ///
    ///* `idx` - Index of byte starting from 0.
    ///
    ///# Result:
    ///
    ///* `Some` - Contains byte.
    ///* `None` - Index out of bounds.
    fn byte(&self, idx: usize) -> Option<u8> {
        if idx >= mem::size_of::<Self>() {
            return None;
        }

        Some(self.byte_slice()[idx])
    }
}

macro_rules! impl_trait {
    ($($type:ty,)+) => {
        $(
            unsafe impl ByteSlice for $type {}
            unsafe impl ByteIndex for $type {}
        )+
    }
}

impl_trait!(u8, i8, u16, i16, u32, i32, f32, u64, i64, f64, usize, isize,);