bundles/org.simantics.document.server/src/org/simantics/document/server/DocumentServerUtils.java

   1 package org.simantics.document.server;\r
   2 \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
   9 \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
  25 \r
  26 public class DocumentServerUtils {\r
  27 \r
  28     public static Collection<Variable> getChildren(ReadGraph graph, Variable variable) throws DatabaseException {\r
  29 \r
  30         DocumentationResource DOC = DocumentationResource.getInstance(graph);\r
  31         \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
  41                                         }\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
  46                                         }\r
  47                                 }\r
  48                         }\r
  49                 }\r
  50                 return result;\r
  51 \r
  52         }\r
  53     \r
  54         public static String findManualOrdinal(ReadGraph graph, Variable v) throws DatabaseException {\r
  55                 DocumentationResource DOC = DocumentationResource.getInstance(graph);\r
  56                 Integer j = null;\r
  57                 while (j == null && v != null) {\r
  58                         j = v.getPossiblePropertyValue(graph, DOC.Components_Component_manualOrdinal);\r
  59                         v = v.getParent(graph);\r
  60                 }\r
  61                 if (j != null) {\r
  62                         return Integer.toString(j);\r
  63                 } else {\r
  64                         return null;\r
  65                 }\r
  66         }\r
  67     \r
  68     public static Collection<Variable> getChildrenInOrdinalOrder(ReadGraph graph, Variable variable) throws DatabaseException {\r
  69         DocumentationResource DOC = DocumentationResource.getInstance(graph);\r
  70         \r
  71                 SortedMap<String, Variable> childMap = new TreeMap<String, Variable>(AlphanumComparator.COMPARATOR);\r
  72                 \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
  79                                         \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
  84                                         }\r
  85                                 } else if (DOC.Relations_partN.equals(property.getPossiblePredicateResource(graph))) {\r
  86                                         Connection conn = property.getValue(graph);\r
  87 \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
  91                                                 if (i == null) {\r
  92                                                         i = "0";\r
  93                                                 }\r
  94                                                 childMap.put(i, child);\r
  95                                         }\r
  96                                 }\r
  97                         }\r
  98                 }\r
  99                 return childMap.values();\r
 100 \r
 101         }    \r
 102 \r
 103         public static Collection<Variable> collectNodes(ReadGraph graph, Variable variable, Collection<Variable> nodes) throws DatabaseException {\r
 104 \r
 105                 DocumentationResource DOC = DocumentationResource.getInstance(graph);\r
 106 \r
 107                 Resource type = variable.getPossibleType(graph);\r
 108                 if(type == null) return nodes;\r
 109                 \r
 110                 if(!graph.isInheritedFrom(type, DOC.Components_Component)) return nodes;\r
 111 \r
 112                 Boolean enabled = variable.getPossiblePropertyValue(graph, DOC.Properties_exists, Bindings.BOOLEAN);\r
 113                 if(enabled != null && !enabled) return nodes;\r
 114 \r
 115                 if(graph.isInheritedFrom(type, DOC.Components_PrimitiveComponent)) {\r
 116                         nodes.add(variable);\r
 117                 } else {\r
 118                         for(Variable child : variable.getChildren(graph)) {\r
 119                                 collectNodes(graph, child, nodes);\r
 120                         }\r
 121                 }\r
 122 \r
 123                 return nodes;\r
 124 \r
 125         }\r
 126 \r
 127         public static Variable getPossibleOtherConnectionPoint(ReadGraph graph, Variable connectionPoint, Connection conn) throws DatabaseException {\r
 128 \r
 129                 Collection<VariableConnectionPointDescriptor> descs = conn.getConnectionPointDescriptors(graph, null);\r
 130                 if(descs.size() != 2) return null;\r
 131 \r
 132                 for(VariableConnectionPointDescriptor desc : descs) {\r
 133                         if(desc.isFlattenedFrom(graph, connectionPoint)) continue;\r
 134                         return desc.getVariable(graph);\r
 135                 }\r
 136                 \r
 137                 return null;\r
 138 \r
 139         }\r
 140         \r
 141         public static Collection<Variable> getOtherConnectionPoints(ReadGraph graph, Variable connectionPoint, Connection conn) throws DatabaseException {\r
 142 \r
 143                 ArrayList<Variable> connectionPoints = new ArrayList<Variable>();\r
 144                 \r
 145                 Collection<VariableConnectionPointDescriptor> descs = conn.getConnectionPointDescriptors(graph, null);\r
 146 \r
 147                 for(VariableConnectionPointDescriptor desc : descs) {\r
 148                         if(desc.isFlattenedFrom(graph, connectionPoint)) continue;\r
 149                         connectionPoints.add(desc.getVariable(graph));\r
 150                 }\r
 151                 \r
 152                 return connectionPoints;\r
 153 \r
 154         }\r
 155 \r
 156         public static Variable getPossibleCommandTriggerConnectionPoint(ReadGraph graph, Variable connectionPoint, Connection conn) throws DatabaseException {\r
 157 \r
 158                 Collection<Variable> cpts = conn.getConnectionPoints(graph, null);\r
 159 \r
 160                 Variable result = null;\r
 161                 \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
 166                                 result = cpt;\r
 167                         }\r
 168                 }\r
 169                 \r
 170                 return result;\r
 171 \r
 172         }\r
 173 \r
 174         public static Collection<Variable> getPossibleOtherConnectionPoints(ReadGraph graph, Variable connectionPoint, Connection conn) throws DatabaseException {\r
 175 \r
 176             Collection<Variable> cpts = conn.getConnectionPoints(graph, null);\r
 177             if(cpts.size() < 2) \r
 178                 return Collections.emptyList();\r
 179 \r
 180             ArrayList<Variable> result = new ArrayList<Variable>();\r
 181             for(Variable cpt : cpts) {\r
 182                 if(!cpt.equals(connectionPoint)) \r
 183                     result.add(cpt);\r
 184             }\r
 185             return result;\r
 186         }\r
 187 \r
 188         public static String getId(ReadGraph graph, Variable node) throws DatabaseException {\r
 189 \r
 190                 if(node == null) return "root";\r
 191                 else {\r
 192                         String uri = node.getURI(graph); \r
 193                         int l = uri.lastIndexOf(ProxyChildVariable.CONTEXT_END);\r
 194                         return uri.substring(l+4);\r
 195                 }\r
 196 \r
 197         }\r
 198 \r
 199         public static class DocumentValue extends VariableRead<Object> {\r
 200 \r
 201                 public DocumentValue(Variable variable) {\r
 202                         super(variable);\r
 203                 }\r
 204 \r
 205                 @Override\r
 206                 public Object perform(ReadGraph graph) throws DatabaseException {\r
 207                         return variable.getValue(graph);\r
 208                 }\r
 209                 \r
 210                 @Override\r
 211                 public String toString() {\r
 212                         return "DocumentValue[" + variable + "]";\r
 213                 }\r
 214                 \r
 215         }\r
 216         \r
 217         public static Object getValue(ReadGraph graph, Variable attrib) throws DatabaseException {\r
 218                 return graph.syncRequest(new DocumentValue(attrib));\r
 219         }\r
 220 \r
 221         public static Variable getParentConnectionPoint(ReadGraph graph, Variable component) throws DatabaseException {\r
 222 \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
 229                         } else {\r
 230                                 return null;\r
 231                         }\r
 232                 }\r
 233                 \r
 234                 Connection conn = connectionPoint.getValue(graph);\r
 235                 Variable otherCp = DocumentServerUtils.getPossibleOtherConnectionPoint(graph, connectionPoint, conn);\r
 236                 if (otherCp != null) {\r
 237                         return otherCp;\r
 238                 } else {\r
 239                         Variable parentCp = graph.sync(new UnaryRead<Connection, Variable>(conn) {\r
 240                     @Override\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
 244 \r
 245                                 for(VariableConnectionPointDescriptor desc : descs) {\r
 246                                         if (DOC.Relations_partN.equals(desc.getConnectionPointResource(graph))) {\r
 247                                                 return desc.getVariable(graph);\r
 248                                         }\r
 249                                 }\r
 250                                 return null;\r
 251                     }\r
 252                 });\r
 253                         if (parentCp != null) {\r
 254                                 return parentCp;\r
 255                         }\r
 256                 }\r
 257                 return null;\r
 258 \r
 259         }\r
 260         \r
 261         /* Children */\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
 264         }\r
 265 \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
 272             result.add(var);\r
 273                 }\r
 274                 return result;\r
 275         }\r
 276 \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
 279         }\r
 280 \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
 284         }\r
 285 \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
 289         }\r
 290 \r
 291         /* Attributes */\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
 294         }\r
 295         \r
 296         static class AttributesRequest extends VariableRead<Pair<Collection<Variable>, Collection<Variable>>> {\r
 297 \r
 298                 public AttributesRequest(Variable variable) {\r
 299                         super(variable);\r
 300                 }\r
 301 \r
 302                 @Override\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
 311                                 continue;\r
 312                         } \r
 313 //                      else {\r
 314 //                              System.err.println("" + property.getURI(graph) + " is not default");\r
 315 //                      }\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
 319                 }\r
 320                 return new Pair<Collection<Variable>, Collection<Variable>>(statics, dynamics);\r
 321                 }\r
 322                 \r
 323         }\r
 324         \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
 328     }\r
 329 \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
 333         }\r
 334         \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
 340         }\r
 341 \r
 342 }\r