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

use std::mem::ManuallyDrop;
use std::ptr;
use crate::utils::Array;
use crate::const_utils::{ConstUsize, ConstInteger};

// TODO: All Arrays can be ConstArrays.
//       Make ConstArray Array. 
/// [ConstInteger]-sized [Array]. 
pub trait ConstArray: Array {
    type Cap: ConstInteger;
    
    // TODO: split machinery is not used anymore.
    /// Self array decremented in size.
    type DecArray: ConstArray<Item=Self::Item, Cap=<Self::Cap as ConstInteger>::Dec>;  
    fn split_last(self) -> (Self::DecArray, Self::Item);
}

impl<T, const N: usize> ConstArray for [T; N]
where
    ConstUsize<N>: ConstInteger
{
    type Cap = ConstUsize<N>;
    
    /// Array with N-1 size/cap.
    type DecArray = ArrayOf<Self::Item, <Self::Cap as ConstInteger>::Dec>;

    #[inline]
    fn split_last(self) -> (Self::DecArray, Self::Item) {
        let this = ManuallyDrop::new(self);
        let left = unsafe{
            Array::from_fn(|i| { 
                ptr::read(this.as_ref().get_unchecked(i))
            })
        };
        let right = unsafe{
            ptr::read(this.as_ref().last().unwrap())
        };
        (left, right)
    }
}

pub type ArrayOf<T, C> = <C as ConstInteger>::ArrayOf<T>;
pub type CopyableArrayOf<T, C> = <C as ConstInteger>::CopyArrayOf<T>;

/*/// [ConstInteger] friendly [PrimitiveArray]
pub trait ConstPrimitiveArray
    : ConstArray<DecArray: PrimitiveArray>
    + PrimitiveArray
{}
impl<T: ConstArray<DecArray: PrimitiveArray> + PrimitiveArray> ConstPrimitiveArray for T {}*/