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
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

use crate::const_utils::const_int::ConstInteger;
use crate::utils::function::NullaryFunction;

pub trait ConstBool: Default + Copy {
    const VALUE: bool;
    
    /// T if true, F otherwise.
    type Conditional<T, F>;
    
    /// Same as [Self::Conditional] but with [ConstBool] bounds.
    type ConditionalBool<T: ConstBool, F: ConstBool>: ConstBool;
    
    // Not used.
    /// Same as [Self::Conditional] but with [ConstInteger] bounds.
    type ConditionalInt<T: ConstInteger, F: ConstInteger>: ConstInteger;
    
    fn value(self) -> bool {
        Self::VALUE
    }
    
    fn conditional_exec<TrueFn, FalseFn>(t: TrueFn, f: FalseFn) 
        -> Self::Conditional<TrueFn::Output, FalseFn::Output>
    where 
        TrueFn: NullaryFunction, FalseFn: NullaryFunction;
    
    type And<Other: ConstBool>: ConstBool;
}

#[derive(Default, Clone, Copy)]
pub struct ConstTrue;
impl ConstBool for ConstTrue {
    const VALUE: bool = true;
    type Conditional<T, F> = T;
    type ConditionalBool<T: ConstBool, F: ConstBool> = T;
    type ConditionalInt<T: ConstInteger, F: ConstInteger> = T;
    
    type And<Other: ConstBool> = Other::ConditionalBool<ConstTrue, ConstFalse>;
    
    #[inline]
    fn conditional_exec<TrueFn, FalseFn>(t: TrueFn, _: FalseFn) 
        -> Self::Conditional<TrueFn::Output, FalseFn::Output>
    where 
        TrueFn: NullaryFunction, FalseFn: NullaryFunction
    {
        t.exec()
    }
}
pub trait IsConstTrue: ConstBool {}
impl IsConstTrue for ConstTrue{}

#[derive(Default, Clone, Copy)]
pub struct ConstFalse;
impl ConstBool for ConstFalse {
    const VALUE: bool = false;
    type Conditional<T, F> = F;
    type ConditionalBool<T: ConstBool, F: ConstBool> = F;
    type ConditionalInt<T: ConstInteger, F: ConstInteger> = F;
    
    type And<Other: ConstBool> = Other::ConditionalBool<ConstFalse, ConstFalse>;
    
    #[inline]
    fn conditional_exec<TrueFn, FalseFn>(_: TrueFn, f: FalseFn) 
        -> Self::Conditional<TrueFn::Output, FalseFn::Output>
    where 
        TrueFn: NullaryFunction, FalseFn: NullaryFunction
    {
        f.exec()
    }    
}
pub trait IsConstFalse: ConstBool {}
impl IsConstFalse for ConstFalse{}

pub type ConstAnd<L, R> = <L as ConstBool>::And<R>;

#[cfg(test)]
mod test{
    use super::*;
    
    struct S<B: ConstBool>{
        v: B::Conditional<usize, f32>
    }
    
    fn test<B: ConstBool>(s: S<B>)
    where
        B::Conditional<usize, f32>: Clone
    {
        let c = s.v.clone();
    }
    
    #[test]
    fn and_test(){
        type T0 = ConstTrue;
        type T1 = ConstTrue;
        type A = ConstAnd<T0, T1>;
        assert_eq!(A::VALUE, true);
        fn test<B: IsConstTrue>(){}
        test::<A>();
    }
}