org.simantics.plant3d/src/org/simantics/plant3d/scl/SCLUtil.java

   1 package org.simantics.plant3d.scl;
   2
   3 import org.simantics.Simantics;
   4 import org.simantics.db.ReadGraph;
   5 import org.simantics.db.RequestProcessor;
   6 import org.simantics.db.Resource;
   7 import org.simantics.db.exception.DatabaseException;
   8 import org.simantics.db.request.Read;
   9 import org.simantics.g3d.scenegraph.base.INode;
  10 import org.simantics.objmap.graph.IMapping;
  11 import org.simantics.objmap.graph.Mappings;
  12 import org.simantics.objmap.graph.schema.IMappingSchema;
  13 import org.simantics.plant3d.ontology.Plant3D;
  14 import org.simantics.plant3d.scenegraph.P3DRootNode;
  15 import org.simantics.plant3d.scenegraph.SchemaBuilder;
  16 import org.simantics.plant3d.scenegraph.controlpoint.ControlPointFactory;
  17 import org.simantics.plant3d.scenegraph.controlpoint.PipingRules;
  18 import org.simantics.plant3d.utils.ComponentUtils;
  19 import org.simantics.plant3d.utils.P3DUtil;
  20 import org.simantics.scl.runtime.SCLContext;
  21
  22 public class SCLUtil {
  23
  24         public static interface SchemaProvider {
  25                 IMappingSchema<Resource,INode> get(ReadGraph graph) throws DatabaseException;
  26         }
  27
  28         public static interface NodeMapProvider {
  29                 P3DScriptNodeMap get(IMapping<Resource, INode> mapping, P3DRootNode rootNode);
  30         }
  31
  32         public static P3DScriptNodeMap load(final Resource root) throws DatabaseException {
  33                 return load(getRequestProcessor(), root);
  34         }
  35
  36         public static P3DScriptNodeMap load(RequestProcessor session, final Resource root) throws DatabaseException {
  37                 preload(Simantics.getSession(), Plant3D.URIs.Builtin);
  38
  39                 SchemaProvider schemaProvider = g -> SchemaBuilder.getSchema(g);
  40                 NodeMapProvider mapProvider = (mapping, rootNode) -> new P3DScriptNodeMap(Simantics.getSession(), mapping, rootNode);
  41                 return load(session, root, schemaProvider, mapProvider);
  42         }
  43
  44         public static P3DRootNode loadReadOnly(final Resource root) throws DatabaseException {
  45                 return loadReadOnly(getRequestProcessor(), root);
  46         }
  47
  48         public static P3DRootNode loadReadOnly(RequestProcessor session, final Resource root) throws DatabaseException {
  49                 preload(session, Plant3D.URIs.Builtin);
  50
  51                 SchemaProvider schemaProvider = g -> SchemaBuilder.getSchema(g);
  52                 return loadReadOnly(session, root, schemaProvider);
  53         }
  54
  55         public static void preload(RequestProcessor session, String symbolSet) throws DatabaseException {
  56                 try {
  57                         ControlPointFactory.preloadCache(session, symbolSet);
  58                         ComponentUtils.preloadCache(session);
  59                 } catch (Exception e) {
  60                         throw new DatabaseException(e);
  61                 }
  62         }
  63
  64         public static <NodeMap extends P3DScriptNodeMap> NodeMap load(final Resource root, SchemaProvider schemaProvider, NodeMapProvider mapProvider) throws DatabaseException {
  65                 return load(getRequestProcessor(), root, schemaProvider, mapProvider);
  66         }
  67
  68         public static <NodeMap extends P3DScriptNodeMap> NodeMap load(RequestProcessor session, final Resource root, SchemaProvider schemaProvider, NodeMapProvider mapProvider) throws DatabaseException {
  69                 return session.syncRequest(new Read<NodeMap>() {
  70                         @Override
  71                         public NodeMap perform(ReadGraph graph) throws DatabaseException {
  72                                 PipingRules.setEnabled(false);
  73                                 IMappingSchema<Resource, INode> schema = schemaProvider.get(graph);
  74                                 IMapping<Resource, INode> mapping = Mappings.createWithListening(schema);
  75                                 P3DRootNode rootNode = (P3DRootNode) mapping.map(graph, root);
  76                                 rootNode.setMapping(mapping);
  77                                 try {
  78                                         P3DUtil.finalizeDBLoad(rootNode);
  79                                         // FIXME: Something needs to be done here...
  80                                         P3DUtil.finalizeDBLoad2(rootNode);
  81                                 } catch (Exception e) {
  82                                         throw new DatabaseException(e);
  83                                 }
  84
  85                                 @SuppressWarnings("unchecked")
  86                                 NodeMap nodeMap = (NodeMap) mapProvider.get(mapping, rootNode);
  87                                 return nodeMap;
  88                         }
  89                 });
  90         }
  91
  92         public static <Root extends P3DRootNode> Root loadReadOnly(RequestProcessor session, final Resource root, SchemaProvider schemaProvider)
  93                         throws DatabaseException {
  94                 return session.syncRequest(new Read<Root>() {
  95                         @Override
  96                         public Root perform(ReadGraph graph) throws DatabaseException {
  97                                 PipingRules.setEnabled(false);
  98                                 IMappingSchema<Resource, INode> schema = schemaProvider.get(graph);
  99                                 IMapping<Resource, INode> mapping = Mappings.createWithoutListening(schema);
 100                                 @SuppressWarnings("unchecked")
 101                                 Root rootNode = (Root) mapping.map(graph, root);
 102                                 rootNode.setMapping(mapping);
 103                                 try {
 104                                         P3DUtil.finalizeDBLoad(rootNode);
 105                                         P3DUtil.finalizeDBLoad2(rootNode);
 106                                 } catch (Exception e) {
 107                                         throw new DatabaseException(e);
 108                                 }
 109
 110                                 return rootNode;
 111                         }
 112                 });
 113         }
 114
 115         /**
 116          * Load a read-only Java object representation of a Plant3d model.
 117          *
 118          * This method can be called from SCL either as a &lt;Proc&gt; or a &lt;ReadGraph&gt; function.
 119          */
 120         public static <Root extends P3DRootNode> Root loadReadOnly(final Resource root, SchemaProvider schemaProvider)
 121                         throws DatabaseException {
 122                 return loadReadOnly(getRequestProcessor(), root, schemaProvider);
 123         }
 124
 125         public static RequestProcessor getRequestProcessor() {
 126                 RequestProcessor rp = (RequestProcessor) SCLContext.getCurrent().get("graph");
 127                 return rp != null ? rp : Simantics.getSession();
 128         }
 129
 130 }