]> gerrit.simantics Code Review - simantics/platform.git/blob - bundles/org.simantics.db.layer0/src/org/simantics/db/layer0/variable/Variables.java
Index query fixes after commit 4e7fd7de
[simantics/platform.git] / bundles / org.simantics.db.layer0 / src / org / simantics / db / layer0 / variable / Variables.java
1 /*******************************************************************************
2  * Copyright (c) 2007, 2010 Association for Decentralized Information Management
3  * in Industry THTH ry.
4  * All rights reserved. This program and the accompanying materials
5  * are made available under the terms of the Eclipse Public License v1.0
6  * which accompanies this distribution, and is available at
7  * http://www.eclipse.org/legal/epl-v10.html
8  *
9  * Contributors:
10  *     VTT Technical Research Centre of Finland - initial API and implementation
11  *******************************************************************************/
12 package org.simantics.db.layer0.variable;
13
14 import java.util.ArrayList;
15 import java.util.Collection;
16 import java.util.Collections;
17 import java.util.LinkedList;
18 import java.util.List;
19 import java.util.Map;
20
21 import org.simantics.databoard.Databoard;
22 import org.simantics.databoard.binding.Binding;
23 import org.simantics.databoard.binding.mutable.Variant;
24 import org.simantics.databoard.type.Datatype;
25 import org.simantics.databoard.type.NumberType;
26 import org.simantics.databoard.util.URIStringUtils;
27 import org.simantics.db.ReadGraph;
28 import org.simantics.db.RequestProcessor;
29 import org.simantics.db.Resource;
30 import org.simantics.db.WriteGraph;
31 import org.simantics.db.common.request.PossibleIndexRoot;
32 import org.simantics.db.common.request.TernaryRead;
33 import org.simantics.db.common.utils.Logger;
34 import org.simantics.db.exception.DatabaseException;
35 import org.simantics.db.layer0.exception.MissingVariableException;
36 import org.simantics.db.layer0.request.Model;
37 import org.simantics.db.layer0.request.PossibleActiveVariableFromVariable;
38 import org.simantics.db.layer0.request.PossibleVariableIndexRoot;
39 import org.simantics.db.layer0.request.PossibleVariableModel;
40 import org.simantics.db.layer0.request.PropertyInfo;
41 import org.simantics.db.layer0.request.PropertyInfoRequest;
42 import org.simantics.db.layer0.request.ResourceURIToVariable;
43 import org.simantics.db.layer0.request.VariableIndexRoot;
44 import org.simantics.db.layer0.request.VariableURI;
45 import org.simantics.layer0.Layer0;
46 import org.simantics.operation.Layer0X;
47 import org.simantics.project.ontology.ProjectResource;
48 import org.simantics.scl.runtime.function.Function1;
49 import org.simantics.scl.runtime.function.Function2;
50 import org.simantics.scl.runtime.function.Function3;
51 import org.simantics.simulation.ontology.SimulationResource;
52 import org.simantics.simulator.variable.exceptions.NodeManagerException;
53 import org.simantics.utils.datastructures.Pair;
54
55 import gnu.trove.map.hash.TObjectIntHashMap;
56
57 final public class Variables {
58
59     public static final Variant PENDING_NODE_VALUE = new Variant();
60
61     public static final NodeStructure PENDING_NODE_STRUCTURE = new NodeStructure(Collections.emptyMap(), Collections.emptyMap()) {
62         public boolean equals(Object object) {
63             return this == object;
64         }
65     };
66
67     public static enum Role {
68
69         CHILD("/"), PROPERTY("#");
70
71         transient final String identifier;
72
73         private Role(String identifier) {
74             this.identifier = identifier;
75         }
76
77         final public String getIdentifier() {
78             return identifier;
79         }
80
81         public static Role getRole( String identifier ) {
82             for (Role role : Role.values()) if (role.identifier.equals( identifier )) return role;
83             return null;
84         }
85
86     }
87
88     // use getPredicate
89     //final public static String PREDICATE = "PREDICATE";
90
91     @Deprecated
92     // use getName
93     final public static String NAME = "HasName";
94     final public static String CLASSIFICATIONS = "classifications";
95     final public static String EXPRESSION = "HasExpression";
96     final public static String INPUT_VALIDATOR = "HasInputValidator";
97     final public static String INPUT_MODIFIER = "HasInputModifier";
98     final public static String FORMATTER = "HasFormatter";
99
100     final public static String STANDARD_RESOURCE = "hasStandardResource";
101     //@Deprecated
102     // use getPresents
103     //final public static String REPRESENTS = "Represents";
104     final public static String TYPE = "Type";
105     final public static String URI = "URI";
106     /**
107      * @deprecated use {@link Variable#getRVI(ReadGraph)} and {@link RVI} instead.
108      */
109 //    @Deprecated
110 //    final public static String SERIALISED = "Serialised";
111 //    @Deprecated
112     // use getParent
113     //final public static String PARENT = "Parent";
114     //final public static String ROLE = "Role";
115     //final public static String DATATYPE = "DATATYPE";
116     //final public static String UNIT = "UNIT";
117
118     final public static String VALID = "valid";
119     final public static String REQUIRED = "required";
120     final public static String DEFAULT = "default";
121     final public static String READONLY = "readOnly";
122     final public static String VALIDATOR = "validator";
123
124     final public static String LABEL = "HasLabel";
125
126     final public static String ENUMERATION_VALUES = "HasEnumerationValues";
127     final public static String CUSTOM_MODIFIER = "HasCustomModifier";
128
129     final public static String DISPLAY_COLUMN = "HasDisplayColumn";
130
131     final public static String DISPLAY_PROPERTY = "HasDisplayProperty";
132     final public static String DISPLAY_VALUE = "HasDisplayValue";
133     final public static String DISPLAY_UNIT = "HasDisplayUnit";
134
135     final public static String CONVERTED_VALUE = "convertedValue";
136
137     /**
138      * This property should exist for array valued property variables.
139      */
140     final public static String ARRAY_SIZE = "ARRAY_SIZE";
141
142
143     @Deprecated
144     // use etc. variable.adapt(graph, Interface.class).getResource()
145     final public static String RESOURCE = "Resource";
146     @Deprecated
147     final public static String CONTAINER_RESOURCE = "ContainerResource";
148     @Deprecated
149     final public static String PROPERTY_RESOURCE = "PROPERTY_RESOURCE";
150
151     @Deprecated
152     public final static String[] builtins = {
153         TYPE, RESOURCE, URI
154         //, SERIALISED
155     };
156
157     public static Variable getPossibleVariable(ReadGraph graph, Resource resource) throws DatabaseException {
158         String uri = graph.getPossibleURI(resource);
159         return uri != null ? getPossibleVariable(graph, uri) : null;
160     }
161
162     public static Variable getPossibleVariable(ReadGraph graph, String uri) throws DatabaseException {
163         try {
164             return getVariable(graph, uri);
165         } catch (DatabaseException e) {
166             return null;
167         }
168     }
169
170     public static Variable getVariable(ReadGraph graph, Resource resource) throws DatabaseException {
171         return getVariable(graph, graph.getURI(resource));
172     }
173
174     public static Variable getVariable(ReadGraph graph, String uri) throws DatabaseException {
175         try {
176             return graph.sync(new ResourceURIToVariable(uri));
177         } catch (MissingVariableException e) {
178             return VariableRepository.get(graph, uri);
179         }
180     }
181
182     private static int commonPrefixLength(String a, String b) {
183         int maxC = Math.min(a.length(), b.length());
184         for(int c=0;c<maxC;++c) {
185             if(a.charAt(c) != b.charAt(c))
186                 return c;
187         }
188         return maxC;
189     }
190
191     private static boolean isSplitPos(String str, int p) {
192         if(p==str.length())
193             return true;
194         char c = str.charAt(p);
195         return c=='/' || c=='#';
196     }
197
198     private static int pathLength(String path) {
199         int count = 0;
200         for(int i=0;i<path.length();++i) {
201             char c = path.charAt(i);
202             if(c=='/' || c=='#')
203                 ++count;
204         }
205         return count;
206     }
207
208     private static String prefixByParentPath(int parentPathLength, String suffix) {
209         StringBuilder b = new StringBuilder();
210         for(int i=0;i<parentPathLength;++i)
211             b.append('.');
212         b.append(suffix);
213         return b.toString();
214     }
215
216     public static String getRVI(ReadGraph graph, Variable base, Variable other) throws DatabaseException {
217         String baseURI = graph.syncRequest(new VariableURI(base));
218         String otherURI = graph.syncRequest(new VariableURI(other));
219         return getRelativeRVI(baseURI, otherURI);
220     }
221
222     public static String getRelativeRVI(String baseURI, String otherURI) {
223         int prefixLength = commonPrefixLength(baseURI, otherURI);
224         if(!isSplitPos(baseURI, prefixLength) || !isSplitPos(otherURI, prefixLength)) {
225             for(--prefixLength;prefixLength > 0 && !isSplitPos(baseURI, prefixLength);--prefixLength);
226         }
227         if(prefixLength == baseURI.length())
228             return otherURI.substring(prefixLength);
229         else 
230             return prefixByParentPath(
231                     pathLength(baseURI.substring(prefixLength)), 
232                     otherURI.substring(prefixLength));      
233     }
234
235     public static String getRVI2(ReadGraph graph, Variable base, Variable other) throws DatabaseException {
236         TObjectIntHashMap<Variable> baseLength = new TObjectIntHashMap<Variable>();
237         for(int depth=0;base != null;base = base.getParent(graph),++depth)
238             baseLength.put(base, depth);
239         Variable cur;
240         for(cur=other;!baseLength.containsKey(cur);cur=cur.getParent(graph));
241
242         // To string
243         String curURI = cur.getURI(graph);
244         String otherURI = other.getURI(graph);
245
246         return prefixByParentPath(baseLength.get(cur), otherURI.substring(curURI.length()));
247     }
248
249     public static String getProjectRVI(ReadGraph graph, Variable variable) throws DatabaseException {
250         Resource project = getProject(graph, variable);
251         String projectURI = graph.getURI(project);
252         return variable.getURI(graph).substring(projectURI.length());
253     }
254
255     private static int getSegmentEnd(String suffix) {
256         int pos;
257         for(pos=1;pos<suffix.length();++pos) {
258             char c = suffix.charAt(pos);
259             if(c == '/' || c == '#')
260                 break;
261         }
262         return pos;
263     }
264
265     public static String getRVI(String rvi, String suffix) throws DatabaseException {
266         if(suffix.isEmpty()) return rvi;
267         switch(suffix.charAt(0)) {
268             case '.': {
269                 return getRVI(URIStringUtils.getRVIParent(rvi), suffix.substring(1));
270             }
271             case '#': {
272                 int segmentEnd = getSegmentEnd(suffix);
273                 return getRVI(rvi + "#" + suffix.substring(1, segmentEnd), suffix.substring(segmentEnd));
274             }
275             case '/': {
276                 int segmentEnd = getSegmentEnd(suffix);
277                 return getRVI(rvi + "/" + suffix.substring(1, segmentEnd), suffix.substring(segmentEnd));
278             }
279             default:
280                 return null;
281         }
282
283     }
284
285     public static Variable getRootVariable(ReadGraph graph) throws DatabaseException {
286         return graph.adapt(graph.getRootLibrary(), Variable.class);
287     }
288     
289     public static Resource getPossibleIndexRoot(ReadGraph graph, Variable variable) throws DatabaseException {
290         return graph.syncRequest(new PossibleVariableIndexRoot(variable));
291     }
292     
293     public static Resource getIndexRoot(ReadGraph graph, Variable variable) throws DatabaseException {
294         return graph.syncRequest(new VariableIndexRoot(variable));
295     }
296     
297     public static Resource getModel(ReadGraph graph, Variable variable) throws DatabaseException {
298         String URI = variable.getURI(graph);
299         return VariablesImpl.getFirst(graph, SimulationResource.getInstance(graph).Model, URI, 8);
300     }
301
302     public static Resource getPossibleModel(ReadGraph graph, Variable variable) throws DatabaseException {
303         return graph.syncRequest(new PossibleVariableModel(variable));
304     }
305
306     public static Resource getProject(ReadGraph graph, Variable variable) throws DatabaseException {
307         String URI = variable.getURI(graph);
308         return VariablesImpl.getFirst(graph, ProjectResource.getInstance(graph).Project, URI, 8);
309     }
310
311     public static Variable getConfigurationContext(ReadGraph graph, Resource resource) throws DatabaseException {
312         SimulationResource SIMU = SimulationResource.getInstance(graph);
313         if(!graph.isInstanceOf(resource, SIMU.Model)) resource = graph.sync(new Model(resource));
314         Resource configurationResource = graph.getSingleObject(resource, SIMU.HasConfiguration);
315         return Variables.getVariable(graph, configurationResource);
316     }
317
318     public static Resource getConfigurationContextResource(ReadGraph graph, Resource resource) throws DatabaseException {
319         Variable config = getConfigurationContext(graph, resource);
320         return config.getRepresents(graph);
321     }
322
323     public static Variable getConfigurationContext(ReadGraph graph, Variable variable) throws DatabaseException {
324         SimulationResource SIMU = SimulationResource.getInstance(graph);
325         Resource model = Variables.getModel(graph, variable);
326         Resource configurationResource = graph.getSingleObject(model, SIMU.HasConfiguration);
327         return Variables.getVariable(graph, configurationResource);
328     }
329
330     public static Resource getPossibleConfigurationContextResource(ReadGraph graph, Resource resource) throws DatabaseException {
331         Variable config = getPossibleConfigurationContext(graph, resource);
332         return config != null ? config.getPossibleRepresents(graph) : null;
333     }
334
335     public static Variable getPossibleConfigurationContext(ReadGraph graph, Resource resource) throws DatabaseException {
336         SimulationResource SIMU = SimulationResource.getInstance(graph);
337         if (!graph.isInstanceOf(resource, SIMU.Model)) resource = graph.sync(new PossibleIndexRoot(resource));
338         if (resource == null)
339             return null;
340         Resource configurationResource = graph.getPossibleObject(resource, SIMU.HasConfiguration);
341         if (configurationResource == null)
342             return null;
343         return Variables.getPossibleVariable(graph, configurationResource);
344     }
345
346     public static Variable getPossibleConfigurationContext(ReadGraph graph, Variable variable) throws DatabaseException {
347         SimulationResource SIMU = SimulationResource.getInstance(graph);
348         Resource model = getPossibleIndexRoot(graph, variable);
349         if (model == null)
350             return null;
351         Resource configurationResource = graph.getPossibleObject(model, SIMU.HasConfiguration);
352         if (configurationResource == null)
353             return null;
354         return Variables.getPossibleVariable(graph, configurationResource);
355     }
356
357     public static Variable getConfigurationVariable(ReadGraph graph, Resource resource, String RVI) throws DatabaseException {
358         Variable context = getConfigurationContext(graph, resource);
359         return context.browse(graph, RVI);
360     }
361     
362     public static Variable getConfigurationVariable(ReadGraph graph, Variable variable) throws DatabaseException {
363         Variable context = getConfigurationContext(graph, variable);
364         RVI rvi = variable.getRVI(graph);
365         return rvi.resolve(graph, context);
366     }
367
368     public static Variable getPossibleConfigurationVariable(ReadGraph graph, Variable variable) throws DatabaseException {
369         Variable context = getPossibleConfigurationContext(graph, variable);
370         if (context == null)
371             return null;
372         try {
373             RVI rvi = variable.getRVI(graph);
374             return rvi.resolvePossible(graph, context);
375         } catch (MissingVariableException e) {
376             // Ignore.
377             return null;
378         }
379     }
380
381     public static Datatype getDatatype(ReadGraph graph, Resource resource, RVI rvi) throws DatabaseException {
382         Variable var = rvi.resolve(graph, getConfigurationContext(graph, resource));
383         return var.getDatatype(graph);
384     }
385
386     @Deprecated
387     public static Resource getRealization(ReadGraph graph, Variable variable) throws DatabaseException {
388         String URI = variable.getURI(graph);
389         return VariablesImpl.getFirst(graph, Layer0X.getInstance(graph).Realization, URI, 8);
390     }
391
392     public static boolean isContext(ReadGraph graph, Variable variable) throws DatabaseException {
393         Resource type = variable.getPossibleType(graph);
394         if(type != null) {
395             if(graph.isInheritedFrom(type, Layer0.getInstance(graph).RVIContext)) return true;
396         }
397         return false;
398     }
399
400     public static Variable getPossibleContext(ReadGraph graph, Variable variable) throws DatabaseException {
401         if(isContext(graph, variable)) return variable;
402         Variable parent = variable.getParent(graph);
403         if(parent == null) return null;
404         return getPossibleContext(graph, parent);
405     }
406
407     public static Variable getContext(ReadGraph graph, Variable variable) throws DatabaseException {
408         Variable context = getPossibleContext(graph, variable);
409         if(context == null) throw new DatabaseException("No context found for " + variable.getURI(graph));
410         else return context;
411     }
412
413     public static RVI getRVI2(ReadGraph graph, Variable variable) throws DatabaseException {
414         return variable.getRVI(graph);
415     }
416
417     public static RVI getPossibleRVI2(ReadGraph graph, Variable variable) throws DatabaseException {
418         try {
419             return variable.getRVI(graph);
420         } catch (DatabaseException e) {
421             return null;
422         }
423     }
424
425     public static String getRVI(ReadGraph graph, Variable variable) throws DatabaseException {
426         Resource realizationResource = getRealization(graph, variable);
427         if (realizationResource == null)
428             throw new DatabaseException("No realization found for " + variable.getURI(graph));
429         return variable.getURI(graph).substring(graph.getURI(realizationResource).length()); 
430     }
431
432     public static String getRVI(ReadGraph graph, Resource config) throws DatabaseException {
433         Variable var = getVariable(graph, config);
434         return getRVI(graph, var);
435     }
436
437     public static String getPossibleRVI(ReadGraph graph, Resource config) throws DatabaseException {
438         Variable var = getPossibleVariable(graph, config);
439         return var != null ? getPossibleRVI(graph, var) : null;
440     }
441
442     public static String getPossibleRVI(ReadGraph graph, Variable variable) throws DatabaseException {
443         try {
444             return getRVI(graph, variable);
445         } catch (DatabaseException e) {
446             return null;
447         }
448     }
449
450     public static List<Variable> getPath(ReadGraph graph, Variable base, Variable var) throws DatabaseException {
451         if(!isChild(graph, base, var)) return null;
452         LinkedList<Variable> result = new LinkedList<Variable>();
453         var = var.getParent(graph);
454         while(!var.equals(base)) {
455             result.addFirst(var);
456             var = var.getParent(graph);
457         }
458         return result;
459     }
460
461     public static Variable getChild(ReadGraph graph, Variable base, Variable var) throws DatabaseException {
462         List<Variable> path = getPath(graph, base, var);
463         if(path == null || path.size() == 0) return null;
464         return path.get(0);
465     }
466
467     public static boolean isChild(ReadGraph graph, Variable base, Variable var) throws DatabaseException {
468         if(base.equals(var)) return false;
469         return var.getURI(graph).startsWith(base.getURI(graph));
470     }
471
472     public static Variable switchRealization(ReadGraph graph, Variable variable, Resource realization) throws DatabaseException {
473         Resource current = getRealization(graph, variable);
474         if(current == null) throw new DatabaseException("No current realization found for variable");
475         return switchRealization(graph, variable, current, realization);
476     }
477
478     public static Variable switchPossibleContext(ReadGraph graph, Variable variable, Resource realization) throws DatabaseException {
479         Variable current = getPossibleContext(graph, variable);
480         if (current == null)
481             return null;
482         Resource currentContext = current.getPossibleRepresents(graph);
483         if (currentContext == null)
484             return null;
485         return switchPossibleRealization(graph, variable, currentContext, realization);
486     }
487
488     public static Variable switchRealization(ReadGraph graph, Variable variable, Variable realization) throws DatabaseException {
489         Resource current = getRealization(graph, variable);
490         return switchRealization(graph, variable, current, realization);
491     }
492
493     public static Variable switchRealization(ReadGraph graph, Variable variable, Resource currentRealization, Resource targetRealization) throws DatabaseException {
494         String currentURI = graph.getURI(currentRealization);
495         String targetURI = graph.getURI(targetRealization);
496         String variableURI = variable.getURI(graph);
497         String targetVariableURI = targetURI + variableURI.substring(currentURI.length());
498         return getVariable(graph, targetVariableURI);
499     }
500
501     public static Variable switchRealization(ReadGraph graph, Variable variable, Resource currentRealization, Variable targetRealization) throws DatabaseException {
502         String currentURI = graph.getURI(currentRealization);
503         String targetURI = targetRealization.getURI(graph);
504         String variableURI = variable.getURI(graph);
505         String targetVariableURI = targetURI + variableURI.substring(currentURI.length());
506         return getVariable(graph, targetVariableURI);
507     }
508
509     public static Variable switchPossibleRealization(ReadGraph graph, Variable variable, Resource currentRealization, Resource targetRealization) throws DatabaseException {
510         String currentURI = graph.getURI(currentRealization);
511         String targetURI = graph.getURI(targetRealization);
512         String variableURI = variable.getURI(graph);
513         String targetVariableURI = targetURI + variableURI.substring(currentURI.length());
514         return getPossibleVariable(graph, targetVariableURI);
515     }
516
517     public static Variable toConfigurationVariable(ReadGraph graph, Variable variable) throws DatabaseException {
518         Variable config = getConfigurationContext(graph, variable);
519         return switchRealization(graph, variable, config);
520     }
521
522     public static Variable toPossibleConfigurationVariable(ReadGraph graph, Variable variable) throws DatabaseException {
523         
524         Resource represents = variable.getPossibleRepresents(graph);
525         if(represents == null) return null;
526         Resource config = getPossibleConfigurationContextResource(graph, represents);
527         if(config == null) return null;
528         return switchPossibleContext(graph, variable, config);
529
530     }
531
532     public static String toRVI(ReadGraph graph, List<Resource> compositePath) throws DatabaseException {
533         Layer0 L0 = Layer0.getInstance(graph);
534         StringBuilder rvi = new StringBuilder();
535         for (Resource composite : compositePath) {
536             String name = graph.getPossibleRelatedValue(composite, L0.HasName);
537             if (name == null)
538                 return null;
539
540             rvi.append('/');
541             String escapedName = URIStringUtils.escape(name);
542             rvi.append(escapedName);
543         }
544         return rvi.toString();
545     }
546
547     public static String appendRVI(ReadGraph graph, String modelURI, String rvi, Resource configuration) throws DatabaseException {
548
549         Layer0 L0 = Layer0.getInstance(graph);
550         String partName = graph.getPossibleRelatedValue(configuration, L0.HasName);
551         if(partName == null) throw new MissingVariableException("Can not append a child corresponding to " + configuration + " to rvi '" + rvi + "' since there is no name.");
552         String escaped = URIStringUtils.escape(partName);
553         return rvi + "/" + escaped;
554
555     }
556
557     public static boolean isValid(ReadGraph graph, Variable variable) {
558         if(variable == null) return false;
559         try {
560             variable.getURI(graph);
561         } catch (DatabaseException e) {
562             return false;
563         }
564         return true;
565     }
566
567     public static Variable possibleChildWithType(ReadGraph graph, Variable variable, Resource targetType) throws DatabaseException {
568         Variable found = null;
569         for(Variable child : variable.getChildren(graph)) {
570             Resource type = child.getPossiblePropertyValue(graph, Variables.TYPE);
571             if(type != null && graph.isInheritedFrom(type, targetType)) {
572                 if(found != null) return null;
573                 found = child;
574             }
575         }
576         return found;
577     }
578
579     public static Collection<Variable> childrenWithType(ReadGraph graph, Variable variable, Resource targetType) throws DatabaseException {
580         ArrayList<Variable> result = new ArrayList<Variable>();
581         for(Variable child : variable.getChildren(graph)) {
582             Resource type = child.getPossiblePropertyValue(graph, Variables.TYPE);
583             if(graph.isInheritedFrom(type, targetType)) result.add(child);
584         }
585         return result;
586     }
587
588     public static <T> T adapt(ReadGraph graph, Variable variable, String property, Class<T> clazz) throws DatabaseException {
589         Resource resource = variable.getPropertyValue(graph, property);
590         return graph.adapt(resource, clazz);
591     }
592
593     public static <T> T getPossiblePropertyValue(RequestProcessor processor, Variable variable, Resource property, Binding binding) {
594         try {
595             return processor.sync(new TernaryRead<Variable,Resource,Binding,T>(variable, property, binding) {
596
597                 @Override
598                 public T perform(ReadGraph graph) throws DatabaseException {
599                     return parameter.getPossiblePropertyValue(graph, parameter2, parameter3);
600                 }
601
602             });
603         } catch (DatabaseException e) {
604             return null;
605         }
606     }
607
608     public static Variable possibleActiveVariable(ReadGraph graph, Variable variable) throws DatabaseException {
609         Variable activeVariable = graph.sync(new PossibleActiveVariableFromVariable(variable));
610         return activeVariable;
611     }
612
613     public static Variant requestNodeValue(ReadGraph graph, VariableNode<?> node) throws DatabaseException {
614         return requestNodeValue(graph, node, null);
615     }
616
617     public static Variant requestNodeValue(ReadGraph graph, VariableNode<?> node, final Binding binding) throws DatabaseException {
618         Variant value = graph.syncRequest(new NodeValueRequest(node, binding));
619         if(PENDING_NODE_VALUE == value && graph.getSynchronous()) {
620                 // In this case a PENDING value was previously cached but now the value needs to be obtained for real.
621                 
622                         ValueGetter getter = new ValueGetter(node, binding);
623                         try {
624                                 node.support.manager.getRealm().syncExec(getter);
625                         } catch (InterruptedException e) {
626                                 Logger.defaultLogError(e);
627                         }
628                         
629                         if (getter.exception != null)
630                                 throw new DatabaseException(getter.exception);
631                         
632                         return getter.result;
633         }
634         return value; 
635     }
636     
637     public static class NodeStructure {
638         // Immutable but wrapped with Collections.unmodifiableMap as an optimization
639         public final Map<String,Object> children;
640         // Immutable but not wrapped with Collections.unmodifiableMap as an optimization
641         public final Map<String,Object> properties;
642         private final int hash;
643
644         public NodeStructure(Map<String, Object> children, Map<String, Object> properties) {
645             this.children = children;
646             this.properties = properties;
647             this.hash = calcHash();
648         }
649
650         private int calcHash() {
651             return 31*children.hashCode() + 41*properties.hashCode();
652         }
653
654         @Override
655         public int hashCode() {
656             return hash;
657         }
658
659         @Override
660         public boolean equals(Object object) {
661             if (this == object)
662                 return true;
663             else if (object == null || object == Variables.PENDING_NODE_STRUCTURE)
664                 return false;
665             else if (!(object instanceof NodeStructure))
666                 return false;
667             NodeStructure r = (NodeStructure)object;
668             return r.children.equals(children) && r.properties.equals(properties);
669         }
670     }
671
672     public static NodeStructure requestNodeStructure(ReadGraph graph, VariableNode<?> node) throws DatabaseException {
673         NodeStructure value = graph.syncRequest(new NodeStructureRequest(node));
674         if (value == null) throw new DatabaseException("External data access error");
675         if(PENDING_NODE_STRUCTURE == value && graph.getSynchronous()) {
676                 // In this case a PENDING value was previously cached but now the value needs to be obtained for real.
677                 
678                         StructureGetter getter = new StructureGetter(node);
679                         try {
680                                 node.support.manager.getRealm().syncExec(getter);
681                         } catch (InterruptedException e) {
682                                 Logger.defaultLogError(e);
683                                 throw new DatabaseException("External data access error", e);
684                         }
685                         
686                         if (getter.exception != null)
687                                 throw new DatabaseException("External data access error", getter.exception);
688                         if (getter.result == null)
689                                 throw new DatabaseException("External data access error");
690                         
691                         return getter.result;
692                 
693         }
694         return value; 
695
696     }
697     
698     public static String getPossibleUnit(ReadGraph graph, Variable variable) throws DatabaseException {
699         
700         try {
701                 
702                 Resource predicate = variable.getPossiblePredicateResource(graph);
703                 if(predicate != null) {
704                         PropertyInfo info = graph.syncRequest(new PropertyInfoRequest(predicate));
705                         if(info.definedUnit != null) return info.definedUnit;
706                 }
707                 
708                 Variant variant = variable.getVariantValue(graph);
709                 Binding binding = variant.getBinding();
710                 if(binding == null) return null;
711                 Datatype dt = binding.type();
712                 if(!(dt instanceof NumberType)) return null;
713                 NumberType nt = (NumberType)dt;
714                 return nt.getUnit();
715                 
716         } catch (DatabaseException e) {
717                 return null;
718         }
719         
720     }
721
722     /**
723      * @param graph
724      * @param rvi
725      * @param context1 primary context to use for resolving the specified RVI, must not be null
726      * @param context2 secondary context to use for resolving the specified RVI, may be <code>null</code>
727      * @return pair of variables where first is the resolved variable and second
728      *         is the context it was resolved with
729      * @throws DatabaseException
730      * @since 1.18.1
731      */
732     public static Pair<Variable, Variable> resolvePossible(ReadGraph graph, RVI rvi, Variable context1, Variable context2) throws DatabaseException {
733         Variable v = rvi.resolvePossible(graph, context1);
734         if (v != null)
735             return new Pair<>(v, context1);
736         if (context2 != null) {
737             v = rvi.resolvePossible(graph, context2);
738             if (v != null)
739                 return new Pair<>(v, context2);
740         }
741         return null;
742     }
743
744
745     @SuppressWarnings("rawtypes")
746     private static class ValueGetter implements VariableNodeReadRunnable {
747
748         final VariableNode n;
749         final Binding binding;
750         Variant result;
751         Exception exception;
752
753         public ValueGetter(VariableNode n, Binding binding) {
754             this.n = n;
755             this.binding = binding;
756         }
757
758         @SuppressWarnings("unchecked")
759         @Override
760         public void run() {
761             try {
762                 if (binding != null)
763                     result = new Variant(binding, n.support.manager.getValue(n.node, binding));
764                 else
765                     result = n.support.manager.getValue(n.node);
766             } catch (Exception e) {
767                 Logger.defaultLogError(e);
768                 exception = e;
769             }
770         }
771
772     }
773
774     @SuppressWarnings("rawtypes")
775     private static class StructureGetter implements VariableNodeReadRunnable {
776
777         final VariableNode n;
778         NodeStructure result;
779         Exception exception;
780
781         public StructureGetter(VariableNode n) {
782             this.n = n;
783         }
784
785         @Override
786         public void run() {
787             try {
788                 result = NodeStructureRequest.get(n);
789             } catch (NodeManagerException e) {
790                 Logger.defaultLogError(e);
791                 exception = e;
792             }
793         }
794
795     };
796
797     public static Variable tryGetProperty(ReadGraph graph, Resource entity, Resource property) throws DatabaseException {
798         Variable v = Variables.getPossibleVariable(graph, entity);
799         return v != null ? v.getPossibleProperty(graph, property) : null;
800     }
801     
802         public static ValueAccessor createValueAccessor(Function1<Variable, Object> getValue1, Function2<Variable, Binding, Object> getValue2,
803                         Function2<Variable, Object, Object> setValue2, Function3<Variable, Object, Binding, Object> setValue3,
804                         Function1<Variable, Datatype> getDatatype) {
805                 return new SCLValueAccessor(getValue1, getValue2, setValue2, setValue3, getDatatype);
806         }
807
808     public static void setRVIProperty(WriteGraph graph, Variable variable, RVI rvi) throws DatabaseException {
809         Layer0 L0 = Layer0.getInstance(graph);
810         Binding rviBinding = graph.getService(Databoard.class).getBindingUnchecked( RVI.class );
811         Resource predicate = variable.getPredicateResource(graph);
812         Resource subject = variable.getParent(graph).getRepresents(graph);
813         graph.deny(subject, predicate);
814         graph.claimLiteral(subject, predicate, L0.RVI, rvi, rviBinding);
815     }
816
817 }