rome 0.1.3

An RDF library in pure Rust
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use rand;
use std::collections::btree_map::Entry;
use std::collections::btree_set;
use std::collections::BTreeMap;
use std::collections::BTreeSet;
use std::iter::FromIterator;
use std::marker::PhantomData;
use std::rc::Rc;
use string_store::*;

/// Graph implementation that allows for multiple indexes
/// All data is stored in vectors.

pub struct VecStore<T> {
    store: Vec<T>,
    unused: Vec<usize>,
}

struct StringUsage {
    subject_count: usize,
    predicate_count: usize,
    object_count: usize,
    datatype_count: usize,
    literal_count: usize,
    langtag_count: usize,
}

impl Default for StringUsage {
    fn default() -> StringUsage {
        StringUsage {
            subject_count: 0,
            predicate_count: 0,
            object_count: 0,
            datatype_count: 0,
            literal_count: 0,
            langtag_count: 0,
        }
    }
}

pub trait TIRI<'a> {
    fn iri(&self) -> &'a str;
}

pub enum TSubject<'a> {
    IRI(&'a TIRI<'a>),
    BlankNode(String),
}

pub struct VecStoreId<T> {
    index: usize,
    phantom: PhantomData<T>,
}

pub struct IndexGraph {
    strings: StringStore<StringUsage>,
    triples: BTreeSet<Triple>,
}

impl<T> VecStore<T> {
    fn new() -> VecStore<T> {
        VecStore {
            store: Vec::new(),
            unused: Vec::new(),
        }
    }
}

enum Which {
    Subject,
    Predicate,
    Object,
    Datatype,
    Literal,
    LangTag,
}

fn up_use(iri: &mut StringUsage, which: Which) {
    match which {
        Which::Subject => iri.subject_count += 1,
        Which::Predicate => iri.predicate_count += 1,
        Which::Object => iri.object_count += 1,
        Which::Datatype => iri.datatype_count += 1,
        Which::Literal => iri.literal_count += 1,
        Which::LangTag => iri.langtag_count += 1,
    }
}

#[derive(PartialEq, Eq, PartialOrd, Ord)]
struct Triple {
    subject: StringId,
    predicate: StringId,
}

impl IndexGraph {
    pub fn new() -> IndexGraph {
        IndexGraph {
            strings: StringStore::new(),
            triples: BTreeSet::new(),
        }
    }
    fn register_string(&mut self, s: &Rc<String>, which: Which) -> StringId {
        let id = self.strings.register_string(s);
        up_use(self.strings.get_mut_item(id), which);
        id
    }
    fn add_triple_si_oi(&mut self, s: &Rc<String>, p: &Rc<String>) {
        let s = self.register_string(s, Which::Subject);
        let p = self.register_string(p, Which::Predicate);
        self.triples.insert(Triple {
            subject: s,
            predicate: p,
        });
    }
}

#[test]
fn insert() {
    let mut graph = IndexGraph::new();
}