nostalgia 0.0.1

A simple wrapper for lmdb to allow for some syntactic sugar
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

// A struct to wrap any sized type that could be used as a key
pub struct Key<T: Sized>(T);

// Implement From for any Sized type and wrap it in a Key struct
impl<T> From<T> for Key<T> {
    fn from(input: T) -> Self {
        Key::<T> { 0: input }
    }
}

impl Into<Key<String>> for Key<&str> {
    fn into(self) -> Key<String> {
        Key::<String> {
            0: self.0.to_string(),
        }
    }
}

impl Into<Vec<u8>> for Key<u32> {
    fn into(self) -> Vec<u8> {
        self.0.to_be_bytes().to_vec()
    }
}

impl Into<Vec<u8>> for Key<u64> {
    fn into(self) -> Vec<u8> {
        self.0.to_be_bytes().to_vec()
    }
}

impl Into<Vec<u8>> for Key<String> {
    fn into(self) -> Vec<u8> {
        self.0.as_bytes().to_vec()
    }
}

impl Into<Vec<u8>> for Key<&str> {
    fn into(self) -> Vec<u8> {
        self.0.as_bytes().to_vec()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::Record;
    use serde::{Deserialize, Serialize};

    #[derive(Serialize, Deserialize)]
    struct Thing {
        id: u32,
    }

    impl Record for Thing {
        type Key = Key<u32>;

        fn key(&self) -> Self::Key {
            Key::from(self.id)
        }
    }

    #[derive(Serialize, Deserialize)]
    struct OtherThing {
        id: std::string::String,
    }

    impl Record for OtherThing {
        type Key = std::string::String;

        fn key(&self) -> Self::Key {
            //Key::from(self.id.clone())
            self.id.clone()
        }
    }

    #[derive(Serialize, Deserialize)]
    struct AnotherThing {
        id: u32,
    }

    impl Record for AnotherThing {
        type Key = Key<u32>;

        fn key(&self) -> Self::Key {
            Key::from(self.id)
        }
    }

    // A dummy function that ensures things compile
    fn get<T: Record>(_key: T::Key) {}

    // Another dummy function to use to see if we can transform inputs and what that looks like
    fn get2<T: Record, K: Into<T::Key>>(_key: K) -> Option<T> {
        None
    }

    #[test]
    fn test_that_are_key_type_is_useful() {
        let a = Key::<u8> { 0: 0 };
        assert_eq!(0, a.0);

        let b = Key::from(8);
        assert_eq!(8, b.0);

        let c = Key::from("Yo");
        assert_eq!("Yo", c.0);

        let d = Key::from(String::from("LOL"));
        assert_eq!("LOL".to_string(), d.0);

        let _e = get::<Thing>(Key::from(8));
        let _f = get::<OtherThing>(String::from("LOL"));
        let g = Key::from([0, 1, 2, 3]);
        assert_eq!([0, 1, 2, 3], g.0);

        let _h: Option<Thing> = get2(8);
        let _i: Option<OtherThing> = get2("Hello".to_string());
        let _j: Option<OtherThing> = get2("Hi");
    }
}