tinycdb 0.0.6

Bindings to the TinyCDB C library (http://www.corpit.ru/mjt/tinycdb.html)
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

#![feature(test)]

extern crate test;
extern crate tinycdb;

use std::fs;
use std::path::{Path, PathBuf};

use test::Bencher;
use tinycdb::Cdb;


// Helper to remove test files after a test is finished, even if the test
// panic!()s
struct RemovingPath {
    underlying: PathBuf,
}

impl RemovingPath {
    pub fn new(p: &Path) -> RemovingPath {
        RemovingPath {
            underlying: p.to_owned(),
        }
    }
}

impl Drop for RemovingPath {
    fn drop(&mut self) {
        match fs::remove_file(&self.underlying) {
            Err(why) => println!("Couldn't remove temp file: {:?}", why),
            Ok(_) => {},
        };
    }
}

#[bench]
fn bench_add(b: &mut Bencher) {
    use std::sync::atomic::{AtomicUsize, Ordering};
    let ctr = AtomicUsize::new(0);

    let path = Path::new("add_bench.cdb");
    let _rem = RemovingPath::new(&path);

    let _ = Cdb::new(&path, |creator| {
        b.iter(|| {
            let cnt_str = ctr.fetch_add(1, Ordering::SeqCst).to_string();
            let mut key = "key".to_string();
            key.push_str(cnt_str.as_ref());

            let mut val = "val".to_string();
            val.push_str(cnt_str.as_ref());

            let _ = creator.add(key.as_bytes(), val.as_bytes());
        })
    });
}

#[bench]
fn bench_find(b: &mut Bencher) {
    let path = Path::new("find_bench.cdb");
    let _rem = RemovingPath::new(&path);

    let res = Cdb::new(&path, |creator| {
        let r = creator.add(b"foo", b"bar");
        assert!(r.is_ok());
    });

    let mut c = match res {
        Ok(c) => c,
        Err(why) => panic!("Could not create: {:?}", why),
    };

    b.iter(|| {
        test::black_box(c.find(b"foo"));
    });
}

#[bench]
fn bench_find_mut(b: &mut Bencher) {
    let path = Path::new("find_mut_bench.cdb");
    let _rem = RemovingPath::new(&path);

    let res = Cdb::new(&path, |creator| {
        let r = creator.add(b"foo", b"bar");
        assert!(r.is_ok());
    });

    let mut c = match res {
        Ok(c) => c,
        Err(why) => panic!("Could not create: {:?}", why),
    };

    b.iter(|| {
        test::black_box(c.find_mut(b"foo"));
    });
}

#[bench]
fn bench_exists(b: &mut Bencher) {
    let path = Path::new("exists_bench.cdb");
    let _rem = RemovingPath::new(&path);

    let res = Cdb::new(&path, |creator| {
        let r = creator.add(b"foo", b"bar");
        assert!(r.is_ok());
    });

    let mut c = match res {
        Ok(c) => c,
        Err(why) => panic!("Could not create: {:?}", why),
    };

    b.iter(|| {
        test::black_box(c.exists(b"foo"));
    });
}