1 /*******************************************************************************
\r
2 * Copyright (c) 2007, 2010 Association for Decentralized Information Management
\r
3 * in Industry THTH ry.
\r
4 * All rights reserved. This program and the accompanying materials
\r
5 * are made available under the terms of the Eclipse Public License v1.0
\r
6 * which accompanies this distribution, and is available at
\r
7 * http://www.eclipse.org/legal/epl-v10.html
\r
10 * VTT Technical Research Centre of Finland - initial API and implementation
\r
11 *******************************************************************************/
\r
12 package org.simantics.layer0.utils.direct;
\r
14 import java.util.Collection;
\r
15 import java.util.HashSet;
\r
16 import java.util.Set;
\r
17 import java.util.Stack;
\r
19 import org.simantics.db.ReadGraph;
\r
20 import org.simantics.db.Resource;
\r
21 import org.simantics.db.Statement;
\r
22 import org.simantics.db.WriteGraph;
\r
23 import org.simantics.db.common.uri.UnescapedChildMapOfResource;
\r
24 import org.simantics.db.common.utils.NameUtils;
\r
25 import org.simantics.db.exception.DatabaseException;
\r
26 import org.simantics.db.exception.ServiceException;
\r
27 import org.simantics.db.exception.ValidationException;
\r
28 import org.simantics.db.procedure.MultiProcedure;
\r
29 import org.simantics.db.procedure.SyncMultiProcedure;
\r
30 import org.simantics.layer0.Layer0;
\r
33 public final class GraphUtils {
\r
35 public static Resource createScalarString(WriteGraph graph, String string) throws DatabaseException {
\r
36 Layer0 b = Layer0.getInstance(graph);
\r
37 Resource ret = graph.newResource();
\r
38 graph.claim(ret, b.InstanceOf, null, b.String);
\r
39 graph.claimValue(ret, string);
\r
43 public static Resource createScalarInteger(WriteGraph graph, int value) throws DatabaseException {
\r
44 Layer0 b = Layer0.getInstance(graph);
\r
45 Resource ret = graph.newResource();
\r
46 graph.claim(ret, b.InstanceOf, null, b.Integer);
\r
47 graph.claimValue(ret, value);
\r
51 public static Resource createScalarLong(WriteGraph graph, long value) throws DatabaseException {
\r
52 Layer0 b = Layer0.getInstance(graph);
\r
53 Resource ret = graph.newResource();
\r
54 graph.claim(ret, b.InstanceOf, null, b.Long);
\r
55 graph.claimValue(ret, value);
\r
59 public static Resource createScalarFloat(WriteGraph graph, float value) throws DatabaseException {
\r
60 Layer0 b = Layer0.getInstance(graph);
\r
61 Resource ret = graph.newResource();
\r
62 graph.claim(ret, b.InstanceOf, null, b.Float);
\r
63 graph.claimValue(ret, value);
\r
67 public static Resource createScalarBoolean(WriteGraph graph, boolean value) throws DatabaseException {
\r
68 Layer0 b = Layer0.getInstance(graph);
\r
69 Resource ret = graph.newResource();
\r
70 graph.claim(ret, b.InstanceOf, null, b.Boolean);
\r
71 graph.claimValue(ret, value);
\r
75 public static Resource createScalarDouble(WriteGraph graph, double value) throws DatabaseException {
\r
76 Layer0 b = Layer0.getInstance(graph);
\r
77 Resource ret = graph.newResource();
\r
78 graph.claim(ret, b.InstanceOf, null, b.Double);
\r
79 graph.claimValue(ret, value);
\r
83 public static void addRelatedScalarString(WriteGraph graph, Resource resource, Resource relation, String string) throws DatabaseException {
\r
84 graph.claim(resource, relation, createScalarString(graph, string));
\r
87 public static void addRelatedScalarInteger(WriteGraph graph, Resource resource, Resource relation, int value) throws DatabaseException {
\r
88 graph.claim(resource, relation, createScalarInteger(graph, value));
\r
91 public static Resource createDoubleArray(WriteGraph graph, double[] array, Resource type) throws DatabaseException {
\r
92 Resource ret = graph.newResource();
\r
93 Layer0 b = Layer0.getInstance(graph);
\r
94 graph.claim(ret, b.InstanceOf, null, type);
\r
95 graph.claimValue(ret, array);
\r
99 public static Resource createDoubleArray(WriteGraph graph, double[] array) throws DatabaseException {
\r
100 Layer0 b = Layer0.getInstance(graph);
\r
101 return createDoubleArray(graph, array, b.DoubleArray);
\r
104 public static Resource createIntegerArray(WriteGraph graph, int[] array, Resource type) throws DatabaseException {
\r
105 Resource ret = graph.newResource();
\r
106 Layer0 b = Layer0.getInstance(graph);
\r
107 graph.claim(ret, b.InstanceOf, null, type);
\r
108 graph.claimValue(ret, array);
\r
112 public static Resource createIntegerArray(WriteGraph graph, int[] array) throws DatabaseException {
\r
113 Layer0 b = Layer0.getInstance(graph);
\r
114 return createIntegerArray(graph, array, b.IntegerArray);
\r
117 public static Resource createLongArray(WriteGraph graph, long[] array, Resource type) throws DatabaseException {
\r
118 Resource ret = graph.newResource();
\r
119 Layer0 b = Layer0.getInstance(graph);
\r
120 graph.claim(ret, b.InstanceOf, null, type);
\r
121 graph.claimValue(ret, array);
\r
125 public static Resource createLongArray(WriteGraph graph, long[] array) throws DatabaseException {
\r
126 Layer0 b = Layer0.getInstance(graph);
\r
127 return createLongArray(graph, array, b.LongArray);
\r
130 public static Resource createFloatArray(WriteGraph graph, float[] array, Resource type) throws DatabaseException {
\r
131 Resource ret = graph.newResource();
\r
132 Layer0 b = Layer0.getInstance(graph);
\r
133 graph.claim(ret, b.InstanceOf, null, type);
\r
134 graph.claimValue(ret, array);
\r
138 public static Resource createFloatArray(WriteGraph graph, float[] array) throws DatabaseException {
\r
139 Layer0 b = Layer0.getInstance(graph);
\r
140 return createFloatArray(graph, array, b.FloatArray);
\r
143 public static Resource createBooleanArray(WriteGraph graph, boolean[] array, Resource type) throws DatabaseException {
\r
144 Resource ret = graph.newResource();
\r
145 Layer0 b = Layer0.getInstance(graph);
\r
146 graph.claim(ret, b.InstanceOf, null, type);
\r
147 graph.claimValue(ret, array);
\r
151 public static Resource createBooleanArray(WriteGraph graph, boolean[] array) throws DatabaseException {
\r
152 Layer0 b = Layer0.getInstance(graph);
\r
153 return createBooleanArray(graph, array, b.BooleanArray);
\r
156 public static Resource createStringArray(WriteGraph graph, String[] array, Resource type) throws DatabaseException {
\r
157 Resource ret = graph.newResource();
\r
158 Layer0 b = Layer0.getInstance(graph);
\r
159 graph.claim(ret, b.InstanceOf, null, type);
\r
160 graph.claimValue(ret, array);
\r
164 public static Resource createStringArray(WriteGraph graph, String[] array) throws DatabaseException {
\r
165 Layer0 b = Layer0.getInstance(graph);
\r
166 return createStringArray(graph, array, b.StringArray);
\r
169 public interface ResourceTester {
\r
170 boolean test(ReadGraph graph, Resource resource) throws DatabaseException ;
\r
173 public static class AcceptAll implements ResourceTester {
\r
176 public boolean test(ReadGraph graph, Resource resource) throws DatabaseException {
\r
182 public static class InstanceOf implements ResourceTester {
\r
184 private final Resource type;
\r
186 public InstanceOf(Resource type) {
\r
191 public boolean test(ReadGraph graph, Resource resource) throws DatabaseException {
\r
192 return graph.isInstanceOf(resource, type);
\r
197 public static class Inherits implements ResourceTester {
\r
199 private final Resource superType;
\r
201 public Inherits(Resource superType) {
\r
202 this.superType = superType;
\r
206 public boolean test(ReadGraph graph, Resource resource) throws DatabaseException {
\r
207 return graph.isInheritedFrom(resource, superType);
\r
212 public static void findResources(ReadGraph graph, Collection<Resource> roots, Resource relation, ResourceTester tester, MultiProcedure<Resource> procedure) throws DatabaseException {
\r
214 Set<Resource> visited = new HashSet<Resource>();
\r
215 Stack<Resource> process = new Stack<Resource>();
\r
217 process.addAll(roots);
\r
218 visited.addAll(roots);
\r
220 while(!process.isEmpty()) {
\r
221 Resource cur = process.pop();
\r
222 for(Resource r : graph.getObjects(cur, relation))
\r
223 if(!visited.contains(r)) {
\r
225 if(tester.test(graph, r))
\r
226 procedure.execute(r);
\r
231 procedure.finished();
\r
236 public static void findResources(ReadGraph graph, Collection<Resource> roots, Resource relation, ResourceTester tester, SyncMultiProcedure<Resource> procedure) throws DatabaseException {
\r
238 Set<Resource> visited = new HashSet<Resource>();
\r
239 Stack<Resource> process = new Stack<Resource>();
\r
241 process.addAll(roots);
\r
242 visited.addAll(roots);
\r
244 while(!process.isEmpty()) {
\r
245 Resource cur = process.pop();
\r
246 for(Resource r : graph.getObjects(cur, relation))
\r
247 if(!visited.contains(r)) {
\r
249 if(tester.test(graph, r))
\r
250 procedure.execute(graph, r);
\r
255 procedure.finished(graph);
\r
260 * @deprecated use {@link NameUtils#getSafeName(ReadGraph, Resource)}
\r
262 public static String getReadableName(ReadGraph graph, Resource resource) throws ValidationException, ServiceException {
\r
263 return NameUtils.getSafeName(graph, resource);
\r
267 * @deprecated use {@link NameUtils#findReservedNames(ReadGraph, String, Resource, Resource, Set)}
\r
269 public static Set<String> findReservedNames(ReadGraph g, String proposition, Resource container, Resource consistRelation, Set<String> result) throws DatabaseException {
\r
270 return NameUtils.findReservedNames(g, proposition, container, consistRelation, result);
\r
274 * @deprecated use {@link NameUtils#findReservedNames(ReadGraph, String, Resource, Resource)
\r
276 public static Set<String> findReservedNames(ReadGraph g, String proposition, Resource container, Resource consistRelation) throws DatabaseException {
\r
277 return NameUtils.findReservedNames(g, proposition, container, consistRelation);
\r
281 * @deprecated use {@link NameUtils#findFreshName(ReadGraph, String, Resource)}
\r
283 public static String findFreshName(ReadGraph g, String proposition, Resource container) throws DatabaseException {
\r
284 return NameUtils.findFreshName(g, proposition, container);
\r
288 * @deprecated use {@link NameUtils#findFreshEscapedName(ReadGraph, String, Resource)}
\r
290 public static String findFreshEscapedName(ReadGraph g, String proposition, Resource container) throws DatabaseException {
\r
291 return NameUtils.findFreshEscapedName(g, proposition, container);
\r
295 * @deprecated use {@link NameUtils#findFreshName(ReadGraph, String, Resource, Resource)}
\r
297 public static String findFreshName(ReadGraph g, String proposition, Resource container, Resource consistRelation) throws DatabaseException {
\r
298 return NameUtils.findFreshName(g, proposition, container, consistRelation);
\r
302 * @deprecated use {@link NameUtils#findFreshEscapedName(ReadGraph, String, Resource, Resource)}
\r
304 public static String findFreshEscapedName(ReadGraph g, String proposition, Resource container, Resource consistRelation) throws DatabaseException {
\r
305 return NameUtils.findFreshEscapedName(g, proposition, container, consistRelation);
\r
309 * @deprecated use {@link NameUtils#findFreshName(ReadGraph, String, Resource, Resource, String)}
\r
311 public static String findFreshName(ReadGraph g, String proposition, Resource container, Resource consistRelation, String nameFormat) throws DatabaseException {
\r
312 return NameUtils.findFreshName(g, proposition, container, consistRelation, nameFormat);
\r
316 * @deprecated use {@link NameUtils#findFreshInstanceName(ReadGraph, Resource, Resource)}
\r
318 public static String findFreshInstanceName(ReadGraph g, Resource type, Resource container) throws DatabaseException {
\r
319 return NameUtils.findFreshInstanceName(g, type, container);
\r
323 * @deprecated use {@link NameUtils#findFreshInstanceName(ReadGraph, Resource, Resource, Resource)}
\r
325 public static String findFreshInstanceName(ReadGraph g, Resource type, Resource container, Resource relation) throws DatabaseException {
\r
326 return NameUtils.findFreshInstanceName(g, type, container, relation);
\r
329 public static Resource create(WriteGraph g, Resource ... predicateObjectPairs) throws DatabaseException {
\r
330 assert(predicateObjectPairs.length % 2 == 0);
\r
331 Resource resource = g.newResource();
\r
332 for(int i=0;i<predicateObjectPairs.length;i+=2)
\r
333 g.claim(resource, predicateObjectPairs[i], predicateObjectPairs[i+1]);
\r
337 private static Resource getObjectOrCreatePrimitiveValue(WriteGraph g, Object object) throws DatabaseException {
\r
338 if (object == null)
\r
339 throw new NullPointerException("null object");
\r
341 Class<?> clazz = object.getClass();
\r
343 if (object instanceof Resource)
\r
344 return (Resource) object;
\r
346 if (String.class.equals(clazz))
\r
347 return createScalarString(g, (String) object);
\r
348 else if (String[].class.equals(clazz))
\r
349 return createStringArray(g, (String[]) object);
\r
350 else if (Integer.class.equals(clazz))
\r
351 return createScalarInteger(g, (Integer) object);
\r
352 else if (int[].class.equals(clazz))
\r
353 return createIntegerArray(g, (int[]) object);
\r
354 else if (Long.class.equals(clazz))
\r
355 return createScalarLong(g, (Long) object);
\r
356 else if (long[].class.equals(clazz))
\r
357 return createLongArray(g, (long[]) object);
\r
358 else if (Float.class.equals(clazz))
\r
359 return createScalarFloat(g, (Float) object);
\r
360 else if (float[].class.equals(clazz))
\r
361 return createFloatArray(g, (float[]) object);
\r
362 else if (Double.class.equals(clazz))
\r
363 return createScalarDouble(g, (Double) object);
\r
364 else if (double[].class.equals(clazz))
\r
365 return createDoubleArray(g, (double[]) object);
\r
366 else if (Boolean.class.equals(clazz))
\r
367 return createScalarBoolean(g, (Boolean) object);
\r
368 else if (boolean[].class.equals(clazz))
\r
369 return createBooleanArray(g, (boolean[]) object);
\r
371 throw new UnsupportedOperationException("unsupported object type: " + object);
\r
374 public static Resource create(WriteGraph g, Object ... predicateObjectPairs) throws DatabaseException {
\r
375 assert(predicateObjectPairs.length % 2 == 0);
\r
376 Resource resource = g.newResource();
\r
377 for(int i=0;i<predicateObjectPairs.length;i+=2) {
\r
378 Resource predicate = (Resource)predicateObjectPairs[i];
\r
379 Object _object = predicateObjectPairs[i+1];
\r
380 Resource object = getObjectOrCreatePrimitiveValue(g, _object);
\r
381 g.claim(resource, predicate, object);
\r
386 public static Resource create2(WriteGraph g, Resource type, Object ... predicateObjectPairs) throws DatabaseException {
\r
387 assert(predicateObjectPairs.length % 2 == 0);
\r
388 assert(type != null);
\r
389 Resource resource = g.newResource();
\r
390 Layer0 b = Layer0.getInstance(g);
\r
391 g.claim(resource, b.InstanceOf, null, type);
\r
392 for(int i=0;i<predicateObjectPairs.length;i+=2) {
\r
393 Resource predicate = (Resource)predicateObjectPairs[i];
\r
394 Object _object = predicateObjectPairs[i+1];
\r
395 Resource object = getObjectOrCreatePrimitiveValue(g, _object);
\r
396 g.claim(resource, predicate, object);
\r
402 * @deprecated use {@link NameUtils#toString(ReadGraph, Statement)}
\r
404 public static String toString(ReadGraph g, Statement stm) throws DatabaseException {
\r
405 return NameUtils.toString(g, stm);
\r
408 // public static Resource getPossiblePath(ReadGraph graph, Resource resource, Resource ... path) throws DatabaseException {
\r
410 // for(Resource p : path) {
\r
411 // resource = graph.getPossibleObject(resource, p);
\r
412 // if(resource == null) return null;
\r
414 // return resource;
\r
418 public static Resource getPossibleChild(ReadGraph g, Resource parent, String name) throws DatabaseException {
\r
419 return g.syncRequest(new UnescapedChildMapOfResource(parent)).get(name);
\r