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