heapless 0.3.6

`static` friendly data structures that don't require dynamic memory allocation
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

/// Temporary fork of some stuff in `core` that's doesn't have a `const fn` API

pub mod mem {
    pub use core::mem::{replace, zeroed};

    use core::ops::{Deref, DerefMut};

    #[allow(unions_with_drop_fields)]
    pub union ManuallyDrop<T> {
        value: T,
    }

    impl<T> ManuallyDrop<T> {
        #[inline]
        pub const fn new(value: T) -> ManuallyDrop<T> {
            ManuallyDrop { value: value }
        }
    }

    impl<T> Deref for ManuallyDrop<T> {
        type Target = T;

        #[inline]
        fn deref(&self) -> &Self::Target {
            unsafe { &self.value }
        }
    }

    impl<T> DerefMut for ManuallyDrop<T> {
        #[inline]
        fn deref_mut(&mut self) -> &mut Self::Target {
            unsafe { &mut self.value }
        }
    }

    pub const unsafe fn uninitialized<T>() -> T {
        #[allow(unions_with_drop_fields)]
        union U<T> {
            none: (),
            some: T,
        }

        U { none: () }.some
    }
}