bumpish 0.4.1

A set of collections using bump allocations
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

//! Some helper functions for bump-stack.

use core::mem;
use core::ptr::NonNull;

macro_rules! impl_iter {
    ($map_fn:expr, $iter_name:ident < $( $life:lifetime, )? $( $arg_ty:ident,)* { $( const $n_ty:ident : usize )? }> => $item_ty:ty ) => {
        impl<$($life,)? $($arg_ty),* $(, const $n_ty: usize )?> core::iter::Iterator for $iter_name<$($life,)? $($arg_ty),* $(, $n_ty)?> {
            type Item = $item_ty;

            #[inline]
            fn next(&mut self) -> Option<Self::Item> {
                self.raw_iter.next().map($map_fn)
            }

            #[inline]
            fn size_hint(&self) -> (usize, Option<usize>) {
                self.raw_iter.size_hint()
            }

            #[inline]
            fn count(self) -> usize {
                self.raw_iter.count()
            }

            #[inline]
            fn nth(&mut self, n: usize) -> Option<Self::Item> {
                self.raw_iter.nth(n).map($map_fn)
            }

            #[inline]
            fn last(self) -> Option<Self::Item>
            where
                Self: Sized,
            {
                self.raw_iter.last().map($map_fn)
            }
        }
    };
}

pub(crate) use impl_iter;

macro_rules! impl_deiter {
    ($map_fn:expr, $iter_name:ident < $( $life:lifetime, )? $( $arg_ty:ident,)* { $( const $n_ty:ident : usize )? }> ) => {
        impl<$($life,)? $($arg_ty),* $(, const $n_ty: usize)?> core::iter::DoubleEndedIterator for $iter_name<$($life,)? $($arg_ty),* $(, $n_ty)?> {
            #[inline]
            fn next_back(&mut self) -> Option<Self::Item> {
                self.raw_iter.next_back().map($map_fn)
            }

            #[inline]
            fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
                self.raw_iter.nth_back(n).map($map_fn)
            }
        }
    };
}

pub(crate) use impl_deiter;

/// Typical overhead per allocation imposed by allocators.
pub(crate) const ALLOC_OVERHEAD: usize = 16;

/// Just helpling trait for getting properties of a type.
pub(crate) trait TypeProps<T> {
    const SIZE: usize = mem::size_of::<T>();
    const ALIGN: usize = mem::align_of::<T>();
    const IS_ZST: bool = Self::SIZE == 0;
}

impl<T> TypeProps<T> for T {}

/// Replacement for standard `max` method until its constancy is stabilized.
pub(crate) const fn max(a: usize, b: usize) -> usize {
    if a > b { a } else { b }
}

/// Checks if `value` is aligned to `alignment`.
pub(crate) fn ptr_is_aligned_to<T>(ptr: *mut T, alignment: usize) -> bool {
    let value = ptr as usize;
    value.is_multiple_of(alignment)
}

/// Returns a properly aligned pointer to a ZST instance.
pub(crate) const fn zst_ptr<T>() -> NonNull<T> {
    assert!(T::IS_ZST);
    let non_zero = core::num::NonZero::new(T::ALIGN).unwrap();
    NonNull::without_provenance(non_zero)
}

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

    #[test]
    fn max_min() {
        assert_eq!(max(1, 2), 2);
        assert_eq!(max(2, 1), 2);
    }
}