import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.Set;
import java.util.TreeMap;
import org.simantics.Simantics;
import org.simantics.db.Statement;
import org.simantics.db.WriteGraph;
import org.simantics.db.common.primitiverequest.Adapter;
+import org.simantics.db.common.procedure.adapter.TransientCacheAsyncListener;
import org.simantics.db.common.procedure.adapter.TransientCacheListener;
-import org.simantics.db.common.request.UnaryRead;
+import org.simantics.db.common.request.BinaryRead;
+import org.simantics.db.common.request.ResourceAsyncRead;
import org.simantics.db.common.request.UniqueRead;
import org.simantics.db.common.request.WriteResultRequest;
import org.simantics.db.common.utils.Logger;
import org.simantics.db.common.utils.NameUtils;
import org.simantics.db.exception.DatabaseException;
+import org.simantics.db.exception.ServiceException;
import org.simantics.db.layer0.function.All;
import org.simantics.db.layer0.request.ProjectModels;
import org.simantics.db.layer0.request.PropertyInfo;
import org.simantics.db.layer0.request.VariableProperty;
import org.simantics.db.layer0.request.VariableRead;
import org.simantics.db.layer0.request.VariableValueWithBinding;
+import org.simantics.db.layer0.scl.SCLDatabaseException;
import org.simantics.db.layer0.variable.ConstantPropertyVariable;
import org.simantics.db.layer0.variable.ProxyChildVariable;
import org.simantics.db.layer0.variable.ProxySessionRequest;
+import org.simantics.db.layer0.variable.ProxyVariableSupport;
import org.simantics.db.layer0.variable.ProxyVariables;
import org.simantics.db.layer0.variable.StandardAssertedGraphPropertyVariable;
-import org.simantics.db.layer0.variable.StandardGraphChildVariable;
import org.simantics.db.layer0.variable.StandardGraphPropertyVariable;
import org.simantics.db.layer0.variable.Variable;
import org.simantics.db.layer0.variable.VariableMap;
import org.simantics.document.server.request.ServerSCLValueRequest;
import org.simantics.document.server.serverResponse.ServerResponse;
import org.simantics.document.server.serverResponse.SuccessResponse;
+import org.simantics.document.server.state.StateNodeManager;
+import org.simantics.document.server.state.StateRealm;
+import org.simantics.document.server.state.StateSessionManager;
import org.simantics.modeling.ModelingResources;
-import org.simantics.modeling.scl.SCLRealm;
-import org.simantics.modeling.scl.SCLSessionManager;
import org.simantics.modeling.services.CaseInsensitiveComponentFunctionNamingStrategy;
import org.simantics.modeling.services.ComponentNamingStrategy;
import org.simantics.operation.Layer0X;
import org.simantics.project.IProject;
+import org.simantics.scl.compiler.module.repository.ImportFailureException;
import org.simantics.scl.compiler.types.TCon;
import org.simantics.scl.compiler.types.Type;
import org.simantics.scl.compiler.types.Types;
import org.simantics.structural2.variables.Connection;
import org.simantics.structural2.variables.StandardProceduralChildVariable;
import org.simantics.structural2.variables.VariableConnectionPointDescriptor;
+import org.slf4j.LoggerFactory;
import gnu.trove.map.hash.THashMap;
public class Functions {
- private static class PrimitivePropertyStatementsProcedure implements AsyncProcedure<DirectStatements> {
-
- public DirectStatements result;
-
- @Override
- public void execute(AsyncReadGraph graph, DirectStatements result) {
- this.result = result;
- }
-
- @Override
- public void exception(AsyncReadGraph graph, Throwable throwable) {
- }
-
- }
-
+ private static final org.slf4j.Logger LOGGER = LoggerFactory.getLogger(Functions.class);
+
@SCLValue(type = "VariableMap")
public static VariableMap primitiveProperties = new VariableMapImpl() {
private void storePropertyValueAndExceptions(ReadGraph graph, Variable parent, String name, Variable property, Map<String, Variable> map) {
}
DirectQuerySupport dqs = graph.getService(DirectQuerySupport.class);
- PrimitivePropertyStatementsProcedure foo = new PrimitivePropertyStatementsProcedure();
+ //PrimitivePropertyStatementsProcedure foo = new PrimitivePropertyStatementsProcedure();
- dqs.forEachDirectPersistentStatement(graph, parentRes, foo);
+ DirectStatements ds = dqs.getDirectPersistentStatements(graph, parentRes);
- for(Statement stm : foo.result) {
+ for(Statement stm : ds) {
Resource predicate = stm.getPredicate();
PropertyInfo info = graph.syncRequest(new PropertyInfoRequest(predicate));
};
+ static class DocumentPropertyKeys extends ResourceAsyncRead<List<String>> {
+
+ protected DocumentPropertyKeys(Resource resource) {
+ super(resource);
+ }
+
+ @Override
+ public void perform(AsyncReadGraph graph, final AsyncProcedure<List<String>> procedure) {
+
+ final List<String> result = new ArrayList<>();
+
+ DocumentationResource DOC = DocumentationResource.getInstance(graph);
+
+ try {
+ if(graph.hasStatement(resource, DOC.Properties_commands))
+ result.add("commands");
+ if(graph.hasStatement(resource, DOC.Properties_dataDefinitions))
+ result.add("dataDefinitions");
+ } catch(ServiceException e) {
+ LOGGER.info(e.getMessage(), e);
+ }
+
+ graph.forEachDirectPredicate(resource, new AsyncProcedure<Set<Resource>>() {
+
+ @Override
+ public void execute(AsyncReadGraph graph, Set<Resource> predicates) {
+
+ for(Resource predicate : predicates) {
+
+ try {
+
+ PropertyInfo info = graph.syncRequest(new PropertyInfoRequest(predicate));
+
+ if(info.isHasProperty && info.hasClassification(DocumentationResource.URIs.Document_AttributeRelation)) {
+ result.add(info.name);
+ } else {
+ Resource definition = graph.getPossibleObject(predicate, DOC.Document_definesAttributeRelation);
+ if(definition != null) {
+ PropertyInfo info2 = graph.syncRequest(new PropertyInfoRequest(definition));
+ result.add(info2.name);
+ }
+ }
+
+ } catch (DatabaseException e) {
+ LOGGER.info(e.getMessage(), e);
+ }
+
+ }
+
+ procedure.execute(graph, result);
+
+ }
+
+ @Override
+ public void exception(AsyncReadGraph graph, Throwable throwable) {
+ LOGGER.info(throwable.getMessage(), throwable);
+ procedure.exception(graph, throwable);
+ }
+
+ });
+
+ }
+
+ }
+
+ static class StandardDocumentProperties implements DocumentProperties {
+
+ @Override
+ public Collection<String> getKeys(ReadGraph graph, Variable parent) throws DatabaseException {
+
+ if(parent instanceof StandardProceduralChildVariable) {
+
+ StandardProceduralChildVariable procedural = (StandardProceduralChildVariable)parent;
+ List<String> result = new ArrayList<>();
+ for(Variable property : procedural.getProperties(graph)) {
+ if(property instanceof StandardAssertedGraphPropertyVariable) {
+ StandardAssertedGraphPropertyVariable ass = (StandardAssertedGraphPropertyVariable)property;
+ if("dataDefinitions".equals(ass.property.name) || "commands".equals(ass.property.name) || "pollingFunction".equals(ass.property.name)) {
+ result.add(ass.property.name);
+ }
+ continue;
+ }
+ Resource predicate = property.getPossiblePredicateResource(graph);
+ if(predicate != null) {
+ PropertyInfo info = graph.syncRequest(new PropertyInfoRequest(predicate));
+ if(info.hasClassification(DocumentationResource.URIs.Document_AttributeRelation)) {
+ result.add(info.name);
+ }
+ }
+ }
+
+ return result;
+
+ } else {
+
+ Resource parentRes = parent.getRepresents(graph);
+ return graph.syncRequest(new DocumentPropertyKeys(parentRes), TransientCacheAsyncListener.instance());
+
+ }
+
+ }
+
+ @Override
+ public Object getValue(ReadGraph graph, Variable context, String key) throws DatabaseException {
+ return context.getPropertyValue(graph, key);
+ }
+
+ }
+
+ public static DocumentProperties primitiveProperties() throws DatabaseException {
+ return new StandardDocumentProperties();
+ }
+
@SCLValue(type = "VariableMap")
public static VariableMap inputSpaceChildren = new VariableMapImpl() {
};
- static class DocumentProxyChildVariable extends ProxyChildVariable {
+ static class DocumentProxyChildVariable extends ProxyChildVariable implements ProxyVariableSupport {
public DocumentProxyChildVariable(Variable base, Variable parent, Variable other, String name) {
super(base, parent, other, name);
if(other instanceof ProxyChildVariable) {
// The context is also a proxy - let it do the job
return super.getPossibleChild(graph, name);
- } else {
- return new RootVariable(this, base.getRepresents(graph));
- }
- }
-
- return super.getPossibleChild(graph, name);
-
- }
-
- public Collection<Variable> getChildren(ReadGraph graph) throws DatabaseException {
-
- Collection<Variable> result = super.getChildren(graph);
- if(!(base instanceof ProxyChildVariable)) {
- result.add(new RootVariable(this, base.getRepresents(graph)));
+ } else {
+ return ProxyVariables.tryToOwnRenamed(graph, this, base, CONTEXT_END);
+ }
}
- return result;
- }
-
- }
-
- static class RootVariable extends StandardGraphChildVariable {
+ return super.getPossibleChild(graph, name);
- public RootVariable(DocumentProxyChildVariable parent, Resource resource) {
- super(parent, null, resource);
}
@Override
- public String getName(ReadGraph graph) throws DatabaseException {
- return ProxyChildVariable.CONTEXT_END;
+ public Variable attachTo(ReadGraph graph, Variable parent) {
+ return attachToRenamed(graph, parent, name);
}
-
- @SuppressWarnings("deprecation")
+
@Override
- public Variable getNameVariable(ReadGraph graph) throws DatabaseException {
- return new ConstantPropertyVariable(this, Variables.NAME, ProxyChildVariable.CONTEXT_END, Bindings.STRING);
+ public Variable attachToRenamed(ReadGraph graph, Variable parent, String name) {
+ if(this.parent.equals(base))
+ return new DocumentProxyChildVariable(parent, parent, other, name);
+ else
+ return new DocumentProxyChildVariable(base, parent, other, name);
}
}
}
}
+ @Deprecated
public static AbstractEventHandler emptyOnClick(ReadGraph graph) throws DatabaseException {
return new EventHandler() {
@Override
};
}
+ @Deprecated
public static AbstractEventHandler writeEventHandler(ReadGraph graph, final Variable variable, final Function fn) {
final Session session = graph.getSession();
return (String)response;
}
return null;
- } catch (Throwable t) {
- t.printStackTrace();
} finally {
sclContext.put("graph", oldGraph);
sclContext.put(SCLReportingHandler.REPORTING_HANDLER, oldPrinter);
}
- return null;
-
}
});
};
}
+ @Deprecated
public static AbstractEventHandler readEventHandler(ReadGraph graph, final Variable variable, final Function fn) {
final Session session = graph.getSession();
return (String)response;
}
return null;
- } catch (Throwable t) {
- t.printStackTrace();
} finally {
sclContext.put("graph", oldGraph);
sclContext.put(SCLReportingHandler.REPORTING_HANDLER, oldPrinter);
}
- return null;
-
}
});
};
}
+ @Deprecated
public static AbstractEventHandler readEventHandler2(ReadGraph graph, final Function fn) {
final Session session = graph.getSession();
return (CommandResult)response;
}
return null;
- } catch (Throwable t) {
- t.printStackTrace();
} finally {
sclContext.put("graph", oldGraph);
sclContext.put(SCLReportingHandler.REPORTING_HANDLER, oldPrinter);
}
- return null;
-
}
});
final List<TCon> effects = ServerSCLHandlerValueRequest.getEffects(graph, anyFunction);
- final Function1<CommandContext, CommandResult> fn = anyFunction.getValue(graph);
- String expression = anyFunction.getPropertyValue(graph, "expression");
+ Function1<CommandContext, CommandResult> fn = anyFunction.getValue(graph);
+ //String expression = anyFunction.getPropertyValue(graph, "expression");
final Session session = graph.getSession();
- return new AbstractResponseHandler(expression) {
+ return new AbstractResponseHandler(fn) {
private String formatError(RequestProcessor proc, Throwable t) {
Object oldGraph = sclContext.put("graph", graph);
Object oldPrinter = sclContext.put(SCLReportingHandler.REPORTING_HANDLER, printer);
try {
- Object response = fn.apply(parameters);
- return response;
- } catch (Throwable t) {
- return new org.simantics.document.server.serverResponse.Error(formatError(graph, t));
+ return fn.apply(parameters);
} finally {
sclContext.put("graph", oldGraph);
sclContext.put(SCLReportingHandler.REPORTING_HANDLER, oldPrinter);
Object oldPrinter = sclContext.put(SCLReportingHandler.REPORTING_HANDLER, printer);
try {
- Object response = fn.apply(parameters);
- return response;
- } catch (Throwable t) {
- return new org.simantics.document.server.serverResponse.Error(formatError(graph, t));
+ return fn.apply(parameters);
} finally {
sclContext.put("graph", oldGraph);
sclContext.put(SCLReportingHandler.REPORTING_HANDLER, oldPrinter);
};
}
+ @Deprecated
public static AbstractEventHandler writeEventHandler2(ReadGraph graph, final Function fn) {
final Session session = graph.getSession();
return (CommandResult)response;
}
return null;
- } catch (Throwable t) {
- t.printStackTrace();
} finally {
sclContext.put("graph", oldGraph);
sclContext.put(SCLReportingHandler.REPORTING_HANDLER, oldPrinter);
}
- return null;
-
}
});
};
}
+
+ @Deprecated
public static AbstractEventHandler eventHandler2(ReadGraph graph, final Function fn) {
return new AbstractEventHandler() {
return (CommandResult)response;
}
return null;
- } catch (Throwable t) {
- t.printStackTrace();
} finally {
sclContext.put(SCLReportingHandler.REPORTING_HANDLER, oldPrinter);
}
- return null;
-
} catch (Throwable e) {
Logger.defaultLogError(e);
return new org.simantics.document.server.serverResponse.Error(e.getMessage());
};
}
+ @Deprecated
public static AbstractEventHandler eventHandler(ReadGraph graph, final Function fn) {
return new AbstractEventHandler() {
if(response instanceof String) {
result = (String)response;
}
- } catch (Throwable t) {
- t.printStackTrace();
} finally {
sclContext.put(SCLReportingHandler.REPORTING_HANDLER, oldPrinter);
}
} else {
- String id = sclStateKey(graph, base, self, ref);
-
- SCLRealm realm = SCLSessionManager.getOrCreateSCLRealm(base.getURI(graph) + "/__scl__");
- realm.getConnection().setVariable(id, getSCLType(defaultValue), defaultValue);
-
return defaultValue;
}
String id = sclStateKey(graph, base, self, ref);
- SCLRealm realm = SCLSessionManager.getOrCreateSCLRealm(base.getURI(graph)+"/__scl__");
- realm.getConnection().setVariable(id, getSCLType(value), value);
- realm.refreshVariablesSync();
+ StateRealm realm = (StateRealm) StateSessionManager.getInstance().getOrCreateRealm(graph, base.getURI(graph)+"/__scl__");
+ StateNodeManager nodeManager = (StateNodeManager) realm.getNodeManager();
+ nodeManager.setState(id, value);
}
return true;
}
} else {
- Variable parentCp = graph.sync(new UnaryRead<Connection, Variable>(conn) {
+ Variable parentCp = graph.sync(new BinaryRead<Variable, Connection, Variable>(widget, conn) {
@Override
public Variable perform(ReadGraph graph) throws DatabaseException {
DocumentationResource DOC = DocumentationResource.getInstance(graph);
- Collection<VariableConnectionPointDescriptor> descs = parameter.getConnectionPointDescriptors(graph, null);
+ Collection<VariableConnectionPointDescriptor> descs = parameter2.getConnection2().getConnectionPointDescriptors(graph, parameter, null);
for(VariableConnectionPointDescriptor desc : descs) {
if (DOC.Relations_partN.equals(desc.getConnectionPointResource(graph))) {
return graph.syncRequest(new PathExistsRequest(context));
}
+ public static String compileDocumentSCLValueExpression(ReadGraph graph, Variable context) {
+ try {
+ ServerSCLValueRequest.validate(graph, context);
+ return "";
+ } catch (Exception e) {
+ return resolveIssueMessage(e);
+ }
+ }
+
+ private static String resolveIssueMessage(Exception e) {
+ if (e instanceof ImportFailureException)
+ return "";
+ if (e.getCause() != null && e.getCause() instanceof ImportFailureException)
+ return "";
+ if (e instanceof SCLDatabaseException) {
+ SCLDatabaseException ee = (SCLDatabaseException) e;
+ return ee.getMessage();
+ }
+ if (LOGGER.isDebugEnabled())
+ LOGGER.debug("", e);
+ return e.getMessage();
+ }
+
}
\ No newline at end of file