smart-hash 0.1.2

partial queries in HashSets, the traits.
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
121
122
123
124
125
126
127
128

extern crate smart_hash;
use smart_hash::get_matching;
use smart_hash::traits::{SmartHash,SmartHashOpt, SmartHashSet};

use std::collections::HashSet;

#[derive(Hash, Eq, PartialEq, Debug)]
// make a derive here.
pub struct Tester {
    value1 : u8,
    value2 : bool,
    value3 : String,
}

// part of the derive macro
#[derive(Hash, Debug)]
pub struct TesterOpt {
    value1 : Option<u8>,
    value2 : Option<bool>,
    value3 : Option<String>,
}
// part of derive macro
impl Default for TesterOpt {
    fn default() -> TesterOpt {
        TesterOpt {
            value1 : None,
            value2 : None,
            value3 : None,
        }
    }
}

// part of the derive macro
impl PartialEq for TesterOpt {
    fn eq(&self, other: &TesterOpt) -> bool {
        (self.value1 == other.value1 || self.value1.is_none() || other.value1.is_none()) &&
        (self.value2 == other.value2 || self.value2.is_none() || other.value2.is_none()) &&
        (self.value3 == other.value3 || self.value3.is_none() || other.value3.is_none())
    }
}
// part of the derive macro
impl Eq for TesterOpt {}

// part of the derive macro
impl SmartHash for Tester {
    type option = TesterOpt; 
    
    fn into_option(&self) -> TesterOpt {
        TesterOpt {
            value1 : Some(self.value1),
            value2 : Some(self.value2),
            value3 : Some(self.value3.to_string()),
        }
    }
}

// part of the derive macro
impl SmartHashOpt for TesterOpt { }

#[test]
fn test_macro() {
    let mut testers : HashSet<Tester> = HashSet::new();

    testers.insert(Tester {
        value1 : 10,
        value2 : false,
        value3 : "Some String".to_string(),
    });

    testers.insert(Tester {
        value1 : 10,
        value2 : true,
        value3 : "Some String".to_string(),
    });

    // style 1
    let result = get_matching!(testers,value1,10);
    assert_eq!(result.unwrap().len(),2);

    // style 2
    let result = get_matching!(testers,value1 == 10);
    assert_eq!(result.unwrap().len(),2);

    // style 3
    let result = get_matching!(testers where value1 is 10, value2 is true);
    assert_eq!(result.unwrap().len(),1);
}

#[test]
fn test_usage() {
    let mut testers : HashSet<Tester> = HashSet::new();

    testers.insert(Tester {
        value1 : 10,
        value2 : false,
        value3 : "Some String".to_string(),
    });

    testers.insert(Tester {
        value1 : 10,
        value2 : true,
        value3 : "Some String".to_string(),
    });

    let matches = testers.get_matching(TesterOpt {
        value1 : Some(10),
        value2 : None,
        value3 : None,
    });

    assert_eq!(matches.unwrap().len(),2);

    let matches = testers.get_matching(TesterOpt {
        value1 : None,
        value2 : Some(false),
        value3 : None,
    });

    assert_eq!(matches.unwrap().len(),1);

    let matches = testers.get_matching(TesterOpt {
        value1 : Some(23),
        value2 : Some(false),
        value3 : None,
    });

    assert!(matches.is_none());
}