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 if(container == null)
613 Map<String,Resource> methods = graph.syncRequest(new UnescapedMethodMapOfResource(container));
614 Resource predicate = methods.get(name);
615 if(predicate != null) {
616 Layer0 L0 = Layer0.getInstance(graph);
617 PropertyInfo info = graph.syncRequest(new PropertyInfoRequest(L0.Entity_method));
618 Resource value = graph.getSingleObject(container, predicate);
619 return new StandardGraphPropertyVariable(context, null, container, info, value);
625 public Map<String, Variable> getVariables(ReadGraph graph, Variable context, Map<String, Variable> map) throws DatabaseException {
626 Variable parent = context.getParent(graph);
627 Resource container = parent.getPossibleRepresents(graph);
628 Map<String,Resource> methods = graph.syncRequest(new UnescapedMethodMapOfResource(container));
629 for(Map.Entry<String, Resource> entry : methods.entrySet()) {
630 String name = entry.getKey();
631 Resource predicate = entry.getValue();
632 Layer0 L0 = Layer0.getInstance(graph);
633 PropertyInfo info = graph.syncRequest(new PropertyInfoRequest(L0.Entity_method));
634 Resource value = graph.getSingleObject(container, predicate);
635 if(map == null) map = new HashMap<>();
636 map.put(name, new StandardGraphPropertyVariable(context, null, container, info, value));
643 public static Variable getStandardPropertyDomainPropertyVariableFromValue(ReadGraph graph, Variable context, String name) throws DatabaseException {
645 if(context instanceof StandardGraphPropertyVariable) {
646 StandardGraphPropertyVariable variable = (StandardGraphPropertyVariable)context;
647 Resource literal = variable.getPossibleRepresents(graph);
648 Object propertyNode = getPossibleNodeProperty(graph, variable, name, false);
650 if(literal != null) {
651 Variable result = getPossiblePropertyFromContext(graph, variable, literal, name, propertyNode);
652 if(result != null) return result;
655 Variable result = getPossibleSubliteralPropertyFromContext(graph, variable, name);
656 if(result != null) return result;
657 result = getPossiblePropertyFromContext(graph, variable, variable.property.predicate, name, propertyNode);
658 if (result != null) return result;
660 // Get possible property from NodeManager
661 if (propertyNode != null)
662 return createStandardGraphPropertyVariable(graph, variable, propertyNode);
664 } else if (context instanceof StandardGraphChildVariable) {
665 return standardChildDomainProperties.getVariable(graph, context, name);
667 throw new DatabaseException("Unknown variable implementation " + context.getClass().getCanonicalName());
672 public static Map<String, Variable> getStandardPropertyDomainPropertyVariablesFromValue(ReadGraph graph, Variable context, Map<String, Variable> map) throws DatabaseException {
674 if(context instanceof StandardGraphPropertyVariable) {
675 StandardGraphPropertyVariable variable = (StandardGraphPropertyVariable)context;
676 map = collectPropertiesFromContext(graph, variable, variable.property.predicate, map);
677 if (variable.parentResource != null) {
678 Resource literal = graph.getPossibleObject(variable.parentResource, variable.property.predicate);
679 if(literal != null) map=collectPropertiesFromContext(graph, variable, literal, map);
680 map=collectSubliteralProperties(graph, variable, map);
683 // Get properties from VariableNode
684 map = getStandardNodePropertyVariables(graph, context, map);
686 } else if (context instanceof StandardGraphChildVariable) {
687 return standardChildDomainProperties.getVariables(graph, context, map);
689 throw new DatabaseException("Unknown variable implementation " + context.getClass().getCanonicalName());
694 public static Map<String, Variable> getStandardPropertyDomainPropertyVariablesFromValue(ReadGraph graph, Variable context, String classification, Map<String, Variable> map) throws DatabaseException {
696 if(context instanceof StandardGraphPropertyVariable) {
697 StandardGraphPropertyVariable variable = (StandardGraphPropertyVariable)context;
698 map = collectPropertiesFromContext(graph, variable, variable.property.predicate, classification, map);
699 if (variable.parentResource != null) {
700 Resource literal = graph.getPossibleObject(variable.parentResource, variable.property.predicate);
701 if(literal != null) map=collectPropertiesFromContext(graph, variable, literal, classification, map);
704 // Get properties from VariableNode
705 map = getStandardNodePropertyVariables(graph, context, map);
707 } else if (context instanceof StandardGraphChildVariable) {
708 return standardChildDomainProperties.getVariables(graph, context, map);
710 throw new DatabaseException("Unknown variable implementation " + context.getClass().getCanonicalName());
715 @SCLValue(type = "VariableMap")
716 public static VariableMap standardPropertyDomainProperties = new VariableMapImpl() {
718 VariableMap getValueVariableMap(ReadGraph graph, Variable context) throws DatabaseException {
719 Resource represents = context.getPossibleRepresents(graph);
720 if(represents == null) return null;
722 VariableMap map = graph.isImmutable(represents) ?
723 graph.syncRequest(new PropertyVariableMapRequest(represents), TransientCacheListener.<VariableMap>instance()) :
724 (VariableMap)graph.getPossibleRelatedValue2(represents, Layer0.getInstance(graph).domainProperties, represents);
726 if(map == standardPropertyDomainProperties) return null;
732 public Variable getVariable(ReadGraph graph, Variable context, String name) throws DatabaseException {
733 VariableMap valueMap = getValueVariableMap(graph, context);
734 if(valueMap != null) return valueMap.getVariable(graph, context, name);
735 return getStandardPropertyDomainPropertyVariableFromValue(graph, context, name);
739 public Map<String, Variable> getVariables(ReadGraph graph, Variable context, Map<String, Variable> map) throws DatabaseException {
740 VariableMap valueMap = getValueVariableMap(graph, context);
741 if(valueMap != null) return valueMap.getVariables(graph, context, map);
742 else return getStandardPropertyDomainPropertyVariablesFromValue(graph, context, map);
746 public Map<String, Variable> getVariables(ReadGraph graph, Variable context, String classification, Map<String, Variable> map) throws DatabaseException {
747 VariableMap valueMap = getValueVariableMap(graph, context);
748 if(valueMap != null) return valueMap.getVariables(graph, context, classification, map);
749 else return getStandardPropertyDomainPropertyVariablesFromValue(graph, context, classification, map);
754 public static Resource getPossibleGraphChild(ReadGraph graph, Variable variable, String name) throws DatabaseException {
755 Resource resource = variable.getPossibleRepresents(graph);
756 if(resource == null) return null;
757 Map<String, Resource> graphChildren = graph.syncRequest(new UnescapedChildMapOfResource(resource));
758 return graphChildren.get(name);
761 public static Map<String,Resource> getPossibleGraphChildren(ReadGraph graph, Variable variable) throws DatabaseException {
762 Resource resource = variable.getPossibleRepresents(graph);
763 if(resource == null) return Collections.emptyMap();
764 return graph.syncRequest(new UnescapedChildMapOfResource(resource));
767 public static Object getPossibleNodeChild(ReadGraph graph, Variable variable, String name) throws DatabaseException {
768 if (!(variable instanceof AbstractVariable)) return null;
769 VariableNode<?> node = ((AbstractVariable)variable).node;
770 if(node == null) return null;
771 NodeStructure structure = Variables.requestNodeStructure(graph, node);
772 if(Variables.PENDING_NODE_STRUCTURE == structure) throw new PendingVariableException("");
773 return structure.children.get(name);
776 public static Collection<Object> getPossibleNodeChildren(ReadGraph graph, Variable variable) throws DatabaseException {
777 if (!(variable instanceof AbstractVariable)) return null;
778 VariableNode<?> node = ((AbstractVariable)variable).node;
779 if(node == null) return Collections.emptyList();
780 NodeStructure structure = Variables.requestNodeStructure(graph, node);
781 if(Variables.PENDING_NODE_STRUCTURE == structure) throw new PendingVariableException("");
782 return structure.children.values();
785 public static Object getPossibleNodeProperty(ReadGraph graph, Variable variable, String name, boolean throwPending) throws DatabaseException {
786 if (!(variable instanceof AbstractVariable)) return null;
787 VariableNode<?> node = ((AbstractVariable)variable).node;
788 if(node == null) return null;
789 NodeStructure structure = Variables.requestNodeStructure(graph, node);
790 if(throwPending && Variables.PENDING_NODE_STRUCTURE == structure) throw new PendingVariableException("");
791 return structure.properties.get(name);
794 public static Collection<Object> getPossibleNodeProperties(ReadGraph graph, Variable variable) throws DatabaseException {
795 if (!(variable instanceof AbstractVariable)) return null;
796 VariableNode<?> node = ((AbstractVariable)variable).node;
797 if(node == null) return Collections.emptyList();
798 NodeStructure structure = Variables.requestNodeStructure(graph, node);
799 if(Variables.PENDING_NODE_STRUCTURE == structure) throw new PendingVariableException("");
800 return structure.properties.values();
803 @SuppressWarnings({ "rawtypes", "unchecked" })
804 public static VariableNode build(VariableNode parent, Object node) {
805 if(node == null) return null;
806 return new VariableNode(parent.support, node);
810 public static Variable getStandardChildDomainChildVariable(ReadGraph graph, Variable context, String name) throws DatabaseException {
811 return StandardChildDomainChildren.getStandardChildDomainChildVariable(graph, context, name);
815 public static Variable getStandardChildDomainChildVariable(ReadGraph graph, Variable context, Resource graphChild, String name) throws DatabaseException {
816 return StandardChildDomainChildren.getStandardChildDomainChildVariable(graph, context, graphChild, name);
820 public static Map<String, Variable> getStandardChildDomainChildVariables(ReadGraph graph, Variable context, Map<String, Variable> map) throws DatabaseException {
821 return StandardChildDomainChildren.getStandardChildDomainChildVariables(graph, context, map);
825 public static Map<String, Variable> getStandardChildDomainChildVariables(ReadGraph graph, Variable context, Map<String,Resource> graphChildren, Map<String, Variable> map) throws DatabaseException {
826 return StandardChildDomainChildren.getStandardChildDomainChildVariables(graph, context, graphChildren, map);
830 * Get a map of child Variables from a node manager-based Variable, combined with the existing variables in #map.
831 * @param graph The read graph.
832 * @param context The parent Variable.
833 * @param map A map of variables into which the new variables are merged.
834 * @return A map from variable names to instances
835 * @throws DatabaseException
837 public static Map<String, Variable> getStandardNodeChildVariables(ReadGraph graph, Variable context, Map<String, Variable> map) throws DatabaseException {
838 AbstractVariable variable = (AbstractVariable)context;
839 if (variable.node == null) return map;
841 Collection<Object> nodeChildren = getPossibleNodeChildren(graph, variable);
842 if (nodeChildren.isEmpty()) return map;
844 map = ensureVariableMap(map, nodeChildren.size());
846 for(Object nodeChild : nodeChildren) {
847 String name = getNodeName(variable, nodeChild);
848 if (!map.containsKey(name))
849 map.put(name, createStandardGraphChildVariable(variable, nodeChild));
856 * Get a map of property Variables from a node manager-based Variable, combined with the existing variables in #map.
857 * @param graph The read graph.
858 * @param context The parent Variable.
859 * @param map A map of variables into which the new variables are merged.
860 * @return A map from variable names to instances
861 * @throws DatabaseException
863 public static Map<String, Variable> getStandardNodePropertyVariables(ReadGraph graph, Variable context, Map<String, Variable> map) throws DatabaseException {
864 AbstractVariable variable = (AbstractVariable)context;
865 if (variable.node == null) return map;
867 Collection<Object> nodeProperties = getPossibleNodeProperties(graph, variable);
868 if (nodeProperties.isEmpty()) return map;
870 map = ensureVariableMap(map, nodeProperties.size());
872 for(Object nodeProperty : nodeProperties) {
873 String name = getNodeName(variable, nodeProperty);
874 if (!map.containsKey(name)) {
875 map.put(name, createStandardGraphPropertyVariable(graph, variable, nodeProperty));
882 @SCLValue(type = "VariableMap")
883 public static VariableMap standardChildDomainChildren = new VariableMapImpl() {
886 public Variable getVariable(ReadGraph graph, Variable context, String name) throws DatabaseException {
887 return StandardChildDomainChildren.getStandardChildDomainChildVariable(graph, context, name);
891 public Map<String, Variable> getVariables(ReadGraph graph, Variable context, Map<String, Variable> map) throws DatabaseException {
892 return StandardChildDomainChildren.getStandardChildDomainChildVariables(graph, context, map);
897 @SCLValue(type = "VariableMap")
898 public static VariableMap standardPropertyDomainChildren = new VariableMapImpl() {
901 * Get a possible non-standard VariableMap defined in the graph.
902 * @param graph The graph
903 * @param context The context node
904 * @return A non-standard VariableMap instance for the context node,
905 * or null, if not defined or defined as this instance.
906 * @throws DatabaseException
908 VariableMap getValueVariableMap(ReadGraph graph, Variable context) throws DatabaseException {
909 Resource represents = context.getPossibleRepresents(graph);
910 if(represents == null) return null;
911 VariableMap map = graph.syncRequest(new ChildVariableMapRequest(represents));
912 if(map == standardPropertyDomainChildren) return null;
917 public Variable getVariable(ReadGraph graph, Variable context, String name) throws DatabaseException {
918 // Delegate call to a non-standard variable map?
919 VariableMap valueMap = getValueVariableMap(graph, context);
920 if(valueMap != null) return valueMap.getVariable(graph, context, name);
922 if(context instanceof StandardGraphPropertyVariable) {
923 StandardGraphPropertyVariable variable = (StandardGraphPropertyVariable)context;
924 Datatype dt = variable.getDatatype(graph);
925 if (dt instanceof ArrayType) {
926 ChildReference ref = getPossibleIndexReference(name);
928 return new SubliteralPropertyVariableDeprecated(variable, ref);
931 // Check for a child node provided by the NodeManager
932 if (variable.node != null) {
933 Object childNode = getPossibleNodeChild(graph, variable, name);
934 if (childNode != null)
935 return createStandardGraphChildVariable(variable, childNode);
937 return standardChildDomainChildren.getVariable(graph, context, name);
938 } else if (context instanceof StandardGraphChildVariable) {
939 return standardChildDomainChildren.getVariable(graph, context, name);
941 throw new DatabaseException("Unknown variable implementation " + context.getClass().getCanonicalName());
946 public Map<String, Variable> getVariables(ReadGraph graph, Variable context, Map<String, Variable> map) throws DatabaseException {
947 // Delegate call to a non-standard variable map?
948 VariableMap valueMap = getValueVariableMap(graph, context);
949 if(valueMap != null) return valueMap.getVariables(graph, context, map);
951 if(context instanceof StandardGraphPropertyVariable) {
952 // Get child variables provided by the NodeManager
953 Map<String, Variable> result = getStandardNodeChildVariables(graph, context, map);
954 return standardChildDomainChildren.getVariables(graph, context, result);
955 } else if (context instanceof StandardGraphChildVariable) {
956 return standardChildDomainChildren.getVariables(graph, context, map);
958 throw new DatabaseException("Unknown variable implementation " + context.getClass().getCanonicalName());
964 protected static ChildReference getPossibleIndexReference(String name) {
965 if (name.startsWith("i-")) {
967 int index = Integer.parseInt(name.substring(2));
968 return new IndexReference(index);
969 } catch (NumberFormatException e) {}
974 protected static ValueAccessor getPossiblePropertyValueAccessor(ReadGraph graph, StandardGraphPropertyVariable variable) throws DatabaseException {
975 if(variable.property == null) return null;
976 return variable.property.valueAccessor;
977 // return graph.syncRequest(new PropertyValueAccessorRequest(variable.property), TransientCacheAsyncListener.<ValueAccessor>instance());
978 // return graph.syncRequest(new PossibleRelatedValueImplied2<ValueAccessor>(variable.property, Layer0.getInstance(graph).valueAccessor));
981 public static ValueAccessor getPossibleValueValueAccessor(ReadGraph graph, Variable variable) throws DatabaseException {
982 Resource value = variable.getPossibleRepresents(graph);
983 if(value == null) return null;
984 //return graph.syncRequest(new PropertyValueAccessorRequest(value));
985 return graph.syncRequest(new PossibleRelatedValueImplied2<ValueAccessor>(value, Layer0.getInstance(graph).valueAccessor));
988 public static PropertyInfo getPossiblePropertyInfoFromContext(ReadGraph graph, Variable variable, Resource context, String name) throws DatabaseException {
989 if(context == null) return null;
990 Map<String, PropertyInfo> predicates = graph.syncRequest(new UnescapedPropertyMapOfResource(context));
991 return predicates.get(name);
994 public static Variable getPossiblePropertyFromContext(ReadGraph graph, Variable variable, Resource context, String name, Object propertyNode) throws DatabaseException {
995 PropertyInfo info = getPossiblePropertyInfoFromContext(graph, variable, context, name);
996 if(info == null || info.builder == null) return null;
997 return buildPropertyVariable(graph, variable, context, info, propertyNode);
1000 public static Variable getPossibleSubliteralPropertyFromContext(ReadGraph graph, StandardGraphPropertyVariable variable, String name) throws DatabaseException {
1002 Resource predicate = variable.property.predicate;
1003 if(predicate == null) return null;
1005 PropertyInfo info = getPropertyInfo(graph, predicate);
1006 Pair<Resource, ChildReference> p = info.subliteralPredicates.get(name);
1007 if(p == null) return null;
1009 return new SubliteralPropertyVariable(graph, variable, p.first, p.second);
1013 public static Map<String, PropertyInfo> collectPropertyInfosFromContext(ReadGraph graph, Variable variable, Resource context) throws DatabaseException {
1014 if(context == null) return Collections.emptyMap();
1015 return graph.isImmutable(context) ?
1016 graph.syncRequest(new UnescapedPropertyMapOfResource(context), TransientCacheAsyncListener.<Map<String,PropertyInfo>>instance()) :
1017 graph.syncRequest(new UnescapedPropertyMapOfResource(context));
1020 public static Map<String, Variable> collectPropertiesFromContext(ReadGraph graph, Variable variable, Resource context, Map<String, Variable> map) throws DatabaseException {
1022 Map<String,PropertyInfo> properties = graph.isImmutable(context) ?
1023 graph.syncRequest(new UnescapedPropertyMapOfResource(context), TransientCacheAsyncListener.<Map<String,PropertyInfo>>instance()) :
1024 graph.syncRequest(new UnescapedPropertyMapOfResource(context));
1026 if(properties.isEmpty()) return map;
1028 map = ensureVariableMap(map, properties.size());
1030 for(PropertyInfo info : properties.values()) {
1031 String name = info.name;
1032 if (info.builder != null) {
1033 Variable v = info.builder.buildProperty(graph, variable, null, context, info.predicate);
1042 public static Map<String, Variable> collectSubliteralProperties(ReadGraph graph, StandardGraphPropertyVariable variable, Map<String, Variable> map) throws DatabaseException {
1044 Resource predicate = variable.property.predicate;
1045 if(predicate == null) return map;
1047 PropertyInfo info = getPropertyInfo(graph, predicate);
1048 if(info.subliteralPredicates.isEmpty()) return map;
1050 map = ensureVariableMap(map, info.subliteralPredicates.size());
1052 for(Map.Entry<String, Pair<Resource, ChildReference>> entry : info.subliteralPredicates.entrySet()) {
1053 String key = entry.getKey();
1054 Pair<Resource, ChildReference> p = entry.getValue();
1055 if(map == null) map = new THashMap<String,Variable>();
1056 map.put(key, new SubliteralPropertyVariable(graph, variable, p.first, p.second));
1063 public static Map<String, Variable> collectPropertiesFromContext(ReadGraph graph, Variable variable, Resource context, String classification, Map<String, Variable> map) throws DatabaseException {
1065 if(graph.isImmutable(context)) {
1067 Map<String,PropertyInfo> properties = graph.syncRequest(new UnescapedPropertyMapOfResource(context), TransientCacheAsyncListener.<Map<String,PropertyInfo>>instance());
1068 for(PropertyInfo info : properties.values()) {
1070 if(info.classifications.contains(classification) && info.builder != null) {
1071 String name = info.name;
1072 Variable v = info.builder.buildProperty(graph, variable, null, context, info.predicate);
1073 if(map == null) map = new THashMap<String,Variable>();
1081 Collection<Resource> predicates = graph.getPredicates(context);
1083 if(predicates.isEmpty()) return map;
1085 map = ensureVariableMap(map, predicates.size());
1087 for(Resource predicate : predicates) {
1089 PropertyInfo info = graph.isImmutable(predicate) ?
1090 graph.syncRequest(new PropertyInfoRequest(predicate), TransientCacheAsyncListener.<PropertyInfo>instance()) :
1091 graph.syncRequest(new PropertyInfoRequest(predicate));
1093 if(!info.isHasProperty) continue;
1095 if(info.classifications.contains(classification) && info.builder != null) {
1096 String name = info.name;
1097 Variable v = info.builder.buildProperty(graph, variable, null, context, info.predicate);
1098 if(map == null) map = new THashMap<String,Variable>();
1110 @SCLValue(type = "ReadGraph -> Resource -> a -> String")
1111 public static String entityLabel(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
1112 if(context instanceof Resource) {
1113 return NameUtils.getSafeLabel(graph, ((Resource)context));
1114 } else if (context instanceof Variable) {
1115 Variable parent = ((Variable)context).getParent(graph);
1116 Resource represents = parent.getRepresents(graph);
1117 return NameUtils.getSafeLabel(graph, represents);
1119 throw new DatabaseException("Unknown context " + context);
1123 @SCLValue(type = "ReadGraph -> Resource -> a -> b")
1124 public static Object listResources(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
1125 return ListUtils.toList(graph, resource);
1128 @SCLValue(type = "ReadGraph -> Resource -> Variable -> [String]")
1129 public static List<String> standardClassifications(ReadGraph graph, Resource resource, Variable context) throws DatabaseException {
1130 ArrayList<String> result = new ArrayList<String>();
1131 Resource predicate = context.getParent(graph).getPossiblePredicateResource(graph);
1132 if(predicate != null) {
1133 for(Resource type : graph.getTypes(predicate)) {
1134 String uri = graph.getPossibleURI(type);
1135 if(uri != null) result.add(uri);
1141 @SCLValue(type = "ReadGraph -> Resource -> a -> Boolean")
1142 public static Boolean standardValidValue(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
1143 return Boolean.TRUE;
1146 @SCLValue(type = "ReadGraph -> Resource -> a -> StringInputValidator")
1147 public static StringInputValidator standardValidator(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
1148 return StringInputValidator.PASS;
1151 @SCLValue(type = "ReadGraph -> Resource -> a -> Boolean")
1152 public static Boolean standardRequiredValue(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
1153 return Boolean.FALSE;
1156 @SCLValue(type = "ReadGraph -> Resource -> Variable -> Boolean")
1157 public static Boolean standardDefaultValue(ReadGraph graph, Resource resource, Variable context) throws DatabaseException {
1158 Variable property = context.getParent(graph);
1159 if(property instanceof StandardGraphPropertyVariable) {
1160 StandardGraphPropertyVariable variable = (StandardGraphPropertyVariable)property;
1161 if (variable.parentResource != null) {
1162 Statement stm = graph.getPossibleStatement(variable.parentResource, variable.property.predicate);
1163 return stm != null && stm.isAsserted(variable.parentResource);
1166 return Boolean.FALSE;
1169 @SCLValue(type = "ReadGraph -> Resource -> a -> Boolean")
1170 public static Boolean standardReadOnlyValue(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
1171 return Boolean.FALSE;
1174 @SCLValue(type = "ReadGraph -> Resource -> a -> b")
1175 public static Object resourceAsValue(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
1179 @SCLValue(type = "ReadGraph -> Resource -> a -> b")
1180 public static Object functionApplication(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
1181 return Functions.exec(graph, resource, graph, resource, context);
1184 @SCLValue(type = "ReadGraph -> Resource -> a -> b")
1185 public static Object computeExpression(ReadGraph graph, Resource converter, Object context) throws DatabaseException {
1186 if(context instanceof Variable) {
1187 return CompileValueRequest.compileAndEvaluate(graph, (Variable)context);
1188 } if (context instanceof Resource) {
1189 return CompileResourceValueRequest.compileAndEvaluate(graph, (Resource)converter);
1191 throw new IllegalStateException("Unknown context " + context);
1195 @SCLValue(type = "ReadGraph -> Resource -> a -> b")
1196 public static Object composedPropertyValue(ReadGraph graph, Resource converter, Object context) throws DatabaseException {
1197 if(context instanceof Variable) {
1198 return new StandardComposedProperty();
1199 } if (context instanceof Resource) {
1200 return new StandardComposedProperty();
1202 throw new IllegalStateException("Unknown context " + context);
1206 @SCLValue(type = "ReadGraph -> Resource -> a -> b")
1207 public static Object numberInputValidator(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
1209 class Validator extends FunctionImpl1<String, String> {
1211 private final Datatype datatype;
1213 public Validator(Datatype datatype) {
1214 this.datatype = datatype;
1218 public String apply(String input) {
1220 if(datatype == null) return null;
1224 if(datatype instanceof NumberType) {
1226 Number number = (Number)PrimitiveValueParser.parse(input, datatype);
1227 NumberType nt = (NumberType)datatype;
1228 Range r = nt.getRange();
1230 if(!r.contains(number)) return "Value is out of valid range";
1235 } catch (NumberFormatException e) {
1236 return "Not a valid floating-point number";
1237 } catch (IllegalArgumentException e) {
1238 return "Not a valid floating-point number";
1245 if(context instanceof Variable) {
1247 Variable variable = (Variable)context;
1248 Variable property = variable.getParent(graph);
1249 Datatype datatype = property.getPossibleDatatype(graph);
1250 return new Validator(datatype);
1252 } else if (context instanceof Resource) {
1254 Layer0 L0 = Layer0.getInstance(graph);
1255 Resource literal = (Resource)context;
1256 Datatype datatype = graph.getRelatedValue(literal, L0.HasDataType, Bindings.getBindingUnchecked(Datatype.class));
1257 return new Validator(datatype);
1261 return new Validator(null);
1267 @SCLValue(type = "ReadGraph -> Resource -> a -> b")
1268 public static Object booleanInputValidator(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
1270 return new FunctionImpl1<String, String>() {
1273 public String apply(String input) {
1275 String lower = input.toLowerCase();
1276 if("true".equals(lower) || "false".equals(lower)) return null;
1278 return "Not a valid boolean: " + input;
1286 @SCLValue(type = "ReadGraph -> Resource -> Variable -> Resource")
1287 public static Resource hasStandardResource(ReadGraph graph, Resource resource, Variable context) throws DatabaseException {
1288 Variable parent = context.getParent(graph);
1289 if(parent instanceof StandardGraphChildVariable) {
1290 StandardGraphChildVariable variable = (StandardGraphChildVariable)parent;
1291 return variable.resource;
1297 @SCLValue(type = "ReadGraph -> Resource -> Variable -> a")
1298 public static Object valueWithoutBinding(ReadGraph graph, Resource converter, Variable context) throws DatabaseException {
1300 StandardGraphPropertyVariable variable = (StandardGraphPropertyVariable)context;
1302 if(graph.sync(new IsEnumeratedValue(variable.getRepresents(graph)))) {
1303 Layer0 L0 = Layer0.getInstance(graph);
1304 return graph.getRelatedValue2(variable.getRepresents(graph), L0.HasLabel);
1307 if (variable.parentResource == null)
1308 throw new VariableException("Variable is not represented by any resource (URI=" + variable.getPossibleURI(graph) + ").");
1311 return graph.getRelatedValue2(variable.parentResource, variable.property.predicate, variable);
1312 } catch (NoSingleResultException e) {
1313 throw new MissingVariableValueException(variable.getPossibleURI(graph));
1314 } catch (DoesNotContainValueException e) {
1315 throw new MissingVariableValueException(variable.getPossibleURI(graph));
1320 @SCLValue(type = "ReadGraph -> Variable -> Binding -> a")
1321 public static Object valueWithBinding(ReadGraph graph, Variable context, Binding binding) throws DatabaseException {
1323 StandardGraphPropertyVariable variable = (StandardGraphPropertyVariable)context;
1325 if(graph.sync(new IsEnumeratedValue(variable.getRepresents(graph)))) {
1326 Layer0 L0 = Layer0.getInstance(graph);
1327 return graph.getRelatedValue2(variable.getRepresents(graph), L0.HasLabel, binding);
1330 if (variable.parentResource == null)
1331 throw new VariableException("Variable is not represented by any resource (URI=" + variable.getPossibleURI(graph) + ").");
1334 return graph.getRelatedValue2(variable.parentResource, variable.property.predicate, variable);
1335 } catch (NoSingleResultException e) {
1336 throw new MissingVariableValueException(variable.getPossibleURI(graph));
1337 } catch (DoesNotContainValueException e) {
1338 throw new MissingVariableValueException(variable.getPossibleURI(graph));
1343 @SCLValue(type = "WriteGraph -> Variable -> a -> Binding -> b")
1344 public static Object valueSetterWithBinding(WriteGraph graph, Variable variable, Object value, Binding binding) throws DatabaseException {
1346 Function4<WriteGraph, Variable, Object, Object, String> modifier = variable.getPossiblePropertyValue(graph, Variables.INPUT_MODIFIER);
1347 if(modifier == null) modifier = VariableUtils.defaultInputModifier;
1348 modifier.apply(graph, variable, value, binding);
1353 static class L0Issue extends StandardIssue {
1355 private final String description;
1357 public L0Issue(String description, Resource type, Resource ... contexts) {
1358 super(type, contexts);
1359 this.description = description;
1363 public Resource write(WriteGraph graph, Resource source) throws DatabaseException {
1364 Layer0 L0 = Layer0.getInstance(graph);
1365 IssueResource IR = IssueResource.getInstance(graph);
1366 Resource issue = super.write(graph, source);
1367 graph.claim(issue, IR.Issue_HasSeverity, IR.Severity_Fatal);
1368 graph.addLiteral(issue, L0.HasDescription, L0.HasDescription_Inverse, description, Bindings.STRING);
1374 private static List<Issue> reportInconsistency(ReadGraph graph, Resource subject, String description, List<Issue> issues) throws DatabaseException {
1375 if(issues == null) issues = new ArrayList<Issue>();
1376 System.err.println("Change set validation reports the following issue: " + NameUtils.getSafeName(graph, subject, true) + ": " + description);
1377 IssueResource IR = IssueResource.getInstance(graph);
1378 issues.add(new L0Issue(description, IR.Issue, subject));
1382 @SCLValue(type = "ReadGraph -> Resource -> [Issue]")
1383 public static List<Issue> relationValidator(ReadGraph graph, Resource resource) throws DatabaseException {
1385 Layer0 L0 = Layer0.getInstance(graph);
1387 List<Issue> issues = null;
1389 for(Statement stm : graph.getStatements(resource, L0.IsWeaklyRelatedTo)) {
1390 Resource predicate = stm.getPredicate();
1391 Resource object = stm.getObject();
1392 if(!isRelation(graph, L0, predicate)) {
1393 issues = reportInconsistency(graph, resource, "The predicate of a statement must be a relation: " + NameUtils.toString(graph, stm), issues);
1395 if(graph.isInstanceOf(predicate, L0.FunctionalRelation)) {
1396 if(graph.getObjects(resource, predicate).size() > 1)
1397 issues = reportInconsistency(graph, resource,
1399 NameUtils.getSafeName(graph, predicate)
1400 + " is functional.", issues);
1403 Collection<Resource> domain = graph.getObjects(predicate, L0.HasDomain);
1404 if (!isInstanceOfAny(graph, resource, domain, true)) {
1405 StringBuilder sb = new StringBuilder()
1406 .append("The domain of ")
1407 .append(NameUtils.getSafeName(graph, predicate))
1408 .append(" relation is ");
1409 orString(graph, sb, domain).append(".");
1410 issues = reportInconsistency(graph, resource, sb.toString(), issues);
1414 Collection<Resource> range = graph.getObjects(predicate, L0.HasRange);
1415 if (!isInstanceOfAny(graph, object, range, true) && !graph.isInstanceOf(object, L0.SCLValue)) {
1416 StringBuilder sb = new StringBuilder()
1417 .append("The range of ")
1418 .append(NameUtils.getSafeName(graph, predicate))
1419 .append(" relation is ");
1420 orString(graph, sb, range).append(" but current object is ")
1421 .append(NameUtils.getSafeName(graph, object)).append(".");
1422 issues = reportInconsistency(graph, resource, sb.toString(), issues);
1427 return issues != null ? issues : Collections.<Issue>emptyList();
1431 @SCLValue(type = "ReadGraph -> Resource -> [Issue]")
1432 public static List<Issue> propertyValidator(ReadGraph graph, Resource resource) throws DatabaseException {
1434 List<Issue> issues = null;
1436 Layer0 L0 = Layer0.getInstance(graph);
1437 for(Statement stm : graph.getStatements(resource, L0.HasProperty)) {
1438 Resource subject = stm.getSubject();
1439 Resource predicate = stm.getPredicate();
1440 String error = L0Validations.checkValueType(graph, subject, predicate);
1441 if(error != null) issues = reportInconsistency(graph, subject, error, issues);
1444 return issues != null ? issues : Collections.<Issue>emptyList();
1449 @SCLValue(type = "ReadGraph -> Resource -> [Issue]")
1450 public static List<Issue> valueValidator(ReadGraph graph, Resource resource) throws DatabaseException {
1452 List<Issue> issues = null;
1454 Layer0 L0 = Layer0.getInstance(graph);
1455 if(graph.hasValue(resource)) {
1456 if(!graph.isInstanceOf(resource, L0.Literal)) {
1457 issues = reportInconsistency(graph, resource,
1458 "Resource has a value but it is not a literal.", issues);
1461 // TODO check that the value is valid for the data type
1465 if(graph.isInstanceOf(resource, L0.Literal)) {
1466 issues = reportInconsistency(graph, resource,
1467 "Resource is a literal but it does not have a value.", issues);
1471 return issues != null ? issues : Collections.<Issue>emptyList();
1476 @SCLValue(type = "ReadGraph -> Resource -> [Issue]")
1477 public static List<Issue> uriValidator(ReadGraph graph, Resource resource) throws DatabaseException {
1479 List<Issue> issues = null;
1481 Layer0 L0 = Layer0.getInstance(graph);
1482 Resource parent = graph.getPossibleObject(resource, L0.PartOf);
1483 if(parent != null) {
1484 String parentURI = graph.syncRequest(new PossibleURI(parent));
1485 if(parentURI != null) {
1486 String name = graph.getPossibleRelatedValue(resource, L0.HasName);
1488 issues = reportInconsistency(graph, resource, "Resource has a parent with URI but has no valid HasName.", issues);
1493 return issues != null ? issues : Collections.<Issue>emptyList();
1497 private static Resource getPossibleNearestClusterSet(ReadGraph graph, Resource base, Resource resource) throws DatabaseException {
1499 ClusteringSupport cs = graph.getService(ClusteringSupport.class);
1500 if(cs.isClusterSet(resource) && !base.equals(resource)) return resource;
1502 Resource nearest = CommonDBUtils.getNearestOwner(graph, Collections.singletonList(resource));
1503 if(nearest == null) return null;
1505 return getPossibleNearestClusterSet(graph, base, nearest);
1509 private static boolean quirks(ReadGraph graph, Resource resource) throws DatabaseException {
1511 if(!resource.isPersistent()) return true;
1512 if(graph.isImmutable(resource)) return true;
1513 if(resource.getResourceId() < 0x2000) return true;
1519 @SCLValue(type = "ReadGraph -> Resource -> [Issue]")
1520 public static List<Issue> clusterValidator(ReadGraph graph, Resource resource) throws DatabaseException {
1522 if(!Development.DEVELOPMENT) return Collections.<Issue>emptyList();
1524 if(quirks(graph, resource)) return Collections.<Issue>emptyList();
1526 List<Issue> issues = null;
1528 ClusteringSupport cs = graph.getService(ClusteringSupport.class);
1529 Resource set = cs.getClusterSetOfCluster(resource);
1531 if(set == null) return reportInconsistency(graph, resource, "Resource cluster is not part of any cluster set", issues);
1533 Resource nearestSet = getPossibleNearestClusterSet(graph, resource, resource);
1534 if(nearestSet == null) {
1535 // This means that there is no owner since RootLibrary is a cluster set
1536 return Collections.<Issue>emptyList();
1539 if(!set.equals(nearestSet)) return reportInconsistency(graph, resource, "The cluster set of a resource is not the nearest owner set", issues);
1541 return Collections.<Issue>emptyList();
1545 private static boolean isInstanceOfAny(ReadGraph graph, Resource r, Collection<Resource> types, boolean ifEmpty) throws DatabaseException {
1546 if (types.isEmpty())
1548 for (Resource type : types) {
1549 if (graph.isInstanceOf(r, type)) {
1556 private static StringBuilder orString(ReadGraph graph, StringBuilder sb, Collection<Resource> rs) throws DatabaseException {
1558 boolean first = true;
1559 for (Resource r : rs) {
1563 sb.append(NameUtils.getSafeName(graph, r));
1569 public static boolean isRelation(ReadGraph g, Layer0 l0, Resource relation) throws DatabaseException {
1570 return g.hasStatement(relation, l0.SubrelationOf) || relation == l0.IsWeaklyRelatedTo;
1573 public static boolean isType(ReadGraph g, Layer0 l0, Resource type) throws DatabaseException {
1574 return g.hasStatement(type, l0.Inherits) || type == l0.Entity;
1577 public static Variable buildChildVariable(ReadGraph graph, Variable context, Resource graphChild, Object nodeChild) throws DatabaseException {
1578 VariableBuilder builder = graph.adapt(graphChild, VariableBuilder.class);
1579 return builder.buildChild(graph, context, build(((AbstractVariable)context).node, nodeChild), graphChild);
1582 private static Variable buildPropertyVariable(ReadGraph graph, Variable variable, Resource parentResource, PropertyInfo graphProperty, Object propertyNode) throws DatabaseException {
1583 VariableNode<?> node = variable instanceof AbstractVariable ? build(((AbstractVariable)variable).node, propertyNode) : null;
1584 return graphProperty.builder.buildProperty(graph, variable, node, parentResource, graphProperty.predicate);
1587 static StandardGraphChildVariable createStandardGraphChildVariable(
1588 AbstractVariable parent, Object child) {
1589 return new StandardGraphChildVariable(parent, build(parent.node, child), null);
1592 private static StandardGraphPropertyVariable createStandardGraphPropertyVariable(
1593 ReadGraph graph, AbstractVariable variable, Object nodeProperty) throws DatabaseException {
1594 Resource propertyResource = getPossiblePropertyResource(graph, variable, nodeProperty);
1595 return new StandardGraphPropertyVariable(graph, variable, build(variable.node, nodeProperty), null, propertyResource);
1598 static Map<String, Variable> ensureVariableMap(
1599 Map<String, Variable> map, int size) {
1600 if(map == null) map = new THashMap<String,Variable>(size);
1604 private static PropertyInfo getPropertyInfo(ReadGraph graph, Resource predicate) throws DatabaseException {
1605 return graph.syncRequest(new PropertyInfoRequest(predicate));
1608 @SuppressWarnings("unchecked")
1609 static String getNodeName(AbstractVariable parent, Object child) {
1610 return parent.node.support.manager.getName(child);
1613 @SuppressWarnings("unchecked")
1614 private static Object getNodeValue(final AbstractVariable variable, final Binding binding) throws NodeManagerException, BindingException {
1615 return variable.node.support.manager.getValue(variable.node.node, binding);
1618 @SuppressWarnings("unchecked")
1619 private static void setNodeValue(final AbstractVariable variable, final Object value, final Binding binding) throws NodeManagerException, BindingException {
1620 variable.node.support.manager.setValue(variable.node.node, value, binding);
1623 @SuppressWarnings("unchecked")
1624 private static String getPossiblePropertyURI(AbstractVariable parent, Object node) {
1625 return parent.node.support.manager.getPropertyURI(parent.node.node, node);
1629 @SCLValue(type = "ReadGraph -> Resource -> Variable -> a")
1630 public static Object defaultInstantiateUnder(ReadGraph graph, Resource converter, Variable context) throws DatabaseException {
1631 return new FunctionImpl2<Resource, Resource, Resource>() {
1632 public Resource apply(Resource container, Resource type) {
1634 WriteGraph graph = (WriteGraph)SCLContext.getCurrent().get("graph");
1636 Layer0 L0 = Layer0.getInstance(graph);
1637 CommonDBUtils.selectClusterSet(graph, container);
1638 Resource result = graph.newResource();
1639 String name = NameUtils.findFreshInstanceName(graph, type, container);
1640 graph.claim(result, L0.InstanceOf, type);
1641 graph.addLiteral(result, L0.HasName, L0.NameOf, name, Bindings.STRING);
1642 graph.claim(container, L0.ConsistsOf, L0.PartOf, result);
1645 } catch (DatabaseException e) {
1646 throw new RuntimeDatabaseException(e);