1 package org.simantics.document.server.request;
5 import org.simantics.databoard.Bindings;
6 import org.simantics.db.ReadGraph;
7 import org.simantics.db.Resource;
8 import org.simantics.db.common.procedure.adapter.TransientCacheListener;
9 import org.simantics.db.common.request.IndexRoot;
10 import org.simantics.db.common.request.UnaryRead;
11 import org.simantics.db.exception.DatabaseException;
12 import org.simantics.db.layer0.scl.AbstractExpressionCompilationContext;
13 import org.simantics.db.layer0.scl.AbstractExpressionCompilationRequest;
14 import org.simantics.db.layer0.util.RuntimeEnvironmentRequest2;
15 import org.simantics.db.layer0.variable.Variable;
16 import org.simantics.document.server.request.ServerSCLValueRequest.CompilationContext;
17 import org.simantics.layer0.Layer0;
18 import org.simantics.scl.compiler.common.names.Name;
19 import org.simantics.scl.compiler.constants.StringConstant;
20 import org.simantics.scl.compiler.elaboration.expressions.EApply;
21 import org.simantics.scl.compiler.elaboration.expressions.EConstant;
22 import org.simantics.scl.compiler.elaboration.expressions.ELiteral;
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.environment.specification.EnvironmentSpecification;
29 import org.simantics.scl.compiler.runtime.RuntimeEnvironment;
30 import org.simantics.scl.compiler.top.SCLExpressionCompilationException;
31 import org.simantics.scl.compiler.types.Type;
32 import org.simantics.scl.compiler.types.Types;
33 import org.simantics.scl.compiler.types.kinds.Kinds;
34 import org.simantics.scl.runtime.SCLContext;
35 import org.simantics.scl.runtime.function.Function1;
36 import org.simantics.structural2.scl.ComponentTypeProperty;
37 import org.simantics.structural2.scl.FindPossibleComponentTypeRequest;
38 import org.simantics.structural2.scl.ReadComponentTypeInterfaceRequest;
39 import org.simantics.utils.datastructures.Pair;
40 import org.slf4j.Logger;
41 import org.slf4j.LoggerFactory;
43 public class ServerSCLValueRequest extends AbstractExpressionCompilationRequest<CompilationContext, Variable> {
45 private static final Logger LOGGER = LoggerFactory.getLogger(ServerSCLValueRequest.class);
47 private final Pair<Resource,Resource> componentTypeAndRoot;
48 private final Resource literal;
49 protected String possibleExpectedValueType;
51 public static class CompilationContext extends AbstractExpressionCompilationContext {
52 public final Map<String, ComponentTypeProperty> propertyMap;
54 public CompilationContext(RuntimeEnvironment runtimeEnvironment,
55 Map<String, ComponentTypeProperty> propertyMap) {
56 super(runtimeEnvironment);
57 this.propertyMap = propertyMap;
61 private ServerSCLValueRequest(Pair<Resource,Resource> componentTypeAndRoot, Resource literal, String possibleExpectedValueType) {
62 assert(literal != null);
63 this.literal = literal;
64 this.componentTypeAndRoot = componentTypeAndRoot;
65 this.possibleExpectedValueType = possibleExpectedValueType;
68 public ServerSCLValueRequest(ReadGraph graph, Variable context) throws DatabaseException {
69 this(getComponentTypeAndRoot(graph, context), context.getRepresents(graph), resolveExpectedValueType(graph, context));
72 private static Pair<Resource,Resource> getComponentTypeAndRoot(ReadGraph graph, Variable property) throws DatabaseException {
73 Variable parent = property.getParent(graph);
74 Resource represents = parent.getRepresents(graph);
75 if(represents != null) {
76 Resource type = graph.syncRequest(new FindPossibleComponentTypeRequest(represents));
78 Resource root = graph.syncRequest(new IndexRoot(type));
79 return Pair.make(type, root);
82 parent = parent.getParent(graph);
83 Resource root = graph.syncRequest(new IndexRoot(property.getRepresents(graph)));
84 return Pair.make(parent.getType(graph), root);
87 public static Object compileAndEvaluate(ReadGraph graph, Variable context) throws DatabaseException {
88 SCLContext sclContext = SCLContext.getCurrent();
89 Object oldGraph = sclContext.get("graph");
91 Function1<Variable,Object> exp = compile(graph, context);
92 sclContext.put("graph", graph);
93 return exp.apply(context);
94 } catch (DatabaseException e) {
95 throw (DatabaseException)e;
96 } catch (Throwable t) {
97 throw new DatabaseException(t);
99 sclContext.put("graph", oldGraph);
103 public static Function1<Variable, Object> compile(ReadGraph graph, Variable context) throws DatabaseException {
104 return graph.syncRequest(new ServerSCLValueRequest(graph, context), TransientCacheListener.<Function1<Variable,Object>>instance());
108 protected String getExpressionText(ReadGraph graph)
109 throws DatabaseException {
110 Layer0 L0 = Layer0.getInstance(graph);
111 return graph.getRelatedValue(literal, L0.SCLValue_expression, Bindings.STRING);
114 protected RuntimeEnvironmentRequest2 getRuntimeEnvironmentRequest(Resource componentType, Resource indexRoot) {
115 return new RuntimeEnvironmentRequest2(componentType, indexRoot) {
117 protected void fillEnvironmentSpecification(
118 EnvironmentSpecification environmentSpecification) {
124 protected CompilationContext getCompilationContext(ReadGraph graph)
125 throws DatabaseException {
126 return graph.syncRequest(new UnaryRead<Pair<Resource,Resource>,CompilationContext>(componentTypeAndRoot) {
128 public CompilationContext perform(ReadGraph graph)
129 throws DatabaseException {
130 RuntimeEnvironment runtimeEnvironment = graph.syncRequest(getRuntimeEnvironmentRequest(parameter.first, parameter.second));
131 Map<String, ComponentTypeProperty> propertyMap =
132 graph.syncRequest(new ReadComponentTypeInterfaceRequest(parameter.first, runtimeEnvironment.getEnvironment()),
133 TransientCacheListener.<Map<String, ComponentTypeProperty>>instance());
134 return new CompilationContext(runtimeEnvironment, propertyMap);
140 protected Type getContextVariableType() {
144 private static Expression accessInputVariable(Environment environment,
145 org.simantics.scl.compiler.elaboration.expressions.Variable contextVariable) {
146 SCLValue variableParentFunction = environment.getValue(VARIABLE_PARENT);
147 return new EApply(new EConstant(variableParentFunction),
148 new EApply(new EConstant(variableParentFunction),
149 new EVariable(contextVariable)));
152 protected static Name PROPERTY_VALUE_CACHED = Name.create("Document/All", "propertyValueCached");
154 protected static Expression getProperty(Environment environment, Expression variable, String propertyName, Type type) {
156 new EConstant(environment.getValue(FROM_DYNAMIC), type),
158 new EConstant(environment.getValue(PROPERTY_VALUE_CACHED), Types.DYNAMIC),
160 new ELiteral(new StringConstant(propertyName))));
163 protected static Expression getPropertyFlexible(Environment environment, Expression variable, String propertyName, Type type) {
164 return makeTypeFlexible(environment, getProperty(environment, variable, propertyName, type), type);
167 protected static Expression standardGetProperty(
168 Environment environment,
169 org.simantics.scl.compiler.elaboration.expressions.Variable contextVariable,
172 return getPropertyFlexible(environment, accessInputVariable(environment, contextVariable), name, type);
177 protected Expression getVariableAccessExpression(
179 CompilationContext context,
180 org.simantics.scl.compiler.elaboration.expressions.Variable contextVariable,
181 String name) throws DatabaseException {
182 ComponentTypeProperty property = context.propertyMap.get(name);
184 return standardGetProperty(
185 context.runtimeEnvironment.getEnvironment(),
188 property.type == null ? Types.metaVar(Kinds.STAR) : property.type);
190 return getSpecialVariableAccessExpression(graph, context, contextVariable, name);
193 protected Expression getSpecialVariableAccessExpression(ReadGraph graph,
194 CompilationContext context,
195 org.simantics.scl.compiler.elaboration.expressions.Variable contextVariable,
196 String name) throws DatabaseException {
197 if(name.equals("input")) {
198 Environment environment = context.runtimeEnvironment.getEnvironment();
199 return accessInputVariable(environment, contextVariable);
201 else if(name.equals("self"))
202 return new EVariable(contextVariable);
208 protected Type getExpectedType(ReadGraph graph, CompilationContext context) throws DatabaseException {
209 if(possibleExpectedValueType != null) {
211 return Environments.getType(context.runtimeEnvironment.getEnvironment(), possibleExpectedValueType);
212 } catch (SCLExpressionCompilationException e) {
213 LOGGER.error("Could not get type for " + String.valueOf(possibleExpectedValueType), e);
216 return super.getExpectedType(graph, context);
221 public int hashCode() {
222 return 31*(31*getClass().hashCode() + literal.hashCode()) + componentTypeAndRoot.hashCode();
226 public boolean equals(Object obj) {
229 if(obj == null || obj.getClass() != getClass())
231 ServerSCLValueRequest other = (ServerSCLValueRequest)obj;
232 return literal.equals(other.literal) && componentTypeAndRoot.equals(other.componentTypeAndRoot);