bundles/org.simantics.structural2/src/org/simantics/structural2/scl/AbstractAnalyseStructuralValueRequest.java

   1 package org.simantics.structural2.scl;
   2
   3 import java.util.Collections;
   4 import java.util.HashSet;
   5 import java.util.Map;
   6 import java.util.Set;
   7
   8 import org.simantics.databoard.Bindings;
   9 import org.simantics.db.ReadGraph;
  10 import org.simantics.db.Resource;
  11 import org.simantics.db.common.procedure.adapter.TransientCacheListener;
  12 import org.simantics.db.common.request.PossibleIndexRoot;
  13 import org.simantics.db.common.request.ResourceRead2;
  14 import org.simantics.db.exception.DatabaseException;
  15 import org.simantics.db.layer0.scl.AbstractExpressionAnalysisRequest;
  16 import org.simantics.db.layer0.scl.AbstractExpressionCompilationContext;
  17 import org.simantics.db.layer0.util.RuntimeEnvironmentRequest;
  18 import org.simantics.db.layer0.util.RuntimeEnvironmentRequest2;
  19 import org.simantics.db.layer0.variable.Variable;
  20 import org.simantics.layer0.Layer0;
  21 import org.simantics.scl.compiler.elaboration.expressions.EApply;
  22 import org.simantics.scl.compiler.elaboration.expressions.EConstant;
  23 import org.simantics.scl.compiler.elaboration.expressions.EVariable;
  24 import org.simantics.scl.compiler.elaboration.expressions.Expression;
  25 import org.simantics.scl.compiler.elaboration.modules.SCLValue;
  26 import org.simantics.scl.compiler.environment.Environment;
  27 import org.simantics.scl.compiler.environment.Environments;
  28 import org.simantics.scl.compiler.runtime.RuntimeEnvironment;
  29 import org.simantics.scl.compiler.top.SCLExpressionCompilationException;
  30 import org.simantics.scl.compiler.types.Type;
  31 import org.simantics.scl.runtime.function.Function1;
  32 import org.simantics.structural2.scl.AbstractAnalyseStructuralValueRequest.AnalysisCompilationContext;
  33
  34 /**
  35  * Compiles an SCL expression that is attached to a literal
  36  * whose parent is a component that is a part of a component type.
  37  *
  38  * @author Antti Villberg
  39  */
  40 abstract public class AbstractAnalyseStructuralValueRequest extends AbstractExpressionAnalysisRequest<AnalysisCompilationContext, Variable> {
  41
  42     protected final Resource relation;
  43
  44     public static class AnalysisCompilationContext extends AbstractExpressionCompilationContext {
  45
  46         final private Map<String, ComponentTypeProperty> propertyMap;
  47         final private Set<String> consumed = new HashSet<>();
  48
  49         public AnalysisCompilationContext(RuntimeEnvironment runtimeEnvironment,
  50                 Map<String, ComponentTypeProperty> propertyMap) {
  51             super(runtimeEnvironment);
  52             this.propertyMap = propertyMap;
  53         }
  54
  55         public ComponentTypeProperty consume(String name) {
  56                 consumed.add(name);
  57                 return propertyMap.get(name);
  58         }
  59
  60         public Set<String> getConsumed() {
  61                 return consumed;
  62         }
  63
  64     }
  65
  66     public AbstractAnalyseStructuralValueRequest(Resource relation) {
  67         this.relation = relation;
  68     }
  69
  70     @Override
  71     abstract protected String getExpressionText(ReadGraph graph) throws DatabaseException;
  72     abstract protected Resource getIndexRoot(ReadGraph graph) throws DatabaseException;
  73     abstract protected Resource getComponentType(ReadGraph graph) throws DatabaseException;
  74
  75     @Override
  76     protected Type getExpectedType(ReadGraph graph, AnalysisCompilationContext context)
  77             throws DatabaseException {
  78         Layer0 L0 = Layer0.getInstance(graph);
  79         String valueType = graph.getPossibleRelatedValue(relation, L0.RequiresValueType, Bindings.STRING);
  80         if(valueType != null) {
  81             Resource relationIndexRoot = graph.syncRequest(new PossibleIndexRoot(relation));
  82             RuntimeEnvironment relationRuntimeEnvironment = relationIndexRoot != null ? graph.syncRequest(new RuntimeEnvironmentRequest(relationIndexRoot)) : context.runtimeEnvironment;
  83             try {
  84                 return Environments.getType(relationRuntimeEnvironment.getEnvironment(), valueType);
  85             } catch (SCLExpressionCompilationException e) {
  86                 e.printStackTrace();
  87             }
  88         }
  89         return super.getExpectedType(graph, context);
  90     }
  91
  92
  93
  94     @Override
  95     protected AnalysisCompilationContext getCompilationContext(ReadGraph graph)
  96             throws DatabaseException {
  97         Resource indexRoot = getIndexRoot(graph);
  98         Resource componentType = getComponentType(graph);
  99         if(componentType == null) {
 100             RuntimeEnvironment runtimeEnvironment = graph.syncRequest(new RuntimeEnvironmentRequest(indexRoot));
 101             return new AnalysisCompilationContext(runtimeEnvironment, Collections.<String,ComponentTypeProperty>emptyMap());
 102         } else {
 103                 return graph.syncRequest(new ResourceRead2<AnalysisCompilationContext>(componentType, indexRoot) {
 104                     @Override
 105                     public AnalysisCompilationContext perform(ReadGraph graph)
 106                             throws DatabaseException {
 107                         RuntimeEnvironment runtimeEnvironment = graph.syncRequest(new RuntimeEnvironmentRequest2(resource, resource2));
 108                         Map<String, ComponentTypeProperty> propertyMap =
 109                                 graph.syncRequest(new ReadComponentTypeInterfaceRequest(resource, runtimeEnvironment.getEnvironment()),
 110                                         TransientCacheListener.<Map<String, ComponentTypeProperty>>instance());
 111                         return new AnalysisCompilationContext(runtimeEnvironment, propertyMap);
 112                     }
 113                 });
 114         }
 115     }
 116
 117     @Override
 118     protected Type getContextVariableType() {
 119         return VARIABLE;
 120     }
 121
 122     protected static Expression accessInputVariable(Environment environment,
 123             org.simantics.scl.compiler.elaboration.expressions.Variable contextVariable) {
 124         SCLValue variableParentFunction = environment.getValue(VARIABLE_PARENT);
 125         return new EApply(new EConstant(variableParentFunction),
 126                 new EApply(new EConstant(variableParentFunction),
 127                         new EVariable(contextVariable)));
 128     }
 129
 130     @Override
 131     protected Expression getVariableAccessExpression(
 132             ReadGraph graph,
 133             AnalysisCompilationContext context,
 134             org.simantics.scl.compiler.elaboration.expressions.Variable contextVariable,
 135             String name) throws DatabaseException {
 136         ComponentTypeProperty property = context.consume(name);
 137         if(property != null) {
 138             Environment environment = context.runtimeEnvironment.getEnvironment();
 139             return getPropertyFlexible(environment,
 140                     accessInputVariable(environment, contextVariable),
 141                     name,
 142                     property.type);
 143         }
 144         else if(name.equals("input")) {
 145             Environment environment = context.runtimeEnvironment.getEnvironment();
 146             return accessInputVariable(environment, contextVariable);
 147         }
 148         else if(name.equals("self"))
 149             return new EVariable(contextVariable);
 150         else
 151             return null;
 152     }
 153
 154 }