graph-store 0.4.0

Access to graph stores over the SPARQL 1.1 Graph Store HTTP Protocol
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

use std::collections::HashMap;
use std::fmt::Debug;
use std::hash::{Hash, Hasher};

#[derive(Debug, Eq, PartialEq)]
pub struct Variable {
    name: String,
}

impl Hash for Variable {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.name.hash(state);
    }
}

impl From<&str> for Variable {
    fn from(s: &str) -> Self {
        Variable {
            name: s.to_string(),
        }
    }
}

#[derive(Debug)]
pub struct Table<A> {
    pub variables: Vec<Variable>,
    pub bindings: Vec<HashMap<Variable, A>>,
}

impl<A> Table<A> {
    pub fn from<B>(
        variables: Vec<String>,
        bindings: Vec<HashMap<String, B>>,
        transform: fn(B) -> A,
    ) -> Table<A> {
        Table {
            bindings: bindings
                .into_iter()
                .map(|binding| {
                    binding
                        .into_iter()
                        .map(|(k, v)| (Variable::from(k.as_str()), transform(v)))
                        .collect()
                })
                .collect(),
            variables: variables
                .into_iter()
                .map(|v| Variable { name: v })
                .collect(),
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::table::Table;
    use std::collections::HashMap;
    use std::iter::FromIterator;

    #[test]
    fn can_create_tables() {
        let vars = vec!["a".to_string(), "b".to_string()];
        let bindings = vec![
            HashMap::from_iter(vec![("a".to_string(), "c"), ("b".to_string(), "d")].into_iter()),
            HashMap::from_iter(vec![("b".to_string(), "f"), ("a".to_string(), "e")].into_iter()),
        ];
        let table = Table::from(vars, bindings, |a| a);
        println!("Result: {:?}", table);
    }

    #[test]
    fn can_iterate() {
        let vars = vec!["a".to_string(), "b".to_string()];
        let bindings = vec![
            HashMap::from_iter(vec![("a".to_string(), "c"), ("b".to_string(), "d")].into_iter()),
            HashMap::from_iter(vec![("b".to_string(), "f"), ("a".to_string(), "e")].into_iter()),
        ];
        let table = Table::from(vars, bindings, |a| a);
        for v in &table.variables {
            print!("|{:?}", v.name);
        }
        println!("|\n|---|---|");
        for row in &table.bindings {
            for v in &table.variables {
                print!("|{:?}", row.get(&v).unwrap());
            }
            println!("|");
        }
    }
}