import java.io.IOException;
+import org.cojen.classfile.TypeDesc;
import org.simantics.Simantics;
import org.simantics.db.ReadGraph;
import org.simantics.db.Resource;
import org.simantics.db.VirtualGraph;
import org.simantics.db.WriteGraph;
+import org.simantics.db.common.procedure.adapter.SyncListenerAdapter;
import org.simantics.db.common.procedure.adapter.TransientCacheAsyncListener;
import org.simantics.db.common.request.BinaryRead;
import org.simantics.db.common.request.DelayedWriteRequest;
import org.simantics.db.common.request.ReadRequest;
+import org.simantics.db.common.request.UnaryRead;
import org.simantics.db.common.request.WriteRequest;
import org.simantics.db.common.request.WriteResultRequest;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.layer0.variable.Variables;
import org.simantics.db.request.Read;
import org.simantics.db.service.ClusterControl;
+import org.simantics.db.service.QueryControl;
import org.simantics.db.service.SerialisationSupport;
import org.simantics.db.service.VirtualGraphSupport;
import org.simantics.layer0.utils.triggers.IActivationManager;
+import org.simantics.scl.compiler.environment.specification.EnvironmentSpecification;
+import org.simantics.scl.compiler.errors.Failable;
+import org.simantics.scl.compiler.internal.codegen.types.JavaTypeTranslator;
+import org.simantics.scl.compiler.module.Module;
+import org.simantics.scl.compiler.module.repository.ImportFailureException;
+import org.simantics.scl.compiler.runtime.RuntimeEnvironment;
+import org.simantics.scl.compiler.types.Type;
+import org.simantics.scl.osgi.SCLOsgi;
import org.simantics.scl.runtime.SCLContext;
import org.simantics.scl.runtime.function.Function;
import org.simantics.scl.runtime.function.Function1;
+import org.simantics.scl.runtime.tuple.Tuple;
import org.simantics.scl.runtime.tuple.Tuple0;
import org.simantics.utils.DataContainer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
@SuppressWarnings({"rawtypes", "unchecked"})
public class SCLFunctions {
+ private static final Logger LOGGER = LoggerFactory.getLogger(SCLFunctions.class);
+
public static final String GRAPH = "graph";
public static <T> T safeExec(final Function f) {
try {
return (T)f.apply(Tuple0.INSTANCE);
} catch (Throwable t) {
- t.printStackTrace();
+ LOGGER.error("safeExec caught exception", t);
return null;
}
}
public static void asyncRead(final Function f) throws DatabaseException {
- final SCLContext context = SCLContext.getCurrent();
- Object graph = context.get(GRAPH);
- if (graph != null) {
- f.apply(Tuple0.INSTANCE);
- } else {
- Simantics.getSession().asyncRequest(new ReadRequest() {
- @Override
- public void run(ReadGraph graph) throws DatabaseException {
- SCLContext.push(context);
- ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);
- try {
- f.apply(Tuple0.INSTANCE);
- } finally {
- context.put(GRAPH, oldGraph);
- SCLContext.pop();
- }
+ final SCLContext context = SCLContext.createDerivedContext();
+ Simantics.getSession().asyncRequest(new ReadRequest() {
+ @Override
+ public void run(ReadGraph graph) throws DatabaseException {
+ SCLContext.push(context);
+ context.put(GRAPH, graph);
+ try {
+ f.apply(Tuple0.INSTANCE);
+ } finally {
+ SCLContext.pop();
}
- });
- }
+ }
+ });
}
public static <T> T syncRead(final Function f) throws DatabaseException {
}
public static void asyncWrite(final Function f) throws DatabaseException {
- final SCLContext context = SCLContext.getCurrent();
- Object graph = context.get(GRAPH);
- if (graph != null) {
- f.apply(Tuple0.INSTANCE);
- } else {
+ SCLContext context = SCLContext.createDerivedContext();
+ if (Simantics.peekSession() != null) {
Simantics.getSession().asyncRequest(new WriteRequest() {
@Override
public void perform(WriteGraph graph) throws DatabaseException {
SCLContext.push(context);
- ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);
+ context.put(GRAPH, graph);
try {
f.apply(Tuple0.INSTANCE);
} finally {
- context.put(GRAPH, oldGraph);
SCLContext.pop();
}
}
});
+ } else {
+ LOGGER.warn("No session available for asynchronous write requests");
}
}
return graph.syncRequest(new SCLUnaryRead(fn, value), TransientCacheAsyncListener.<Object>instance());
}
+
+ private static class Subquery extends UnaryRead<Function, Object> {
+
+ public Subquery(Function q) {
+ super(q);
+ }
+
+ @Override
+ public Object perform(ReadGraph graph) throws DatabaseException {
+ return Simantics.applySCLRead(graph, parameter, Tuple0.INSTANCE);
+ }
+
+ }
+
+ public static Object subquery(ReadGraph graph, Function q) throws DatabaseException {
+ return graph.syncRequest(new Subquery(q));
+ }
+
+ public static Object subqueryC(ReadGraph graph, Function q) throws DatabaseException {
+ return graph.syncRequest(new Subquery(q), TransientCacheAsyncListener.<Object>instance());
+ }
+
+ public static void subqueryL(ReadGraph graph, Function query, Function executeCallback, Function1<Throwable, Tuple> exceptionCallback, Function1<Tuple0, Boolean> isDisposedCallback) throws DatabaseException {
+ graph.asyncRequest(new Subquery(query), new SyncListenerAdapter<Object>() {
+ @Override
+ public void execute(ReadGraph graph, Object result) throws DatabaseException {
+ Simantics.applySCLRead(graph, executeCallback, result);
+ }
+
+ @Override
+ public void exception(ReadGraph graph, Throwable t) throws DatabaseException {
+ Simantics.applySCLRead(graph, exceptionCallback, t);
+ }
+
+ @Override
+ public boolean isDisposed() {
+ return isDisposedCallback.apply(Tuple0.INSTANCE);
+ }
+ });
+ }
+
+ public static Object possibleFromDynamic(Type expectedType, String moduleName, Object value) {
+
+ try {
+
+
+ Failable<Module> failable = SCLOsgi.MODULE_REPOSITORY.getModule(moduleName);
+ Module module = failable.getResult();
+
+ RuntimeEnvironment env = SCLOsgi.MODULE_REPOSITORY.createRuntimeEnvironment(
+ EnvironmentSpecification.of(moduleName, ""), module.getParentClassLoader());
+
+ JavaTypeTranslator tr = new JavaTypeTranslator(env.getEnvironment());
+ TypeDesc desc = tr.toTypeDesc(expectedType);
+ String className = desc.getFullName();
+ Class<?> clazz = env.getMutableClassLoader().loadClass(className);
+ if (!clazz.isAssignableFrom(value.getClass()))
+ return null;
+
+ } catch (ImportFailureException | ClassNotFoundException e) {
+ }
+ return value;
+ }
+
+ public static void restrictQueries(ReadGraph graph, int amount, int step, int maxTimeInMs) {
+
+ QueryControl qc = graph.getService(QueryControl.class);
+ long start = System.currentTimeMillis();
+ while(true) {
+ int current = qc.count();
+ if(current < amount) return;
+ qc.gc(graph, step);
+ long duration = System.currentTimeMillis() - start;
+ if(duration > maxTimeInMs) return;
+ }
+
+ }
+
+ public static int countQueries(ReadGraph graph) {
+
+ QueryControl qc = graph.getService(QueryControl.class);
+ return qc.count();
+
+ }
+
}
Code Review / simantics / platform.git / blobdiff