|
128
|
1 import { EventEmitter } from "events";
|
|
|
2 import {
|
|
|
3 BlankNode,
|
|
|
4 OTerm,
|
|
|
5 Quad,
|
|
|
6 QuadPredicate,
|
|
|
7 Store,
|
|
|
8 Term,
|
|
|
9 extractListOptions,
|
|
|
10 } from "n3";
|
|
|
11 import * as RDF from "rdf-js";
|
|
|
12 import { SubEvent } from "sub-events";
|
|
|
13 import { Patch } from "./Patch";
|
|
|
14 import { SourceGraph } from "./SourceGraph";
|
|
|
15
|
|
|
16 // queries over multiple Store objects
|
|
|
17 export class MultiStore implements Store {
|
|
|
18 // emitted when there's been a net change to the graph data
|
|
|
19 graphChanged: SubEvent<Patch> = new SubEvent();
|
|
|
20
|
|
|
21 // sources of statements
|
|
|
22 private stores: Store[] = [];
|
|
|
23 private tempCombinedGraph: Store;
|
|
|
24
|
|
|
25 constructor() {
|
|
|
26 this.tempCombinedGraph = new Store();
|
|
|
27 }
|
|
|
28
|
|
|
29 newStore(s: SourceGraph) {
|
|
|
30 this.stores.push(s.store);
|
|
|
31 const p = new Patch(); // todo
|
|
|
32 s.sourceGraphChanged.subscribe((p) => {
|
|
|
33 console.log("patchlife1: ");
|
|
|
34 this.sourceGraphDataChanged(p); // todo
|
|
|
35 });
|
|
|
36 }
|
|
|
37
|
|
|
38 lostStore(s: Store) {
|
|
|
39 throw new Error("notimplemented");
|
|
|
40 }
|
|
|
41
|
|
|
42 sourceGraphDataChanged(p: Patch) {
|
|
|
43 console.log("patchlife2: multistore saw a graph change", p);
|
|
|
44
|
|
|
45 this.tempCombinedGraph = new Store();
|
|
|
46 for (let st of this.stores) {
|
|
|
47 for (let q of st.getQuads(null, null, null, null)) {
|
|
|
48 this.tempCombinedGraph.addQuad(q);
|
|
|
49 }
|
|
|
50 }
|
|
|
51 console.log("patchlife3: tempgraph is rebuilt");
|
|
|
52 this.graphChanged.emit(p);
|
|
|
53 }
|
|
|
54
|
|
|
55 //
|
|
|
56 // Store interface follows:
|
|
|
57 //
|
|
|
58 forEach(qfn: (qfn: Quad) => void, s: OTerm, p: OTerm, o: OTerm, g: OTerm) {
|
|
|
59 this.tempCombinedGraph.forEach(qfn, s, p, o, g);
|
|
|
60 }
|
|
|
61 countQuads(s: OTerm, p: OTerm, o: OTerm, g: OTerm): number {
|
|
|
62 return this.tempCombinedGraph.countQuads(s, p, o, g);
|
|
|
63 // const seen: Set<Quad> = new Set();
|
|
|
64 // let count = 0;
|
|
|
65 // for (let src of this.sources.currentSourceGraphs) {
|
|
|
66 // for (let q of src.store.getQuads(s, p, o, g)) {
|
|
|
67 // if (!seen.has(q)) {
|
|
|
68 // count++;
|
|
|
69 // seen.add(q);
|
|
|
70 // }
|
|
|
71 // }
|
|
|
72 // }
|
|
|
73 // return count;
|
|
|
74 }
|
|
|
75
|
|
|
76 get size(): number {
|
|
|
77 return this.countQuads(null, null, null, null);
|
|
|
78 }
|
|
|
79 has(quad: Quad): boolean {
|
|
|
80 throw new Error("notimplemented");
|
|
|
81 }
|
|
|
82 getQuads(
|
|
|
83 subject: OTerm,
|
|
|
84 predicate: OTerm,
|
|
|
85 object: OTerm | OTerm[],
|
|
|
86 graph: OTerm
|
|
|
87 ): Quad[] {
|
|
|
88 return this.tempCombinedGraph.getQuads(subject, predicate, object, graph);
|
|
|
89 }
|
|
|
90 match(
|
|
|
91 subject?: Term | null,
|
|
|
92 predicate?: Term | null,
|
|
|
93 object?: Term | null,
|
|
|
94 graph?: Term | null
|
|
|
95 ): RDF.Stream<Quad> & RDF.DatasetCore<Quad, Quad> {
|
|
|
96 throw new Error("notimplemented");
|
|
|
97 }
|
|
|
98
|
|
|
99 every(
|
|
|
100 callback: QuadPredicate<Quad>,
|
|
|
101 subject: OTerm,
|
|
|
102 predicate: OTerm,
|
|
|
103 object: OTerm,
|
|
|
104 graph: OTerm
|
|
|
105 ): boolean {
|
|
|
106 throw new Error("notimplemented");
|
|
|
107 }
|
|
|
108 some(
|
|
|
109 callback: QuadPredicate<Quad>,
|
|
|
110 subject: OTerm,
|
|
|
111 predicate: OTerm,
|
|
|
112 object: OTerm,
|
|
|
113 graph: OTerm
|
|
|
114 ): boolean {
|
|
|
115 throw new Error("notimplemented");
|
|
|
116 }
|
|
|
117 getSubjects(
|
|
|
118 predicate: OTerm,
|
|
|
119 object: OTerm,
|
|
|
120 graph: OTerm
|
|
|
121 ): Array<Quad["subject"]> {
|
|
|
122 throw new Error("notimplemented");
|
|
|
123 }
|
|
|
124 forSubjects(
|
|
|
125 callback: (result: Quad["subject"]) => void,
|
|
|
126 predicate: OTerm,
|
|
|
127 object: OTerm,
|
|
|
128 graph: OTerm
|
|
|
129 ): void {
|
|
|
130 throw new Error("notimplemented");
|
|
|
131 }
|
|
|
132 getPredicates(
|
|
|
133 subject: OTerm,
|
|
|
134 object: OTerm,
|
|
|
135 graph: OTerm
|
|
|
136 ): Array<Quad["predicate"]> {
|
|
|
137 throw new Error("notimplemented");
|
|
|
138 return [];
|
|
|
139 }
|
|
|
140 forPredicates(
|
|
|
141 callback: (result: Quad["predicate"]) => void,
|
|
|
142 subject: OTerm,
|
|
|
143 object: OTerm,
|
|
|
144 graph: OTerm
|
|
|
145 ): void {
|
|
|
146 throw new Error("notimplemented");
|
|
|
147 }
|
|
|
148 getObjects(
|
|
|
149 subject: OTerm,
|
|
|
150 predicate: OTerm,
|
|
|
151 graph: OTerm
|
|
|
152 ): Array<Quad["object"]> {
|
|
|
153 return this.tempCombinedGraph.getObjects(subject, predicate, graph);
|
|
|
154 }
|
|
|
155 forObjects(
|
|
|
156 callback: (result: Quad["object"]) => void,
|
|
|
157 subject: OTerm,
|
|
|
158 predicate: OTerm,
|
|
|
159 graph: OTerm
|
|
|
160 ): void {
|
|
|
161 throw new Error("notimplemented");
|
|
|
162 }
|
|
|
163 getGraphs(
|
|
|
164 subject: OTerm,
|
|
|
165 predicate: OTerm,
|
|
|
166 object: OTerm
|
|
|
167 ): Array<Quad["graph"]> {
|
|
|
168 throw new Error("notimplemented");
|
|
|
169 }
|
|
|
170 forGraphs(
|
|
|
171 callback: (result: Quad["graph"]) => void,
|
|
|
172 subject: OTerm,
|
|
|
173 predicate: OTerm,
|
|
|
174 object: OTerm
|
|
|
175 ): void {
|
|
|
176 throw new Error("notimplemented");
|
|
|
177 }
|
|
|
178 extractLists(options?: extractListOptions): Record<string, RDF.Term[]> {
|
|
|
179 throw new Error("notimplemented");
|
|
|
180 }
|
|
|
181 [Symbol.iterator](): Iterator<Quad> {
|
|
|
182 throw new Error("notimplemented");
|
|
|
183 }
|
|
|
184
|
|
|
185 add(): this {
|
|
|
186 throw new Error("MultiStore is readonly");
|
|
|
187 }
|
|
|
188 addQuad() {
|
|
|
189 throw new Error("notimplemented");
|
|
|
190 }
|
|
|
191 addQuads(): void {
|
|
|
192 throw new Error("MultiStore is readonly");
|
|
|
193 }
|
|
|
194 delete(): this {
|
|
|
195 throw new Error("MultiStore is readonly");
|
|
|
196 }
|
|
|
197 import(): EventEmitter {
|
|
|
198 throw new Error("MultiStore is readonly");
|
|
|
199 }
|
|
|
200 removeQuad(): void {
|
|
|
201 throw new Error("MultiStore is readonly");
|
|
|
202 }
|
|
|
203 removeQuads(): void {
|
|
|
204 throw new Error("MultiStore is readonly");
|
|
|
205 }
|
|
|
206 remove(): EventEmitter {
|
|
|
207 throw new Error("MultiStore is readonly");
|
|
|
208 }
|
|
|
209 removeMatches(): EventEmitter {
|
|
|
210 throw new Error("MultiStore is readonly");
|
|
|
211 }
|
|
|
212 deleteGraph(): EventEmitter {
|
|
|
213 throw new Error("MultiStore is readonly");
|
|
|
214 }
|
|
|
215 createBlankNode(): BlankNode {
|
|
|
216 throw new Error("MultiStore is readonly");
|
|
|
217 }
|
|
|
218 }
|
