1 package org.simantics.document.server;
\r
3 import java.util.ArrayList;
\r
4 import java.util.Collection;
\r
5 import java.util.Collections;
\r
6 import java.util.Set;
\r
7 import java.util.SortedMap;
\r
8 import java.util.TreeMap;
\r
10 import org.simantics.databoard.Bindings;
\r
11 import org.simantics.db.ReadGraph;
\r
12 import org.simantics.db.Resource;
\r
13 import org.simantics.db.common.request.UnaryRead;
\r
14 import org.simantics.db.exception.DatabaseException;
\r
15 import org.simantics.db.layer0.request.VariableRead;
\r
16 import org.simantics.db.layer0.variable.ProxyChildVariable;
\r
17 import org.simantics.db.layer0.variable.Variable;
\r
18 import org.simantics.db.layer0.variable.Variables;
\r
19 import org.simantics.document.base.ontology.DocumentationResource;
\r
20 import org.simantics.document.server.Functions.RootVariable;
\r
21 import org.simantics.structural2.variables.Connection;
\r
22 import org.simantics.structural2.variables.VariableConnectionPointDescriptor;
\r
23 import org.simantics.utils.datastructures.Pair;
\r
24 import org.simantics.utils.strings.AlphanumComparator;
\r
26 public class DocumentServerUtils {
\r
28 public static Collection<Variable> getChildren(ReadGraph graph, Variable variable) throws DatabaseException {
\r
30 DocumentationResource DOC = DocumentationResource.getInstance(graph);
\r
32 ArrayList<Variable> result = new ArrayList<Variable>();
\r
33 for(Variable property : variable.getProperties(graph)) {
\r
34 Collection<String> classifications = property.getPossiblePropertyValue(graph, Variables.CLASSIFICATIONS);
\r
35 if(classifications != null) {
\r
36 if(classifications.contains(DocumentationResource.URIs.Document_ChildRelation)) {
\r
37 Connection conn = property.getValue(graph);
\r
38 Variable childConnectionPoint = DocumentServerUtils.getPossibleOtherConnectionPoint(graph, property, conn);
\r
39 if(childConnectionPoint != null) {
\r
40 result.add(childConnectionPoint.getParent(graph));
\r
42 } else if (DOC.Relations_partN.equals(property.getPossiblePredicateResource(graph))) {
\r
43 Connection conn = property.getValue(graph);
\r
44 for (Variable childConnectionPoint : DocumentServerUtils.getOtherConnectionPoints(graph, property, conn)) {
\r
45 result.add(childConnectionPoint.getParent(graph));
\r
54 public static String findManualOrdinal(ReadGraph graph, Variable v) throws DatabaseException {
\r
55 DocumentationResource DOC = DocumentationResource.getInstance(graph);
\r
57 while (j == null && v != null) {
\r
58 j = v.getPossiblePropertyValue(graph, DOC.Components_Component_manualOrdinal);
\r
59 v = v.getParent(graph);
\r
62 return Integer.toString(j);
\r
68 public static Collection<Variable> getChildrenInOrdinalOrder(ReadGraph graph, Variable variable) throws DatabaseException {
\r
69 DocumentationResource DOC = DocumentationResource.getInstance(graph);
\r
71 SortedMap<String, Variable> childMap = new TreeMap<String, Variable>(AlphanumComparator.COMPARATOR);
\r
73 for(Variable property : variable.getProperties(graph)) {
\r
74 Collection<String> classifications = property.getPossiblePropertyValue(graph, Variables.CLASSIFICATIONS);
\r
75 if(classifications != null) {
\r
76 if(classifications.contains(DocumentationResource.URIs.Document_ChildRelation)) {
\r
77 Resource cp = property.getPossiblePredicateResource(graph);
\r
78 String i = graph.getRelatedValue(cp, DOC.Document_ChildRelation_ordinal, Bindings.STRING);
\r
80 Connection conn = property.getValue(graph);
\r
81 Variable childConnectionPoint = DocumentServerUtils.getPossibleOtherConnectionPoint(graph, property, conn);
\r
82 if(childConnectionPoint != null) {
\r
83 childMap.put(i, childConnectionPoint.getParent(graph));
\r
85 } else if (DOC.Relations_partN.equals(property.getPossiblePredicateResource(graph))) {
\r
86 Connection conn = property.getValue(graph);
\r
88 for (Variable childConnectionPoint : DocumentServerUtils.getOtherConnectionPoints(graph, property, conn)) {
\r
89 Variable child = childConnectionPoint.getParent(graph);
\r
90 String i = findManualOrdinal(graph, child);
\r
94 childMap.put(i, child);
\r
99 return childMap.values();
\r
103 public static Collection<Variable> collectNodes(ReadGraph graph, Variable variable, Collection<Variable> nodes) throws DatabaseException {
\r
105 DocumentationResource DOC = DocumentationResource.getInstance(graph);
\r
107 Resource type = variable.getPossibleType(graph);
\r
108 if(type == null) return nodes;
\r
110 if(!graph.isInheritedFrom(type, DOC.Components_Component)) return nodes;
\r
112 Boolean enabled = variable.getPossiblePropertyValue(graph, DOC.Properties_exists, Bindings.BOOLEAN);
\r
113 if(enabled != null && !enabled) return nodes;
\r
115 if(graph.isInheritedFrom(type, DOC.Components_PrimitiveComponent)) {
\r
116 nodes.add(variable);
\r
118 for(Variable child : variable.getChildren(graph)) {
\r
119 collectNodes(graph, child, nodes);
\r
127 public static Variable getPossibleOtherConnectionPoint(ReadGraph graph, Variable connectionPoint, Connection conn) throws DatabaseException {
\r
129 Collection<VariableConnectionPointDescriptor> descs = conn.getConnectionPointDescriptors(graph, null);
\r
130 if(descs.size() != 2) return null;
\r
132 for(VariableConnectionPointDescriptor desc : descs) {
\r
133 if(desc.isFlattenedFrom(graph, connectionPoint)) continue;
\r
134 return desc.getVariable(graph);
\r
141 public static Collection<Variable> getOtherConnectionPoints(ReadGraph graph, Variable connectionPoint, Connection conn) throws DatabaseException {
\r
143 ArrayList<Variable> connectionPoints = new ArrayList<Variable>();
\r
145 Collection<VariableConnectionPointDescriptor> descs = conn.getConnectionPointDescriptors(graph, null);
\r
147 for(VariableConnectionPointDescriptor desc : descs) {
\r
148 if(desc.isFlattenedFrom(graph, connectionPoint)) continue;
\r
149 connectionPoints.add(desc.getVariable(graph));
\r
152 return connectionPoints;
\r
156 public static Variable getPossibleCommandTriggerConnectionPoint(ReadGraph graph, Variable connectionPoint, Connection conn) throws DatabaseException {
\r
158 Collection<Variable> cpts = conn.getConnectionPoints(graph, null);
\r
160 Variable result = null;
\r
162 for(Variable cpt : cpts) {
\r
163 Set<String> classifications = cpt.getClassifications(graph);
\r
164 if(classifications.contains(DocumentationResource.URIs.Relations_commandExecutorRelation)) {
\r
165 if(result != null) throw new DatabaseException("Multiple executor connection points in command connection");
\r
174 public static Collection<Variable> getPossibleOtherConnectionPoints(ReadGraph graph, Variable connectionPoint, Connection conn) throws DatabaseException {
\r
176 Collection<Variable> cpts = conn.getConnectionPoints(graph, null);
\r
177 if(cpts.size() < 2)
\r
178 return Collections.emptyList();
\r
180 ArrayList<Variable> result = new ArrayList<Variable>();
\r
181 for(Variable cpt : cpts) {
\r
182 if(!cpt.equals(connectionPoint))
\r
188 public static String getId(ReadGraph graph, Variable node) throws DatabaseException {
\r
190 if(node == null) return "root";
\r
192 String uri = node.getURI(graph);
\r
193 int l = uri.lastIndexOf(ProxyChildVariable.CONTEXT_END);
\r
194 return uri.substring(l+4);
\r
199 public static class DocumentValue extends VariableRead<Object> {
\r
201 public DocumentValue(Variable variable) {
\r
206 public Object perform(ReadGraph graph) throws DatabaseException {
\r
207 return variable.getValue(graph);
\r
211 public String toString() {
\r
212 return "DocumentValue[" + variable + "]";
\r
217 public static Object getValue(ReadGraph graph, Variable attrib) throws DatabaseException {
\r
218 return graph.syncRequest(new DocumentValue(attrib));
\r
221 public static Variable getParentConnectionPoint(ReadGraph graph, Variable component) throws DatabaseException {
\r
223 Variable connectionPoint = component.getPossibleProperty(graph, "parent");
\r
224 if(connectionPoint == null) {
\r
225 DocumentationResource DOC = DocumentationResource.getInstance(graph);
\r
226 Collection<Variable> cps = component.getProperties(graph, DOC.Relations_parentRelation);
\r
227 if(cps.size() == 1) {
\r
228 connectionPoint = cps.iterator().next();
\r
234 Connection conn = connectionPoint.getValue(graph);
\r
235 Variable otherCp = DocumentServerUtils.getPossibleOtherConnectionPoint(graph, connectionPoint, conn);
\r
236 if (otherCp != null) {
\r
239 Variable parentCp = graph.sync(new UnaryRead<Connection, Variable>(conn) {
\r
241 public Variable perform(ReadGraph graph) throws DatabaseException {
\r
242 DocumentationResource DOC = DocumentationResource.getInstance(graph);
\r
243 Collection<VariableConnectionPointDescriptor> descs = parameter.getConnectionPointDescriptors(graph, null);
\r
245 for(VariableConnectionPointDescriptor desc : descs) {
\r
246 if (DOC.Relations_partN.equals(desc.getConnectionPointResource(graph))) {
\r
247 return desc.getVariable(graph);
\r
253 if (parentCp != null) {
\r
262 public static Collection<Variable> getChildConnections(ReadGraph graph, Variable variable) throws DatabaseException {
\r
263 return variable.getProperties(graph, DocumentationResource.getInstance(graph).Document_ChildRelation);
\r
266 /* Command sequence */
\r
267 public static Collection<Variable> getTriggerCommands(ReadGraph graph, Variable variable) throws DatabaseException {
\r
268 ArrayList<Variable> result = new ArrayList<Variable>();
\r
269 DocumentationResource DOC = DocumentationResource.getInstance(graph);
\r
270 for(Variable var : variable.getProperties(graph, DOC.Document_CommandRelation)) {
\r
271 if(DOC.Relations_broadcasted.equals(var.getPredicateResource(graph))) continue;
\r
277 public static Collection<Variable> getCommands(ReadGraph graph, Variable variable) throws DatabaseException {
\r
278 return variable.getProperties(graph, DocumentationResource.getInstance(graph).Document_CommandRelation);
\r
281 /* Data definition */
\r
282 public static Collection<Variable> getDataDefinitions(ReadGraph graph, Variable variable) throws DatabaseException {
\r
283 return variable.getProperties(graph, DocumentationResource.getInstance(graph).Document_DataDefinitionRelation);
\r
286 /* Data relation */
\r
287 public static Collection<Variable> getDataRelations(ReadGraph graph, Variable variable) throws DatabaseException {
\r
288 return variable.getProperties(graph, DocumentationResource.getInstance(graph).Document_DataRelation);
\r
292 public static Collection<Variable> getAttributes(ReadGraph graph, DocumentationResource DOC, Variable variable) throws DatabaseException {
\r
293 return variable.getProperties(graph, DOC.Document_AttributeRelation);
\r
296 static class AttributesRequest extends VariableRead<Pair<Collection<Variable>, Collection<Variable>>> {
\r
298 public AttributesRequest(Variable variable) {
\r
303 public Pair<Collection<Variable>,Collection<Variable>> perform(ReadGraph graph) throws DatabaseException {
\r
304 ArrayList<Variable> statics = new ArrayList<Variable>();
\r
305 ArrayList<Variable> dynamics = new ArrayList<Variable>();
\r
306 DocumentationResource DOC = DocumentationResource.getInstance(graph);
\r
307 for(Variable property : getAttributes(graph, DOC, variable)) {
\r
308 Boolean defaultProperty = property.getPossiblePropertyValue(graph, "default");
\r
309 if(defaultProperty != null && defaultProperty) {
\r
310 // System.err.println("" + property.getURI(graph) + " is default");
\r
314 // System.err.println("" + property.getURI(graph) + " is not default");
\r
316 Boolean dynamicProperty = property.getPossiblePropertyValue(graph, DOC.Document_AttributeRelation_dynamic);
\r
317 if(dynamicProperty != null && dynamicProperty) dynamics.add(property);
\r
318 else statics.add(property);
\r
320 return new Pair<Collection<Variable>, Collection<Variable>>(statics, dynamics);
\r
325 public static Collection<Variable> getStaticAttributes(ReadGraph graph, DocumentationResource DOC, Variable variable) throws DatabaseException {
\r
326 Pair<Collection<Variable>, Collection<Variable>> attribs = graph.syncRequest(new AttributesRequest(variable));
\r
327 return attribs.first;
\r
330 public static Collection<Variable> getDynamicAttributes(ReadGraph graph, final DocumentationResource DOC, Variable variable) throws DatabaseException {
\r
331 Pair<Collection<Variable>, Collection<Variable>> attribs = graph.syncRequest(new AttributesRequest(variable));
\r
332 return attribs.second;
\r
335 public static Variable getPossibleDocumentRootVariable(ReadGraph graph, Variable documentPart) throws DatabaseException {
\r
336 if(documentPart instanceof RootVariable) return documentPart;
\r
337 Variable parent = documentPart.getParent(graph);
\r
338 if(parent == null) return null;
\r
339 return getPossibleDocumentRootVariable(graph, parent);
\r