std-traits 0.7.0

Traits for types in the standard library.
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

use core::fmt::Debug;

use crate::{num::Integer, primitive::Primitive, reference::Mutability, util::cast_int};

macro_rules! cast_ptr {
    ($T:ty, $P:ty, $value:expr) => {
        match <$P>::ptr_type() {
            $crate::reference::Mutability::Const => unsafe {
                $crate::util::transmute_unchecked::<*const $T, $P>($value as *const $T)
            },
            $crate::reference::Mutability::Mut => unsafe {
                $crate::util::transmute_unchecked::<*mut $T, $P>($value as *mut $T)
            },
        }
    };
}

pub(crate) use cast_ptr;

pub trait Pointer<T: ?Sized>: Primitive + Copy + Debug + Sized {
    fn ptr_type() -> Mutability;

    fn cast_ptr<U: Sized, P: Pointer<U>>(self) -> P
    where
        Self: Sized;

    fn cast_int<I: Integer>(self) -> I
    where
        T: Sized;
}

macro_rules! impl_pointer {
    ($mut:tt, $ty:expr) => {
        impl<T: ?Sized> Primitive for *$mut T {}

        impl<T: ?Sized> Pointer<T> for *$mut T {
            fn ptr_type() -> Mutability {
                $ty
            }

            fn cast_ptr<U: Sized, P: Pointer<U>>(self) -> P where Self: Sized {
                cast_ptr!(T, P, self)
            }

            fn cast_int<I: Integer>(self) -> I where T: Sized {
                cast_int!(self => I)
            }
        }
    }
}

impl_pointer!(const, Mutability::Const);
impl_pointer!(mut, Mutability::Mut);

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn test_cast() {
        let ptr: *const u8 = "foo".as_ptr();
        let int: usize = ptr.cast_int();
        let ptr2: *const u8 = int.cast_ptr();

        assert_eq!(ptr, ptr2);
    }
}