(refs #7607) Fixed handling of SCLContext in asynchronous requests

[simantics/platform.git] / bundles / org.simantics.scl.db / src / org / simantics / scl / db / SCLFunctions.java

diff --git a/bundles/org.simantics.scl.db/src/org/simantics/scl/db/SCLFunctions.java b/bundles/org.simantics.scl.db/src/org/simantics/scl/db/SCLFunctions.java
index 9b4d6b8ac92ec90d5c3970285efbe15d7550c008..59923933f6107f3e8f0d25e928c9b2fdc7229f1e 100644 (file)
--- a/bundles/org.simantics.scl.db/src/org/simantics/scl/db/SCLFunctions.java
+++ b/bundles/org.simantics.scl.db/src/org/simantics/scl/db/SCLFunctions.java
@@ -2,11 +2,13 @@ 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;
@@ -21,9 +23,18 @@ 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;
 
@@ -42,25 +53,19 @@ public class SCLFunctions {
     }
     
     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 {
@@ -86,25 +91,19 @@ public class SCLFunctions {
     }
     
     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 {
-            Simantics.getSession().asyncRequest(new WriteRequest() {
-                @Override
-                public void perform(WriteGraph 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();
-                    }
+        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 {
@@ -310,4 +309,48 @@ public class SCLFunctions {
     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;
+    }
+
 }