Enable model loading using an existing transaction.

[simantics/3d.git] / org.simantics.plant3d / src / org / simantics / plant3d / scl / SCLUtil.java

diff --git a/org.simantics.plant3d/src/org/simantics/plant3d/scl/SCLUtil.java b/org.simantics.plant3d/src/org/simantics/plant3d/scl/SCLUtil.java
index 4c4b6d5760a6f40b68533dba92a67b741585fc27..6b1947d43e802e2b1a5609987e4b727cfd9ab454 100644 (file)
--- a/org.simantics.plant3d/src/org/simantics/plant3d/scl/SCLUtil.java
+++ b/org.simantics.plant3d/src/org/simantics/plant3d/scl/SCLUtil.java
@@ -2,9 +2,11 @@ package org.simantics.plant3d.scl;
 
 import org.simantics.Simantics;
 import org.simantics.db.ReadGraph;
+import org.simantics.db.RequestProcessor;
 import org.simantics.db.Resource;
 import org.simantics.db.exception.DatabaseException;
 import org.simantics.db.request.Read;
+import org.simantics.g3d.scenegraph.base.INode;
 import org.simantics.objmap.graph.IMapping;
 import org.simantics.objmap.graph.Mappings;
 import org.simantics.objmap.graph.schema.IMappingSchema;
@@ -15,50 +17,63 @@ import org.simantics.plant3d.scenegraph.controlpoint.ControlPointFactory;
 import org.simantics.plant3d.scenegraph.controlpoint.PipingRules;
 import org.simantics.plant3d.utils.ComponentUtils;
 import org.simantics.plant3d.utils.P3DUtil;
+import org.simantics.scl.runtime.SCLContext;
 
 public class SCLUtil {
 
        public static interface SchemaProvider {
-               IMappingSchema<Resource,Object> get(ReadGraph graph) throws DatabaseException;
+               IMappingSchema<Resource,INode> get(ReadGraph graph) throws DatabaseException;
        }
 
        public static interface NodeMapProvider {
-               P3DScriptNodeMap get(IMapping<Resource, Object> mapping, P3DRootNode rootNode);
+               P3DScriptNodeMap get(IMapping<Resource, INode> mapping, P3DRootNode rootNode);
        }
        
        public static P3DScriptNodeMap load(final Resource root) throws DatabaseException {
-               preload(Plant3D.URIs.Builtin);
+               return load(getRequestProcessor(), root);
+       }
+       
+       public static P3DScriptNodeMap load(RequestProcessor session, final Resource root) throws DatabaseException {
+               preload(Simantics.getSession(), Plant3D.URIs.Builtin);
 
                SchemaProvider schemaProvider = g -> SchemaBuilder.getSchema(g);
                NodeMapProvider mapProvider = (mapping, rootNode) -> new P3DScriptNodeMap(Simantics.getSession(), mapping, rootNode);
-               return load(root, schemaProvider, mapProvider);
+               return load(session, root, schemaProvider, mapProvider);
        }
 
        public static P3DRootNode loadReadOnly(final Resource root) throws DatabaseException {
-               preload(Plant3D.URIs.Builtin);
+               return loadReadOnly(getRequestProcessor(), root);
+       }
+
+       public static P3DRootNode loadReadOnly(RequestProcessor session, final Resource root) throws DatabaseException {
+               preload(session, Plant3D.URIs.Builtin);
                
                SchemaProvider schemaProvider = g -> SchemaBuilder.getSchema(g);
-               return loadReadOnly(root, schemaProvider);
+               return loadReadOnly(session, root, schemaProvider);
        }
 
-       public static void preload(String symbolSet) throws DatabaseException {
+       public static void preload(RequestProcessor session, String symbolSet) throws DatabaseException {
                try {
-                       ControlPointFactory.preloadCache(symbolSet);
-                       ComponentUtils.preloadCache();
+                       ControlPointFactory.preloadCache(session, symbolSet);
+                       ComponentUtils.preloadCache(session);
                } catch (Exception e) {
                        throw new DatabaseException(e);
                }
        }
 
        public static <NodeMap extends P3DScriptNodeMap> NodeMap load(final Resource root, SchemaProvider schemaProvider, NodeMapProvider mapProvider) throws DatabaseException {
-               return Simantics.getSession().syncRequest(new Read<NodeMap>() {
+               return load(getRequestProcessor(), root, schemaProvider, mapProvider);
+       }
+       
+       public static <NodeMap extends P3DScriptNodeMap> NodeMap load(RequestProcessor session, final Resource root, SchemaProvider schemaProvider, NodeMapProvider mapProvider) throws DatabaseException {
+               return session.syncRequest(new Read<NodeMap>() {
                        @Override
                        public NodeMap perform(ReadGraph graph) throws DatabaseException {
                                PipingRules.setEnabled(false);
-                               IMappingSchema<Resource, Object> schema = schemaProvider.get(graph);
-                               IMapping<Resource, Object> mapping = Mappings.createWithListening(schema);
+                               IMappingSchema<Resource, INode> schema = schemaProvider.get(graph);
+                               IMapping<Resource, INode> mapping = Mappings.createWithListening(schema);
                                P3DRootNode rootNode = (P3DRootNode) mapping.map(graph, root);
-                               rootNode.setMapping((IMapping)mapping);
+                               rootNode.setMapping(mapping);
                                try {
                                        P3DUtil.finalizeDBLoad(rootNode);
                                        // FIXME: Something needs to be done here...
@@ -74,17 +89,17 @@ public class SCLUtil {
                });
        }
 
-       public static <Root extends P3DRootNode> Root loadReadOnly(final Resource root, SchemaProvider schemaProvider)
+       public static <Root extends P3DRootNode> Root loadReadOnly(RequestProcessor session, final Resource root, SchemaProvider schemaProvider)
                        throws DatabaseException {
-               return Simantics.getSession().syncRequest(new Read<Root>() {
+               return session.syncRequest(new Read<Root>() {
                        @Override
                        public Root perform(ReadGraph graph) throws DatabaseException {
                                PipingRules.setEnabled(false);
-                               IMappingSchema<Resource, Object> schema = schemaProvider.get(graph);
-                               IMapping<Resource, Object> mapping = Mappings.createWithoutListening(schema);
+                               IMappingSchema<Resource, INode> schema = schemaProvider.get(graph);
+                               IMapping<Resource, INode> mapping = Mappings.createWithoutListening(schema);
                                @SuppressWarnings("unchecked")
                                Root rootNode = (Root) mapping.map(graph, root);
-                               rootNode.setMapping((IMapping)mapping);
+                               rootNode.setMapping(mapping);
                                try {
                                        P3DUtil.finalizeDBLoad(rootNode);
                                        P3DUtil.finalizeDBLoad2(rootNode);
@@ -97,4 +112,19 @@ public class SCLUtil {
                });
        }
 
+       /**
+        * Load a read-only Java object representation of a Plant3d model.
+        * 
+        * This method can be called from SCL either as a &lt;Proc&gt; or a &lt;ReadGraph&gt; function.
+        */
+       public static <Root extends P3DRootNode> Root loadReadOnly(final Resource root, SchemaProvider schemaProvider)
+                       throws DatabaseException {
+               return loadReadOnly(getRequestProcessor(), root, schemaProvider);
+       }
+
+       public static RequestProcessor getRequestProcessor() {
+               RequestProcessor rp = (RequestProcessor) SCLContext.getCurrent().get("graph");
+               return rp != null ? rp : Simantics.getSession();
+       }
+
 }