1 package org.simantics.db.layer0.function;
3 import java.util.ArrayList;
4 import java.util.Collection;
5 import java.util.Collections;
6 import java.util.HashMap;
10 import java.util.concurrent.atomic.AtomicReference;
12 import org.simantics.databoard.Bindings;
13 import org.simantics.databoard.accessor.reference.ChildReference;
14 import org.simantics.databoard.accessor.reference.IndexReference;
15 import org.simantics.databoard.adapter.AdaptException;
16 import org.simantics.databoard.binding.Binding;
17 import org.simantics.databoard.binding.error.BindingConstructionException;
18 import org.simantics.databoard.binding.error.BindingException;
19 import org.simantics.databoard.binding.mutable.Variant;
20 import org.simantics.databoard.type.ArrayType;
21 import org.simantics.databoard.type.Datatype;
22 import org.simantics.databoard.type.NumberType;
23 import org.simantics.databoard.util.Range;
24 import org.simantics.db.Issue;
25 import org.simantics.db.ReadGraph;
26 import org.simantics.db.Resource;
27 import org.simantics.db.Statement;
28 import org.simantics.db.WriteGraph;
29 import org.simantics.db.common.issue.StandardIssue;
30 import org.simantics.db.common.primitiverequest.PossibleRelatedValueImplied2;
31 import org.simantics.db.common.primitiverequest.PossibleResource;
32 import org.simantics.db.common.procedure.adapter.TransientCacheAsyncListener;
33 import org.simantics.db.common.procedure.adapter.TransientCacheListener;
34 import org.simantics.db.common.request.IsEnumeratedValue;
35 import org.simantics.db.common.uri.UnescapedChildMapOfResource;
36 import org.simantics.db.common.utils.CommonDBUtils;
37 import org.simantics.db.common.utils.Functions;
38 import org.simantics.db.common.utils.ListUtils;
39 import org.simantics.db.common.utils.Logger;
40 import org.simantics.db.common.utils.NameUtils;
41 import org.simantics.db.common.validation.L0Validations;
42 import org.simantics.db.exception.DatabaseException;
43 import org.simantics.db.exception.DoesNotContainValueException;
44 import org.simantics.db.exception.NoSingleResultException;
45 import org.simantics.db.exception.RuntimeDatabaseException;
46 import org.simantics.db.layer0.exception.MissingVariableValueException;
47 import org.simantics.db.layer0.exception.PendingVariableException;
48 import org.simantics.db.layer0.exception.VariableException;
49 import org.simantics.db.layer0.request.PossibleURI;
50 import org.simantics.db.layer0.request.PropertyInfo;
51 import org.simantics.db.layer0.request.PropertyInfoRequest;
52 import org.simantics.db.layer0.request.UnescapedAssertedPropertyMapOfResource;
53 import org.simantics.db.layer0.request.UnescapedMethodMapOfResource;
54 import org.simantics.db.layer0.request.UnescapedPropertyMapOfResource;
55 import org.simantics.db.layer0.scl.CompileResourceValueRequest;
56 import org.simantics.db.layer0.scl.CompileValueRequest;
57 import org.simantics.db.layer0.util.Layer0Utils;
58 import org.simantics.db.layer0.util.PrimitiveValueParser;
59 import org.simantics.db.layer0.variable.AbstractVariable;
60 import org.simantics.db.layer0.variable.ChildVariableMapRequest;
61 import org.simantics.db.layer0.variable.ExternalSetValue;
62 import org.simantics.db.layer0.variable.PropertyVariableMapRequest;
63 import org.simantics.db.layer0.variable.StandardAssertedGraphPropertyVariable;
64 import org.simantics.db.layer0.variable.StandardComposedProperty;
65 import org.simantics.db.layer0.variable.StandardGraphChildVariable;
66 import org.simantics.db.layer0.variable.StandardGraphPropertyVariable;
67 import org.simantics.db.layer0.variable.SubliteralPropertyVariable;
68 import org.simantics.db.layer0.variable.SubliteralPropertyVariableDeprecated;
69 import org.simantics.db.layer0.variable.ValueAccessor;
70 import org.simantics.db.layer0.variable.Variable;
71 import org.simantics.db.layer0.variable.VariableBuilder;
72 import org.simantics.db.layer0.variable.VariableMap;
73 import org.simantics.db.layer0.variable.VariableMapImpl;
74 import org.simantics.db.layer0.variable.VariableNode;
75 import org.simantics.db.layer0.variable.VariableNodeReadRunnable;
76 import org.simantics.db.layer0.variable.VariableUtils;
77 import org.simantics.db.layer0.variable.Variables;
78 import org.simantics.db.layer0.variable.Variables.NodeStructure;
79 import org.simantics.db.service.ClusteringSupport;
80 import org.simantics.db.service.UndoRedoSupport;
81 import org.simantics.issues.ontology.IssueResource;
82 import org.simantics.layer0.Layer0;
83 import org.simantics.scl.reflection.annotations.SCLValue;
84 import org.simantics.scl.runtime.SCLContext;
85 import org.simantics.scl.runtime.function.Function4;
86 import org.simantics.scl.runtime.function.FunctionImpl1;
87 import org.simantics.scl.runtime.function.FunctionImpl2;
88 import org.simantics.simulator.variable.exceptions.NodeManagerException;
89 import org.simantics.utils.Development;
90 import org.simantics.utils.datastructures.Pair;
91 import org.simantics.utils.strings.StringInputValidator;
93 import gnu.trove.map.hash.THashMap;
94 import gnu.trove.set.hash.THashSet;
98 public static Object standardGetValue1(ReadGraph graph, Variable context) throws DatabaseException {
100 StandardGraphPropertyVariable variable = (StandardGraphPropertyVariable)context;
103 if(variable.node != null) {
104 Variant value = Variables.requestNodeValue(graph, variable.node);
105 if(Variables.PENDING_NODE_VALUE == value) throw new PendingVariableException("");
106 return value.getValue();
111 if(variable.property.hasEnumerationRange) {
112 Resource object = variable.getRepresents(graph);
113 if(graph.sync(new IsEnumeratedValue(object))) {
114 Layer0 L0 = Layer0.getInstance(graph);
115 if(graph.isInstanceOf(object, L0.Literal)) {
116 return graph.getValue(object);
118 String label = graph.getPossibleRelatedValue2(variable.getRepresents(graph), L0.HasLabel, Bindings.STRING);
119 if(label == null) label = graph.getPossibleRelatedValue(variable.getRepresents(graph), L0.HasName, Bindings.STRING);
120 if(label == null) label = "<no label>";
126 if (variable.isAsserted()) {
127 if (variable.parentResource != null) {
128 Map<String, Pair<PropertyInfo, Resource>> assertions = graph.syncRequest(
129 new UnescapedAssertedPropertyMapOfResource(variable.parentResource),
130 TransientCacheAsyncListener.instance());
132 // NOTE: This optimization assumes the property
133 // variable's representation is the asserted object.
134 Resource object = variable.getPossibleRepresents(graph);
135 if (object != null) {
136 return graph.getValue2(object, variable);
138 for (Pair<PropertyInfo, Resource> assertion : assertions.values()) {
139 if (assertion.first.predicate.equals(variable.property.predicate)) {
140 return graph.getValue2(assertion.second, variable);
147 return graph.getValue2(variable.getRepresents(graph), variable);
149 } catch (NoSingleResultException e) {
150 throw new MissingVariableValueException(variable.getPossibleURI(graph), e);
151 } catch (DoesNotContainValueException e) {
152 throw new MissingVariableValueException(variable.getPossibleURI(graph), e);
153 } catch (DatabaseException e) {
154 throw new MissingVariableValueException(variable.getPossibleURI(graph), e);
159 public static Object standardGetValue2(ReadGraph graph, Variable context, Binding binding) throws DatabaseException {
160 StandardGraphPropertyVariable variable = (StandardGraphPropertyVariable)context;
163 if(variable.node != null) {
165 Variant value = Variables.requestNodeValue(graph, variable.node, binding);
166 if(Variables.PENDING_NODE_VALUE == value) throw new PendingVariableException("");
167 if(value == null) throw new MissingVariableValueException(variable.getPossibleURI(graph));
168 return value.getValue(binding);
169 } catch (AdaptException e) {
170 throw new DatabaseException(e);
176 if(variable.property.hasEnumerationRange) {
177 Resource object = variable.getRepresents(graph);
178 if(graph.sync(new IsEnumeratedValue(object))) {
179 Layer0 L0 = Layer0.getInstance(graph);
180 if(graph.isInstanceOf(object, L0.Literal)) {
181 return graph.getValue(object, binding);
183 return graph.getRelatedValue2(variable.getRepresents(graph), L0.HasLabel, binding);
188 if (variable.isAsserted()) {
189 if (variable.parentResource != null) {
190 Map<String, Pair<PropertyInfo, Resource>> assertions = graph.syncRequest(
191 new UnescapedAssertedPropertyMapOfResource(variable.parentResource),
192 TransientCacheAsyncListener.instance());
194 // NOTE: This optimization assumes the property
195 // variable's representation is the asserted object.
196 Resource object = variable.getPossibleRepresents(graph);
197 if (object != null) {
198 return graph.getValue2(object, variable, binding);
200 for (Pair<PropertyInfo, Resource> assertion : assertions.values()) {
201 if (assertion.first.predicate.equals(variable.property.predicate)) {
202 return graph.getValue2(assertion.second, variable, binding);
209 return graph.getValue2(variable.getRepresents(graph), context, binding);
211 } catch (NoSingleResultException e) {
212 throw new MissingVariableValueException(variable.getPossibleURI(graph));
213 } catch (DoesNotContainValueException e) {
214 throw new MissingVariableValueException(variable.getPossibleURI(graph));
215 } catch (DatabaseException e) {
216 throw new MissingVariableValueException(variable.getPossibleURI(graph), e);
221 public static void standardSetValue2(WriteGraph graph, Variable context, final Object value) throws DatabaseException {
223 if(context instanceof StandardGraphPropertyVariable) {
225 final StandardGraphPropertyVariable variable = (StandardGraphPropertyVariable)context;
228 if(variable.node != null) {
230 final Binding binding = Layer0Utils.getDefaultBinding(graph, variable);
232 final AtomicReference<Object> oldValueRef = new AtomicReference<Object>();
234 variable.node.support.manager.getRealm().syncExec(new Runnable() {
238 oldValueRef.set(getNodeValue(variable, binding));
239 setNodeValue(variable, value, binding);
240 } catch (NodeManagerException e) {
241 throw new RuntimeException(e);
242 } catch (BindingException e) {
243 throw new RuntimeException(e);
247 } catch(RuntimeException e) {
248 if(e.getCause() instanceof NodeManagerException || e.getCause() instanceof BindingException)
249 throw new DatabaseException(e.getCause());
252 } catch (InterruptedException e) {
253 throw new DatabaseException(e);
256 ExternalSetValue ext = new ExternalSetValue(variable.node.support.manager, variable.node.node,
257 oldValueRef.get(), value, binding);
258 graph.getService(UndoRedoSupport.class).addExternalOperation(graph, ext);
265 Function4<WriteGraph, Variable, Object, Object, String> modifier = context.getPossiblePropertyValue(graph, Variables.INPUT_MODIFIER);
266 if(modifier == null) modifier = VariableUtils.defaultInputModifier;
268 modifier.apply(graph, context, value, Bindings.getBinding(value.getClass()));
269 } catch (BindingConstructionException e) {
270 throw new DatabaseException(e);
275 public static void standardSetValue3(final WriteGraph graph, Variable context, final Object value, final Binding binding) throws DatabaseException {
278 if(context instanceof StandardGraphPropertyVariable) {
280 final StandardGraphPropertyVariable variable = (StandardGraphPropertyVariable)context;
283 if(variable.node != null) {
287 variable.node.support.manager.getRealm().syncExec(new Runnable() {
292 Object oldValue = getNodeValue(variable, binding);
293 setNodeValue(variable, value, binding);
294 ExternalSetValue ext = new ExternalSetValue(variable.node.support.manager, variable.node.node, oldValue, value, binding);
295 graph.getService(UndoRedoSupport.class).addExternalOperation(graph, ext);
296 } catch (NodeManagerException | BindingException e) {
297 Logger.defaultLogError(e);
306 } catch (InterruptedException e) {
307 throw new DatabaseException(e);
314 Function4<WriteGraph, Variable, Object, Object, String> modifier = context.getPossiblePropertyValue(graph, Variables.INPUT_MODIFIER);
315 if(modifier == null) modifier = VariableUtils.defaultInputModifier;
316 modifier.apply(graph, context, value, binding);
320 public static Datatype getDatatypeFromValue(ReadGraph graph, Variable context) throws DatabaseException {
321 if (context instanceof AbstractVariable) {
322 Binding defaultBinding = ((AbstractVariable)context).getPossibleDefaultBinding(graph);
323 if (defaultBinding != null)
324 return defaultBinding.type();
327 Variant value = context.getVariantValue(graph);
328 if (value.getBinding() == null)
329 throw new DatabaseException("No value binding for " + context.getURI(graph));
331 return value.getBinding().type();
334 @SuppressWarnings("rawtypes")
335 private static class DatatypeGetter implements VariableNodeReadRunnable {
336 final VariableNode node;
340 public DatatypeGetter(VariableNode node) {
344 @SuppressWarnings("unchecked")
348 type = node.support.manager.getDatatype(node.node);
349 } catch (NodeManagerException e) {
354 public String toString() {
355 return "DatatypeGetter(" + node.node + ")";
359 public static Datatype standardGetDatatype(ReadGraph graph, Variable context) throws DatabaseException {
360 if (context instanceof AbstractVariable) {
361 final AbstractVariable variable = (AbstractVariable)context;
362 if (variable.node != null) {
364 DatatypeGetter request = new DatatypeGetter(variable.node);
366 variable.node.support.manager.getRealm().syncExec(request);
368 if (request.exception != null)
369 throw new DatabaseException(request.exception);
372 } catch (InterruptedException e) {
377 return getDatatypeFromValue(graph, context);
380 // @SCLValue(type = "ValueAccessor")
381 // public static ValueAccessor standardValueAccessor = new ValueAccessor() {
384 // public Object getValue(ReadGraph graph, Variable context) throws DatabaseException {
385 // return standardGetValue(graph, (StandardGraphPropertyVariable)context);
389 // public Object getValue(ReadGraph graph, Variable context, Binding binding) throws DatabaseException {
390 // return standardGetValue(graph, context, binding);
394 // public void setValue(WriteGraph graph, Variable context, Object value) throws DatabaseException {
395 // standardSetValue(graph, context, value);
399 // public void setValue(WriteGraph graph, Variable context, Object value, Binding binding) throws DatabaseException {
400 // standardSetValue(graph, context, value, binding);
404 // public Datatype getDatatype(ReadGraph graph, Variable context) throws DatabaseException {
405 // return standardGetDatatype(graph, context);
410 @SCLValue(type = "ValueAccessor")
411 public static ValueAccessor standardValueAccessor = new ValueAccessor() {
414 public Object getValue(ReadGraph graph, Variable context) throws DatabaseException {
415 ValueAccessor accessor = getPossibleValueValueAccessor(graph, context);
416 if(accessor != null) return accessor.getValue(graph, context);
418 return standardGetValue1(graph, context);
422 public Object getValue(ReadGraph graph, Variable context, Binding binding) throws DatabaseException {
423 ValueAccessor accessor = getPossibleValueValueAccessor(graph, context);
424 if(accessor != null) return accessor.getValue(graph, context, binding);
426 return standardGetValue2(graph, context, binding);
430 public void setValue(WriteGraph graph, Variable context, Object value) throws DatabaseException {
431 ValueAccessor accessor = getPossibleValueValueAccessor(graph, context);
432 if(accessor != null) accessor.setValue(graph, context, value);
434 standardSetValue2(graph, context, value);
438 public void setValue(WriteGraph graph, Variable context, Object value, Binding binding) throws DatabaseException {
439 ValueAccessor accessor = getPossibleValueValueAccessor(graph, context);
440 if(accessor != null) accessor.setValue(graph, context, value, binding);
442 standardSetValue3(graph, context, value, binding);
446 public Datatype getDatatype(ReadGraph graph, Variable context)
447 throws DatabaseException {
448 ValueAccessor accessor = getPossibleValueValueAccessor(graph, context);
449 if(accessor != null) return accessor.getDatatype(graph, context);
451 return standardGetDatatype(graph, context);
456 public static Variable getStandardChildDomainPropertyVariable(ReadGraph graph, Variable context, String name) throws DatabaseException {
457 StandardGraphChildVariable variable = (StandardGraphChildVariable)context;
458 PropertyInfo graphProperty = getPossiblePropertyInfoFromContext(graph, variable, variable.resource, name);
459 return getStandardChildDomainPropertyVariable(graph, context, graphProperty, name);
462 public static Resource getPossiblePropertyResource(ReadGraph graph, AbstractVariable parent, Object node) throws DatabaseException {
463 if(parent != null && parent.node != null && parent.node.node != null && parent.node.support != null) {
464 String propertyURI = getPossiblePropertyURI(parent, node);
465 if(propertyURI != null)
466 return graph.getPossibleResource(propertyURI);
471 public static Variable getStandardChildDomainPropertyVariable(ReadGraph graph, Variable context, PropertyInfo graphProperty, String name) throws DatabaseException {
472 StandardGraphChildVariable variable = (StandardGraphChildVariable)context;
473 Object propertyNode = getPossibleNodeProperty(graph, variable, name, true);
474 if(graphProperty != null && graphProperty.builder != null)
475 return buildPropertyVariable(graph, variable, variable.resource, graphProperty, propertyNode);
476 if(propertyNode != null) {
477 // Fallback: try to ask property resource uri from NodeManager
478 return createStandardGraphPropertyVariable(graph, variable, propertyNode);
480 // Final fallback: check types corresponding to
481 // node classification(s) and look for asserted
482 // properties from the URIs specified.
483 if (variable.node != null) {
485 @SuppressWarnings("unchecked")
486 Set<String> classifications = variable.node.support.manager.getClassifications(variable.node.node);
487 if (!classifications.isEmpty()) {
488 for (String uri : classifications) {
489 Resource type = graph.syncRequest(
490 new PossibleResource(uri),
491 TransientCacheAsyncListener.instance());
494 Map<String, Pair<PropertyInfo, Resource>> pm = graph.syncRequest(
495 new UnescapedAssertedPropertyMapOfResource(type),
496 TransientCacheAsyncListener.instance());
497 Pair<PropertyInfo, Resource> pi = pm.get(name);
499 return new StandardAssertedGraphPropertyVariable(graph, context, null, type, pi.first.predicate, pi.second);
503 } catch(NodeManagerException e) {
504 throw new DatabaseException(e);
510 public static Map<String, Variable> getStandardChildDomainPropertyVariables(ReadGraph graph, Variable context, Map<String, Variable> map) throws DatabaseException {
511 // Get properties with null identification
512 return getStandardChildDomainPropertyVariables(graph, context, null, map);
515 public static Map<String, Variable> getStandardChildDomainPropertyVariables(ReadGraph graph, Variable context, String classification, Map<String, Variable> map) throws DatabaseException {
517 StandardGraphChildVariable variable = (StandardGraphChildVariable)context;
519 Collection<Object> nodeProperties = getPossibleNodeProperties(graph, variable);
520 if(!nodeProperties.isEmpty()) {
522 // Get variables for properties read from the graph
523 Map<String,PropertyInfo> graphProperties = collectPropertyInfosFromContext(graph, variable, variable.resource);
525 Set<String> used = new THashSet<String>(nodeProperties.size());
527 map = ensureVariableMap(map, graphProperties.size() + nodeProperties.size());
529 // Process NodeManager property nodes
530 for(Object nodeProperty : nodeProperties) {
531 String name = getNodeName(variable, nodeProperty);
534 PropertyInfo graphProperty = graphProperties.get(name);
535 if(graphProperty != null && graphProperty.builder != null) {
536 if (classification != null && !graphProperty.hasClassification(classification)) continue;
538 // Combine with identically named graph property
539 map.put(name, buildPropertyVariable(graph, variable, variable.resource, graphProperty, nodeProperty));
543 map.put(name, createStandardGraphPropertyVariable(graph, variable, nodeProperty));
546 // Process graph properties
547 for(PropertyInfo info : graphProperties.values()) {
548 String name = info.name;
549 if(used != null && used.contains(name)) continue;
550 if (classification != null && !info.hasClassification(classification)) continue;
551 if (info.builder != null) {
552 map.put(name, buildPropertyVariable(graph, variable, variable.resource, info, null));
559 if(variable.resource == null) return map;
561 // Only graph properties
562 Collection<Resource> predicates = graph.getPredicates(variable.resource);
563 if(predicates.isEmpty()) return map;
565 map = ensureVariableMap(map, predicates.size());
567 // Process graph properties
568 for(Resource predicate : predicates) {
570 PropertyInfo info = graph.isImmutable(predicate) ?
571 graph.syncRequest(new PropertyInfoRequest(predicate), TransientCacheAsyncListener.<PropertyInfo>instance()) :
572 graph.syncRequest(new PropertyInfoRequest(predicate));
574 if(!info.isHasProperty) continue;
576 if (classification != null && !info.hasClassification(classification)) continue;
577 if (info.builder != null) {
578 map.put(info.name, buildPropertyVariable(graph, variable, variable.resource, info, null));
589 @SCLValue(type = "VariableMap")
590 public static VariableMap standardChildDomainProperties = new VariableMapImpl() {
593 public Variable getVariable(ReadGraph graph, Variable context, String name) throws DatabaseException {
594 return getStandardChildDomainPropertyVariable(graph, context, name);
598 public Map<String, Variable> getVariables(ReadGraph graph, Variable context, Map<String, Variable> map) throws DatabaseException {
599 return getStandardChildDomainPropertyVariables(graph, context, map);
604 @SCLValue(type = "VariableMap")
605 public static VariableMap methodsPropertyDomainProperties = new VariableMapImpl() {
608 public Variable getVariable(ReadGraph graph, Variable context, String name) throws DatabaseException {
609 Variable parent = context.getParent(graph);
610 Resource container = parent.getPossibleRepresents(graph);
611 Map<String,Resource> methods = graph.syncRequest(new UnescapedMethodMapOfResource(container));
612 Resource predicate = methods.get(name);
613 if(predicate != null) {
614 Layer0 L0 = Layer0.getInstance(graph);
615 PropertyInfo info = graph.syncRequest(new PropertyInfoRequest(L0.Entity_method));
616 Resource value = graph.getSingleObject(container, predicate);
617 return new StandardGraphPropertyVariable(context, null, container, info, value);
623 public Map<String, Variable> getVariables(ReadGraph graph, Variable context, Map<String, Variable> map) throws DatabaseException {
624 Variable parent = context.getParent(graph);
625 Resource container = parent.getPossibleRepresents(graph);
626 Map<String,Resource> methods = graph.syncRequest(new UnescapedMethodMapOfResource(container));
627 for(Map.Entry<String, Resource> entry : methods.entrySet()) {
628 String name = entry.getKey();
629 Resource predicate = entry.getValue();
630 Layer0 L0 = Layer0.getInstance(graph);
631 PropertyInfo info = graph.syncRequest(new PropertyInfoRequest(L0.Entity_method));
632 Resource value = graph.getSingleObject(container, predicate);
633 if(map == null) map = new HashMap<>();
634 map.put(name, new StandardGraphPropertyVariable(context, null, container, info, value));
641 public static Variable getStandardPropertyDomainPropertyVariableFromValue(ReadGraph graph, Variable context, String name) throws DatabaseException {
643 if(context instanceof StandardGraphPropertyVariable) {
644 StandardGraphPropertyVariable variable = (StandardGraphPropertyVariable)context;
645 Resource literal = variable.getPossibleRepresents(graph);
646 Object propertyNode = getPossibleNodeProperty(graph, variable, name, false);
648 if(literal != null) {
649 Variable result = getPossiblePropertyFromContext(graph, variable, literal, name, propertyNode);
650 if(result != null) return result;
653 Variable result = getPossibleSubliteralPropertyFromContext(graph, variable, name);
654 if(result != null) return result;
655 result = getPossiblePropertyFromContext(graph, variable, variable.property.predicate, name, propertyNode);
656 if (result != null) return result;
658 // Get possible property from NodeManager
659 if (propertyNode != null)
660 return createStandardGraphPropertyVariable(graph, variable, propertyNode);
662 } else if (context instanceof StandardGraphChildVariable) {
663 return standardChildDomainProperties.getVariable(graph, context, name);
665 throw new DatabaseException("Unknown variable implementation " + context.getClass().getCanonicalName());
670 public static Map<String, Variable> getStandardPropertyDomainPropertyVariablesFromValue(ReadGraph graph, Variable context, Map<String, Variable> map) throws DatabaseException {
672 if(context instanceof StandardGraphPropertyVariable) {
673 StandardGraphPropertyVariable variable = (StandardGraphPropertyVariable)context;
674 map = collectPropertiesFromContext(graph, variable, variable.property.predicate, map);
675 if (variable.parentResource != null) {
676 Resource literal = graph.getPossibleObject(variable.parentResource, variable.property.predicate);
677 if(literal != null) map=collectPropertiesFromContext(graph, variable, literal, map);
678 map=collectSubliteralProperties(graph, variable, map);
681 // Get properties from VariableNode
682 map = getStandardNodePropertyVariables(graph, context, map);
684 } else if (context instanceof StandardGraphChildVariable) {
685 return standardChildDomainProperties.getVariables(graph, context, map);
687 throw new DatabaseException("Unknown variable implementation " + context.getClass().getCanonicalName());
692 public static Map<String, Variable> getStandardPropertyDomainPropertyVariablesFromValue(ReadGraph graph, Variable context, String classification, Map<String, Variable> map) throws DatabaseException {
694 if(context instanceof StandardGraphPropertyVariable) {
695 StandardGraphPropertyVariable variable = (StandardGraphPropertyVariable)context;
696 map = collectPropertiesFromContext(graph, variable, variable.property.predicate, classification, map);
697 if (variable.parentResource != null) {
698 Resource literal = graph.getPossibleObject(variable.parentResource, variable.property.predicate);
699 if(literal != null) map=collectPropertiesFromContext(graph, variable, literal, classification, map);
702 // Get properties from VariableNode
703 map = getStandardNodePropertyVariables(graph, context, map);
705 } else if (context instanceof StandardGraphChildVariable) {
706 return standardChildDomainProperties.getVariables(graph, context, map);
708 throw new DatabaseException("Unknown variable implementation " + context.getClass().getCanonicalName());
713 @SCLValue(type = "VariableMap")
714 public static VariableMap standardPropertyDomainProperties = new VariableMapImpl() {
716 VariableMap getValueVariableMap(ReadGraph graph, Variable context) throws DatabaseException {
717 Resource represents = context.getPossibleRepresents(graph);
718 if(represents == null) return null;
720 VariableMap map = graph.isImmutable(represents) ?
721 graph.syncRequest(new PropertyVariableMapRequest(represents), TransientCacheListener.<VariableMap>instance()) :
722 (VariableMap)graph.getPossibleRelatedValue2(represents, Layer0.getInstance(graph).domainProperties, represents);
724 if(map == standardPropertyDomainProperties) return null;
730 public Variable getVariable(ReadGraph graph, Variable context, String name) throws DatabaseException {
731 VariableMap valueMap = getValueVariableMap(graph, context);
732 if(valueMap != null) return valueMap.getVariable(graph, context, name);
733 return getStandardPropertyDomainPropertyVariableFromValue(graph, context, name);
737 public Map<String, Variable> getVariables(ReadGraph graph, Variable context, Map<String, Variable> map) throws DatabaseException {
738 VariableMap valueMap = getValueVariableMap(graph, context);
739 if(valueMap != null) return valueMap.getVariables(graph, context, map);
740 else return getStandardPropertyDomainPropertyVariablesFromValue(graph, context, map);
744 public Map<String, Variable> getVariables(ReadGraph graph, Variable context, String classification, Map<String, Variable> map) throws DatabaseException {
745 VariableMap valueMap = getValueVariableMap(graph, context);
746 if(valueMap != null) return valueMap.getVariables(graph, context, classification, map);
747 else return getStandardPropertyDomainPropertyVariablesFromValue(graph, context, classification, map);
752 public static Resource getPossibleGraphChild(ReadGraph graph, Variable variable, String name) throws DatabaseException {
753 Resource resource = variable.getPossibleRepresents(graph);
754 if(resource == null) return null;
755 Map<String, Resource> graphChildren = graph.syncRequest(new UnescapedChildMapOfResource(resource));
756 return graphChildren.get(name);
759 public static Map<String,Resource> getPossibleGraphChildren(ReadGraph graph, Variable variable) throws DatabaseException {
760 Resource resource = variable.getPossibleRepresents(graph);
761 if(resource == null) return Collections.emptyMap();
762 return graph.syncRequest(new UnescapedChildMapOfResource(resource));
765 public static Object getPossibleNodeChild(ReadGraph graph, Variable variable, String name) throws DatabaseException {
766 if (!(variable instanceof AbstractVariable)) return null;
767 VariableNode<?> node = ((AbstractVariable)variable).node;
768 if(node == null) return null;
769 NodeStructure structure = Variables.requestNodeStructure(graph, node);
770 if(Variables.PENDING_NODE_STRUCTURE == structure) throw new PendingVariableException("");
771 return structure.children.get(name);
774 public static Collection<Object> getPossibleNodeChildren(ReadGraph graph, Variable variable) throws DatabaseException {
775 if (!(variable instanceof AbstractVariable)) return null;
776 VariableNode<?> node = ((AbstractVariable)variable).node;
777 if(node == null) return Collections.emptyList();
778 NodeStructure structure = Variables.requestNodeStructure(graph, node);
779 if(Variables.PENDING_NODE_STRUCTURE == structure) throw new PendingVariableException("");
780 return structure.children.values();
783 public static Object getPossibleNodeProperty(ReadGraph graph, Variable variable, String name, boolean throwPending) throws DatabaseException {
784 if (!(variable instanceof AbstractVariable)) return null;
785 VariableNode<?> node = ((AbstractVariable)variable).node;
786 if(node == null) return null;
787 NodeStructure structure = Variables.requestNodeStructure(graph, node);
788 if(throwPending && Variables.PENDING_NODE_STRUCTURE == structure) throw new PendingVariableException("");
789 return structure.properties.get(name);
792 public static Collection<Object> getPossibleNodeProperties(ReadGraph graph, Variable variable) throws DatabaseException {
793 if (!(variable instanceof AbstractVariable)) return null;
794 VariableNode<?> node = ((AbstractVariable)variable).node;
795 if(node == null) return Collections.emptyList();
796 NodeStructure structure = Variables.requestNodeStructure(graph, node);
797 if(Variables.PENDING_NODE_STRUCTURE == structure) throw new PendingVariableException("");
798 return structure.properties.values();
801 @SuppressWarnings({ "rawtypes", "unchecked" })
802 public static VariableNode build(VariableNode parent, Object node) {
803 if(node == null) return null;
804 return new VariableNode(parent.support, node);
808 public static Variable getStandardChildDomainChildVariable(ReadGraph graph, Variable context, String name) throws DatabaseException {
809 return StandardChildDomainChildren.getStandardChildDomainChildVariable(graph, context, name);
813 public static Variable getStandardChildDomainChildVariable(ReadGraph graph, Variable context, Resource graphChild, String name) throws DatabaseException {
814 return StandardChildDomainChildren.getStandardChildDomainChildVariable(graph, context, graphChild, name);
818 public static Map<String, Variable> getStandardChildDomainChildVariables(ReadGraph graph, Variable context, Map<String, Variable> map) throws DatabaseException {
819 return StandardChildDomainChildren.getStandardChildDomainChildVariables(graph, context, map);
823 public static Map<String, Variable> getStandardChildDomainChildVariables(ReadGraph graph, Variable context, Map<String,Resource> graphChildren, Map<String, Variable> map) throws DatabaseException {
824 return StandardChildDomainChildren.getStandardChildDomainChildVariables(graph, context, graphChildren, map);
828 * Get a map of child Variables from a node manager-based Variable, combined with the existing variables in #map.
829 * @param graph The read graph.
830 * @param context The parent Variable.
831 * @param map A map of variables into which the new variables are merged.
832 * @return A map from variable names to instances
833 * @throws DatabaseException
835 public static Map<String, Variable> getStandardNodeChildVariables(ReadGraph graph, Variable context, Map<String, Variable> map) throws DatabaseException {
836 AbstractVariable variable = (AbstractVariable)context;
837 if (variable.node == null) return map;
839 Collection<Object> nodeChildren = getPossibleNodeChildren(graph, variable);
840 if (nodeChildren.isEmpty()) return map;
842 map = ensureVariableMap(map, nodeChildren.size());
844 for(Object nodeChild : nodeChildren) {
845 String name = getNodeName(variable, nodeChild);
846 if (!map.containsKey(name))
847 map.put(name, createStandardGraphChildVariable(variable, nodeChild));
854 * Get a map of property Variables from a node manager-based Variable, combined with the existing variables in #map.
855 * @param graph The read graph.
856 * @param context The parent Variable.
857 * @param map A map of variables into which the new variables are merged.
858 * @return A map from variable names to instances
859 * @throws DatabaseException
861 public static Map<String, Variable> getStandardNodePropertyVariables(ReadGraph graph, Variable context, Map<String, Variable> map) throws DatabaseException {
862 AbstractVariable variable = (AbstractVariable)context;
863 if (variable.node == null) return map;
865 Collection<Object> nodeProperties = getPossibleNodeProperties(graph, variable);
866 if (nodeProperties.isEmpty()) return map;
868 map = ensureVariableMap(map, nodeProperties.size());
870 for(Object nodeProperty : nodeProperties) {
871 String name = getNodeName(variable, nodeProperty);
872 if (!map.containsKey(name)) {
873 map.put(name, createStandardGraphPropertyVariable(graph, variable, nodeProperty));
880 @SCLValue(type = "VariableMap")
881 public static VariableMap standardChildDomainChildren = new VariableMapImpl() {
884 public Variable getVariable(ReadGraph graph, Variable context, String name) throws DatabaseException {
885 return StandardChildDomainChildren.getStandardChildDomainChildVariable(graph, context, name);
889 public Map<String, Variable> getVariables(ReadGraph graph, Variable context, Map<String, Variable> map) throws DatabaseException {
890 return StandardChildDomainChildren.getStandardChildDomainChildVariables(graph, context, map);
895 @SCLValue(type = "VariableMap")
896 public static VariableMap standardPropertyDomainChildren = new VariableMapImpl() {
899 * Get a possible non-standard VariableMap defined in the graph.
900 * @param graph The graph
901 * @param context The context node
902 * @return A non-standard VariableMap instance for the context node,
903 * or null, if not defined or defined as this instance.
904 * @throws DatabaseException
906 VariableMap getValueVariableMap(ReadGraph graph, Variable context) throws DatabaseException {
907 Resource represents = context.getPossibleRepresents(graph);
908 if(represents == null) return null;
909 VariableMap map = graph.syncRequest(new ChildVariableMapRequest(represents));
910 if(map == standardPropertyDomainChildren) return null;
915 public Variable getVariable(ReadGraph graph, Variable context, String name) throws DatabaseException {
916 // Delegate call to a non-standard variable map?
917 VariableMap valueMap = getValueVariableMap(graph, context);
918 if(valueMap != null) return valueMap.getVariable(graph, context, name);
920 if(context instanceof StandardGraphPropertyVariable) {
921 StandardGraphPropertyVariable variable = (StandardGraphPropertyVariable)context;
922 Datatype dt = variable.getDatatype(graph);
923 if (dt instanceof ArrayType) {
924 ChildReference ref = getPossibleIndexReference(name);
926 return new SubliteralPropertyVariableDeprecated(variable, ref);
929 // Check for a child node provided by the NodeManager
930 if (variable.node != null) {
931 Object childNode = getPossibleNodeChild(graph, variable, name);
932 if (childNode != null)
933 return createStandardGraphChildVariable(variable, childNode);
935 return standardChildDomainChildren.getVariable(graph, context, name);
936 } else if (context instanceof StandardGraphChildVariable) {
937 return standardChildDomainChildren.getVariable(graph, context, name);
939 throw new DatabaseException("Unknown variable implementation " + context.getClass().getCanonicalName());
944 public Map<String, Variable> getVariables(ReadGraph graph, Variable context, Map<String, Variable> map) throws DatabaseException {
945 // Delegate call to a non-standard variable map?
946 VariableMap valueMap = getValueVariableMap(graph, context);
947 if(valueMap != null) return valueMap.getVariables(graph, context, map);
949 if(context instanceof StandardGraphPropertyVariable) {
950 // Get child variables provided by the NodeManager
951 Map<String, Variable> result = getStandardNodeChildVariables(graph, context, map);
952 return standardChildDomainChildren.getVariables(graph, context, result);
953 } else if (context instanceof StandardGraphChildVariable) {
954 return standardChildDomainChildren.getVariables(graph, context, map);
956 throw new DatabaseException("Unknown variable implementation " + context.getClass().getCanonicalName());
962 protected static ChildReference getPossibleIndexReference(String name) {
963 if (name.startsWith("i-")) {
965 int index = Integer.parseInt(name.substring(2));
966 return new IndexReference(index);
967 } catch (NumberFormatException e) {}
972 protected static ValueAccessor getPossiblePropertyValueAccessor(ReadGraph graph, StandardGraphPropertyVariable variable) throws DatabaseException {
973 if(variable.property == null) return null;
974 return variable.property.valueAccessor;
975 // return graph.syncRequest(new PropertyValueAccessorRequest(variable.property), TransientCacheAsyncListener.<ValueAccessor>instance());
976 // return graph.syncRequest(new PossibleRelatedValueImplied2<ValueAccessor>(variable.property, Layer0.getInstance(graph).valueAccessor));
979 public static ValueAccessor getPossibleValueValueAccessor(ReadGraph graph, Variable variable) throws DatabaseException {
980 Resource value = variable.getPossibleRepresents(graph);
981 if(value == null) return null;
982 //return graph.syncRequest(new PropertyValueAccessorRequest(value));
983 return graph.syncRequest(new PossibleRelatedValueImplied2<ValueAccessor>(value, Layer0.getInstance(graph).valueAccessor));
986 public static PropertyInfo getPossiblePropertyInfoFromContext(ReadGraph graph, Variable variable, Resource context, String name) throws DatabaseException {
987 if(context == null) return null;
988 Map<String, PropertyInfo> predicates = graph.syncRequest(new UnescapedPropertyMapOfResource(context));
989 return predicates.get(name);
992 public static Variable getPossiblePropertyFromContext(ReadGraph graph, Variable variable, Resource context, String name, Object propertyNode) throws DatabaseException {
993 PropertyInfo info = getPossiblePropertyInfoFromContext(graph, variable, context, name);
994 if(info == null || info.builder == null) return null;
995 return buildPropertyVariable(graph, variable, context, info, propertyNode);
998 public static Variable getPossibleSubliteralPropertyFromContext(ReadGraph graph, StandardGraphPropertyVariable variable, String name) throws DatabaseException {
1000 Resource predicate = variable.property.predicate;
1001 if(predicate == null) return null;
1003 PropertyInfo info = getPropertyInfo(graph, predicate);
1004 Pair<Resource, ChildReference> p = info.subliteralPredicates.get(name);
1005 if(p == null) return null;
1007 return new SubliteralPropertyVariable(graph, variable, p.first, p.second);
1011 public static Map<String, PropertyInfo> collectPropertyInfosFromContext(ReadGraph graph, Variable variable, Resource context) throws DatabaseException {
1012 if(context == null) return Collections.emptyMap();
1013 return graph.isImmutable(context) ?
1014 graph.syncRequest(new UnescapedPropertyMapOfResource(context), TransientCacheAsyncListener.<Map<String,PropertyInfo>>instance()) :
1015 graph.syncRequest(new UnescapedPropertyMapOfResource(context));
1018 public static Map<String, Variable> collectPropertiesFromContext(ReadGraph graph, Variable variable, Resource context, Map<String, Variable> map) throws DatabaseException {
1020 Map<String,PropertyInfo> properties = graph.isImmutable(context) ?
1021 graph.syncRequest(new UnescapedPropertyMapOfResource(context), TransientCacheAsyncListener.<Map<String,PropertyInfo>>instance()) :
1022 graph.syncRequest(new UnescapedPropertyMapOfResource(context));
1024 if(properties.isEmpty()) return map;
1026 map = ensureVariableMap(map, properties.size());
1028 for(PropertyInfo info : properties.values()) {
1029 String name = info.name;
1030 if (info.builder != null) {
1031 Variable v = info.builder.buildProperty(graph, variable, null, context, info.predicate);
1040 public static Map<String, Variable> collectSubliteralProperties(ReadGraph graph, StandardGraphPropertyVariable variable, Map<String, Variable> map) throws DatabaseException {
1042 Resource predicate = variable.property.predicate;
1043 if(predicate == null) return map;
1045 PropertyInfo info = getPropertyInfo(graph, predicate);
1046 if(info.subliteralPredicates.isEmpty()) return map;
1048 map = ensureVariableMap(map, info.subliteralPredicates.size());
1050 for(Map.Entry<String, Pair<Resource, ChildReference>> entry : info.subliteralPredicates.entrySet()) {
1051 String key = entry.getKey();
1052 Pair<Resource, ChildReference> p = entry.getValue();
1053 if(map == null) map = new THashMap<String,Variable>();
1054 map.put(key, new SubliteralPropertyVariable(graph, variable, p.first, p.second));
1061 public static Map<String, Variable> collectPropertiesFromContext(ReadGraph graph, Variable variable, Resource context, String classification, Map<String, Variable> map) throws DatabaseException {
1063 if(graph.isImmutable(context)) {
1065 Map<String,PropertyInfo> properties = graph.syncRequest(new UnescapedPropertyMapOfResource(context), TransientCacheAsyncListener.<Map<String,PropertyInfo>>instance());
1066 for(PropertyInfo info : properties.values()) {
1068 if(info.classifications.contains(classification) && info.builder != null) {
1069 String name = info.name;
1070 Variable v = info.builder.buildProperty(graph, variable, null, context, info.predicate);
1071 if(map == null) map = new THashMap<String,Variable>();
1079 Collection<Resource> predicates = graph.getPredicates(context);
1081 if(predicates.isEmpty()) return map;
1083 map = ensureVariableMap(map, predicates.size());
1085 for(Resource predicate : predicates) {
1087 PropertyInfo info = graph.isImmutable(predicate) ?
1088 graph.syncRequest(new PropertyInfoRequest(predicate), TransientCacheAsyncListener.<PropertyInfo>instance()) :
1089 graph.syncRequest(new PropertyInfoRequest(predicate));
1091 if(!info.isHasProperty) continue;
1093 if(info.classifications.contains(classification) && info.builder != null) {
1094 String name = info.name;
1095 Variable v = info.builder.buildProperty(graph, variable, null, context, info.predicate);
1096 if(map == null) map = new THashMap<String,Variable>();
1108 @SCLValue(type = "ReadGraph -> Resource -> a -> String")
1109 public static String entityLabel(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
1110 if(context instanceof Resource) {
1111 return NameUtils.getSafeLabel(graph, ((Resource)context));
1112 } else if (context instanceof Variable) {
1113 Variable parent = ((Variable)context).getParent(graph);
1114 Resource represents = parent.getRepresents(graph);
1115 return NameUtils.getSafeLabel(graph, represents);
1117 throw new DatabaseException("Unknown context " + context);
1121 @SCLValue(type = "ReadGraph -> Resource -> a -> b")
1122 public static Object listResources(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
1123 return ListUtils.toList(graph, resource);
1126 @SCLValue(type = "ReadGraph -> Resource -> Variable -> [String]")
1127 public static List<String> standardClassifications(ReadGraph graph, Resource resource, Variable context) throws DatabaseException {
1128 ArrayList<String> result = new ArrayList<String>();
1129 Resource predicate = context.getParent(graph).getPossiblePredicateResource(graph);
1130 if(predicate != null) {
1131 for(Resource type : graph.getTypes(predicate)) {
1132 String uri = graph.getPossibleURI(type);
1133 if(uri != null) result.add(uri);
1139 @SCLValue(type = "ReadGraph -> Resource -> a -> Boolean")
1140 public static Boolean standardValidValue(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
1141 return Boolean.TRUE;
1144 @SCLValue(type = "ReadGraph -> Resource -> a -> StringInputValidator")
1145 public static StringInputValidator standardValidator(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
1146 return StringInputValidator.PASS;
1149 @SCLValue(type = "ReadGraph -> Resource -> a -> Boolean")
1150 public static Boolean standardRequiredValue(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
1151 return Boolean.FALSE;
1154 @SCLValue(type = "ReadGraph -> Resource -> Variable -> Boolean")
1155 public static Boolean standardDefaultValue(ReadGraph graph, Resource resource, Variable context) throws DatabaseException {
1156 Variable property = context.getParent(graph);
1157 if(property instanceof StandardGraphPropertyVariable) {
1158 StandardGraphPropertyVariable variable = (StandardGraphPropertyVariable)property;
1159 if (variable.parentResource != null) {
1160 Statement stm = graph.getPossibleStatement(variable.parentResource, variable.property.predicate);
1161 return stm != null && stm.isAsserted(variable.parentResource);
1164 return Boolean.FALSE;
1167 @SCLValue(type = "ReadGraph -> Resource -> a -> Boolean")
1168 public static Boolean standardReadOnlyValue(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
1169 return Boolean.FALSE;
1172 @SCLValue(type = "ReadGraph -> Resource -> a -> b")
1173 public static Object resourceAsValue(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
1177 @SCLValue(type = "ReadGraph -> Resource -> a -> b")
1178 public static Object functionApplication(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
1179 return Functions.exec(graph, resource, graph, resource, context);
1182 @SCLValue(type = "ReadGraph -> Resource -> a -> b")
1183 public static Object computeExpression(ReadGraph graph, Resource converter, Object context) throws DatabaseException {
1184 if(context instanceof Variable) {
1185 return CompileValueRequest.compileAndEvaluate(graph, (Variable)context);
1186 } if (context instanceof Resource) {
1187 return CompileResourceValueRequest.compileAndEvaluate(graph, (Resource)converter);
1189 throw new IllegalStateException("Unknown context " + context);
1193 @SCLValue(type = "ReadGraph -> Resource -> a -> b")
1194 public static Object composedPropertyValue(ReadGraph graph, Resource converter, Object context) throws DatabaseException {
1195 if(context instanceof Variable) {
1196 return new StandardComposedProperty();
1197 } if (context instanceof Resource) {
1198 return new StandardComposedProperty();
1200 throw new IllegalStateException("Unknown context " + context);
1204 @SCLValue(type = "ReadGraph -> Resource -> a -> b")
1205 public static Object numberInputValidator(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
1207 class Validator extends FunctionImpl1<String, String> {
1209 private final Datatype datatype;
1211 public Validator(Datatype datatype) {
1212 this.datatype = datatype;
1216 public String apply(String input) {
1218 if(datatype == null) return null;
1222 if(datatype instanceof NumberType) {
1224 Number number = (Number)PrimitiveValueParser.parse(input, datatype);
1225 NumberType nt = (NumberType)datatype;
1226 Range r = nt.getRange();
1228 if(!r.contains(number)) return "Value is out of valid range";
1233 } catch (NumberFormatException e) {
1234 return "Not a valid floating-point number";
1235 } catch (IllegalArgumentException e) {
1236 return "Not a valid floating-point number";
1243 if(context instanceof Variable) {
1245 Variable variable = (Variable)context;
1246 Variable property = variable.getParent(graph);
1247 Datatype datatype = property.getPossibleDatatype(graph);
1248 return new Validator(datatype);
1250 } else if (context instanceof Resource) {
1252 Layer0 L0 = Layer0.getInstance(graph);
1253 Resource literal = (Resource)context;
1254 Datatype datatype = graph.getRelatedValue(literal, L0.HasDataType, Bindings.getBindingUnchecked(Datatype.class));
1255 return new Validator(datatype);
1259 return new Validator(null);
1265 @SCLValue(type = "ReadGraph -> Resource -> a -> b")
1266 public static Object booleanInputValidator(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
1268 return new FunctionImpl1<String, String>() {
1271 public String apply(String input) {
1273 String lower = input.toLowerCase();
1274 if("true".equals(lower) || "false".equals(lower)) return null;
1276 return "Not a valid boolean: " + input;
1284 @SCLValue(type = "ReadGraph -> Resource -> Variable -> Resource")
1285 public static Resource hasStandardResource(ReadGraph graph, Resource resource, Variable context) throws DatabaseException {
1286 Variable parent = context.getParent(graph);
1287 if(parent instanceof StandardGraphChildVariable) {
1288 StandardGraphChildVariable variable = (StandardGraphChildVariable)parent;
1289 return variable.resource;
1295 @SCLValue(type = "ReadGraph -> Resource -> Variable -> a")
1296 public static Object valueWithoutBinding(ReadGraph graph, Resource converter, Variable context) throws DatabaseException {
1298 StandardGraphPropertyVariable variable = (StandardGraphPropertyVariable)context;
1300 if(graph.sync(new IsEnumeratedValue(variable.getRepresents(graph)))) {
1301 Layer0 L0 = Layer0.getInstance(graph);
1302 return graph.getRelatedValue2(variable.getRepresents(graph), L0.HasLabel);
1305 if (variable.parentResource == null)
1306 throw new VariableException("Variable is not represented by any resource (URI=" + variable.getPossibleURI(graph) + ").");
1309 return graph.getRelatedValue2(variable.parentResource, variable.property.predicate, variable);
1310 } catch (NoSingleResultException e) {
1311 throw new MissingVariableValueException(variable.getPossibleURI(graph));
1312 } catch (DoesNotContainValueException e) {
1313 throw new MissingVariableValueException(variable.getPossibleURI(graph));
1318 @SCLValue(type = "ReadGraph -> Variable -> Binding -> a")
1319 public static Object valueWithBinding(ReadGraph graph, Variable context, Binding binding) throws DatabaseException {
1321 StandardGraphPropertyVariable variable = (StandardGraphPropertyVariable)context;
1323 if(graph.sync(new IsEnumeratedValue(variable.getRepresents(graph)))) {
1324 Layer0 L0 = Layer0.getInstance(graph);
1325 return graph.getRelatedValue2(variable.getRepresents(graph), L0.HasLabel, binding);
1328 if (variable.parentResource == null)
1329 throw new VariableException("Variable is not represented by any resource (URI=" + variable.getPossibleURI(graph) + ").");
1332 return graph.getRelatedValue2(variable.parentResource, variable.property.predicate, variable);
1333 } catch (NoSingleResultException e) {
1334 throw new MissingVariableValueException(variable.getPossibleURI(graph));
1335 } catch (DoesNotContainValueException e) {
1336 throw new MissingVariableValueException(variable.getPossibleURI(graph));
1341 @SCLValue(type = "WriteGraph -> Variable -> a -> Binding -> b")
1342 public static Object valueSetterWithBinding(WriteGraph graph, Variable variable, Object value, Binding binding) throws DatabaseException {
1344 Function4<WriteGraph, Variable, Object, Object, String> modifier = variable.getPossiblePropertyValue(graph, Variables.INPUT_MODIFIER);
1345 if(modifier == null) modifier = VariableUtils.defaultInputModifier;
1346 modifier.apply(graph, variable, value, binding);
1351 static class L0Issue extends StandardIssue {
1353 private final String description;
1355 public L0Issue(String description, Resource type, Resource ... contexts) {
1356 super(type, contexts);
1357 this.description = description;
1361 public Resource write(WriteGraph graph, Resource source) throws DatabaseException {
1362 Layer0 L0 = Layer0.getInstance(graph);
1363 IssueResource IR = IssueResource.getInstance(graph);
1364 Resource issue = super.write(graph, source);
1365 graph.claim(issue, IR.Issue_HasSeverity, IR.Severity_Fatal);
1366 graph.addLiteral(issue, L0.HasDescription, L0.HasDescription_Inverse, description, Bindings.STRING);
1372 private static List<Issue> reportInconsistency(ReadGraph graph, Resource subject, String description, List<Issue> issues) throws DatabaseException {
1373 if(issues == null) issues = new ArrayList<Issue>();
1374 System.err.println("Change set validation reports the following issue: " + NameUtils.getSafeName(graph, subject, true) + ": " + description);
1375 IssueResource IR = IssueResource.getInstance(graph);
1376 issues.add(new L0Issue(description, IR.Issue, subject));
1380 @SCLValue(type = "ReadGraph -> Resource -> [Issue]")
1381 public static List<Issue> relationValidator(ReadGraph graph, Resource resource) throws DatabaseException {
1383 Layer0 L0 = Layer0.getInstance(graph);
1385 List<Issue> issues = null;
1387 for(Statement stm : graph.getStatements(resource, L0.IsWeaklyRelatedTo)) {
1388 Resource predicate = stm.getPredicate();
1389 Resource object = stm.getObject();
1390 if(!isRelation(graph, L0, predicate)) {
1391 issues = reportInconsistency(graph, resource, "The predicate of a statement must be a relation: " + NameUtils.toString(graph, stm), issues);
1393 if(graph.isInstanceOf(predicate, L0.FunctionalRelation)) {
1394 if(graph.getObjects(resource, predicate).size() > 1)
1395 issues = reportInconsistency(graph, resource,
1397 NameUtils.getSafeName(graph, predicate)
1398 + " is functional.", issues);
1401 Collection<Resource> domain = graph.getObjects(predicate, L0.HasDomain);
1402 if (!isInstanceOfAny(graph, resource, domain, true)) {
1403 StringBuilder sb = new StringBuilder()
1404 .append("The domain of ")
1405 .append(NameUtils.getSafeName(graph, predicate))
1406 .append(" relation is ");
1407 orString(graph, sb, domain).append(".");
1408 issues = reportInconsistency(graph, resource, sb.toString(), issues);
1412 Collection<Resource> range = graph.getObjects(predicate, L0.HasRange);
1413 if (!isInstanceOfAny(graph, object, range, true) && !graph.isInstanceOf(object, L0.SCLValue)) {
1414 StringBuilder sb = new StringBuilder()
1415 .append("The range of ")
1416 .append(NameUtils.getSafeName(graph, predicate))
1417 .append(" relation is ");
1418 orString(graph, sb, range).append(" but current object is ")
1419 .append(NameUtils.getSafeName(graph, object)).append(".");
1420 issues = reportInconsistency(graph, resource, sb.toString(), issues);
1425 return issues != null ? issues : Collections.<Issue>emptyList();
1429 @SCLValue(type = "ReadGraph -> Resource -> [Issue]")
1430 public static List<Issue> propertyValidator(ReadGraph graph, Resource resource) throws DatabaseException {
1432 List<Issue> issues = null;
1434 Layer0 L0 = Layer0.getInstance(graph);
1435 for(Statement stm : graph.getStatements(resource, L0.HasProperty)) {
1436 Resource subject = stm.getSubject();
1437 Resource predicate = stm.getPredicate();
1438 String error = L0Validations.checkValueType(graph, subject, predicate);
1439 if(error != null) issues = reportInconsistency(graph, subject, error, issues);
1442 return issues != null ? issues : Collections.<Issue>emptyList();
1447 @SCLValue(type = "ReadGraph -> Resource -> [Issue]")
1448 public static List<Issue> valueValidator(ReadGraph graph, Resource resource) throws DatabaseException {
1450 List<Issue> issues = null;
1452 Layer0 L0 = Layer0.getInstance(graph);
1453 if(graph.hasValue(resource)) {
1454 if(!graph.isInstanceOf(resource, L0.Literal)) {
1455 issues = reportInconsistency(graph, resource,
1456 "Resource has a value but it is not a literal.", issues);
1459 // TODO check that the value is valid for the data type
1463 if(graph.isInstanceOf(resource, L0.Literal)) {
1464 issues = reportInconsistency(graph, resource,
1465 "Resource is a literal but it does not have a value.", issues);
1469 return issues != null ? issues : Collections.<Issue>emptyList();
1474 @SCLValue(type = "ReadGraph -> Resource -> [Issue]")
1475 public static List<Issue> uriValidator(ReadGraph graph, Resource resource) throws DatabaseException {
1477 List<Issue> issues = null;
1479 Layer0 L0 = Layer0.getInstance(graph);
1480 Resource parent = graph.getPossibleObject(resource, L0.PartOf);
1481 if(parent != null) {
1482 String parentURI = graph.syncRequest(new PossibleURI(parent));
1483 if(parentURI != null) {
1484 String name = graph.getPossibleRelatedValue(resource, L0.HasName);
1486 issues = reportInconsistency(graph, resource, "Resource has a parent with URI but has no valid HasName.", issues);
1491 return issues != null ? issues : Collections.<Issue>emptyList();
1495 private static Resource getPossibleNearestClusterSet(ReadGraph graph, Resource base, Resource resource) throws DatabaseException {
1497 ClusteringSupport cs = graph.getService(ClusteringSupport.class);
1498 if(cs.isClusterSet(resource) && !base.equals(resource)) return resource;
1500 Resource nearest = CommonDBUtils.getNearestOwner(graph, Collections.singletonList(resource));
1501 if(nearest == null) return null;
1503 return getPossibleNearestClusterSet(graph, base, nearest);
1507 private static boolean quirks(ReadGraph graph, Resource resource) throws DatabaseException {
1509 if(!resource.isPersistent()) return true;
1510 if(graph.isImmutable(resource)) return true;
1511 if(resource.getResourceId() < 0x2000) return true;
1517 @SCLValue(type = "ReadGraph -> Resource -> [Issue]")
1518 public static List<Issue> clusterValidator(ReadGraph graph, Resource resource) throws DatabaseException {
1520 if(!Development.DEVELOPMENT) return Collections.<Issue>emptyList();
1522 if(quirks(graph, resource)) return Collections.<Issue>emptyList();
1524 List<Issue> issues = null;
1526 ClusteringSupport cs = graph.getService(ClusteringSupport.class);
1527 Resource set = cs.getClusterSetOfCluster(resource);
1529 if(set == null) return reportInconsistency(graph, resource, "Resource cluster is not part of any cluster set", issues);
1531 Resource nearestSet = getPossibleNearestClusterSet(graph, resource, resource);
1532 if(nearestSet == null) {
1533 // This means that there is no owner since RootLibrary is a cluster set
1534 return Collections.<Issue>emptyList();
1537 if(!set.equals(nearestSet)) return reportInconsistency(graph, resource, "The cluster set of a resource is not the nearest owner set", issues);
1539 return Collections.<Issue>emptyList();
1543 private static boolean isInstanceOfAny(ReadGraph graph, Resource r, Collection<Resource> types, boolean ifEmpty) throws DatabaseException {
1544 if (types.isEmpty())
1546 for (Resource type : types) {
1547 if (graph.isInstanceOf(r, type)) {
1554 private static StringBuilder orString(ReadGraph graph, StringBuilder sb, Collection<Resource> rs) throws DatabaseException {
1556 boolean first = true;
1557 for (Resource r : rs) {
1561 sb.append(NameUtils.getSafeName(graph, r));
1567 public static boolean isRelation(ReadGraph g, Layer0 l0, Resource relation) throws DatabaseException {
1568 return g.hasStatement(relation, l0.SubrelationOf) || relation == l0.IsWeaklyRelatedTo;
1571 public static boolean isType(ReadGraph g, Layer0 l0, Resource type) throws DatabaseException {
1572 return g.hasStatement(type, l0.Inherits) || type == l0.Entity;
1575 public static Variable buildChildVariable(ReadGraph graph, Variable context, Resource graphChild, Object nodeChild) throws DatabaseException {
1576 VariableBuilder builder = graph.adapt(graphChild, VariableBuilder.class);
1577 return builder.buildChild(graph, context, build(((AbstractVariable)context).node, nodeChild), graphChild);
1580 private static Variable buildPropertyVariable(ReadGraph graph, Variable variable, Resource parentResource, PropertyInfo graphProperty, Object propertyNode) throws DatabaseException {
1581 VariableNode<?> node = variable instanceof AbstractVariable ? build(((AbstractVariable)variable).node, propertyNode) : null;
1582 return graphProperty.builder.buildProperty(graph, variable, node, parentResource, graphProperty.predicate);
1585 static StandardGraphChildVariable createStandardGraphChildVariable(
1586 AbstractVariable parent, Object child) {
1587 return new StandardGraphChildVariable(parent, build(parent.node, child), null);
1590 private static StandardGraphPropertyVariable createStandardGraphPropertyVariable(
1591 ReadGraph graph, AbstractVariable variable, Object nodeProperty) throws DatabaseException {
1592 Resource propertyResource = getPossiblePropertyResource(graph, variable, nodeProperty);
1593 return new StandardGraphPropertyVariable(graph, variable, build(variable.node, nodeProperty), null, propertyResource);
1596 static Map<String, Variable> ensureVariableMap(
1597 Map<String, Variable> map, int size) {
1598 if(map == null) map = new THashMap<String,Variable>(size);
1602 private static PropertyInfo getPropertyInfo(ReadGraph graph, Resource predicate) throws DatabaseException {
1603 return graph.syncRequest(new PropertyInfoRequest(predicate));
1606 @SuppressWarnings("unchecked")
1607 static String getNodeName(AbstractVariable parent, Object child) {
1608 return parent.node.support.manager.getName(child);
1611 @SuppressWarnings("unchecked")
1612 private static Object getNodeValue(final AbstractVariable variable, final Binding binding) throws NodeManagerException, BindingException {
1613 return variable.node.support.manager.getValue(variable.node.node, binding);
1616 @SuppressWarnings("unchecked")
1617 private static void setNodeValue(final AbstractVariable variable, final Object value, final Binding binding) throws NodeManagerException, BindingException {
1618 variable.node.support.manager.setValue(variable.node.node, value, binding);
1621 @SuppressWarnings("unchecked")
1622 private static String getPossiblePropertyURI(AbstractVariable parent, Object node) {
1623 return parent.node.support.manager.getPropertyURI(parent.node.node, node);
1627 @SCLValue(type = "ReadGraph -> Resource -> Variable -> a")
1628 public static Object defaultInstantiateUnder(ReadGraph graph, Resource converter, Variable context) throws DatabaseException {
1629 return new FunctionImpl2<Resource, Resource, Resource>() {
1630 public Resource apply(Resource container, Resource type) {
1632 WriteGraph graph = (WriteGraph)SCLContext.getCurrent().get("graph");
1634 Layer0 L0 = Layer0.getInstance(graph);
1635 CommonDBUtils.selectClusterSet(graph, container);
1636 Resource result = graph.newResource();
1637 String name = NameUtils.findFreshInstanceName(graph, type, container);
1638 graph.claim(result, L0.InstanceOf, type);
1639 graph.addLiteral(result, L0.HasName, L0.NameOf, name, Bindings.STRING);
1640 graph.claim(container, L0.ConsistsOf, L0.PartOf, result);
1643 } catch (DatabaseException e) {
1644 throw new RuntimeDatabaseException(e);