-package org.simantics.scl.db;\r
-\r
-import java.io.IOException;\r
-\r
-import org.simantics.Simantics;\r
-import org.simantics.db.ReadGraph;\r
-import org.simantics.db.Resource;\r
-import org.simantics.db.VirtualGraph;\r
-import org.simantics.db.WriteGraph;\r
-import org.simantics.db.common.procedure.adapter.TransientCacheAsyncListener;\r
-import org.simantics.db.common.request.BinaryRead;\r
-import org.simantics.db.common.request.DelayedWriteRequest;\r
-import org.simantics.db.common.request.ReadRequest;\r
-import org.simantics.db.common.request.WriteRequest;\r
-import org.simantics.db.common.request.WriteResultRequest;\r
-import org.simantics.db.exception.DatabaseException;\r
-import org.simantics.db.layer0.util.Layer0Utils;\r
-import org.simantics.db.layer0.variable.Variables;\r
-import org.simantics.db.request.Read;\r
-import org.simantics.db.service.ClusterControl;\r
-import org.simantics.db.service.SerialisationSupport;\r
-import org.simantics.db.service.VirtualGraphSupport;\r
-import org.simantics.layer0.utils.triggers.IActivationManager;\r
-import org.simantics.scl.runtime.SCLContext;\r
-import org.simantics.scl.runtime.function.Function;\r
-import org.simantics.scl.runtime.function.Function1;\r
-import org.simantics.scl.runtime.tuple.Tuple0;\r
-import org.simantics.utils.DataContainer;\r
-\r
-@SuppressWarnings({"rawtypes", "unchecked"})\r
-public class SCLFunctions {\r
-\r
- public static final String GRAPH = "graph";\r
-\r
- public static <T> T safeExec(final Function f) {\r
- try {\r
- return (T)f.apply(Tuple0.INSTANCE);\r
- } catch (Throwable t) {\r
- t.printStackTrace();\r
- return null;\r
- }\r
- }\r
- \r
- public static void asyncRead(final Function f) throws DatabaseException {\r
- final SCLContext context = SCLContext.getCurrent();\r
- Object graph = context.get(GRAPH);\r
- if (graph != null) {\r
- f.apply(Tuple0.INSTANCE);\r
- } else {\r
- Simantics.getSession().asyncRequest(new ReadRequest() {\r
- @Override\r
- public void run(ReadGraph graph) throws DatabaseException {\r
- SCLContext.push(context);\r
- ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);\r
- try {\r
- f.apply(Tuple0.INSTANCE);\r
- } finally {\r
- context.put(GRAPH, oldGraph);\r
- SCLContext.pop();\r
- }\r
- }\r
- });\r
- }\r
- }\r
- \r
- public static <T> T syncRead(final Function f) throws DatabaseException {\r
- final SCLContext context = SCLContext.getCurrent();\r
- Object graph = context.get(GRAPH);\r
- if (graph != null) {\r
- return (T)f.apply(Tuple0.INSTANCE);\r
- } else {\r
- return Simantics.getSession().syncRequest(new Read<T>() {\r
- @Override\r
- public T perform(ReadGraph graph) throws DatabaseException {\r
- SCLContext.push(context);\r
- ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);\r
- try {\r
- return (T)f.apply(Tuple0.INSTANCE);\r
- } finally {\r
- context.put(GRAPH, oldGraph);\r
- SCLContext.pop();\r
- }\r
- }\r
- });\r
- }\r
- }\r
- \r
- public static void asyncWrite(final Function f) throws DatabaseException {\r
- final SCLContext context = SCLContext.getCurrent();\r
- Object graph = context.get(GRAPH);\r
- if (graph != null) {\r
- f.apply(Tuple0.INSTANCE);\r
- } else {\r
- Simantics.getSession().asyncRequest(new WriteRequest() {\r
- @Override\r
- public void perform(WriteGraph graph) throws DatabaseException {\r
- SCLContext.push(context);\r
- ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);\r
- try {\r
- f.apply(Tuple0.INSTANCE);\r
- } finally {\r
- context.put(GRAPH, oldGraph);\r
- SCLContext.pop();\r
- }\r
- }\r
- });\r
- }\r
- }\r
- \r
- public static <T> T syncWrite(final Function f) throws DatabaseException {\r
- final SCLContext context = SCLContext.getCurrent();\r
- Object graph = context.get(GRAPH);\r
- if (graph != null) {\r
- return (T)f.apply(Tuple0.INSTANCE);\r
- } else {\r
- return Simantics.getSession().syncRequest(new WriteResultRequest<T>() {\r
- @Override\r
- public T perform(WriteGraph graph) throws DatabaseException {\r
- SCLContext.push(context);\r
- ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);\r
- try {\r
- return (T)f.apply(Tuple0.INSTANCE);\r
- } finally {\r
- context.put(GRAPH, oldGraph);\r
- SCLContext.pop();\r
- }\r
- }\r
- });\r
- }\r
- }\r
- \r
- public static <T> T delayedSyncWrite(final Function f) throws DatabaseException {\r
- final SCLContext context = SCLContext.getCurrent();\r
- final DataContainer<T> dc = new DataContainer<T>(null);\r
-\r
- DelayedWriteRequest request = new DelayedWriteRequest() {\r
- @Override\r
- public void perform(WriteGraph graph) throws DatabaseException {\r
- final SCLContext context = SCLContext.getCurrent();\r
- SCLContext.push(context);\r
- ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);\r
- try {\r
- dc.set((T)f.apply(Tuple0.INSTANCE));\r
- } finally {\r
- context.put(GRAPH, oldGraph);\r
- SCLContext.pop();\r
- }\r
- }\r
- };\r
- \r
- Object graph = context.get(GRAPH);\r
- if (graph != null) {\r
- if (graph instanceof WriteGraph) {\r
- ((WriteGraph)graph).syncRequest(request);\r
- } else {\r
- throw new DatabaseException("Caller is inside a read transaction.");\r
- }\r
- } else {\r
- Simantics.getSession().syncRequest(request);\r
- }\r
- return dc.get();\r
- }\r
-\r
- public static <T> T virtualSyncWriteMem(WriteGraph graph, String virtualGraphId, final Function f) throws DatabaseException {\r
- final SCLContext context = SCLContext.getCurrent();\r
- VirtualGraphSupport vgs = graph.getService(VirtualGraphSupport.class);\r
- VirtualGraph vg = vgs.getMemoryPersistent(virtualGraphId);\r
- return graph.syncRequest(new WriteResultRequest<T>(vg) {\r
- @Override\r
- public T perform(WriteGraph graph) throws DatabaseException {\r
- SCLContext.push(context);\r
- ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);\r
- try {\r
- return (T)f.apply(Tuple0.INSTANCE);\r
- } finally {\r
- context.put(GRAPH, oldGraph);\r
- SCLContext.pop();\r
- }\r
- }\r
- });\r
- }\r
- \r
- public static <T> T virtualSyncWriteWS(WriteGraph graph, String virtualGraphId, final Function f) throws DatabaseException {\r
- final SCLContext context = SCLContext.getCurrent();\r
- VirtualGraphSupport vgs = graph.getService(VirtualGraphSupport.class);\r
- VirtualGraph vg = vgs.getWorkspacePersistent(virtualGraphId);\r
- return graph.syncRequest(new WriteResultRequest<T>(vg) {\r
- @Override\r
- public T perform(WriteGraph graph) throws DatabaseException {\r
- SCLContext.push(context);\r
- ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);\r
- try {\r
- return (T)f.apply(Tuple0.INSTANCE);\r
- } finally {\r
- context.put(GRAPH, oldGraph);\r
- SCLContext.pop();\r
- }\r
- }\r
- });\r
- }\r
- \r
- public static <T> T readValue(final String uri) throws DatabaseException {\r
- return Simantics.getSession().syncRequest(new Read<T>() {\r
- @Override\r
- public T perform(ReadGraph graph) throws DatabaseException {\r
- return Variables.getVariable(graph, uri).getValue(graph);\r
- } \r
- });\r
- }\r
- \r
- public static <T> void writeValue(final String uri, final T value) throws DatabaseException {\r
- Simantics.getSession().syncRequest(new WriteRequest() {\r
- @Override\r
- public void perform(WriteGraph graph) throws DatabaseException {\r
- Variables.getVariable(graph, uri).setValue(graph, value);\r
- } \r
- });\r
- }\r
- \r
- public static void activateOnce(Resource r) {\r
- Simantics.getSession().getService(IActivationManager.class).activateOnce(r);\r
- }\r
- \r
- public static void syncActivateOnce(WriteGraph graph, Resource r) throws DatabaseException {\r
- graph.getService(IActivationManager.class).activateOnce(graph, r);\r
- }\r
-\r
- public static Resource resourceFromId(ReadGraph graph, long id) throws DatabaseException, IOException {\r
- SerialisationSupport ss = graph.getService(SerialisationSupport.class);\r
- return ss.getResource(id);\r
- }\r
- \r
- public static void disableDependencies(WriteGraph graph) {\r
- Layer0Utils.setDependenciesIndexingDisabled(graph, true); \r
- }\r
- \r
- public static void enableDependencies(WriteGraph graph) {\r
- Layer0Utils.setDependenciesIndexingDisabled(graph, false); \r
- }\r
- \r
- public static void collectClusters() {\r
- Simantics.getSession().getService(ClusterControl.class).collectClusters(Integer.MAX_VALUE);\r
- }\r
- \r
- public static class SCLUnaryRead extends BinaryRead<Function1<Object,Object>, Object, Object> {\r
-\r
- public SCLUnaryRead(Function1<Object, Object> parameter1, Object parameter2) {\r
- super(parameter1, parameter2);\r
- }\r
-\r
- @Override\r
- public Object perform(ReadGraph graph) throws DatabaseException {\r
- return Simantics.applySCLRead(graph, parameter, parameter2);\r
- }\r
- \r
- }\r
- \r
- public static Object unaryQuery(ReadGraph graph, Function1<Object,Object> fn, Object value) throws DatabaseException {\r
- return graph.syncRequest(new SCLUnaryRead(fn, value));\r
- }\r
-\r
- public static Object unaryQueryCached(ReadGraph graph, Function1<Object,Object> fn, Object value) throws DatabaseException {\r
- return graph.syncRequest(new SCLUnaryRead(fn, value), TransientCacheAsyncListener.<Object>instance());\r
- }\r
- \r
-}\r
+package org.simantics.scl.db;
+
+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.WriteRequest;
+import org.simantics.db.common.request.WriteResultRequest;
+import org.simantics.db.exception.DatabaseException;
+import org.simantics.db.layer0.util.Layer0Utils;
+import org.simantics.db.layer0.variable.Variables;
+import org.simantics.db.request.Read;
+import org.simantics.db.service.ClusterControl;
+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;
+
+@SuppressWarnings({"rawtypes", "unchecked"})
+public class SCLFunctions {
+
+ 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();
+ return null;
+ }
+ }
+
+ public static void asyncRead(final Function f) throws DatabaseException {
+ 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 {
+ final SCLContext context = SCLContext.getCurrent();
+ Object graph = context.get(GRAPH);
+ if (graph != null) {
+ return (T)f.apply(Tuple0.INSTANCE);
+ } else {
+ return Simantics.getSession().syncRequest(new Read<T>() {
+ @Override
+ public T perform(ReadGraph graph) throws DatabaseException {
+ SCLContext.push(context);
+ ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);
+ try {
+ return (T)f.apply(Tuple0.INSTANCE);
+ } finally {
+ context.put(GRAPH, oldGraph);
+ SCLContext.pop();
+ }
+ }
+ });
+ }
+ }
+
+ public static void asyncWrite(final Function f) throws DatabaseException {
+ SCLContext context = SCLContext.createDerivedContext();
+ Simantics.getSession().asyncRequest(new WriteRequest() {
+ @Override
+ public void perform(WriteGraph graph) throws DatabaseException {
+ SCLContext.push(context);
+ context.put(GRAPH, graph);
+ try {
+ f.apply(Tuple0.INSTANCE);
+ } finally {
+ SCLContext.pop();
+ }
+ }
+ });
+ }
+
+ public static <T> T syncWrite(final Function f) throws DatabaseException {
+ final SCLContext context = SCLContext.getCurrent();
+ Object graph = context.get(GRAPH);
+ if (graph != null) {
+ return (T)f.apply(Tuple0.INSTANCE);
+ } else {
+ return Simantics.getSession().syncRequest(new WriteResultRequest<T>() {
+ @Override
+ public T perform(WriteGraph graph) throws DatabaseException {
+ SCLContext.push(context);
+ ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);
+ try {
+ return (T)f.apply(Tuple0.INSTANCE);
+ } finally {
+ context.put(GRAPH, oldGraph);
+ SCLContext.pop();
+ }
+ }
+ });
+ }
+ }
+
+ public static <T> T delayedSyncWrite(final Function f) throws DatabaseException {
+ final SCLContext context = SCLContext.getCurrent();
+ final DataContainer<T> dc = new DataContainer<T>(null);
+
+ DelayedWriteRequest request = new DelayedWriteRequest() {
+ @Override
+ public void perform(WriteGraph graph) throws DatabaseException {
+ final SCLContext context = SCLContext.getCurrent();
+ SCLContext.push(context);
+ ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);
+ try {
+ dc.set((T)f.apply(Tuple0.INSTANCE));
+ } finally {
+ context.put(GRAPH, oldGraph);
+ SCLContext.pop();
+ }
+ }
+ };
+
+ Object graph = context.get(GRAPH);
+ if (graph != null) {
+ if (graph instanceof WriteGraph) {
+ ((WriteGraph)graph).syncRequest(request);
+ } else {
+ throw new DatabaseException("Caller is inside a read transaction.");
+ }
+ } else {
+ Simantics.getSession().syncRequest(request);
+ }
+ return dc.get();
+ }
+
+ public static <T> T virtualSyncWriteMem(WriteGraph graph, String virtualGraphId, final Function f) throws DatabaseException {
+ final SCLContext context = SCLContext.getCurrent();
+ VirtualGraphSupport vgs = graph.getService(VirtualGraphSupport.class);
+ VirtualGraph vg = vgs.getMemoryPersistent(virtualGraphId);
+ return graph.syncRequest(new WriteResultRequest<T>(vg) {
+ @Override
+ public T perform(WriteGraph graph) throws DatabaseException {
+ SCLContext.push(context);
+ ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);
+ try {
+ return (T)f.apply(Tuple0.INSTANCE);
+ } finally {
+ context.put(GRAPH, oldGraph);
+ SCLContext.pop();
+ }
+ }
+ });
+ }
+
+ public static <T> T virtualSyncWriteWS(WriteGraph graph, String virtualGraphId, final Function f) throws DatabaseException {
+ final SCLContext context = SCLContext.getCurrent();
+ VirtualGraphSupport vgs = graph.getService(VirtualGraphSupport.class);
+ VirtualGraph vg = vgs.getWorkspacePersistent(virtualGraphId);
+ return graph.syncRequest(new WriteResultRequest<T>(vg) {
+ @Override
+ public T perform(WriteGraph graph) throws DatabaseException {
+ SCLContext.push(context);
+ ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);
+ try {
+ return (T)f.apply(Tuple0.INSTANCE);
+ } finally {
+ context.put(GRAPH, oldGraph);
+ SCLContext.pop();
+ }
+ }
+ });
+ }
+
+ public static <T> T readValue(final String uri) throws DatabaseException {
+ return Simantics.getSession().syncRequest(new Read<T>() {
+ @Override
+ public T perform(ReadGraph graph) throws DatabaseException {
+ return Variables.getVariable(graph, uri).getValue(graph);
+ }
+ });
+ }
+
+ public static <T> void writeValue(final String uri, final T value) throws DatabaseException {
+ Simantics.getSession().syncRequest(new WriteRequest() {
+ @Override
+ public void perform(WriteGraph graph) throws DatabaseException {
+ Variables.getVariable(graph, uri).setValue(graph, value);
+ }
+ });
+ }
+
+ public static void activateOnce(Resource r) {
+ Simantics.getSession().getService(IActivationManager.class).activateOnce(r);
+ }
+
+ public static void syncActivateOnce(WriteGraph graph, Resource r) throws DatabaseException {
+ graph.getService(IActivationManager.class).activateOnce(graph, r);
+ }
+
+ public static Resource resourceFromId(ReadGraph graph, long id) throws DatabaseException, IOException {
+ SerialisationSupport ss = graph.getService(SerialisationSupport.class);
+ return ss.getResource(id);
+ }
+
+ public static void disableDependencies(WriteGraph graph) {
+ Layer0Utils.setDependenciesIndexingDisabled(graph, true);
+ }
+
+ public static void enableDependencies(WriteGraph graph) {
+ Layer0Utils.setDependenciesIndexingDisabled(graph, false);
+ }
+
+ public static void collectClusters() {
+ Simantics.getSession().getService(ClusterControl.class).collectClusters(Integer.MAX_VALUE);
+ }
+
+ public static class SCLUnaryRead extends BinaryRead<Function1<Object,Object>, Object, Object> {
+
+ public SCLUnaryRead(Function1<Object, Object> parameter1, Object parameter2) {
+ super(parameter1, parameter2);
+ }
+
+ @Override
+ public Object perform(ReadGraph graph) throws DatabaseException {
+ return Simantics.applySCLRead(graph, parameter, parameter2);
+ }
+
+ }
+
+ public static Object unaryQuery(ReadGraph graph, Function1<Object,Object> fn, Object value) throws DatabaseException {
+ return graph.syncRequest(new SCLUnaryRead(fn, value));
+ }
+
+ public static Object unaryQueryCached(ReadGraph graph, Function1<Object,Object> fn, Object value) throws DatabaseException {
+ return graph.syncRequest(new SCLUnaryRead(fn, value), TransientCacheAsyncListener.<Object>instance());
+ }
+
+
+ private static class Subquery implements Read<Object> {
+ Function q;
+
+ public Subquery(Function q) {
+ this.q = q;
+ }
+
+ @Override
+ public Object perform(ReadGraph graph) throws DatabaseException {
+ SCLContext sclContext = SCLContext.getCurrent();
+ Object oldGraph = sclContext.put("graph", graph);
+ try {
+ return q.apply(Tuple0.INSTANCE);
+ } catch (Throwable e) {
+ if(e instanceof DatabaseException)
+ throw (DatabaseException)e;
+ else
+ throw new DatabaseException(e);
+ } finally {
+ sclContext.put("graph", oldGraph);
+ }
+ }
+
+ @Override
+ public int hashCode() {
+ return q.hashCode();
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if(this == obj)
+ return true;
+ if(obj == null || obj.getClass() != getClass())
+ return false;
+ Subquery other = (Subquery)obj;
+ return q.equals(other.q);
+ }
+ }
+
+ 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) {
+ executeCallback.apply(result);
+ }
+
+ @Override
+ public void exception(ReadGraph graph, Throwable t) {
+ exceptionCallback.apply(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;
+ }
+
+}
Code Review / simantics / platform.git / blobdiff