bundles/org.simantics.structural2/src/org/simantics/structural2/variables/ActualConnectionDescriptor.java

   1 package org.simantics.structural2.variables;
   2
   3 import java.util.Collection;
   4
   5 import org.simantics.databoard.Bindings;
   6 import org.simantics.databoard.util.URIStringUtils;
   7 import org.simantics.db.ReadGraph;
   8 import org.simantics.db.Resource;
   9 import org.simantics.db.common.procedure.adapter.TransientCacheAsyncListener;
  10 import org.simantics.db.common.request.UnaryRead;
  11 import org.simantics.db.common.utils.NameUtils;
  12 import org.simantics.db.exception.DatabaseException;
  13 import org.simantics.db.layer0.variable.Variable;
  14 import org.simantics.layer0.Layer0;
  15 import org.simantics.modeling.ModelingResources;
  16 import org.simantics.structural.stubs.StructuralResource2;
  17 import org.simantics.structural2.Functions;
  18 import org.simantics.structural2.Functions.InterfaceResolution;
  19 import org.simantics.structural2.variables.ConnectionBrowser.IsLeafType;
  20
  21 /*
  22  * This connection descriptor variable
  23  * -has not been lifted into interface
  24  * -has a structural configuration defined as resources
  25  * -has not been drilled
  26  */
  27 class ActualConnectionDescriptor extends AbstractVariableConnectionPointDescriptor {
  28
  29         final private Variable root;
  30         final private Resource component;
  31         final private Resource cp;
  32
  33         public ActualConnectionDescriptor(Variable root, Resource component, Resource cp) {
  34                 this.root = root;
  35                 this.component = component;
  36                 this.cp = cp;
  37         }
  38
  39         static class ComputeInterfaceDescription extends UnaryRead<ActualConnectionDescriptor, Collection<InterfaceResolution>> {
  40
  41                 public ComputeInterfaceDescription(ActualConnectionDescriptor desc) {
  42                         super(desc);
  43                 }
  44
  45                 @Override
  46                 public Collection<InterfaceResolution> perform(ReadGraph graph) throws DatabaseException {
  47
  48                 StructuralResource2 STR = StructuralResource2.getInstance(graph);
  49                 Resource type = graph.getPossibleType(parameter.component, STR.Component);
  50                 if(graph.syncRequest(new IsLeafType(type))) return null;
  51
  52                         return Functions.computeInterfacePaths(graph, parameter.getVariable(graph).getParent(graph));
  53
  54                 }
  55
  56         }
  57
  58         @Override
  59         public Collection<InterfaceResolution> getInterfaceDescription(ReadGraph graph) throws DatabaseException {
  60                 return graph.syncRequest(new ComputeInterfaceDescription(this), TransientCacheAsyncListener.<Collection<InterfaceResolution>>instance());
  61         }
  62
  63         public Resource getConnectionPointResource(ReadGraph graph) throws DatabaseException {
  64                 return cp;
  65         }
  66
  67         static class ComputeVariable extends UnaryRead<ActualConnectionDescriptor, Variable> {
  68
  69                 public ComputeVariable(ActualConnectionDescriptor desc) {
  70                         super(desc);
  71                 }
  72
  73                 @Override
  74                 public Variable perform(ReadGraph graph) throws DatabaseException {
  75
  76                 Variable c = ConnectionBrowser.resolve(graph, parameter.root, parameter.component);
  77                 if(c != null) {
  78                         Variable cnp = c.getPossibleProperty(graph, parameter.cp);
  79                         if(cnp != null) {
  80                                 return cnp;
  81                         }
  82                 }
  83
  84                 throw new DatabaseException("Unresolved connection point (root=" + parameter.root.getURI(graph) + ", component=" + NameUtils.getURIOrSafeNameInternal(graph, parameter.component) + ", cp=" + NameUtils.getURIOrSafeNameInternal(graph, parameter.cp) + ")");
  85
  86                 }
  87
  88         }
  89
  90         @Override
  91         public Variable getVariable(ReadGraph graph) throws DatabaseException {
  92                 return graph.syncRequest(new ComputeVariable(this), TransientCacheAsyncListener.<Variable>instance());
  93         }
  94
  95         @Override
  96         public String getURI(ReadGraph graph) throws DatabaseException {
  97
  98                 Variable var = getVariable(graph);
  99                 return var.getURI(graph);
 100
 101         }
 102
 103         @Override
 104         public boolean isFlattenedFrom(ReadGraph graph, Variable possiblyStructuralCp) throws DatabaseException {
 105
 106                 // This is a top-level configured connection point - we return true if possiblyStructuralCp is actually this connection point
 107
 108                 Resource otherCp = possiblyStructuralCp.getPossiblePredicateResource(graph);
 109                 if(!cp.equals(otherCp)) return false;
 110
 111                 Variable otherComponentVariable = possiblyStructuralCp.getParent(graph);
 112
 113                 Resource otherComponent = otherComponentVariable.getPossibleRepresents(graph);
 114                 if(!component.equals(otherComponent)) return false;
 115
 116                 Variable otherContainer = otherComponentVariable.getParent(graph);
 117                 if(otherContainer.equals(root)) return true;
 118
 119                 return getVariable(graph).equals(possiblyStructuralCp);
 120
 121         }
 122
 123         @Override
 124         public String getRelativeRVI(ReadGraph graph, Variable base) throws DatabaseException {
 125
 126         Layer0 L0 = Layer0.getInstance(graph);
 127         String cpName = graph.getRelatedValue(cp, L0.HasName, Bindings.STRING);
 128
 129         if(cpName.startsWith("/")) {
 130             ModelingResources MOD = ModelingResources.getInstance(graph);
 131             if(graph.isInstanceOf(component, MOD.ReferenceElement)) {
 132                 return "#" + cpName;
 133             }
 134             }
 135
 136                 if(root.equals(base.getParent(graph))) {
 137
 138                         StringBuilder b = new StringBuilder();
 139                         b.append("./");
 140                         String cName = graph.getRelatedValue(component, L0.HasName, Bindings.STRING);
 141                         b.append(URIStringUtils.escape(cName));
 142                         b.append("#");
 143                         b.append(cpName);
 144
 145                         return b.toString();
 146
 147                 }
 148
 149                 return super.getRelativeRVI(graph, base);
 150
 151         }
 152
 153 }