hibit_tree 0.1.0-beta.1

Hierarchical bitmap tree. Integer-key map that can intersect FAST.
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

use std::array;
use std::mem::MaybeUninit;

/// [Item; CAP]
pub trait Array
    : AsRef<[Self::Item]> 
    + AsMut<[Self::Item]>
    + Sized
{
    type Item;
    const CAP: usize;
    
    fn from_fn<F>(f: F) -> Self
    where
        F: FnMut(usize) -> Self::Item;
    
    /// Array of MaybeUninit items
    type UninitArray: Array<Item = MaybeUninit<Self::Item>>;
    fn uninit_array() -> Self::UninitArray;
    
    unsafe fn assume_init_array(uninit_array: Self::UninitArray) -> Self;
}

impl<T, const N: usize> Array for [T; N]{
    type Item = T;
    const CAP: usize = N;
         
    type UninitArray = [MaybeUninit<Self::Item>; N];
    
    #[inline]
    fn from_fn<F>(f: F) -> Self 
    where 
        F: FnMut(usize) -> T 
    {
        array::from_fn(f)
    }

    #[inline]
    fn uninit_array() -> Self::UninitArray {
        [const { MaybeUninit::uninit() }; N]
    }

    #[inline]
    unsafe fn assume_init_array(uninit_array: Self::UninitArray) -> Self {
        //MaybeUninit::array_assume_init(uninit_array)
        
        // Compiler SHOULD optimize away this copy.
        // This should be just transmute, but compiler can't work with "dependently-sized types"
        std::mem::transmute_copy(&uninit_array)
        /*std::mem::transmute::<
            [MaybeUninit::<Self::Item>; N],
            [Self::Item; N]
        >(uninit_array)*/
    }
}