linear-map 1.2.0

A map implemented by searching linearly in a vector.
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

#![feature(test)]

extern crate linear_map;
extern crate test;

use linear_map::LinearMap;

const SMALL:  u32 =   10;
const MEDIUM: u32 =  100;
const BIG:    u32 = 1000;

fn insert(b: &mut test::Bencher, num: u32) {
    b.iter(|| {
        let mut map = LinearMap::new();
        for i in 0..num {
            map.insert(i, i);
        }
    })
}

fn remove_insert(b: &mut test::Bencher, num: u32) {
    b.iter(|| {
        let mut map = LinearMap::new();
        for i in 0..num {
            map.insert(i, i);
        }
        for i in 0..num {
            map.remove(&i);
        }
    })
}

fn remove_rev_insert(b: &mut test::Bencher, num: u32) {
    b.iter(|| {
        let mut map = LinearMap::new();
        for i in 0..num {
            map.insert(i, i);
        }
        for i in 0..num {
            map.remove(&(num - i - 1));
        }
    })
}

fn get_middle(b: &mut test::Bencher, num: u32) {
    let mut map = LinearMap::new();
    for i in 0..num {
        map.insert(i, i);
    }
    let middle = num / 2;
    b.iter(|| {
        test::black_box(map.get(&middle));
        test::black_box(map.get_mut(&middle));
    })
}

fn get_none(b: &mut test::Bencher, num: u32) {
    let mut map = LinearMap::new();
    for i in 0..num {
        map.insert(i, i);
    }
    let none = num + 1;
    b.iter(|| {
        test::black_box(map.get(&none));
        test::black_box(map.get_mut(&none));
    })
}

#[bench] fn bench_insert_small (b: &mut test::Bencher) { insert(b, SMALL);  }
#[bench] fn bench_insert_medium(b: &mut test::Bencher) { insert(b, MEDIUM); }
#[bench] fn bench_insert_big   (b: &mut test::Bencher) { insert(b, BIG);    }

#[bench] fn bench_remove_insert_small (b: &mut test::Bencher) { remove_insert(b, SMALL);  }
#[bench] fn bench_remove_insert_medium(b: &mut test::Bencher) { remove_insert(b, MEDIUM); }
#[bench] fn bench_remove_insert_big   (b: &mut test::Bencher) { remove_insert(b, BIG);    }

#[bench] fn bench_remove_rev_insert_small (b: &mut test::Bencher) { remove_rev_insert(b, SMALL);  }
#[bench] fn bench_remove_rev_insert_medium(b: &mut test::Bencher) { remove_rev_insert(b, MEDIUM); }
#[bench] fn bench_remove_rev_insert_big   (b: &mut test::Bencher) { remove_rev_insert(b, BIG);    }

#[bench] fn bench_get_middle_small (b: &mut test::Bencher) { get_middle(b, SMALL);  }
#[bench] fn bench_get_middle_medium(b: &mut test::Bencher) { get_middle(b, MEDIUM); }
#[bench] fn bench_get_middle_big   (b: &mut test::Bencher) { get_middle(b, BIG);    }

#[bench] fn bench_get_none_small (b: &mut test::Bencher) { get_none(b, SMALL);  }
#[bench] fn bench_get_none_medium(b: &mut test::Bencher) { get_none(b, MEDIUM); }
#[bench] fn bench_get_none_big   (b: &mut test::Bencher) { get_none(b, BIG);    }