persistent_array 0.5.0

Persistent array is a library for working with memory mapped arrays
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

// Copyright (c) 2016 Jonathan Nilsson
//
// Licensed under the Apache License, Version 2.0
// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT
// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. All files in the project carrying such notice may not be copied,
// modified, or distributed except according to those terms.

extern crate persistent_array;

use persistent_array::{Error, PersistentArray};
use std::default::Default;

#[derive(Debug, Copy, Clone)]
struct Pair {
    a: u32,
    b: u32,
}

impl Default for Pair {
    fn default() -> Pair {
        Pair {
            a: 0xddaaddaa,
            b: 0xffeeffee,
        }
    }
}

#[derive(Debug, Default, Copy, Clone)]
struct Pair3 {
    a: u32,
    b: u32,
    c: u32,
}

#[derive(Debug, Default, Copy, Clone)]
struct OtherPair2 {
    a: u32,
    b: u32,
}

#[test]
fn test() {
    {
        let mut db = PersistentArray::<Pair>::new("pair.db", 1024).unwrap();

        db[0] = Pair { a: 1, b: 2 };

        assert_eq!(db[0].a, 1);
        assert_eq!(db[0].b, 2);

        assert_eq!(db[1023].a, 0xddaaddaa);
        assert_eq!(db[1023].b, 0xffeeffee);
    }
    {
        let db = PersistentArray::<Pair>::open("pair.db").unwrap();

        assert_eq!(db.len(), 1024);

        assert_eq!(db[0].a, 1);
        assert_eq!(db[0].b, 2);

        assert_eq!(db[1023].a, 0xddaaddaa);
        assert_eq!(db[1023].b, 0xffeeffee);
    }
    {
        let db = PersistentArray::<Pair>::open("README.md");

        match db {
            Err(Error::WrongMagicBytes) => (),
            _ => assert!(false),
        };
    }
    {
        let db = PersistentArray::<Pair3>::open("pair.db");

        match db {
            Err(Error::WrongFileSize) => (),
            _ => assert!(false),
        };
    }
    {
        let db = PersistentArray::<OtherPair2>::open("pair.db");

        match db {
            Err(Error::WrongTypeId) => (),
            _ => assert!(false),
        };
    }
}