1 package org.simantics.graph.db.old;
\r
3 import java.io.DataOutput;
\r
4 import java.io.DataOutputStream;
\r
5 import java.io.FileNotFoundException;
\r
6 import java.io.FileOutputStream;
\r
7 import java.io.IOException;
\r
8 import java.util.HashSet;
\r
9 import java.util.Map;
\r
10 import java.util.Set;
\r
12 import org.simantics.databoard.Bindings;
\r
13 import org.simantics.databoard.adapter.AdaptException;
\r
14 import org.simantics.databoard.binding.mutable.Variant;
\r
15 import org.simantics.db.ReadGraph;
\r
16 import org.simantics.db.Resource;
\r
17 import org.simantics.db.VirtualGraph;
\r
18 import org.simantics.db.WriteOnlyGraph;
\r
19 import org.simantics.db.common.WriteBindings;
\r
20 import org.simantics.db.common.procedure.adapter.TransientCacheAsyncListener;
\r
21 import org.simantics.db.common.uri.UnescapedChildMapOfResource;
\r
22 import org.simantics.db.common.utils.Logger;
\r
23 import org.simantics.db.exception.DatabaseException;
\r
24 import org.simantics.db.exception.ResourceNotFoundException;
\r
25 import org.simantics.db.service.ClusterBuilder;
\r
26 import org.simantics.db.service.ClusterBuilder.ResourceHandle;
\r
27 import org.simantics.db.service.SerialisationSupport;
\r
28 import org.simantics.db.service.TransferableGraphSupport;
\r
29 import org.simantics.graph.db.CoreInitialization;
\r
30 import org.simantics.graph.db.IImportAdvisor;
\r
31 import org.simantics.graph.representation.Extensions;
\r
32 import org.simantics.graph.representation.External;
\r
33 import org.simantics.graph.representation.Identity;
\r
34 import org.simantics.graph.representation.IdentityDefinition;
\r
35 import org.simantics.graph.representation.Internal;
\r
36 import org.simantics.graph.representation.Optional;
\r
37 import org.simantics.graph.representation.Root;
\r
38 import org.simantics.graph.representation.TransferableGraphUtils;
\r
39 import org.simantics.graph.representation.old.OldTransferableGraph1;
\r
40 import org.simantics.graph.representation.old.OldValue1;
\r
42 public class OldTransferableGraphImportProcess1 {
\r
44 public static String LOG_FILE = "transferableGraphs.log";
\r
45 final static private boolean LOG = false;
\r
47 static DataOutput log;
\r
53 FileOutputStream stream = new FileOutputStream(LOG_FILE);
\r
54 log = new DataOutputStream(stream);
\r
55 } catch (FileNotFoundException e) {
\r
56 e.printStackTrace();
\r
62 private static void log(String line) {
\r
65 log.writeUTF(line + "\n");
\r
66 } catch (IOException e) {
\r
67 e.printStackTrace();
\r
72 OldTransferableGraph1 tg;
\r
73 IImportAdvisor advisor;
\r
75 Resource[] resources;
\r
76 ResourceHandle[] handles;
\r
78 Set<String> missingExternals = new HashSet<String>();
\r
81 Resource RootLibrary;
\r
85 Resource InstanceOf;
\r
86 Resource ConsistsOf;
\r
91 public OldTransferableGraphImportProcess1(OldTransferableGraph1 tg, IImportAdvisor advisor) {
\r
93 this.advisor = advisor;
\r
94 /*System.out.println("Transferable graph identities:");
\r
95 for(Identity id : tg.identities) {
\r
96 if(id.definition instanceof Internal) {
\r
97 Internal def = (Internal)id.definition;
\r
98 System.out.println(" internal " + def.name);
\r
100 else if(id.definition instanceof External) {
\r
101 External def = (External)id.definition;
\r
102 System.out.println(" external " + def.name);
\r
107 public void findBuiltins(WriteOnlyGraph g) throws DatabaseException {
\r
108 RootLibrary = g.getBuiltin("http:/");
\r
109 String = g.getBuiltin(CoreInitialization.LAYER0 + "String");
\r
110 Library = g.getBuiltin(CoreInitialization.LAYER0 + "Library");
\r
111 InstanceOf = g.getBuiltin(CoreInitialization.LAYER0 + "InstanceOf");
\r
112 ConsistsOf = g.getBuiltin(CoreInitialization.LAYER0 + "ConsistsOf");
\r
113 PartOf = g.getBuiltin(CoreInitialization.LAYER0 + "PartOf");
\r
114 HasName = g.getBuiltin(CoreInitialization.LAYER0 + "HasName");
\r
115 NameOf = g.getBuiltin(CoreInitialization.LAYER0 + "NameOf");
\r
118 public void findBuiltins(ReadGraph g) throws DatabaseException {
\r
119 RootLibrary = g.getBuiltin("http:/");
\r
120 String = g.getBuiltin(CoreInitialization.LAYER0 + "String");
\r
121 Library = g.getBuiltin(CoreInitialization.LAYER0 + "Library");
\r
122 InstanceOf = g.getBuiltin(CoreInitialization.LAYER0 + "InstanceOf");
\r
123 ConsistsOf = g.getBuiltin(CoreInitialization.LAYER0 + "ConsistsOf");
\r
124 PartOf = g.getBuiltin(CoreInitialization.LAYER0 + "PartOf");
\r
125 HasName = g.getBuiltin(CoreInitialization.LAYER0 + "HasName");
\r
126 NameOf = g.getBuiltin(CoreInitialization.LAYER0 + "NameOf");
\r
129 /* Preparation that is used when the core is empty.
\r
131 void initialPrepare(WriteOnlyGraph graph) throws DatabaseException {
\r
132 findBuiltins(graph);
\r
134 resources = new Resource[tg.resourceCount];
\r
137 int SimanticsDomain = -1;
\r
140 for(Identity identity : tg.identities) {
\r
141 if(identity.definition instanceof Internal) {
\r
142 Internal def = (Internal)identity.definition;
\r
143 Resource res = null;
\r
144 if(def.parent == Layer0) {
\r
146 res = graph.getBuiltin(CoreInitialization.LAYER0 + def.name);
\r
147 } catch(ResourceNotFoundException e) {
\r
150 else if(def.parent == SimanticsDomain) {
\r
151 if(def.name.equals("Layer0-1.1"))
\r
152 Layer0 = identity.resource;
\r
154 else if(def.parent == Root) {
\r
155 if(def.name.equals("www.simantics.org"))
\r
156 SimanticsDomain = identity.resource;
\r
160 res = createChild(graph, resources[def.parent], def.name);
\r
162 createChild(graph, res, resources[def.parent], def.name);
\r
163 resources[identity.resource] = res;
\r
165 else if(identity.definition instanceof Root) {
\r
166 Root = identity.resource;
\r
167 resources[identity.resource] = RootLibrary;
\r
172 void addMissing(String external) {
\r
173 Set<String> removals = new HashSet<String>();
\r
174 for(String ext : missingExternals) if(ext.startsWith(external)) return;
\r
175 for(String ext : missingExternals) if(external.startsWith(ext)) removals.add(ext);
\r
176 missingExternals.removeAll(removals);
\r
177 missingExternals.add(external);
\r
180 void prepare(ReadGraph graph) throws DatabaseException {
\r
181 findBuiltins(graph);
\r
183 Resource[] resources = new Resource[tg.resourceCount];
\r
185 for(Identity identity : tg.identities) {
\r
186 IdentityDefinition definition = identity.definition;
\r
187 if(definition instanceof External) {
\r
188 External def = (External)definition;
\r
189 if(def.parent == -1) {
\r
190 resources[identity.resource] = RootLibrary;
\r
192 if("@inverse".equals(def.name)) {
\r
193 Resource parent = resources[def.parent];
\r
194 Resource child = graph.getInverse(parent);
\r
195 resources[identity.resource] = child;
\r
197 Resource parent = resources[def.parent];
\r
198 // TODO: escape should be removed when names become well-behaving
\r
199 if(parent != null) {
\r
200 Resource child = graph
\r
201 .syncRequest(new UnescapedChildMapOfResource(parent),
\r
202 new TransientCacheAsyncListener<Map<String, Resource>>())
\r
204 if(child == null) {
\r
205 addMissing(graph.getURI(parent) + "/" + def.name);
\r
207 resources[identity.resource] = child;
\r
209 addMissing(TransferableGraphUtils.getURI(tg.resourceCount, tg.identities, def.parent) + "/" + def.name);
\r
214 else if(definition instanceof Internal) {
\r
215 // Do not do anything for now
\r
217 else if(definition instanceof Root) {
\r
218 Root root = (Root)definition;
\r
219 if(root.name.equals(""))
\r
220 resources[identity.resource] = RootLibrary;
\r
222 advisor.analyzeRoot(graph, root);
\r
224 else if(definition instanceof Optional) {
\r
225 External def = (External)definition;
\r
226 Resource parent = resources[def.parent];
\r
228 resources[identity.resource] =
\r
229 graph.syncRequest(new UnescapedChildMapOfResource(parent)).get(def.name);
\r
233 this.resources = resources;
\r
235 if(!missingExternals.isEmpty()) throw new OldMissingDependencyException(this);
\r
239 Resource createChild(WriteOnlyGraph graph, Resource parent, String name) throws DatabaseException {
\r
240 Resource child = graph.newResource();
\r
241 graph.claim(parent, ConsistsOf, PartOf, child);
\r
242 Resource nameResource = graph.newResource();
\r
243 graph.claim(nameResource, InstanceOf, null, String);
\r
244 graph.claimValue(nameResource, name, WriteBindings.STRING);
\r
245 graph.claim(child, HasName, NameOf, nameResource);
\r
249 void createChild(WriteOnlyGraph graph, Resource child, Resource parent, String name) throws DatabaseException {
\r
250 graph.claim(parent, ConsistsOf, PartOf, child);
\r
251 Resource nameResource = graph.newResource();
\r
252 graph.claim(nameResource, InstanceOf, null, String);
\r
253 graph.claimValue(nameResource, name, WriteBindings.STRING);
\r
254 graph.claim(child, HasName, NameOf, nameResource);
\r
257 int[] getClustering() {
\r
258 Variant v = tg.extensions.get(Extensions.CLUSTERING);
\r
259 if(v == null) return null;
\r
261 return (int[])v.getValue(Bindings.INT_ARRAY);
\r
262 } catch (AdaptException e) {
\r
263 Logger.defaultLogError(e);
\r
268 void write(WriteOnlyGraph graph) throws DatabaseException {
\r
270 Resource[] resources = this.resources;
\r
272 this.handles = new ResourceHandle[resources.length];
\r
274 ResourceHandle[] handles = this.handles;
\r
276 int[] clustering = getClustering();
\r
278 // Internal identities
\r
279 for(Identity identity : tg.identities) {
\r
280 IdentityDefinition definition = identity.definition;
\r
281 if(resources[identity.resource] != null)
\r
283 if(definition instanceof External) {
\r
284 // Already done everything
\r
286 else if(definition instanceof Internal) {
\r
287 Internal def = (Internal)definition;
\r
288 resources[identity.resource] =
\r
289 createChild(graph, resources[def.parent], def.name);
\r
291 else if(definition instanceof Root) {
\r
292 Root root = (Root)definition;
\r
293 resources[identity.resource] = advisor.createRoot(graph, root);
\r
295 else if(definition instanceof Optional) {
\r
296 Optional def = (Optional)definition;
\r
297 Resource child = createChild(graph, resources[def.parent], def.name);
\r
298 graph.claim(child, InstanceOf, null, Library); // ???
\r
299 resources[identity.resource] = child;
\r
303 ClusterBuilder builder = graph.getService(ClusterBuilder.class);
\r
304 SerialisationSupport ss = graph.getService(SerialisationSupport.class);
\r
306 if(clustering != null) {
\r
309 for(int c : clustering) {
\r
310 builder.newCluster();
\r
311 for(int r=0;r<c;r++, i++)
\r
312 if(resources[i] == null)
\r
313 handles[i] = builder.newResource();
\r
315 handles[i] = builder.resource(resources[i]);
\r
319 for(;i<resources.length;++i)
\r
320 if(resources[i] == null)
\r
321 handles[i] = builder.newResource();
\r
323 handles[i] = builder.resource(resources[i]);
\r
327 // Create blank resources
\r
328 for(int i=0;i<resources.length;++i)
\r
329 if(resources[i] == null)
\r
330 handles[i] = builder.newResource();
\r
332 handles[i] = builder.resource(resources[i]);
\r
336 // Write statements
\r
337 int[] statements = tg.statements;
\r
339 int internals = tg.resourceCount - tg.identities.length;
\r
341 for(int i=0;i<statements.length;i+=4) {
\r
343 int sub = statements[i];
\r
344 int pred = statements[i+1];
\r
345 int inv = statements[i+2];
\r
346 int obj = statements[i+3];
\r
348 ResourceHandle subject = handles[sub];
\r
349 ResourceHandle predicate = handles[pred];
\r
350 ResourceHandle object = handles[obj];
\r
352 if(resources[sub] == null) {
\r
353 subject.addStatement(graph, predicate, object);
\r
356 handles[sub].resource(ss),
\r
357 handles[pred].resource(ss),
\r
358 null, handles[obj].resource(ss));
\r
363 if(resources[obj] == null) {
\r
364 ResourceHandle inverse = handles[inv];
\r
365 object.addStatement(graph, inverse, subject);
\r
368 handles[obj].resource(ss),
\r
369 handles[inv].resource(ss),
\r
370 null, handles[sub].resource(ss));
\r
376 log("[STATEMENT] " + resources[statements[i]].getResourceId() + ", " + resources[statements[i+1]].getResourceId() + ", " + resources[statements[i+3]].getResourceId());
\r
382 TransferableGraphSupport tgSupport =
\r
383 graph.getService(TransferableGraphSupport.class);
\r
384 VirtualGraph vg = graph.getProvider();
\r
385 for(OldValue1 value : tg.values) {
\r
386 int file = value.resource & 0x80000000;
\r
387 int resource = value.resource & 0x7FFFFFFF;
\r
389 graph.claimValue(handles[resource].resource(ss), value.value, Bindings.BYTE_ARRAY);
\r
391 if(resource < internals) {
\r
392 handles[resource].addValue(graph, value.value);
\r
394 tgSupport.setValue(graph, handles[resource].resource(ss), vg, value.value);
\r
396 //tgSupport.setValue(resources[resource], vg, value.value);
\r
401 void write2(WriteOnlyGraph graph) throws DatabaseException {
\r
402 Resource[] resources = this.resources;
\r
404 // Internal identities
\r
405 for(Identity identity : tg.identities) {
\r
406 IdentityDefinition definition = identity.definition;
\r
407 if(resources[identity.resource] != null)
\r
409 if(definition instanceof External) {
\r
410 // Already done everything
\r
412 else if(definition instanceof Internal) {
\r
413 Internal def = (Internal)definition;
\r
414 resources[identity.resource] =
\r
415 createChild(graph, resources[def.parent], def.name);
\r
417 else if(definition instanceof Root) {
\r
418 Root root = (Root)definition;
\r
419 resources[identity.resource] = advisor.createRoot(graph, root);
\r
421 else if(definition instanceof Optional) {
\r
422 Optional def = (Optional)definition;
\r
423 Resource child = createChild(graph, resources[def.parent], def.name);
\r
424 graph.claim(child, InstanceOf, null, Library); // ???
\r
425 resources[identity.resource] = child;
\r
429 // Create blank resources
\r
430 for(int i=0;i<resources.length;++i)
\r
431 if(resources[i] == null)
\r
432 resources[i] = graph.newResource();
\r
434 // Write statements
\r
435 int[] statements = tg.statements;
\r
437 for(int i=0;i<statements.length;i+=4) {
\r
438 int inv = statements[i+2];
\r
440 resources[statements[i]],
\r
441 resources[statements[i+1]],
\r
442 inv < 0 ? null : resources[inv],
\r
443 resources[statements[i+3]]
\r
446 log("[STATEMENT] " + resources[statements[i]].getResourceId() + ", " + resources[statements[i+1]].getResourceId() + ", " + resources[statements[i+3]].getResourceId());
\r
451 TransferableGraphSupport tgSupport =
\r
452 graph.getService(TransferableGraphSupport.class);
\r
453 VirtualGraph vg = graph.getProvider();
\r
454 for(OldValue1 value : tg.values) {
\r
455 int file = value.resource & 0x80000000;
\r
456 int resource = value.resource & 0x7FFFFFFF;
\r
458 graph.claimValue(resources[resource], value.value, Bindings.BYTE_ARRAY);
\r
460 tgSupport.setValue(graph, resources[resource], vg, value.value);
\r
466 public long[] getResourceIds(SerialisationSupport serializer) throws DatabaseException {
\r
467 final int count = resources.length;
\r
468 long[] resourceIds = new long[count];
\r
469 if(handles != null) {
\r
470 for(int i=0;i<count;++i)
\r
471 resourceIds[i] = serializer.getRandomAccessId(handles[i].resource(serializer));
\r
473 for(int i=0;i<count;++i)
\r
474 resourceIds[i] = serializer.getRandomAccessId(resources[i]);
\r
476 return resourceIds;
\r