graphannis 0.10.1

This is a prototype for a new backend implementation of the ANNIS linguistic search and visualization system.
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

use super::*;
use annis::types::NodeID;

#[test]
fn insert_same_anno() {
    let test_anno = Annotation {
        key: AnnoKey {
            name: "anno1".to_owned(),
            ns: "annis".to_owned(),
        },
        val: "test".to_owned(),
    };
    let mut a: AnnoStorage<NodeID> = AnnoStorage::new();
    a.insert(1, test_anno.clone());
    a.insert(1, test_anno.clone());
    a.insert(2, test_anno.clone());
    a.insert(3, test_anno);

    assert_eq!(3, a.number_of_annotations());
    assert_eq!(3, a.by_container.len());
    assert_eq!(1, a.by_anno.len());
    assert_eq!(1, a.anno_keys.len());

    assert_eq!(
        "test",
        a.get_value_for_item(
            &3,
            &AnnoKey {
                name: "anno1".to_owned(),
                ns: "annis".to_owned()
            }
        ).unwrap()
    );
}

#[test]
fn get_all_for_node() {
    let test_anno1 = Annotation {
        key: AnnoKey {
            name: "anno1".to_owned(),
            ns: "annis1".to_owned(),
        },
        val: "test".to_owned(),
    };
    let test_anno2 = Annotation {
        key: AnnoKey {
            name: "anno2".to_owned(),
            ns: "annis2".to_owned(),
        },
        val: "test".to_owned(),
    };
    let test_anno3 = Annotation {
        key: AnnoKey {
            name: "anno3".to_owned(),
            ns: "annis1".to_owned(),
        },
        val: "test".to_owned(),
    };

    let mut a: AnnoStorage<NodeID> = AnnoStorage::new();
    a.insert(1, test_anno1.clone());
    a.insert(1, test_anno2.clone());
    a.insert(1, test_anno3.clone());

    assert_eq!(3, a.number_of_annotations());

    let all = a.get_annotations_for_item(&1);
    assert_eq!(3, all.len());

    assert_eq!(test_anno1, all[0]);
    assert_eq!(test_anno2, all[1]);
    assert_eq!(test_anno3, all[2]);
}

#[test]
fn remove() {
    let test_anno = Annotation {
        key: AnnoKey {
            name: "anno1".to_owned(),
            ns: "annis1".to_owned(),
        },
        val: "test".to_owned(),
    };
    let mut a: AnnoStorage<NodeID> = AnnoStorage::new();
    a.insert(1, test_anno.clone());

    assert_eq!(1, a.number_of_annotations());
    assert_eq!(1, a.by_container.len());
    assert_eq!(1, a.by_anno.len());
    assert_eq!(1, a.anno_key_sizes.len());
    assert_eq!(&1, a.anno_key_sizes.get(&test_anno.key).unwrap());

    a.remove_annotation_for_item(&1, &test_anno.key);

    assert_eq!(0, a.number_of_annotations());
    assert_eq!(0, a.by_container.len());
    assert_eq!(0, a.by_anno.len());
    assert_eq!(&0, a.anno_key_sizes.get(&test_anno.key).unwrap_or(&0));
}