memory_cache_rust/bloom/
haskey.rs

1use std::any::TypeId;
2use std::mem::size_of;
3use std::ops::Deref;
4
5use xxhash_rust::const_xxh3::xxh3_64 as const_xxh3;
6
7use crate::bloom::rutil::mem_hash;
8
9pub type KeyHash<T> = Box<dyn FnMut(T) -> (u64, i64)>;
10
11
12
13pub fn key_to_hash<T: Copy + 'static + std::fmt::Display>(key: & T) -> (u64, u64)
14    where
15
16{
17    let key = *key.deref();
18    if equals::<T, String>() {
19        let v = cast_ref::<_, String>(&key).unwrap();
20        let raw = v.as_bytes();
21        return (mem_hash(raw), const_xxh3(raw) as u64);
22    }
23
24
25    // if equals::<T, Vec<u8>>() {
26    //     let value = unsafe { std::mem::transmute::<T, Vec<u8>>(key) };
27    //
28    //     return (mem_hash(&value), const_xxh3(&value) as i64);
29    // }
30
31
32    if equals::<T, u64>() {
33        let value = cast_ref::<_, u64>(&key).unwrap();
34        return (*value, 0);
35    }
36
37    if equals::<T, usize>() {
38        let value = cast_ref::<_, usize>(&key).unwrap();
39        return (*value as u64, 0);
40    }
41
42
43    if equals::<T, i64>() {
44        let value = cast_ref::<_, i64>(&key).unwrap();
45        return (*value as u64, 0);
46    }
47
48
49    if equals::<T, i32>() {
50        let value = cast_ref::<_, i32>(&key).unwrap();
51
52        return (*value as u64, 0);
53    }
54
55    if equals::<T, u8>() {
56        let value = cast_ref::<_, u8>(&key).unwrap();
57        return (*value as u64, 0);
58    }
59    if equals::<T, u16>() {
60        let value = cast_ref::<_, u16>(&key).unwrap();
61
62        return (*value as u64, 0);
63    }
64    if equals::<T, u32>() {
65        let value = cast_ref::<_, u32>(&key).unwrap();
66
67        return (*value as u64, 0);
68    }
69    if equals::<T, i16>() {
70        let value = cast_ref::<_, i16>(&key).unwrap();
71
72        return (*value as u64, 0);
73    }
74
75    let f = format!("{}",key);
76
77    match cast_ref::<_, String>(&f) {
78        None => {
79            panic!("not suported");
80        }
81        Some(v) => {
82            let raw = v.as_bytes();
83            return (mem_hash(raw), const_xxh3(raw) as u64);
84        }
85    }
86
87
88    // panic!("! Key type not supported")
89
90
91    // if TypeId::of::<T>() == TypeId::of::<[u8]>() {
92    //     let raw = (key) as [u8];
93    //     return (mem_hash_byte(&raw), const_xxh3(&raw) as i64);
94    // }
95    // return (mem_hash(&mut key.into_bytes()), const_xxh3(&* key.into_bytes()) as i64);
96}
97
98
99pub fn value_to_int<T: 'static>(key: T) -> i64 {
100    if equals::<T, u64>() {
101        let value = cast_ref::<_, u64>(&key).unwrap();
102        return *value as i64;
103    }
104
105    if equals::<T, usize>() {
106        let value = cast_ref::<_, usize>(&key).unwrap();
107        return *value as i64;
108    }
109
110
111    if equals::<T, i64>() {
112        let value = cast_ref::<_, i64>(&key).unwrap();
113        return *value as i64;
114    }
115
116
117    if equals::<T, i32>() {
118        let value = cast_ref::<_, i32>(&key).unwrap();
119
120        return *value as i64;
121    }
122
123    if equals::<T, u8>() {
124        let value = cast_ref::<_, u8>(&key).unwrap();
125        return *value as i64;
126    }
127    if equals::<T, u16>() {
128        let value = cast_ref::<_, u16>(&key).unwrap();
129
130        return *value as i64;
131    }
132    if equals::<T, u32>() {
133        let value = cast_ref::<_, u32>(&key).unwrap();
134
135        return *value as i64;
136    }
137    if equals::<T, i16>() {
138        let value = cast_ref::<_, i16>(&key).unwrap();
139
140        return *value as i64;
141    }
142    panic!("! value type not supported")
143}
144
145pub fn equals<U: 'static, V: 'static>() -> bool {
146    TypeId::of::<U>() == TypeId::of::<V>() && size_of::<U>() == size_of::<V>()
147}
148
149pub fn cast_ref<U: 'static, V: 'static>(u: &U) -> Option<&V> {
150    if equals::<U, V>() {
151        Some(unsafe { std::mem::transmute::<&U, &V>(u) })
152    } else {
153        None
154    }
155}
156
157pub fn cast_mut<U: 'static, V: 'static>(u: &mut U) -> Option<&mut V> {
158    if equals::<U, V>() {
159        Some(unsafe { std::mem::transmute::<&mut U, &mut V>(u) })
160    } else {
161        None
162    }
163}
164
165#[cfg(test)]
166mod tests {
167    use super::*;
168
169    #[test]
170    fn test_hash() {
171        let a ="22";
172        let d = key_to_hash(&a);
173        ;
174        println!("{:?}", d);
175    }
176}
memory_cache_rust/bloom/haskey.rs

memory_cache_rust/bloom/
haskey.rs
