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
100
101
102
103
104
105
106

use annis::db::annostorage::AnnoStorage;
use annis::db::Graph;
use annis::db::graphstorage::GraphStorage;
use annis::types::{Component, ComponentType, NodeID};

use std::sync::Arc;

#[derive(Clone)]
pub struct TokenHelper {
    node_annos: Arc<AnnoStorage<NodeID>>,
    left_edges: Arc<GraphStorage>,
    right_edges: Arc<GraphStorage>,
    cov_edges: Option<Arc<GraphStorage>>,
    tok_key: usize,
}

lazy_static! {
    static ref COMPONENT_LEFT: Component = {
        let c = Component {
            ctype: ComponentType::LeftToken,
            layer: String::from("annis"),
            name: String::from(""),
        };
        c
    };
    static ref COMPONENT_RIGHT: Component = {
        let c = Component {
            ctype: ComponentType::RightToken,
            layer: String::from("annis"),
            name: String::from(""),
        };
        c
    };
    static ref COMPONENT_COV: Component = {
        let c = Component {
            ctype: ComponentType::Coverage,
            layer: String::from("annis"),
            name: String::from(""),
        };
        c
    };
}

pub fn necessary_components() -> Vec<Component> {
    vec![
        COMPONENT_LEFT.clone(),
        COMPONENT_RIGHT.clone(),
        COMPONENT_COV.clone(),
    ]
}

impl TokenHelper {
    pub fn new(db: &Graph) -> Option<TokenHelper> {
        Some(TokenHelper {
            node_annos: db.node_annos.clone(),
            left_edges: db.get_graphstorage(&COMPONENT_LEFT)?,
            right_edges: db.get_graphstorage(&COMPONENT_RIGHT)?,
            cov_edges: db.get_graphstorage(&COMPONENT_COV),
            tok_key: db.node_annos.get_key_id(&db.get_token_key())?,
        })
    }

    pub fn is_token(&self, id: &NodeID) -> bool {
        return self
            .node_annos
            .get_value_for_item_by_id(id, self.tok_key)
            .is_some()
            && self.cov_edges.is_some()
            && self
                .cov_edges
                .as_ref()
                .unwrap()
                .get_outgoing_edges(id)
                .next()
                .is_none();
    }

    pub fn right_token_for(&self, n: &NodeID) -> Option<NodeID> {
        if self.is_token(n) {
            return Some(n.clone());
        } else {
            let mut out = self.right_edges.get_outgoing_edges(n);
            return out.next();
        }
    }

    pub fn left_token_for(&self, n: &NodeID) -> Option<NodeID> {
        if self.is_token(n) {
            return Some(n.clone());
        } else {
            let mut out = self.left_edges.get_outgoing_edges(n);
            return out.next();
        }
    }

    pub fn left_right_token_for(&self, n: &NodeID) -> (Option<NodeID>, Option<NodeID>) {
        if self.is_token(n) {
            return (Some(n.clone()), Some(n.clone()));
        } else {
            let mut out_left = self.left_edges.get_outgoing_edges(n);
            let mut out_right = self.right_edges.get_outgoing_edges(n);

            return (out_left.next(), out_right.next());
        }
    }
}