f93023b77ccd36a6db7d44af8d9981f4a47fc983
[simantics/platform.git] / bundles / org.simantics.db.layer0 / src / org / simantics / db / layer0 / function / All.java
1 package org.simantics.db.layer0.function;
2
3 import java.util.ArrayList;
4 import java.util.Collection;
5 import java.util.Collections;
6 import java.util.HashMap;
7 import java.util.List;
8 import java.util.Map;
9 import java.util.Set;
10 import java.util.concurrent.atomic.AtomicReference;
11
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.utils.NearestOwnerFinder;
42 import org.simantics.db.common.validation.L0Validations;
43 import org.simantics.db.exception.AdaptionException;
44 import org.simantics.db.exception.DatabaseException;
45 import org.simantics.db.exception.DoesNotContainValueException;
46 import org.simantics.db.exception.NoSingleResultException;
47 import org.simantics.db.exception.RuntimeDatabaseException;
48 import org.simantics.db.layer0.exception.InvalidVariableException;
49 import org.simantics.db.layer0.exception.MissingVariableException;
50 import org.simantics.db.layer0.exception.MissingVariableValueException;
51 import org.simantics.db.layer0.exception.PendingVariableException;
52 import org.simantics.db.layer0.request.PossibleURI;
53 import org.simantics.db.layer0.request.PropertyInfo;
54 import org.simantics.db.layer0.request.PropertyInfoRequest;
55 import org.simantics.db.layer0.request.UnescapedAssertedPropertyMapOfResource;
56 import org.simantics.db.layer0.request.UnescapedMethodMapOfResource;
57 import org.simantics.db.layer0.request.UnescapedPropertyMapOfResource;
58 import org.simantics.db.layer0.scl.CompileResourceValueRequest;
59 import org.simantics.db.layer0.scl.CompileValueRequest;
60 import org.simantics.db.layer0.util.Layer0Utils;
61 import org.simantics.db.layer0.util.PrimitiveValueParser;
62 import org.simantics.db.layer0.variable.AbstractVariable;
63 import org.simantics.db.layer0.variable.ChildVariableMapRequest;
64 import org.simantics.db.layer0.variable.ExternalSetValue;
65 import org.simantics.db.layer0.variable.PropertyVariableMapRequest;
66 import org.simantics.db.layer0.variable.StandardAssertedGraphPropertyVariable;
67 import org.simantics.db.layer0.variable.StandardComposedProperty;
68 import org.simantics.db.layer0.variable.StandardGraphChildVariable;
69 import org.simantics.db.layer0.variable.StandardGraphPropertyVariable;
70 import org.simantics.db.layer0.variable.SubliteralPropertyVariable;
71 import org.simantics.db.layer0.variable.SubliteralPropertyVariableDeprecated;
72 import org.simantics.db.layer0.variable.ValueAccessor;
73 import org.simantics.db.layer0.variable.Variable;
74 import org.simantics.db.layer0.variable.VariableBuilder;
75 import org.simantics.db.layer0.variable.VariableMap;
76 import org.simantics.db.layer0.variable.VariableMapImpl;
77 import org.simantics.db.layer0.variable.VariableNode;
78 import org.simantics.db.layer0.variable.VariableNodeReadRunnable;
79 import org.simantics.db.layer0.variable.VariableUtils;
80 import org.simantics.db.layer0.variable.Variables;
81 import org.simantics.db.layer0.variable.Variables.NodeStructure;
82 import org.simantics.db.service.ClusteringSupport;
83 import org.simantics.db.service.UndoRedoSupport;
84 import org.simantics.issues.ontology.IssueResource;
85 import org.simantics.layer0.Layer0;
86 import org.simantics.scl.reflection.annotations.SCLValue;
87 import org.simantics.scl.runtime.SCLContext;
88 import org.simantics.scl.runtime.function.Function4;
89 import org.simantics.scl.runtime.function.FunctionImpl1;
90 import org.simantics.scl.runtime.function.FunctionImpl2;
91 import org.simantics.simulator.variable.exceptions.NodeManagerException;
92 import org.simantics.utils.Development;
93 import org.simantics.utils.datastructures.Pair;
94 import org.simantics.utils.strings.StringInputValidator;
95
96 import gnu.trove.map.hash.THashMap;
97 import gnu.trove.set.hash.THashSet;
98
99 public class All {
100
101         public static Object standardGetValue1(ReadGraph graph, Variable context) throws DatabaseException {
102
103                 StandardGraphPropertyVariable variable = (StandardGraphPropertyVariable)context;
104
105         // First from node
106         if(variable.node != null) {
107             Variant value = Variables.requestNodeValue(graph, variable.node);
108             if(Variables.PENDING_NODE_VALUE == value) throw new PendingVariableException("");
109             return value.getValue();
110         }
111                 
112                 try {
113
114             if(variable.property.hasEnumerationRange) {
115                         Resource object = variable.getRepresents(graph);
116                                 if(graph.sync(new IsEnumeratedValue(object))) {
117                             Layer0 L0 = Layer0.getInstance(graph);
118                                         if(graph.isInstanceOf(object, L0.Literal)) {
119                                                 return graph.getValue(object);
120                                         } else {
121                                                 String label = graph.getPossibleRelatedValue2(variable.getRepresents(graph), L0.HasLabel, Bindings.STRING);
122                                                 if(label == null) label = graph.getPossibleRelatedValue(variable.getRepresents(graph), L0.HasName, Bindings.STRING);
123                                                 if(label == null) label = "<no label>";
124                                                 return label;
125                                         }
126                                 }
127             }
128                         
129             if (variable.isAsserted()) {
130                                 if (variable.parentResource != null) {
131                                         Map<String, Pair<PropertyInfo, Resource>> assertions = graph.syncRequest(
132                                                         new UnescapedAssertedPropertyMapOfResource(variable.parentResource),
133                                                         TransientCacheAsyncListener.instance());
134
135                                         // NOTE: This optimization assumes the property
136                                         // variable's representation is the asserted object.
137                                         Resource object = variable.getPossibleRepresents(graph);
138                                         if (object != null) {
139                                                 return graph.getValue2(object, variable);
140                                         } else {
141                                                 for (Pair<PropertyInfo, Resource> assertion : assertions.values()) {
142                                                         if (assertion.first.predicate.equals(variable.property.predicate)) {
143                                                                 return graph.getValue2(assertion.second, variable);
144                                                         }
145                                                 }
146                                         }
147                                 }
148             }
149                 
150                         return graph.getValue2(variable.getRepresents(graph), variable);
151                         
152                 } catch (NoSingleResultException e) {
153                         throw new MissingVariableValueException(variable.getPossibleURI(graph), e);
154                 } catch (DoesNotContainValueException e) {
155                         throw new MissingVariableValueException(variable.getPossibleURI(graph), e);
156                 } catch (DatabaseException e) {
157                         throw new MissingVariableValueException(variable.getPossibleURI(graph), e);
158                 }
159
160         }
161         
162         public static Object standardGetValue2(ReadGraph graph, Variable context, Binding binding) throws DatabaseException {           
163                 StandardGraphPropertyVariable variable = (StandardGraphPropertyVariable)context;
164
165         // First from node
166         if(variable.node != null) {
167             try {
168                 Variant value = Variables.requestNodeValue(graph, variable.node, binding);
169                 if(Variables.PENDING_NODE_VALUE == value) throw new PendingVariableException("");
170                 if(value == null) throw new MissingVariableValueException(variable.getPossibleURI(graph));
171                 return value.getValue(binding);
172             } catch (AdaptException e) {
173                 throw new AdaptionException("Could not get value for " + context.getURI(graph), e);
174             }
175         }
176                 
177         try {
178                         
179                 if(variable.property.hasEnumerationRange) {
180                 Resource object = variable.getRepresents(graph);
181                 if(graph.sync(new IsEnumeratedValue(object))) {
182                         Layer0 L0 = Layer0.getInstance(graph);
183                         if(graph.isInstanceOf(object, L0.Literal)) {
184                                 return graph.getValue(object, binding);
185                         } else {
186                                 return graph.getRelatedValue2(variable.getRepresents(graph), L0.HasLabel, binding);
187                         }
188                 }
189             }
190                         
191                 if (variable.isAsserted()) {
192                         if (variable.parentResource != null) {
193                                         Map<String, Pair<PropertyInfo, Resource>> assertions = graph.syncRequest(
194                                                         new UnescapedAssertedPropertyMapOfResource(variable.parentResource),
195                                                         TransientCacheAsyncListener.instance());
196
197                                         // NOTE: This optimization assumes the property
198                                         // variable's representation is the asserted object.
199                                         Resource object = variable.getPossibleRepresents(graph);
200                                         if (object != null) {
201                                                 return graph.getValue2(object, variable, binding);
202                                         } else {
203                                                 for (Pair<PropertyInfo, Resource> assertion : assertions.values()) {
204                                                         if (assertion.first.predicate.equals(variable.property.predicate)) {
205                                                                 return graph.getValue2(assertion.second, variable, binding);
206                                                         }
207                                                 }
208                                         }
209                         }
210                 }
211                         
212                         return graph.getValue2(variable.getRepresents(graph), context, binding);
213                         
214                 } catch (NoSingleResultException e) {
215                         throw new MissingVariableValueException(variable.getPossibleURI(graph));
216                 } catch (DoesNotContainValueException e) {
217                         throw new MissingVariableValueException(variable.getPossibleURI(graph));
218                 } catch (DatabaseException e) {
219                         throw new MissingVariableValueException(variable.getPossibleURI(graph), e);
220                 }
221
222         }
223
224         public static void standardSetValue2(WriteGraph graph, Variable context, final Object value) throws DatabaseException {
225                 
226             if(context instanceof StandardGraphPropertyVariable) {
227
228                 final StandardGraphPropertyVariable variable = (StandardGraphPropertyVariable)context; 
229                 
230                 // First from node
231             if(variable.node != null) {
232
233                 final Binding binding = Layer0Utils.getDefaultBinding(graph, variable);
234
235                 final AtomicReference<Object> oldValueRef = new AtomicReference<Object>();
236                 try {
237                     variable.node.support.manager.getRealm().syncExec(new Runnable() {
238                         @Override
239                         public void run() {
240                             try {
241                                 oldValueRef.set(getNodeValue(variable, binding));
242                                 setNodeValue(variable, value, binding);
243                             } catch (NodeManagerException e) {
244                                 throw new RuntimeException(e);
245                             } catch (BindingException e) {
246                                     throw new RuntimeException(e);
247                                 }
248                         }
249                     });
250                 } catch(RuntimeException e) {
251                     if(e.getCause() instanceof NodeManagerException || e.getCause() instanceof BindingException)
252                         throw new DatabaseException(e.getCause());
253                     else
254                         throw e;
255                 } catch (InterruptedException e) {
256                     throw new DatabaseException(e);
257                 }
258
259                 ExternalSetValue ext = new ExternalSetValue(variable.node.support.manager, variable.node.node,
260                         oldValueRef.get(), value, binding);
261                 graph.getService(UndoRedoSupport.class).addExternalOperation(graph, ext);
262
263                 return;
264             }
265                 
266             }
267             
268                 Function4<WriteGraph, Variable, Object, Object, String> modifier = context.getPossiblePropertyValue(graph, Variables.INPUT_MODIFIER);
269                 if(modifier == null) modifier = VariableUtils.defaultInputModifier; 
270                 try {
271                         modifier.apply(graph, context, value, Bindings.getBinding(value.getClass()));
272                 } catch (BindingConstructionException e) {
273                         throw new org.simantics.db.exception.BindingException("",e);
274                 }
275
276         }
277
278         public static void standardSetValue3(final WriteGraph graph, Variable context, final Object value, final Binding binding) throws DatabaseException {
279
280         // First from node
281         if(context instanceof StandardGraphPropertyVariable) {
282
283             final StandardGraphPropertyVariable variable = (StandardGraphPropertyVariable)context; 
284             
285             // First from node
286             if(variable.node != null) {
287                 
288                 try {
289                     
290                     variable.node.support.manager.getRealm().syncExec(new Runnable() {
291
292                         @Override
293                         public void run() {
294                             try {
295                                 Object oldValue = getNodeValue(variable, binding);
296                                 setNodeValue(variable, value, binding);
297                                 ExternalSetValue ext = new ExternalSetValue(variable.node.support.manager, variable.node.node, oldValue, value, binding);
298                                 graph.getService(UndoRedoSupport.class).addExternalOperation(graph, ext);
299                             } catch (NodeManagerException | BindingException e) {
300                                 Logger.defaultLogError(e);
301                             }
302                         }
303
304                         
305                     });
306                     
307                     return;
308                     
309                 } catch (InterruptedException e) {
310                     throw new DatabaseException(e);
311                 }
312                 
313             }
314             
315         }
316             
317                 Function4<WriteGraph, Variable, Object, Object, String> modifier = context.getPossiblePropertyValue(graph, Variables.INPUT_MODIFIER);
318                 if(modifier == null) modifier = VariableUtils.defaultInputModifier; 
319                 modifier.apply(graph, context, value, binding);
320
321         }
322
323         public static Datatype getDatatypeFromValue(ReadGraph graph, Variable context) throws DatabaseException {
324                 if (context instanceof AbstractVariable) {
325                         Binding defaultBinding = ((AbstractVariable)context).getPossibleDefaultBinding(graph);
326                         if (defaultBinding != null)
327                                 return defaultBinding.type();
328                 }
329                         
330         Variant value = context.getVariantValue(graph);
331         if (value.getBinding() == null)
332                 throw new DatabaseException("No value binding for " + context.getURI(graph));
333         
334         return value.getBinding().type();
335         }
336
337     @SuppressWarnings("rawtypes")
338     private static class DatatypeGetter implements VariableNodeReadRunnable {
339         final VariableNode node;
340         Datatype type;
341         Exception exception;
342
343         public DatatypeGetter(VariableNode node) {
344             this.node = node;
345         }
346
347         @SuppressWarnings("unchecked")
348         @Override
349         public void run() {
350             try {
351                 type = node.support.manager.getDatatype(node.node);
352             } catch (NodeManagerException e) {
353                 exception = e;
354             }
355         }
356         @Override
357         public String toString() {
358             return "DatatypeGetter(" + node.node + ")";
359         }
360     }
361
362     public static Datatype standardGetDatatype(ReadGraph graph, Variable context) throws DatabaseException {
363         if (context instanceof AbstractVariable) {
364                 final AbstractVariable variable = (AbstractVariable)context;
365                 if (variable.node != null) {
366                         try {
367                                 DatatypeGetter request = new DatatypeGetter(variable.node);
368                                 
369                                         variable.node.support.manager.getRealm().syncExec(request);
370                                         
371                                         if (request.exception != null)
372                                                 throw new DatabaseException(request.exception);
373                                         
374                                         return request.type;
375                                 } catch (InterruptedException e) {
376                                 }
377                 }
378         }
379         
380         return getDatatypeFromValue(graph, context);
381         }
382
383 //      @SCLValue(type = "ValueAccessor")
384 //      public static ValueAccessor standardValueAccessor = new ValueAccessor() {
385 //
386 //              @Override
387 //              public Object getValue(ReadGraph graph, Variable context) throws DatabaseException {
388 //                      return standardGetValue(graph, (StandardGraphPropertyVariable)context);
389 //              }
390 //
391 //              @Override
392 //              public Object getValue(ReadGraph graph, Variable context, Binding binding) throws DatabaseException {
393 //                      return standardGetValue(graph, context, binding);
394 //              }
395 //
396 //              @Override
397 //              public void setValue(WriteGraph graph, Variable context, Object value) throws DatabaseException {
398 //                      standardSetValue(graph, context, value);
399 //              }
400 //
401 //              @Override
402 //              public void setValue(WriteGraph graph, Variable context, Object value, Binding binding) throws DatabaseException {
403 //                      standardSetValue(graph, context, value, binding);
404 //              }
405 //
406 //              @Override
407 //              public Datatype getDatatype(ReadGraph graph, Variable context) throws DatabaseException {
408 //                      return standardGetDatatype(graph, context);
409 //              }
410 //              
411 //      };
412         
413         @SCLValue(type = "ValueAccessor")
414         public static ValueAccessor standardValueAccessor = new ValueAccessor() {
415
416                 @Override
417                 public Object getValue(ReadGraph graph, Variable context) throws DatabaseException {
418                         ValueAccessor accessor = getPossibleValueValueAccessor(graph, context);
419                         if(accessor != null) return accessor.getValue(graph, context);
420                         else 
421                                 return standardGetValue1(graph, context);
422                 }
423
424                 @Override
425                 public Object getValue(ReadGraph graph, Variable context, Binding binding) throws DatabaseException {
426                         ValueAccessor accessor = getPossibleValueValueAccessor(graph, context);
427                         if(accessor != null) return accessor.getValue(graph, context, binding);
428                         else 
429                                 return standardGetValue2(graph, context, binding);
430                 }
431
432                 @Override
433                 public void setValue(WriteGraph graph, Variable context, Object value) throws DatabaseException {
434                         ValueAccessor accessor = getPossibleValueValueAccessor(graph, context);
435                         if(accessor != null) accessor.setValue(graph, context, value);
436                         else 
437                                 standardSetValue2(graph, context, value);
438                 }
439
440                 @Override
441                 public void setValue(WriteGraph graph, Variable context, Object value, Binding binding) throws DatabaseException {
442                         ValueAccessor accessor = getPossibleValueValueAccessor(graph, context);
443                         if(accessor != null) accessor.setValue(graph, context, value, binding);
444                         else 
445                                 standardSetValue3(graph, context, value, binding);
446                 }
447
448                 @Override
449                 public Datatype getDatatype(ReadGraph graph, Variable context)
450                                 throws DatabaseException {
451                         ValueAccessor accessor = getPossibleValueValueAccessor(graph, context);
452                         if(accessor != null) return accessor.getDatatype(graph, context);
453                         else 
454                                 return standardGetDatatype(graph, context);
455                 }
456                 
457         };
458
459         public static Variable getStandardChildDomainPropertyVariable(ReadGraph graph, Variable context, String name) throws DatabaseException {
460         StandardGraphChildVariable variable = (StandardGraphChildVariable)context;
461         PropertyInfo graphProperty = getPossiblePropertyInfoFromContext(graph, variable, variable.resource, name);
462         return getStandardChildDomainPropertyVariable(graph, context, graphProperty, name);
463     }
464
465     public static Resource getPossiblePropertyResource(ReadGraph graph, AbstractVariable parent, Object node) throws DatabaseException {
466         if(parent != null && parent.node != null && parent.node.node != null && parent.node.support != null) {
467             String propertyURI = getPossiblePropertyURI(parent, node);
468             if(propertyURI != null)
469                 return graph.getPossibleResource(propertyURI);
470         }
471         return null;
472     }
473
474         public static Variable getStandardChildDomainPropertyVariable(ReadGraph graph, Variable context, PropertyInfo graphProperty, String name) throws DatabaseException {
475         StandardGraphChildVariable variable = (StandardGraphChildVariable)context;
476         Object propertyNode = getPossibleNodeProperty(graph, variable, name, true);
477         if(graphProperty != null && graphProperty.builder != null)
478             return buildPropertyVariable(graph, variable, variable.resource, graphProperty, propertyNode);
479         if(propertyNode != null) {
480             // Fallback: try to ask property resource uri from NodeManager
481             return createStandardGraphPropertyVariable(graph, variable, propertyNode);
482         }
483         // Final fallback: check types corresponding to
484         // node classification(s) and look for asserted
485         // properties from the URIs specified.
486         if (variable.node != null) {
487             try {
488                 @SuppressWarnings("unchecked")
489                 Set<String> classifications = variable.node.support.manager.getClassifications(variable.node.node);
490                 if (!classifications.isEmpty()) {
491                     for (String uri : classifications) {
492                         Resource type = graph.syncRequest(
493                                 new PossibleResource(uri),
494                                 TransientCacheAsyncListener.instance());
495                         if (type == null)
496                             continue;
497                         Map<String, Pair<PropertyInfo, Resource>> pm = graph.syncRequest(
498                                 new UnescapedAssertedPropertyMapOfResource(type),
499                                 TransientCacheAsyncListener.instance());
500                         Pair<PropertyInfo, Resource> pi = pm.get(name);
501                         if (pi != null) {
502                             return new StandardAssertedGraphPropertyVariable(graph, context, null, type, pi.first.predicate, pi.second);
503                         }
504                     }
505                 }
506             } catch(NodeManagerException e) {
507                 throw new DatabaseException(e);
508             }
509         }
510         return null;
511     }
512
513     public static Map<String, Variable> getStandardChildDomainPropertyVariables(ReadGraph graph, Variable context, Map<String, Variable> map) throws DatabaseException {
514         // Get properties with null identification
515         return getStandardChildDomainPropertyVariables(graph, context, null, map);
516     }
517
518     public static Map<String, Variable> getStandardChildDomainPropertyVariables(ReadGraph graph, Variable context, String classification, Map<String, Variable> map) throws DatabaseException {
519         
520         StandardGraphChildVariable variable = (StandardGraphChildVariable)context;
521         
522         Collection<Object> nodeProperties = getPossibleNodeProperties(graph, variable);
523         if(!nodeProperties.isEmpty()) {
524
525             // Get variables for properties read from the graph
526             Map<String,PropertyInfo> graphProperties = collectPropertyInfosFromContext(graph, variable, variable.resource);
527             
528             Set<String> used = new THashSet<String>(nodeProperties.size());
529             
530             map = ensureVariableMap(map, graphProperties.size() + nodeProperties.size());
531             
532             // Process NodeManager property nodes
533             for(Object nodeProperty : nodeProperties) {
534                 String name = getNodeName(variable, nodeProperty);
535                 used.add(name);
536                 
537                 PropertyInfo graphProperty = graphProperties.get(name); 
538                 if(graphProperty != null && graphProperty.builder != null) {
539                     if (classification != null && !graphProperty.hasClassification(classification)) continue;
540                     
541                     // Combine with identically named graph property
542                     map.put(name, buildPropertyVariable(graph, variable, variable.resource, graphProperty, nodeProperty));
543                     continue;
544                 }
545                 
546                 map.put(name, createStandardGraphPropertyVariable(graph, variable, nodeProperty));
547             }
548             
549             // Process graph properties
550             for(PropertyInfo info : graphProperties.values()) {
551                 String name = info.name;
552                 if(used != null && used.contains(name)) continue;
553                 if (classification != null && !info.hasClassification(classification)) continue;
554                 if (info.builder != null) {
555                     map.put(name, buildPropertyVariable(graph, variable, variable.resource, info, null));
556                 }
557             }
558             return map;
559                 
560         } else {
561
562                 if(variable.resource == null) return map;
563
564                 // Only graph properties
565                 Collection<Resource> predicates = graph.getPredicates(variable.resource);
566                 if(predicates.isEmpty()) return map;
567                 
568                 map = ensureVariableMap(map, predicates.size());
569                 
570             // Process graph properties
571             for(Resource predicate : predicates) {
572                 
573                         PropertyInfo info = graph.isImmutable(predicate) ?
574                                         graph.syncRequest(new PropertyInfoRequest(predicate), TransientCacheAsyncListener.<PropertyInfo>instance()) :
575                                                 graph.syncRequest(new PropertyInfoRequest(predicate));
576
577                         if(!info.isHasProperty) continue;
578                                         
579                 if (classification != null && !info.hasClassification(classification)) continue;
580                 if (info.builder != null) {
581                     map.put(info.name, buildPropertyVariable(graph, variable, variable.resource, info, null));
582                 }
583                 
584             }
585             
586             return map;
587                 
588         }
589         
590      }
591         
592     @SCLValue(type = "VariableMap")
593         public static VariableMap standardChildDomainProperties = new VariableMapImpl() {
594         
595                 @Override
596                 public Variable getVariable(ReadGraph graph, Variable context, String name) throws DatabaseException {
597                 return getStandardChildDomainPropertyVariable(graph, context, name);
598                 }
599
600                 @Override
601                 public Map<String, Variable> getVariables(ReadGraph graph, Variable context, Map<String, Variable> map) throws DatabaseException {
602                     return getStandardChildDomainPropertyVariables(graph, context, map);
603                 }
604                 
605         };
606         
607     @SCLValue(type = "VariableMap")
608         public static VariableMap methodsPropertyDomainProperties = new VariableMapImpl() {
609         
610                 @Override
611                 public Variable getVariable(ReadGraph graph, Variable context, String name) throws DatabaseException {
612                         Variable parent = context.getParent(graph);
613                         Resource container = parent.getPossibleRepresents(graph);
614                         if(container == null)
615                                 return null;
616                         Map<String,Resource> methods = graph.syncRequest(new UnescapedMethodMapOfResource(container));
617                         Resource predicate = methods.get(name);
618                         if(predicate != null) {
619                                 Layer0 L0 = Layer0.getInstance(graph);
620                                 PropertyInfo info = graph.syncRequest(new PropertyInfoRequest(L0.Entity_method));
621                                 Resource value = graph.getSingleObject(container, predicate);
622                                 return new StandardGraphPropertyVariable(context, null, container, info, value);
623                         }
624                         return null;
625                 }
626
627                 @Override
628                 public Map<String, Variable> getVariables(ReadGraph graph, Variable context, Map<String, Variable> map) throws DatabaseException {
629                         Variable parent = context.getParent(graph);
630                         Resource container = parent.getPossibleRepresents(graph);
631                         if(container == null)
632                                 return Collections.emptyMap();
633                         Map<String,Resource> methods = graph.syncRequest(new UnescapedMethodMapOfResource(container));
634                         for(Map.Entry<String, Resource> entry : methods.entrySet()) {
635                                 String name = entry.getKey();
636                                 Resource predicate = entry.getValue();
637                                 Layer0 L0 = Layer0.getInstance(graph);
638                                 PropertyInfo info = graph.syncRequest(new PropertyInfoRequest(L0.Entity_method));
639                                 Resource value = graph.getSingleObject(container, predicate);
640                                 if(map == null) map = new HashMap<>();
641                                 map.put(name, new StandardGraphPropertyVariable(context, null, container, info, value));
642                         }
643                         return map;
644                 }
645                 
646         };
647
648         public static Variable getStandardPropertyDomainPropertyVariableFromValue(ReadGraph graph, Variable context, String name) throws DatabaseException {
649
650                 if(context instanceof StandardGraphPropertyVariable) {
651                 StandardGraphPropertyVariable variable = (StandardGraphPropertyVariable)context;
652                 Resource literal = variable.getPossibleRepresents(graph);
653                 Object propertyNode = getPossibleNodeProperty(graph, variable, name, false);
654
655                 if(literal != null) {
656                         Variable result = getPossiblePropertyFromContext(graph, variable, literal, name, propertyNode);
657                         if(result != null) return result;
658                 }
659                 
660                 Variable result = getPossibleSubliteralPropertyFromContext(graph, variable, name);
661                 if(result != null) return result;
662                 result = getPossiblePropertyFromContext(graph, variable, variable.property.predicate, name, propertyNode);
663                 if (result != null) return result;
664                 
665                 // Get possible property from NodeManager
666                 if (propertyNode != null)
667                         return createStandardGraphPropertyVariable(graph, variable, propertyNode);
668                 return null;
669                 } else if (context instanceof StandardGraphChildVariable) {
670                         return standardChildDomainProperties.getVariable(graph, context, name);
671                 } else {
672                         throw new DatabaseException("Unknown variable implementation " + context.getClass().getCanonicalName());
673                 }                       
674                 
675         }
676         
677         public static Map<String, Variable> getStandardPropertyDomainPropertyVariablesFromValue(ReadGraph graph, Variable context, Map<String, Variable> map) throws DatabaseException {
678
679                 if(context instanceof StandardGraphPropertyVariable) {
680                         StandardGraphPropertyVariable variable = (StandardGraphPropertyVariable)context;
681                         map = collectPropertiesFromContext(graph, variable, variable.property.predicate, map);
682                         if (variable.parentResource != null) {
683                                 Resource literal = graph.getPossibleObject(variable.parentResource, variable.property.predicate);
684                                 if(literal != null) map=collectPropertiesFromContext(graph, variable, literal, map);
685                                 map=collectSubliteralProperties(graph, variable, map);
686                         }
687
688                         // Get properties from VariableNode
689                         map = getStandardNodePropertyVariables(graph, context, map);
690                         return map;
691                 } else if (context instanceof StandardGraphChildVariable) {
692                         return standardChildDomainProperties.getVariables(graph, context, map);
693                 } else {
694                         throw new DatabaseException("Unknown variable implementation " + context.getClass().getCanonicalName());
695                 }
696                 
697         }
698         
699         public static Map<String, Variable> getStandardPropertyDomainPropertyVariablesFromValue(ReadGraph graph, Variable context, String classification, Map<String, Variable> map) throws DatabaseException {
700
701                 if(context instanceof StandardGraphPropertyVariable) {
702                         StandardGraphPropertyVariable variable = (StandardGraphPropertyVariable)context;
703                         map = collectPropertiesFromContext(graph, variable, variable.property.predicate, classification, map);
704                         if (variable.parentResource != null) {
705                                 Resource literal = graph.getPossibleObject(variable.parentResource, variable.property.predicate);
706                                 if(literal != null) map=collectPropertiesFromContext(graph, variable, literal, classification, map);
707                         }
708                         
709                         // Get properties from VariableNode
710                         map = getStandardNodePropertyVariables(graph, context, map);
711                         return map;
712                 } else if (context instanceof StandardGraphChildVariable) {
713                         return standardChildDomainProperties.getVariables(graph, context, map);
714                 } else {
715                         throw new DatabaseException("Unknown variable implementation " + context.getClass().getCanonicalName());
716                 }       
717                 
718         }       
719         
720     @SCLValue(type = "VariableMap")
721         public static VariableMap standardPropertyDomainProperties = new VariableMapImpl() {
722
723         VariableMap getValueVariableMap(ReadGraph graph, Variable context) throws DatabaseException {
724                 Resource represents = context.getPossibleRepresents(graph);
725                 if(represents == null) return null;
726                 
727                 VariableMap map = graph.isImmutable(represents) ?
728                                 graph.syncRequest(new PropertyVariableMapRequest(represents), TransientCacheListener.<VariableMap>instance()) :
729                                         (VariableMap)graph.getPossibleRelatedValue2(represents, Layer0.getInstance(graph).domainProperties, represents);
730                 
731                 if(map == standardPropertyDomainProperties) return null;
732                 else return map;
733                 
734         }
735         
736                 @Override
737                 public Variable getVariable(ReadGraph graph, Variable context, String name) throws DatabaseException {
738                         VariableMap valueMap = getValueVariableMap(graph, context);
739                         if(valueMap != null) return valueMap.getVariable(graph, context, name);
740                         return getStandardPropertyDomainPropertyVariableFromValue(graph, context, name);
741                 }
742
743                 @Override
744                 public Map<String, Variable> getVariables(ReadGraph graph, Variable context, Map<String, Variable> map) throws DatabaseException {
745                         VariableMap valueMap = getValueVariableMap(graph, context);
746                         if(valueMap != null) return valueMap.getVariables(graph, context, map);
747                         else return getStandardPropertyDomainPropertyVariablesFromValue(graph, context, map);
748                 }
749                 
750                 @Override
751                 public Map<String, Variable> getVariables(ReadGraph graph, Variable context, String classification, Map<String, Variable> map) throws DatabaseException {
752                         VariableMap valueMap = getValueVariableMap(graph, context);
753                         if(valueMap != null) return valueMap.getVariables(graph, context, classification, map);
754                         else return getStandardPropertyDomainPropertyVariablesFromValue(graph, context, classification, map);
755                 }
756                 
757         };
758
759     public static Resource getPossibleGraphChild(ReadGraph graph, Variable variable, String name) throws DatabaseException {
760         Resource resource = variable.getPossibleRepresents(graph);
761         if(resource == null) return null;
762         Map<String, Resource> graphChildren = graph.syncRequest(new UnescapedChildMapOfResource(resource));
763         return graphChildren.get(name);
764     }
765
766     public static Map<String,Resource> getPossibleGraphChildren(ReadGraph graph, Variable variable) throws DatabaseException {
767         Resource resource = variable.getPossibleRepresents(graph);
768         if(resource == null) return Collections.emptyMap();
769         return graph.syncRequest(new UnescapedChildMapOfResource(resource));
770     }
771
772     public static Object getPossibleNodeChild(ReadGraph graph, Variable variable, String name) throws DatabaseException {
773         if (!(variable instanceof AbstractVariable)) return null;
774         VariableNode<?> node = ((AbstractVariable)variable).node;
775         if(node == null) return null;
776         NodeStructure structure = Variables.requestNodeStructure(graph, node);
777         if(Variables.PENDING_NODE_STRUCTURE == structure) throw new PendingVariableException("");
778         return structure.children.get(name);
779         }
780         
781     public static Collection<Object> getPossibleNodeChildren(ReadGraph graph, Variable variable) throws DatabaseException {
782         if (!(variable instanceof AbstractVariable)) return null;
783         VariableNode<?> node = ((AbstractVariable)variable).node;
784         if(node == null) return Collections.emptyList();
785         NodeStructure structure = Variables.requestNodeStructure(graph, node);
786         if(Variables.PENDING_NODE_STRUCTURE == structure) throw new PendingVariableException("");
787         return structure.children.values();
788     }
789     
790     public static Object getPossibleNodeProperty(ReadGraph graph, Variable variable, String name, boolean throwPending) throws DatabaseException {
791         if (!(variable instanceof AbstractVariable)) return null;
792         VariableNode<?> node = ((AbstractVariable)variable).node;
793         if(node == null) return null;
794         NodeStructure structure = Variables.requestNodeStructure(graph, node);
795         if(throwPending && Variables.PENDING_NODE_STRUCTURE == structure) throw new PendingVariableException("");
796         return structure.properties.get(name);
797     }
798     
799     public static Collection<Object> getPossibleNodeProperties(ReadGraph graph, Variable variable) throws DatabaseException {
800         if (!(variable instanceof AbstractVariable)) return null;
801         VariableNode<?> node = ((AbstractVariable)variable).node;
802         if(node == null) return Collections.emptyList();
803         NodeStructure structure = Variables.requestNodeStructure(graph, node);
804         if(Variables.PENDING_NODE_STRUCTURE == structure) throw new PendingVariableException("");
805         return structure.properties.values();
806     }
807
808     @SuppressWarnings({ "rawtypes", "unchecked" })
809     public static VariableNode build(VariableNode parent, Object node) {
810         if(node == null) return null;
811         return new VariableNode(parent.support, node);
812     }
813
814     @Deprecated
815     public static Variable getStandardChildDomainChildVariable(ReadGraph graph, Variable context, String name) throws DatabaseException {
816         return StandardChildDomainChildren.getStandardChildDomainChildVariable(graph, context, name);
817     }
818
819     @Deprecated
820     public static Variable getStandardChildDomainChildVariable(ReadGraph graph, Variable context, Resource graphChild, String name) throws DatabaseException {
821         return StandardChildDomainChildren.getStandardChildDomainChildVariable(graph, context, graphChild, name);
822     }
823         
824     @Deprecated
825     public static Map<String, Variable> getStandardChildDomainChildVariables(ReadGraph graph, Variable context, Map<String, Variable> map) throws DatabaseException {
826         return StandardChildDomainChildren.getStandardChildDomainChildVariables(graph, context, map);
827     }
828
829     @Deprecated
830     public static Map<String, Variable> getStandardChildDomainChildVariables(ReadGraph graph, Variable context, Map<String,Resource> graphChildren, Map<String, Variable> map) throws DatabaseException {
831         return StandardChildDomainChildren.getStandardChildDomainChildVariables(graph, context, graphChildren, map);
832     }
833     
834     /**
835      * Get a map of child Variables from a node manager-based Variable, combined with the existing variables in #map.
836      * @param graph  The read graph.
837      * @param context  The parent Variable.
838      * @param map  A map of variables into which the new variables are merged.
839      * @return  A map from variable names to instances
840      * @throws DatabaseException
841      */
842     public static Map<String, Variable> getStandardNodeChildVariables(ReadGraph graph, Variable context, Map<String, Variable> map) throws DatabaseException {
843         AbstractVariable variable = (AbstractVariable)context;
844         if (variable.node == null) return map;
845         
846         Collection<Object> nodeChildren = getPossibleNodeChildren(graph, variable);
847         if (nodeChildren.isEmpty()) return map;
848         
849         map = ensureVariableMap(map, nodeChildren.size());
850
851         for(Object nodeChild : nodeChildren) {
852             String name = getNodeName(variable, nodeChild);
853             if (!map.containsKey(name))
854                 map.put(name, createStandardGraphChildVariable(variable, nodeChild));
855         }
856
857         return map;
858     }
859
860     /**
861      * Get a map of property Variables from a node manager-based Variable, combined with the existing variables in #map.
862      * @param graph  The read graph.
863      * @param context  The parent Variable.
864      * @param map  A map of variables into which the new variables are merged.
865      * @return  A map from variable names to instances
866      * @throws DatabaseException
867      */
868     public static Map<String, Variable> getStandardNodePropertyVariables(ReadGraph graph, Variable context, Map<String, Variable> map) throws DatabaseException {
869         AbstractVariable variable = (AbstractVariable)context;
870         if (variable.node == null) return map;
871         
872         Collection<Object> nodeProperties = getPossibleNodeProperties(graph, variable);
873         if (nodeProperties.isEmpty()) return map;
874         
875         map = ensureVariableMap(map, nodeProperties.size());
876
877         for(Object nodeProperty : nodeProperties) {
878             String name = getNodeName(variable, nodeProperty);
879             if (!map.containsKey(name)) {
880                 map.put(name, createStandardGraphPropertyVariable(graph, variable, nodeProperty));
881             }
882         }
883
884         return map;
885     }    
886
887         @SCLValue(type = "VariableMap")
888         public static VariableMap standardChildDomainChildren = new VariableMapImpl() {
889
890                 @Override
891                 public Variable getVariable(ReadGraph graph, Variable context, String name) throws DatabaseException {
892                         return StandardChildDomainChildren.getStandardChildDomainChildVariable(graph, context, name);
893                 }
894
895                 @Override
896                 public Map<String, Variable> getVariables(ReadGraph graph, Variable context, Map<String, Variable> map) throws DatabaseException {
897                     return StandardChildDomainChildren.getStandardChildDomainChildVariables(graph, context, map);
898                 }
899                 
900         };
901
902     @SCLValue(type = "VariableMap")
903         public static VariableMap standardPropertyDomainChildren = new VariableMapImpl() {
904
905         /**
906          * Get a possible non-standard VariableMap defined in the graph.
907          * @param graph  The graph
908          * @param context  The context node
909          * @return  A non-standard VariableMap instance for the context node,
910          *          or null, if not defined or defined as this instance.
911          * @throws DatabaseException
912          */
913         VariableMap getValueVariableMap(ReadGraph graph, Variable context) throws DatabaseException {
914                 Resource represents = context.getPossibleRepresents(graph);
915                 if(represents == null) return null;
916                         VariableMap map = graph.syncRequest(new ChildVariableMapRequest(represents));
917                 if(map == standardPropertyDomainChildren) return null;
918                 else return map;
919         }
920         
921                 @Override
922                 public Variable getVariable(ReadGraph graph, Variable context, String name) throws DatabaseException {
923                         // Delegate call to a non-standard variable map?
924                         VariableMap valueMap = getValueVariableMap(graph, context);
925                         if(valueMap != null) return valueMap.getVariable(graph, context, name);
926                         
927                         if(context instanceof StandardGraphPropertyVariable) {
928                                 StandardGraphPropertyVariable variable = (StandardGraphPropertyVariable)context;
929                                 Datatype dt = variable.getDatatype(graph);
930                                 if (dt instanceof ArrayType) {
931                                         ChildReference ref = getPossibleIndexReference(name);
932                                         if (ref != null)
933                                                 return new SubliteralPropertyVariableDeprecated(variable, ref);
934                                 }
935                                 
936                                 // Check for a child node provided by the NodeManager
937                                 if (variable.node != null) {
938                                         Object childNode = getPossibleNodeChild(graph, variable, name);
939                                         if (childNode != null)
940                                                 return createStandardGraphChildVariable(variable, childNode);
941                                 }
942                                 return standardChildDomainChildren.getVariable(graph, context, name);
943                         } else if (context instanceof StandardGraphChildVariable) {
944                                 return standardChildDomainChildren.getVariable(graph, context, name);
945                         } else {
946                                 throw new DatabaseException("Unknown variable implementation " + context.getClass().getCanonicalName());
947                         }
948                 }
949
950                 @Override
951                 public Map<String, Variable> getVariables(ReadGraph graph, Variable context, Map<String, Variable> map) throws DatabaseException {
952                         // Delegate call to a non-standard variable map?
953                         VariableMap valueMap = getValueVariableMap(graph, context);
954                         if(valueMap != null) return valueMap.getVariables(graph, context, map);
955                         
956                         if(context instanceof StandardGraphPropertyVariable) {
957                                 // Get child variables provided by the NodeManager
958                                 Map<String, Variable> result = getStandardNodeChildVariables(graph, context, map); 
959                                 return standardChildDomainChildren.getVariables(graph, context, result);
960                         } else if (context instanceof StandardGraphChildVariable) {
961                                 return standardChildDomainChildren.getVariables(graph, context, map);
962                         } else {
963                                 throw new DatabaseException("Unknown variable implementation " + context.getClass().getCanonicalName());
964                         }       
965                 }
966                 
967         };
968         
969         protected static ChildReference getPossibleIndexReference(String name) {
970                 if (name.startsWith("i-")) {
971                     try {
972                         int index = Integer.parseInt(name.substring(2));
973                         return new IndexReference(index);
974                     } catch (NumberFormatException e) {}
975                 }
976                 return null;
977         }
978
979         protected static ValueAccessor getPossiblePropertyValueAccessor(ReadGraph graph, StandardGraphPropertyVariable variable) throws DatabaseException {
980             if(variable.property == null) return null;
981             return variable.property.valueAccessor;
982 //        return graph.syncRequest(new PropertyValueAccessorRequest(variable.property), TransientCacheAsyncListener.<ValueAccessor>instance());
983 //              return graph.syncRequest(new PossibleRelatedValueImplied2<ValueAccessor>(variable.property, Layer0.getInstance(graph).valueAccessor));
984         }
985
986         public static ValueAccessor getPossibleValueValueAccessor(ReadGraph graph, Variable variable) throws DatabaseException {
987             Resource value = variable.getPossibleRepresents(graph);
988             if(value == null) return null;
989             //return graph.syncRequest(new PropertyValueAccessorRequest(value));
990                 return graph.syncRequest(new PossibleRelatedValueImplied2<ValueAccessor>(value, Layer0.getInstance(graph).valueAccessor));      
991         }
992         
993         public static PropertyInfo getPossiblePropertyInfoFromContext(ReadGraph graph, Variable variable, Resource context, String name) throws DatabaseException {
994             if(context == null) return null;
995                 Map<String, PropertyInfo> predicates = graph.syncRequest(new UnescapedPropertyMapOfResource(context));
996                 return predicates.get(name);
997         }
998
999     public static Variable getPossiblePropertyFromContext(ReadGraph graph, Variable variable, Resource context, String name, Object propertyNode) throws DatabaseException {
1000         PropertyInfo info = getPossiblePropertyInfoFromContext(graph, variable, context, name);
1001         if(info == null || info.builder == null) return null;
1002         return buildPropertyVariable(graph, variable, context, info, propertyNode);
1003     }
1004     
1005     public static Variable getPossibleSubliteralPropertyFromContext(ReadGraph graph, StandardGraphPropertyVariable variable, String name) throws DatabaseException {
1006         
1007                 Resource predicate = variable.property.predicate;
1008                 if(predicate == null) return null;
1009
1010         PropertyInfo info = getPropertyInfo(graph, predicate);
1011         Pair<Resource, ChildReference> p = info.subliteralPredicates.get(name);
1012         if(p == null) return null;
1013         
1014                 return new SubliteralPropertyVariable(graph, variable, p.first, p.second);
1015         
1016     }
1017
1018     public static Map<String, PropertyInfo> collectPropertyInfosFromContext(ReadGraph graph, Variable variable, Resource context) throws DatabaseException {
1019         if(context == null) return Collections.emptyMap();
1020                 return graph.isImmutable(context) ?
1021                                 graph.syncRequest(new UnescapedPropertyMapOfResource(context), TransientCacheAsyncListener.<Map<String,PropertyInfo>>instance()) :
1022                                 graph.syncRequest(new UnescapedPropertyMapOfResource(context));
1023     }
1024
1025         public static Map<String, Variable> collectPropertiesFromContext(ReadGraph graph, Variable variable, Resource context, Map<String, Variable> map) throws DatabaseException {
1026
1027                 Map<String,PropertyInfo> properties = graph.isImmutable(context) ?
1028                                 graph.syncRequest(new UnescapedPropertyMapOfResource(context), TransientCacheAsyncListener.<Map<String,PropertyInfo>>instance()) :
1029                                 graph.syncRequest(new UnescapedPropertyMapOfResource(context));
1030                                 
1031                 if(properties.isEmpty()) return map;
1032                 
1033                 map = ensureVariableMap(map, properties.size());
1034                 
1035                 for(PropertyInfo info : properties.values()) {
1036                         String name = info.name;
1037                         if (info.builder != null) {
1038                                 Variable v = info.builder.buildProperty(graph, variable, null, context, info.predicate);
1039                                 map.put(name, v);
1040                         }
1041                 }
1042                 
1043                 return map;
1044                 
1045         }
1046
1047         public static Map<String, Variable> collectSubliteralProperties(ReadGraph graph, StandardGraphPropertyVariable variable, Map<String, Variable> map) throws DatabaseException {
1048
1049                 Resource predicate = variable.property.predicate;
1050                 if(predicate == null) return map;
1051                 
1052                 PropertyInfo info = getPropertyInfo(graph, predicate);
1053                 if(info.subliteralPredicates.isEmpty()) return map;
1054                 
1055                 map = ensureVariableMap(map, info.subliteralPredicates.size());
1056                 
1057                 for(Map.Entry<String, Pair<Resource, ChildReference>> entry : info.subliteralPredicates.entrySet()) {
1058                         String key = entry.getKey();
1059                         Pair<Resource, ChildReference> p = entry.getValue();
1060                         if(map == null) map = new THashMap<String,Variable>();
1061                         map.put(key, new SubliteralPropertyVariable(graph, variable, p.first, p.second));
1062                 }
1063         
1064         return map;
1065                 
1066         }
1067
1068         public static Map<String, Variable> collectPropertiesFromContext(ReadGraph graph, Variable variable, Resource context, String classification, Map<String, Variable> map) throws DatabaseException {
1069
1070                 if(graph.isImmutable(context)) {
1071
1072                         Map<String,PropertyInfo> properties = graph.syncRequest(new UnescapedPropertyMapOfResource(context), TransientCacheAsyncListener.<Map<String,PropertyInfo>>instance());
1073                         for(PropertyInfo info : properties.values()) {
1074
1075                                 if(info.classifications.contains(classification) && info.builder != null) {
1076                                         String name = info.name;
1077                                         Variable v = info.builder.buildProperty(graph, variable, null, context, info.predicate);
1078                                         if(map == null) map = new THashMap<String,Variable>();
1079                                         map.put(name, v);
1080                                 }
1081
1082                         }
1083
1084                 } else {
1085                                 
1086                         Collection<Resource> predicates = graph.getPredicates(context);
1087                                         
1088                         if(predicates.isEmpty()) return map;
1089                         
1090                         map = ensureVariableMap(map, predicates.size());
1091                 
1092                         for(Resource predicate : predicates) {
1093                                 
1094                                 PropertyInfo info = graph.isImmutable(predicate) ?
1095                                                 graph.syncRequest(new PropertyInfoRequest(predicate), TransientCacheAsyncListener.<PropertyInfo>instance()) :
1096                                                         graph.syncRequest(new PropertyInfoRequest(predicate));
1097                                                 
1098                                 if(!info.isHasProperty) continue;
1099         
1100                                 if(info.classifications.contains(classification) && info.builder != null) {
1101                                         String name = info.name;
1102                                         Variable v = info.builder.buildProperty(graph, variable, null, context, info.predicate);
1103                                         if(map == null) map = new THashMap<String,Variable>();
1104                                         map.put(name, v);
1105                                 }
1106                                 
1107                         }
1108                         
1109                 }
1110                 
1111                 return map;
1112                 
1113         }       
1114         
1115     @SCLValue(type = "ReadGraph -> Resource -> a -> String")
1116     public static String entityLabel(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
1117         if(context instanceof Resource) {
1118                 return NameUtils.getSafeLabel(graph, ((Resource)context));      
1119         } else if (context instanceof Variable) {
1120                 Variable parent = ((Variable)context).getParent(graph);
1121                 Resource represents = parent.getRepresents(graph);
1122                 return NameUtils.getSafeLabel(graph, represents);
1123         } else {
1124                 throw new DatabaseException("Unknown context " + context);
1125         }
1126     }
1127
1128     @SCLValue(type = "ReadGraph -> Resource -> a -> b")
1129     public static Object listResources(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
1130         return ListUtils.toList(graph, resource);
1131     }
1132
1133     @SCLValue(type = "ReadGraph -> Resource -> Variable -> [String]")
1134     public static List<String> standardClassifications(ReadGraph graph, Resource resource, Variable context) throws DatabaseException {
1135         ArrayList<String> result = new ArrayList<String>();
1136         Resource predicate = context.getParent(graph).getPossiblePredicateResource(graph);
1137         if(predicate != null) {
1138                 for(Resource type : graph.getTypes(predicate)) {
1139                         String uri = graph.getPossibleURI(type);
1140                         if(uri != null) result.add(uri);
1141                 }
1142         }
1143         return result;
1144     }
1145
1146     @SCLValue(type = "ReadGraph -> Resource -> a -> Boolean")
1147     public static Boolean standardValidValue(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
1148         return Boolean.TRUE;
1149     }
1150
1151     @SCLValue(type = "ReadGraph -> Resource -> a -> StringInputValidator")
1152     public static StringInputValidator standardValidator(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
1153         return StringInputValidator.PASS;
1154     }
1155
1156     @SCLValue(type = "ReadGraph -> Resource -> a -> Boolean")
1157     public static Boolean standardRequiredValue(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
1158         return Boolean.FALSE;
1159     }
1160
1161     @SCLValue(type = "ReadGraph -> Resource -> Variable -> Boolean")
1162     public static Boolean standardDefaultValue(ReadGraph graph, Resource resource, Variable context) throws DatabaseException {
1163         Variable property = context.getParent(graph);
1164         if(property instanceof StandardGraphPropertyVariable) {
1165                 StandardGraphPropertyVariable variable = (StandardGraphPropertyVariable)property;
1166                 if (variable.parentResource != null) {
1167                         Statement stm = graph.getPossibleStatement(variable.parentResource, variable.property.predicate);
1168                         return stm != null && stm.isAsserted(variable.parentResource);
1169                         }
1170         }
1171         return Boolean.FALSE;
1172     }
1173
1174     @SCLValue(type = "ReadGraph -> Resource -> a -> Boolean")
1175     public static Boolean standardReadOnlyValue(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
1176         return Boolean.FALSE;
1177     }
1178
1179     @SCLValue(type = "ReadGraph -> Resource -> a -> b")
1180     public static Object resourceAsValue(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
1181         return resource;
1182     }
1183     
1184     @SCLValue(type = "ReadGraph -> Resource -> a -> b")
1185     public static Object functionApplication(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
1186         return Functions.exec(graph, resource, graph, resource, context);
1187     }
1188
1189     @SCLValue(type = "ReadGraph -> Resource -> a -> b")
1190     public static Object computeExpression(ReadGraph graph, Resource converter, Object context) throws DatabaseException {
1191         if(context instanceof Variable) {
1192             return CompileValueRequest.compileAndEvaluate(graph, (Variable)context);
1193         } if (context instanceof Resource) {
1194             return CompileResourceValueRequest.compileAndEvaluate(graph, (Resource)converter);
1195         } else {
1196                 throw new IllegalStateException("Unknown context " + context);
1197         }
1198     }
1199
1200     @SCLValue(type = "ReadGraph -> Resource -> a -> b")
1201     public static Object composedPropertyValue(ReadGraph graph, Resource converter, Object context) throws DatabaseException {
1202         if(context instanceof Variable) {
1203                 return new StandardComposedProperty();
1204         } if (context instanceof Resource) {
1205                 return new StandardComposedProperty();
1206         } else {
1207                 throw new IllegalStateException("Unknown context " + context);
1208         }
1209     }
1210     
1211     @SCLValue(type = "ReadGraph -> Resource -> a -> b")
1212     public static Object numberInputValidator(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
1213         
1214         class Validator extends FunctionImpl1<String, String> {
1215
1216             private final Datatype datatype;
1217             
1218             public Validator(Datatype datatype) {
1219                 this.datatype = datatype;
1220             }
1221             
1222             @Override
1223             public String apply(String input) {
1224                 
1225                 if(datatype == null) return null;
1226                 
1227                 try {
1228
1229                     if(datatype instanceof NumberType) {
1230                         
1231                         Number number = (Number)PrimitiveValueParser.parse(input, datatype);
1232                         NumberType nt = (NumberType)datatype;
1233                         Range r = nt.getRange();
1234                         if(r != null) {
1235                             if(!r.contains(number)) return "Value is out of valid range";
1236                         }
1237                     }
1238                     return null;
1239                     
1240                 } catch (NumberFormatException e) {
1241                     return "Not a valid floating-point number";
1242                 } catch (IllegalArgumentException e) {
1243                     return "Not a valid floating-point number";
1244                 }
1245                 
1246             }
1247             
1248         }
1249
1250         if(context instanceof Variable) {
1251             
1252             Variable variable = (Variable)context;
1253             Variable property = variable.getParent(graph);
1254             Datatype datatype = property.getPossibleDatatype(graph);
1255             return new Validator(datatype);
1256             
1257         } else if (context instanceof Resource) {
1258
1259             Layer0 L0 = Layer0.getInstance(graph);
1260             Resource literal = (Resource)context;
1261             Datatype datatype = graph.getRelatedValue(literal, L0.HasDataType, Bindings.getBindingUnchecked(Datatype.class));
1262             return new Validator(datatype);
1263             
1264         } else {
1265             
1266             return new Validator(null);
1267             
1268         }
1269         
1270     }
1271     
1272     @SCLValue(type = "ReadGraph -> Resource -> a -> b")
1273     public static Object booleanInputValidator(ReadGraph graph, Resource resource, Object context) throws DatabaseException {
1274         
1275         return new FunctionImpl1<String, String>() {
1276
1277             @Override
1278             public String apply(String input) {
1279                 
1280                 String lower = input.toLowerCase();
1281                 if("true".equals(lower) || "false".equals(lower)) return null;
1282
1283                 return "Not a valid boolean: " + input;
1284                 
1285             }
1286             
1287         };
1288         
1289     }
1290
1291     @SCLValue(type = "ReadGraph -> Resource -> Variable -> Resource")
1292     public static Resource hasStandardResource(ReadGraph graph, Resource resource, Variable context) throws DatabaseException {
1293         Variable parent = context.getParent(graph);
1294         if(parent instanceof StandardGraphChildVariable) {
1295                 StandardGraphChildVariable variable = (StandardGraphChildVariable)parent;
1296                 return variable.resource;
1297         }
1298         return null;
1299     }
1300
1301
1302     @SCLValue(type = "ReadGraph -> Resource -> Variable -> a")
1303         public static Object valueWithoutBinding(ReadGraph graph, Resource converter, Variable context) throws DatabaseException {
1304
1305         StandardGraphPropertyVariable variable = (StandardGraphPropertyVariable)context;
1306                 
1307                 if(graph.sync(new IsEnumeratedValue(variable.getRepresents(graph)))) {
1308                         Layer0 L0 = Layer0.getInstance(graph);
1309                         return graph.getRelatedValue2(variable.getRepresents(graph), L0.HasLabel);
1310                 }
1311
1312                 if (variable.parentResource == null)
1313                         throw new InvalidVariableException("Variable is not represented by any resource (URI=" + variable.getPossibleURI(graph) + ").");
1314
1315                 try {
1316                         return graph.getRelatedValue2(variable.parentResource, variable.property.predicate, variable);
1317                 } catch (NoSingleResultException e) {
1318                         throw new MissingVariableValueException(variable.getPossibleURI(graph), e);
1319                 } catch (DoesNotContainValueException e) {
1320                         throw new MissingVariableValueException(variable.getPossibleURI(graph), e);
1321                 }
1322                 
1323         }
1324
1325     @SCLValue(type = "ReadGraph -> Variable -> Binding -> a")
1326         public static Object valueWithBinding(ReadGraph graph, Variable context, Binding binding) throws DatabaseException {
1327
1328         StandardGraphPropertyVariable variable = (StandardGraphPropertyVariable)context;
1329                 
1330                 if(graph.sync(new IsEnumeratedValue(variable.getRepresents(graph)))) {
1331                         Layer0 L0 = Layer0.getInstance(graph);
1332                         return graph.getRelatedValue2(variable.getRepresents(graph), L0.HasLabel, binding);
1333                 }
1334
1335                 if (variable.parentResource == null)
1336                         throw new MissingVariableException("Variable is not represented by any resource (URI=" + variable.getPossibleURI(graph) + ").", context.getPossibleRepresents(graph));
1337
1338                 try {
1339                         return graph.getRelatedValue2(variable.parentResource, variable.property.predicate, variable);
1340                 } catch (NoSingleResultException e) {
1341                         throw new MissingVariableValueException(variable.getPossibleURI(graph), e);
1342                 } catch (DoesNotContainValueException e) {
1343                         throw new MissingVariableValueException(variable.getPossibleURI(graph), e);
1344                 }
1345                 
1346         }
1347
1348     @SCLValue(type = "WriteGraph -> Variable -> a -> Binding -> b")
1349         public static Object valueSetterWithBinding(WriteGraph graph, Variable variable, Object value, Binding binding) throws DatabaseException {
1350                 
1351                 Function4<WriteGraph, Variable, Object, Object, String> modifier = variable.getPossiblePropertyValue(graph, Variables.INPUT_MODIFIER);
1352                 if(modifier == null) modifier = VariableUtils.defaultInputModifier; 
1353                 modifier.apply(graph, variable, value, binding);
1354                 return null;
1355                 
1356         }
1357     
1358     static class L0Issue extends StandardIssue {
1359         
1360         private final String description;
1361         
1362         public L0Issue(String description, Resource type, Resource ... contexts) {
1363             super(type, contexts);
1364             this.description = description;
1365         }
1366
1367         @Override
1368         public Resource write(WriteGraph graph, Resource source) throws DatabaseException {
1369             Layer0 L0 = Layer0.getInstance(graph);
1370             IssueResource IR = IssueResource.getInstance(graph);
1371             Resource issue = super.write(graph, source);
1372             graph.claim(issue, IR.Issue_HasSeverity, IR.Severity_Fatal);
1373             graph.addLiteral(issue, L0.HasDescription, L0.HasDescription_Inverse, description, Bindings.STRING);
1374             return issue;
1375         }
1376         
1377     }
1378     
1379         private static List<Issue> reportInconsistency(ReadGraph graph, Resource subject, String description, List<Issue> issues) throws DatabaseException {
1380             if(issues == null) issues = new ArrayList<Issue>();
1381                 System.err.println("Change set validation reports the following issue: " + NameUtils.getSafeName(graph, subject, true) + ": " + description);
1382                 IssueResource IR = IssueResource.getInstance(graph);
1383                 issues.add(new L0Issue(description, IR.Issue, subject));
1384                 return issues;
1385         }
1386     
1387     @SCLValue(type = "ReadGraph -> Resource -> [Issue]")
1388     public static List<Issue> relationValidator(ReadGraph graph, Resource resource) throws DatabaseException {
1389
1390         Layer0 L0 = Layer0.getInstance(graph);
1391
1392         List<Issue> issues = null;
1393         
1394         for(Statement stm : graph.getStatements(resource, L0.IsWeaklyRelatedTo)) {
1395                 Resource predicate = stm.getPredicate();
1396                 Resource object = stm.getObject();
1397                 if(!isRelation(graph, L0, predicate)) {
1398                         issues = reportInconsistency(graph, resource, "The predicate of a statement must be a relation: " + NameUtils.toString(graph, stm), issues);
1399                 }
1400                 if(graph.isInstanceOf(predicate, L0.FunctionalRelation)) {
1401                         if(graph.getObjects(resource, predicate).size() > 1)
1402                                 issues = reportInconsistency(graph, resource, 
1403                                                 "Relation " +
1404                                                                 NameUtils.getSafeName(graph, predicate)
1405                                                                 + " is functional.", issues);
1406                 }
1407                 {
1408                         Collection<Resource> domain = graph.getObjects(predicate, L0.HasDomain);
1409                         if (!isInstanceOfAny(graph, resource, domain, true)) {
1410                                 StringBuilder sb = new StringBuilder()
1411                                 .append("The domain of ")
1412                                 .append(NameUtils.getSafeName(graph, predicate))
1413                                 .append(" relation is ");
1414                                 orString(graph, sb, domain).append(".");
1415                                 issues = reportInconsistency(graph, resource, sb.toString(), issues);
1416                         }
1417                 }
1418                 {
1419                         Collection<Resource> range = graph.getObjects(predicate, L0.HasRange);
1420                         if (!isInstanceOfAny(graph, object, range, true) && !graph.isInstanceOf(object, L0.SCLValue)) {
1421                                 StringBuilder sb = new StringBuilder()
1422                                 .append("The range of ")
1423                                 .append(NameUtils.getSafeName(graph, predicate))
1424                                 .append(" relation is ");
1425                                 orString(graph, sb, range).append(" but current object is ")
1426                                 .append(NameUtils.getSafeName(graph, object)).append(".");
1427                                 issues = reportInconsistency(graph, resource, sb.toString(), issues);
1428                         }
1429                 }               
1430         }
1431                 
1432                 return issues != null ? issues : Collections.<Issue>emptyList();
1433
1434     }
1435
1436     @SCLValue(type = "ReadGraph -> Resource -> [Issue]")
1437     public static List<Issue> propertyValidator(ReadGraph graph, Resource resource) throws DatabaseException {
1438
1439         List<Issue> issues = null;
1440
1441         Layer0 L0 = Layer0.getInstance(graph);
1442         for(Statement stm : graph.getStatements(resource, L0.HasProperty)) {
1443                 Resource subject = stm.getSubject();
1444                 Resource predicate = stm.getPredicate();
1445                 String error = L0Validations.checkValueType(graph, subject, predicate);
1446                 if(error != null) issues = reportInconsistency(graph, subject, error, issues);
1447         }
1448                 
1449         return issues != null ? issues : Collections.<Issue>emptyList();
1450
1451     }
1452     
1453     
1454     @SCLValue(type = "ReadGraph -> Resource -> [Issue]")
1455     public static List<Issue> valueValidator(ReadGraph graph, Resource resource) throws DatabaseException {
1456
1457         List<Issue> issues = null;
1458
1459         Layer0 L0 = Layer0.getInstance(graph);
1460         if(graph.hasValue(resource)) {
1461                 if(!graph.isInstanceOf(resource, L0.Literal)) {
1462                         issues = reportInconsistency(graph, resource, 
1463                                         "Resource has a value but it is not a literal.", issues);
1464                 }
1465                 else {
1466                         // TODO check that the value is valid for the data type
1467                 }
1468         }
1469         else {
1470                 if(graph.isInstanceOf(resource, L0.Literal)) {
1471                         issues = reportInconsistency(graph, resource, 
1472                                         "Resource is a literal but it does not have a value.", issues);
1473                 }
1474         }
1475         
1476         return issues != null ? issues : Collections.<Issue>emptyList();
1477         
1478     }
1479
1480     
1481     @SCLValue(type = "ReadGraph -> Resource -> [Issue]")
1482     public static List<Issue> uriValidator(ReadGraph graph, Resource resource) throws DatabaseException {
1483         
1484         List<Issue> issues = null;
1485
1486         Layer0 L0 = Layer0.getInstance(graph);
1487         Resource parent = graph.getPossibleObject(resource, L0.PartOf);
1488         if(parent != null) {
1489             String parentURI = graph.syncRequest(new PossibleURI(parent));
1490             if(parentURI != null) {
1491                         String name = graph.getPossibleRelatedValue(resource, L0.HasName);
1492                         if(name == null) {
1493                                 issues = reportInconsistency(graph, resource, "Resource has a parent with URI but has no valid HasName.", issues);
1494                         }
1495             }
1496         }
1497
1498         return issues != null ? issues : Collections.<Issue>emptyList();
1499         
1500     }
1501     
1502     private static Resource getPossibleNearestClusterSet(ReadGraph graph, Resource base, Resource resource) throws DatabaseException {
1503
1504         ClusteringSupport cs = graph.getService(ClusteringSupport.class);
1505         if(cs.isClusterSet(resource) && !base.equals(resource)) return resource;
1506         
1507         Resource nearest = NearestOwnerFinder.getNearestOwner(graph, resource);
1508         if(nearest == null) return null;
1509         
1510         return getPossibleNearestClusterSet(graph, base, nearest);
1511
1512     }
1513
1514     private static boolean quirks(ReadGraph graph, Resource resource) throws DatabaseException {
1515
1516         if(!resource.isPersistent()) return true;
1517         if(graph.isImmutable(resource)) return true;
1518         if(resource.getResourceId() < 0x2000) return true;
1519
1520         return false;
1521         
1522     }
1523     
1524     @SCLValue(type = "ReadGraph -> Resource -> [Issue]")
1525     public static List<Issue> clusterValidator(ReadGraph graph, Resource resource) throws DatabaseException {
1526
1527         if(!Development.DEVELOPMENT) return Collections.<Issue>emptyList();
1528         
1529         if(quirks(graph, resource)) return Collections.<Issue>emptyList();
1530         
1531         List<Issue> issues = null;
1532
1533         ClusteringSupport cs = graph.getService(ClusteringSupport.class);
1534         Resource set = cs.getClusterSetOfCluster(resource);
1535         
1536         if(set == null) return reportInconsistency(graph, resource, "Resource cluster is not part of any cluster set", issues);
1537         
1538         Resource nearestSet = getPossibleNearestClusterSet(graph, resource, resource);
1539         if(nearestSet == null) {
1540                 // This means that there is no owner since RootLibrary is a cluster set
1541                 return Collections.<Issue>emptyList();
1542         }
1543         
1544         if(!set.equals(nearestSet)) return reportInconsistency(graph, resource, "The cluster set of a resource is not the nearest owner set", issues);
1545
1546         return Collections.<Issue>emptyList();
1547         
1548     }
1549
1550     private static boolean isInstanceOfAny(ReadGraph graph, Resource r, Collection<Resource> types, boolean ifEmpty) throws DatabaseException {
1551                 if (types.isEmpty())
1552                         return ifEmpty;
1553                 for (Resource type : types) {
1554                         if (graph.isInstanceOf(r, type)) {
1555                                 return true;
1556                         }
1557                 }
1558                 return false;
1559         }
1560
1561         private static StringBuilder orString(ReadGraph graph, StringBuilder sb, Collection<Resource> rs) throws DatabaseException {
1562                 sb.append("(");
1563                 boolean first = true;
1564                 for (Resource r : rs) {
1565                         if (!first)
1566                                 sb.append(" | ");
1567                         first = false;
1568                         sb.append(NameUtils.getSafeName(graph, r));
1569                 }
1570                 sb.append(")");
1571                 return sb;
1572         }
1573
1574     public static boolean isRelation(ReadGraph g, Layer0 l0, Resource relation) throws DatabaseException {
1575                 return g.hasStatement(relation, l0.SubrelationOf) || relation == l0.IsWeaklyRelatedTo;
1576         }
1577         
1578         public static boolean isType(ReadGraph g, Layer0 l0, Resource type) throws DatabaseException {
1579                 return g.hasStatement(type, l0.Inherits) || type == l0.Entity;
1580         }
1581         
1582     public static Variable buildChildVariable(ReadGraph graph, Variable context, Resource graphChild, Object nodeChild) throws DatabaseException {
1583         VariableBuilder builder = graph.adapt(graphChild, VariableBuilder.class);
1584         return builder.buildChild(graph, context, build(((AbstractVariable)context).node, nodeChild), graphChild);
1585         }
1586
1587         private static Variable buildPropertyVariable(ReadGraph graph, Variable variable, Resource parentResource, PropertyInfo graphProperty, Object propertyNode) throws DatabaseException {
1588                 VariableNode<?> node = variable instanceof AbstractVariable ? build(((AbstractVariable)variable).node, propertyNode) : null;
1589                 return graphProperty.builder.buildProperty(graph, variable, node, parentResource, graphProperty.predicate);
1590         }
1591         
1592         static StandardGraphChildVariable createStandardGraphChildVariable(
1593                         AbstractVariable parent, Object child) {
1594                 return new StandardGraphChildVariable(parent, build(parent.node, child), null);
1595         }
1596
1597         private static StandardGraphPropertyVariable createStandardGraphPropertyVariable(
1598                         ReadGraph graph, AbstractVariable variable, Object nodeProperty) throws DatabaseException {
1599         Resource propertyResource = getPossiblePropertyResource(graph, variable, nodeProperty);
1600         return new StandardGraphPropertyVariable(graph, variable, build(variable.node, nodeProperty), null, propertyResource);
1601         }
1602         
1603         static Map<String, Variable> ensureVariableMap(
1604                         Map<String, Variable> map, int size) {
1605                 if(map == null) map = new THashMap<String,Variable>(size);
1606                 return map;
1607         }
1608
1609         private static PropertyInfo getPropertyInfo(ReadGraph graph, Resource predicate) throws DatabaseException {
1610                 return graph.syncRequest(new PropertyInfoRequest(predicate));
1611         }
1612
1613         @SuppressWarnings("unchecked")
1614         static String getNodeName(AbstractVariable parent, Object child) {
1615                 return parent.node.support.manager.getName(child);
1616         }
1617
1618         @SuppressWarnings("unchecked")
1619         private static Object getNodeValue(final AbstractVariable variable, final Binding binding) throws NodeManagerException, BindingException {
1620                 return variable.node.support.manager.getValue(variable.node.node, binding);
1621         }
1622
1623         @SuppressWarnings("unchecked")
1624         private static void setNodeValue(final AbstractVariable variable, final Object value, final Binding binding) throws NodeManagerException, BindingException {
1625                 variable.node.support.manager.setValue(variable.node.node, value, binding);
1626         }
1627         
1628         @SuppressWarnings("unchecked")
1629         private static String getPossiblePropertyURI(AbstractVariable parent, Object node) {
1630                 return parent.node.support.manager.getPropertyURI(parent.node.node, node);
1631         }
1632     
1633
1634     @SCLValue(type = "ReadGraph -> Resource -> Variable -> a")
1635     public static Object defaultInstantiateUnder(ReadGraph graph, Resource converter, Variable context) throws DatabaseException {
1636         return new FunctionImpl2<Resource, Resource, Resource>() {
1637             public Resource apply(Resource container, Resource type) {
1638                 try {
1639                     WriteGraph graph = (WriteGraph)SCLContext.getCurrent().get("graph");
1640
1641                     Layer0 L0 = Layer0.getInstance(graph);
1642                     CommonDBUtils.selectClusterSet(graph, container);
1643                     Resource result = graph.newResource();
1644                     String name = NameUtils.findFreshInstanceName(graph, type, container);
1645                     graph.claim(result, L0.InstanceOf, type);
1646                     graph.addLiteral(result, L0.HasName, L0.NameOf, name, Bindings.STRING);
1647                     graph.claim(container, L0.ConsistsOf, L0.PartOf, result);
1648
1649                     return result;
1650                 } catch (DatabaseException e) {
1651                     throw new RuntimeDatabaseException(e);
1652                 }
1653             }
1654         };
1655     }
1656
1657 }