bundles/org.simantics.document.server/src/org/simantics/document/server/request/ServerSCLValueRequest.java

   1 package org.simantics.document.server.request;\r
   2 \r
   3 import java.util.Map;\r
   4 \r
   5 import org.simantics.databoard.Bindings;\r
   6 import org.simantics.db.ReadGraph;\r
   7 import org.simantics.db.Resource;\r
   8 import org.simantics.db.common.procedure.adapter.TransientCacheListener;\r
   9 import org.simantics.db.common.request.IndexRoot;\r
  10 import org.simantics.db.common.request.UnaryRead;\r
  11 import org.simantics.db.exception.DatabaseException;\r
  12 import org.simantics.db.layer0.scl.AbstractExpressionCompilationContext;\r
  13 import org.simantics.db.layer0.scl.AbstractExpressionCompilationRequest;\r
  14 import org.simantics.db.layer0.util.RuntimeEnvironmentRequest;\r
  15 import org.simantics.db.layer0.util.RuntimeEnvironmentRequest2;\r
  16 import org.simantics.db.layer0.variable.Variable;\r
  17 import org.simantics.document.server.request.ServerSCLValueRequest.CompilationContext;\r
  18 import org.simantics.layer0.Layer0;\r
  19 import org.simantics.scl.compiler.common.names.Name;\r
  20 import org.simantics.scl.compiler.constants.StringConstant;\r
  21 import org.simantics.scl.compiler.elaboration.expressions.EApply;\r
  22 import org.simantics.scl.compiler.elaboration.expressions.EConstant;\r
  23 import org.simantics.scl.compiler.elaboration.expressions.ELiteral;\r
  24 import org.simantics.scl.compiler.elaboration.expressions.EVariable;\r
  25 import org.simantics.scl.compiler.elaboration.expressions.Expression;\r
  26 import org.simantics.scl.compiler.elaboration.modules.SCLValue;\r
  27 import org.simantics.scl.compiler.environment.Environment;\r
  28 import org.simantics.scl.compiler.environment.specification.EnvironmentSpecification;\r
  29 import org.simantics.scl.compiler.runtime.RuntimeEnvironment;\r
  30 import org.simantics.scl.compiler.types.Type;\r
  31 import org.simantics.scl.compiler.types.Types;\r
  32 import org.simantics.scl.compiler.types.kinds.Kinds;\r
  33 import org.simantics.scl.runtime.SCLContext;\r
  34 import org.simantics.scl.runtime.function.Function1;\r
  35 import org.simantics.structural2.scl.ComponentTypeProperty;\r
  36 import org.simantics.structural2.scl.FindPossibleComponentTypeRequest;\r
  37 import org.simantics.structural2.scl.ReadComponentTypeInterfaceRequest;\r
  38 import org.simantics.utils.datastructures.Pair;\r
  39 \r
  40 public class ServerSCLValueRequest extends AbstractExpressionCompilationRequest<CompilationContext, Variable> {\r
  41 \r
  42         private final Pair<Resource,Resource> componentTypeAndRoot;\r
  43         private final Resource literal;\r
  44 \r
  45         public static class CompilationContext extends AbstractExpressionCompilationContext {\r
  46                 public final Map<String, ComponentTypeProperty> propertyMap;\r
  47 \r
  48                 public CompilationContext(RuntimeEnvironment runtimeEnvironment,\r
  49                                 Map<String, ComponentTypeProperty> propertyMap) {\r
  50                         super(runtimeEnvironment);\r
  51                         this.propertyMap = propertyMap;\r
  52                 }\r
  53         }\r
  54 \r
  55         private ServerSCLValueRequest(Pair<Resource,Resource> componentTypeAndRoot, Resource literal) {\r
  56                 assert(literal != null);\r
  57                 this.literal = literal;\r
  58                 this.componentTypeAndRoot = componentTypeAndRoot;\r
  59         }\r
  60 \r
  61         public ServerSCLValueRequest(ReadGraph graph, Variable context) throws DatabaseException {\r
  62                 this(getComponentTypeAndRoot(graph, context), context.getRepresents(graph));\r
  63         }\r
  64 \r
  65         private static Pair<Resource,Resource> getComponentTypeAndRoot(ReadGraph graph, Variable property)  throws DatabaseException {\r
  66                 Variable parent = property.getParent(graph);\r
  67                 Resource represents = parent.getRepresents(graph);\r
  68                 if(represents != null) {\r
  69                         Resource type = graph.syncRequest(new FindPossibleComponentTypeRequest(represents));\r
  70                         if(type != null) {\r
  71                                 Resource root = graph.syncRequest(new IndexRoot(type));\r
  72                                 return Pair.make(type, root);\r
  73                         }\r
  74                 }\r
  75                 parent = parent.getParent(graph);\r
  76                 Resource root = graph.syncRequest(new IndexRoot(property.getRepresents(graph)));\r
  77                 return Pair.make(parent.getType(graph), root);\r
  78         }\r
  79 \r
  80         public static Object compileAndEvaluate(ReadGraph graph, Variable context) throws DatabaseException {\r
  81                 SCLContext sclContext = SCLContext.getCurrent();\r
  82         Object oldGraph = sclContext.get("graph");\r
  83                 try {\r
  84                         Function1<Variable,Object> exp = graph.syncRequest(new ServerSCLValueRequest(graph, context),\r
  85                                         TransientCacheListener.<Function1<Variable,Object>>instance());\r
  86                         sclContext.put("graph", graph);\r
  87                         return exp.apply(context);\r
  88                 } catch (DatabaseException e) {\r
  89                         throw (DatabaseException)e;\r
  90                 } catch (Throwable t) {\r
  91                         throw new DatabaseException(t);\r
  92                 } finally {\r
  93             sclContext.put("graph", oldGraph);\r
  94                 }\r
  95         }\r
  96 \r
  97         @Override\r
  98         protected String getExpressionText(ReadGraph graph)\r
  99                         throws DatabaseException {\r
 100                 Layer0 L0 = Layer0.getInstance(graph);\r
 101                 return graph.getRelatedValue(literal, L0.SCLValue_expression, Bindings.STRING);\r
 102         }\r
 103 \r
 104         protected RuntimeEnvironmentRequest2 getRuntimeEnvironmentRequest(Resource componentType, Resource indexRoot) {\r
 105                 return new RuntimeEnvironmentRequest2(componentType, indexRoot) {\r
 106                         @Override\r
 107                         protected void fillEnvironmentSpecification(\r
 108                                         EnvironmentSpecification environmentSpecification) {\r
 109                         }\r
 110                 };\r
 111         }\r
 112 \r
 113         @Override\r
 114         protected CompilationContext getCompilationContext(ReadGraph graph)\r
 115                         throws DatabaseException {\r
 116                 return graph.syncRequest(new UnaryRead<Pair<Resource,Resource>,CompilationContext>(componentTypeAndRoot) {\r
 117                         @Override\r
 118                         public CompilationContext perform(ReadGraph graph)\r
 119                                         throws DatabaseException {\r
 120                                 RuntimeEnvironment runtimeEnvironment = graph.syncRequest(getRuntimeEnvironmentRequest(parameter.first, parameter.second));\r
 121                                 Map<String, ComponentTypeProperty> propertyMap =\r
 122                                                 graph.syncRequest(new ReadComponentTypeInterfaceRequest(parameter.first, runtimeEnvironment.getEnvironment()),\r
 123                                                                 TransientCacheListener.<Map<String, ComponentTypeProperty>>instance());\r
 124                                 return new CompilationContext(runtimeEnvironment, propertyMap);\r
 125                         }\r
 126                 });\r
 127         }\r
 128 \r
 129         @Override\r
 130         protected Type getContextVariableType() {\r
 131                 return VARIABLE; \r
 132         }\r
 133 \r
 134         private static Expression accessInputVariable(Environment environment,\r
 135                         org.simantics.scl.compiler.elaboration.expressions.Variable contextVariable) {\r
 136                 SCLValue variableParentFunction = environment.getValue(VARIABLE_PARENT);\r
 137                 return new EApply(new EConstant(variableParentFunction),\r
 138                                 new EApply(new EConstant(variableParentFunction),\r
 139                                                 new EVariable(contextVariable)));\r
 140         }\r
 141 \r
 142     protected static Name PROPERTY_VALUE_CACHED = Name.create("Document/All", "propertyValueCached");\r
 143 \r
 144     protected static Expression getProperty(Environment environment, Expression variable, String propertyName, Type type) {\r
 145         return new EApply(\r
 146                 new EConstant(environment.getValue(FROM_DYNAMIC), type),\r
 147                 new EApply(\r
 148                         new EConstant(environment.getValue(PROPERTY_VALUE_CACHED), Types.DYNAMIC),\r
 149                         variable,\r
 150                         new ELiteral(new StringConstant(propertyName))));\r
 151     }\r
 152     \r
 153     protected static Expression getPropertyFlexible(Environment environment, Expression variable, String propertyName, Type type) {\r
 154         return makeTypeFlexible(environment, getProperty(environment, variable, propertyName, type), type);\r
 155     }\r
 156         \r
 157         protected static Expression standardGetProperty(\r
 158                         Environment environment,\r
 159                         org.simantics.scl.compiler.elaboration.expressions.Variable contextVariable,\r
 160                         String name,\r
 161                         Type type) {\r
 162                 return getPropertyFlexible(environment, accessInputVariable(environment, contextVariable), name, type);\r
 163         }\r
 164 \r
 165 \r
 166         @Override\r
 167         protected Expression getVariableAccessExpression(\r
 168                         ReadGraph graph,\r
 169                         CompilationContext context,\r
 170                         org.simantics.scl.compiler.elaboration.expressions.Variable contextVariable,\r
 171                         String name) throws DatabaseException {\r
 172                 ComponentTypeProperty property = context.propertyMap.get(name);\r
 173                 if(property != null)\r
 174                         return standardGetProperty(\r
 175                                         context.runtimeEnvironment.getEnvironment(),\r
 176                                         contextVariable,\r
 177                                         name,\r
 178                                         property.type == null ? Types.metaVar(Kinds.STAR) : property.type);\r
 179                 else\r
 180                         return getSpecialVariableAccessExpression(graph, context, contextVariable, name);\r
 181         }\r
 182 \r
 183         protected Expression getSpecialVariableAccessExpression(ReadGraph graph,\r
 184                         CompilationContext context,\r
 185                         org.simantics.scl.compiler.elaboration.expressions.Variable contextVariable,\r
 186                         String name) throws DatabaseException {\r
 187                 if(name.equals("input")) {\r
 188                         Environment environment = context.runtimeEnvironment.getEnvironment();\r
 189                         return accessInputVariable(environment, contextVariable);\r
 190                 }\r
 191                 else if(name.equals("self"))\r
 192                         return new EVariable(contextVariable);\r
 193                 else\r
 194                         return null;\r
 195         }\r
 196 \r
 197         @Override\r
 198         public int hashCode() {\r
 199                 return 31*(31*getClass().hashCode() + literal.hashCode()) + componentTypeAndRoot.hashCode();\r
 200         }\r
 201 \r
 202         @Override\r
 203         public boolean equals(Object obj) {\r
 204                 if(this == obj)\r
 205                         return true;\r
 206                 if(obj == null || obj.getClass() != getClass())\r
 207                         return false;\r
 208                 ServerSCLValueRequest other = (ServerSCLValueRequest)obj;\r
 209                 return literal.equals(other.literal) && componentTypeAndRoot.equals(other.componentTypeAndRoot);\r
 210         }\r
 211 }\r