recursive_variadic 0.1.0

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

//! This is an implementation of variadic templates using recursive generics.
//! It functions something like a TypeMap, but the optimizer should make getting
//! and adding values much faster.

use std::any::{Any, TypeId};
use std::mem;

pub trait Key {
    type Value: Any;
}

/// The building block trait for recursive variadics.
pub trait RecursiveVariadic {
    /// Try to get the value for N.
    fn get<N: Key>(&self) -> Option<&N::Value>;
    /// Try to get the value for N mutably.
    fn get_mut<N: Key>(&mut self) -> Option<&mut N::Value>;
    /// Add a key-value pair to this.
    fn and<N: Key>(self, val: N::Value) -> Entry<N, Self> where Self: Sized {
        Entry {
            data: val,
            parent: self,
        }
    }
    /// Add the default value for N
    fn and_default<N: Key>(self) -> Entry<N, Self> 
    where N::Value: Default, Self: Sized {
        self.and(N::Value::default())
    }
}

/// The base case for recursive variadics: no fields.
pub type Empty = ();
impl RecursiveVariadic for Empty {
    fn get<N: Key>(&self) -> Option<&N::Value> { None }
    fn get_mut<N: Key>(&mut self) -> Option<&mut N::Value> { None }
}

/// Wraps some field data and a parent, which is either another Entry or Empty
pub struct Entry<T: Key, R> {
    data: T::Value,
    parent: R,
}

impl<T: Key, R: RecursiveVariadic> RecursiveVariadic for Entry<T, R> {
    fn get<N: Key>(&self) -> Option<&N::Value> { 
        if TypeId::of::<N::Value>() == TypeId::of::<T::Value>() {
            Some(unsafe { mem::transmute(&self.data) })
        } else {
            self.parent.get::<N>()
        }
    }
    fn get_mut<N: Key>(&mut self) -> Option<&mut N::Value> { 
        if TypeId::of::<N::Value>() == TypeId::of::<T::Value>() {
            Some(unsafe { mem::transmute(&mut self.data) })
        } else {
            self.parent.get_mut::<N>()
        }
    }
}

#[cfg(test)]
mod tests {
    use std::any::Any;

    use super::*;

    #[test]
    fn it_works() {
        impl Key for i32 { type Value = i32; }
        impl Key for usize { type Value = Vec<usize>; }
        impl Key for bool { type Value = bool; }
        impl Key for &'static str { type Value = &'static str; }

        let mut thing = ().and::<i32>(23).and_default::<usize>().and::<&'static str>("Hello!");
        thing.get_mut::<usize>().unwrap().push(1);
        assert!(thing.get::<i32>().is_some());
        assert!(thing.get::<&'static str>().is_some());
        assert!(thing.get::<bool>().is_none());
    }
}