import org.simantics.scl.compiler.elaboration.expressions.Expression;
import org.simantics.scl.compiler.elaboration.modules.SCLValue;
import org.simantics.scl.compiler.environment.Environment;
+import org.simantics.scl.compiler.environment.Environments;
import org.simantics.scl.compiler.environment.specification.EnvironmentSpecification;
import org.simantics.scl.compiler.runtime.RuntimeEnvironment;
+import org.simantics.scl.compiler.top.SCLExpressionCompilationException;
import org.simantics.scl.compiler.types.Type;
import org.simantics.scl.compiler.types.Types;
import org.simantics.scl.compiler.types.kinds.Kinds;
import org.simantics.structural2.scl.FindPossibleComponentTypeRequest;
import org.simantics.structural2.scl.ReadComponentTypeInterfaceRequest;
import org.simantics.utils.datastructures.Pair;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class ServerSCLValueRequest extends AbstractExpressionCompilationRequest<CompilationContext, Variable> {
private final Pair<Resource,Resource> componentTypeAndRoot;
private final Resource literal;
+ protected String possibleExpectedValueType;
public static class CompilationContext extends AbstractExpressionCompilationContext {
public final Map<String, ComponentTypeProperty> propertyMap;
}
}
- private ServerSCLValueRequest(Pair<Resource,Resource> componentTypeAndRoot, Resource literal) {
+ private ServerSCLValueRequest(Pair<Resource,Resource> componentTypeAndRoot, Resource literal, String possibleExpectedValueType) {
assert(literal != null);
this.literal = literal;
this.componentTypeAndRoot = componentTypeAndRoot;
+ this.possibleExpectedValueType = possibleExpectedValueType;
}
public ServerSCLValueRequest(ReadGraph graph, Variable context) throws DatabaseException {
- this(getComponentTypeAndRoot(graph, context), context.getRepresents(graph));
+ this(getComponentTypeAndRoot(graph, context), context.getRepresents(graph), resolveExpectedValueType(graph, context));
}
private static Pair<Resource,Resource> getComponentTypeAndRoot(ReadGraph graph, Variable property) throws DatabaseException {
SCLContext sclContext = SCLContext.getCurrent();
Object oldGraph = sclContext.get("graph");
try {
- Function1<Variable,Object> exp = graph.syncRequest(new ServerSCLValueRequest(graph, context),
- TransientCacheListener.<Function1<Variable,Object>>instance());
+ Function1<Variable,Object> exp = compile(graph, context);
sclContext.put("graph", graph);
return exp.apply(context);
} catch (DatabaseException e) {
sclContext.put("graph", oldGraph);
}
}
+
+ public static Function1<Variable, Object> compile(ReadGraph graph, Variable context) throws DatabaseException {
+ return graph.syncRequest(new ServerSCLValueRequest(graph, context), TransientCacheListener.<Function1<Variable,Object>>instance());
+ }
@Override
protected String getExpressionText(ReadGraph graph)
else
return null;
}
+
+ @Override
+ protected Type getExpectedType(ReadGraph graph, CompilationContext context) throws DatabaseException {
+ return super.getExpectedType(graph, context);
+ }
+
@Override
public int hashCode() {
ServerSCLValueRequest other = (ServerSCLValueRequest)obj;
return literal.equals(other.literal) && componentTypeAndRoot.equals(other.componentTypeAndRoot);
}
+
+ public static Function1<Variable, Object> validate(ReadGraph graph, Variable context) throws DatabaseException {
+ return graph.syncRequest(new ServerSCLValueValidationRequest(graph, context), TransientCacheListener.<Function1<Variable,Object>>instance());
+ }
+
+ public static class ServerSCLValueValidationRequest extends ServerSCLValueRequest {
+
+ private static final Logger LOGGER = LoggerFactory.getLogger(ServerSCLHandlerValueRequest.class);
+
+ public ServerSCLValueValidationRequest(ReadGraph graph, Variable context) throws DatabaseException {
+ super(graph, context);
+ }
+
+ @Override
+ protected Type getExpectedType(ReadGraph graph, CompilationContext context) throws DatabaseException {
+ if(possibleExpectedValueType != null) {
+ try {
+ return Environments.getType(context.runtimeEnvironment.getEnvironment(), possibleExpectedValueType);
+ } catch (SCLExpressionCompilationException e) {
+ LOGGER.error("Could not get type for " + String.valueOf(possibleExpectedValueType), e);
+ }
+ }
+ return super.getExpectedType(graph, context);
+ }
+ }
}