Mercurial > code > home > repos > streamed-graph

comparison src/MultiStore.ts @ 128:5a1a79f54779

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
big rewrite
author drewp@bigasterisk.com
date Fri, 05 May 2023 21:26:36 -0700
parents
children 27fad20dc101
comparison
equal deleted inserted replaced
127:d2580faef057 128:5a1a79f54779
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 }