bundles/org.simantics.scl.db/src/org/simantics/scl/db/SCLFunctions.java

   1 package org.simantics.scl.db;\r
   2 \r
   3 import java.io.IOException;\r
   4 \r
   5 import org.simantics.Simantics;\r
   6 import org.simantics.db.ReadGraph;\r
   7 import org.simantics.db.Resource;\r
   8 import org.simantics.db.VirtualGraph;\r
   9 import org.simantics.db.WriteGraph;\r
  10 import org.simantics.db.common.procedure.adapter.TransientCacheAsyncListener;\r
  11 import org.simantics.db.common.request.BinaryRead;\r
  12 import org.simantics.db.common.request.DelayedWriteRequest;\r
  13 import org.simantics.db.common.request.ReadRequest;\r
  14 import org.simantics.db.common.request.WriteRequest;\r
  15 import org.simantics.db.common.request.WriteResultRequest;\r
  16 import org.simantics.db.exception.DatabaseException;\r
  17 import org.simantics.db.layer0.util.Layer0Utils;\r
  18 import org.simantics.db.layer0.variable.Variables;\r
  19 import org.simantics.db.request.Read;\r
  20 import org.simantics.db.service.ClusterControl;\r
  21 import org.simantics.db.service.SerialisationSupport;\r
  22 import org.simantics.db.service.VirtualGraphSupport;\r
  23 import org.simantics.layer0.utils.triggers.IActivationManager;\r
  24 import org.simantics.scl.runtime.SCLContext;\r
  25 import org.simantics.scl.runtime.function.Function;\r
  26 import org.simantics.scl.runtime.function.Function1;\r
  27 import org.simantics.scl.runtime.tuple.Tuple0;\r
  28 import org.simantics.utils.DataContainer;\r
  29 \r
  30 @SuppressWarnings({"rawtypes", "unchecked"})\r
  31 public class SCLFunctions {\r
  32 \r
  33     public static final String GRAPH = "graph";\r
  34 \r
  35     public static <T> T safeExec(final Function f) {\r
  36         try {\r
  37             return (T)f.apply(Tuple0.INSTANCE);\r
  38         } catch (Throwable t) {\r
  39             t.printStackTrace();\r
  40             return null;\r
  41         }\r
  42     }\r
  43     \r
  44     public static void asyncRead(final Function f) throws DatabaseException {\r
  45         final SCLContext context = SCLContext.getCurrent();\r
  46         Object graph = context.get(GRAPH);\r
  47         if (graph != null) {\r
  48             f.apply(Tuple0.INSTANCE);\r
  49         } else {\r
  50             Simantics.getSession().asyncRequest(new ReadRequest() {\r
  51                 @Override\r
  52                 public void run(ReadGraph graph) throws DatabaseException {\r
  53                     SCLContext.push(context);\r
  54                     ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);\r
  55                     try {\r
  56                         f.apply(Tuple0.INSTANCE);\r
  57                     } finally {\r
  58                         context.put(GRAPH, oldGraph);\r
  59                         SCLContext.pop();\r
  60                     }\r
  61                 }\r
  62             });\r
  63         }\r
  64     }\r
  65     \r
  66     public static <T> T syncRead(final Function f) throws DatabaseException {\r
  67         final SCLContext context = SCLContext.getCurrent();\r
  68         Object graph = context.get(GRAPH);\r
  69         if (graph != null) {\r
  70             return (T)f.apply(Tuple0.INSTANCE);\r
  71         } else {\r
  72             return Simantics.getSession().syncRequest(new Read<T>() {\r
  73                 @Override\r
  74                 public T perform(ReadGraph graph) throws DatabaseException {\r
  75                     SCLContext.push(context);\r
  76                     ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);\r
  77                     try {\r
  78                         return (T)f.apply(Tuple0.INSTANCE);\r
  79                     } finally {\r
  80                         context.put(GRAPH, oldGraph);\r
  81                         SCLContext.pop();\r
  82                     }\r
  83                 }\r
  84             });\r
  85         }\r
  86     }\r
  87     \r
  88     public static void asyncWrite(final Function f) throws DatabaseException {\r
  89         final SCLContext context = SCLContext.getCurrent();\r
  90         Object graph = context.get(GRAPH);\r
  91         if (graph != null) {\r
  92             f.apply(Tuple0.INSTANCE);\r
  93         } else {\r
  94             Simantics.getSession().asyncRequest(new WriteRequest() {\r
  95                 @Override\r
  96                 public void perform(WriteGraph graph) throws DatabaseException {\r
  97                     SCLContext.push(context);\r
  98                     ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);\r
  99                     try {\r
 100                         f.apply(Tuple0.INSTANCE);\r
 101                     } finally {\r
 102                         context.put(GRAPH, oldGraph);\r
 103                         SCLContext.pop();\r
 104                     }\r
 105                 }\r
 106             });\r
 107         }\r
 108     }\r
 109     \r
 110     public static <T> T syncWrite(final Function f) throws DatabaseException {\r
 111         final SCLContext context = SCLContext.getCurrent();\r
 112         Object graph = context.get(GRAPH);\r
 113         if (graph != null) {\r
 114             return (T)f.apply(Tuple0.INSTANCE);\r
 115         } else {\r
 116             return Simantics.getSession().syncRequest(new WriteResultRequest<T>() {\r
 117                 @Override\r
 118                 public T perform(WriteGraph graph) throws DatabaseException {\r
 119                     SCLContext.push(context);\r
 120                     ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);\r
 121                     try {\r
 122                         return (T)f.apply(Tuple0.INSTANCE);\r
 123                     } finally {\r
 124                         context.put(GRAPH, oldGraph);\r
 125                         SCLContext.pop();\r
 126                     }\r
 127                 }\r
 128             });\r
 129         }\r
 130     }\r
 131     \r
 132     public static <T> T delayedSyncWrite(final Function f) throws DatabaseException {\r
 133         final SCLContext context = SCLContext.getCurrent();\r
 134         final DataContainer<T> dc = new DataContainer<T>(null);\r
 135 \r
 136         DelayedWriteRequest request = new DelayedWriteRequest() {\r
 137             @Override\r
 138             public void perform(WriteGraph graph) throws DatabaseException {\r
 139                 final SCLContext context = SCLContext.getCurrent();\r
 140                 SCLContext.push(context);\r
 141                 ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);\r
 142                 try {\r
 143                     dc.set((T)f.apply(Tuple0.INSTANCE));\r
 144                 } finally {\r
 145                     context.put(GRAPH, oldGraph);\r
 146                     SCLContext.pop();\r
 147                 }\r
 148             }\r
 149         };\r
 150         \r
 151         Object graph = context.get(GRAPH);\r
 152         if (graph != null) {\r
 153             if (graph instanceof WriteGraph) {\r
 154                 ((WriteGraph)graph).syncRequest(request);\r
 155             } else {\r
 156                 throw new DatabaseException("Caller is inside a read transaction.");\r
 157             }\r
 158         } else {\r
 159             Simantics.getSession().syncRequest(request);\r
 160         }\r
 161         return dc.get();\r
 162     }\r
 163 \r
 164     public static <T> T virtualSyncWriteMem(WriteGraph graph, String virtualGraphId, final Function f) throws DatabaseException {\r
 165         final SCLContext context = SCLContext.getCurrent();\r
 166         VirtualGraphSupport vgs = graph.getService(VirtualGraphSupport.class);\r
 167         VirtualGraph vg = vgs.getMemoryPersistent(virtualGraphId);\r
 168         return graph.syncRequest(new WriteResultRequest<T>(vg) {\r
 169             @Override\r
 170             public T perform(WriteGraph graph) throws DatabaseException {\r
 171                 SCLContext.push(context);\r
 172                 ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);\r
 173                 try {\r
 174                     return (T)f.apply(Tuple0.INSTANCE);\r
 175                 } finally {\r
 176                     context.put(GRAPH, oldGraph);\r
 177                     SCLContext.pop();\r
 178                 }\r
 179             }\r
 180         });\r
 181     }\r
 182     \r
 183     public static <T> T virtualSyncWriteWS(WriteGraph graph, String virtualGraphId, final Function f) throws DatabaseException {\r
 184         final SCLContext context = SCLContext.getCurrent();\r
 185         VirtualGraphSupport vgs = graph.getService(VirtualGraphSupport.class);\r
 186         VirtualGraph vg = vgs.getWorkspacePersistent(virtualGraphId);\r
 187         return graph.syncRequest(new WriteResultRequest<T>(vg) {\r
 188             @Override\r
 189             public T perform(WriteGraph graph) throws DatabaseException {\r
 190                 SCLContext.push(context);\r
 191                 ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);\r
 192                 try {\r
 193                     return (T)f.apply(Tuple0.INSTANCE);\r
 194                 } finally {\r
 195                     context.put(GRAPH, oldGraph);\r
 196                     SCLContext.pop();\r
 197                 }\r
 198             }\r
 199         });\r
 200     }\r
 201     \r
 202     public static <T> T readValue(final String uri) throws DatabaseException {\r
 203         return Simantics.getSession().syncRequest(new Read<T>() {\r
 204             @Override\r
 205             public T perform(ReadGraph graph) throws DatabaseException {\r
 206                 return Variables.getVariable(graph, uri).getValue(graph);\r
 207             }            \r
 208         });\r
 209     }\r
 210     \r
 211     public static <T> void writeValue(final String uri, final T value) throws DatabaseException {\r
 212         Simantics.getSession().syncRequest(new WriteRequest() {\r
 213             @Override\r
 214             public void perform(WriteGraph graph) throws DatabaseException {\r
 215                 Variables.getVariable(graph, uri).setValue(graph, value);\r
 216             }            \r
 217         });\r
 218     }\r
 219     \r
 220     public static void activateOnce(Resource r) {\r
 221         Simantics.getSession().getService(IActivationManager.class).activateOnce(r);\r
 222     }\r
 223     \r
 224     public static void syncActivateOnce(WriteGraph graph, Resource r) throws DatabaseException {\r
 225         graph.getService(IActivationManager.class).activateOnce(graph, r);\r
 226     }\r
 227 \r
 228     public static Resource resourceFromId(ReadGraph graph, long id) throws DatabaseException, IOException {\r
 229         SerialisationSupport ss = graph.getService(SerialisationSupport.class);\r
 230         return ss.getResource(id);\r
 231     }\r
 232     \r
 233     public static void disableDependencies(WriteGraph graph) {\r
 234         Layer0Utils.setDependenciesIndexingDisabled(graph, true);       \r
 235     }\r
 236     \r
 237     public static void enableDependencies(WriteGraph graph) {\r
 238         Layer0Utils.setDependenciesIndexingDisabled(graph, false);       \r
 239     }\r
 240     \r
 241     public static void collectClusters() {\r
 242         Simantics.getSession().getService(ClusterControl.class).collectClusters(Integer.MAX_VALUE);\r
 243     }\r
 244     \r
 245     public static class SCLUnaryRead extends BinaryRead<Function1<Object,Object>, Object, Object> {\r
 246 \r
 247                 public SCLUnaryRead(Function1<Object, Object> parameter1, Object parameter2) {\r
 248                         super(parameter1, parameter2);\r
 249                 }\r
 250 \r
 251                 @Override\r
 252                 public Object perform(ReadGraph graph) throws DatabaseException {\r
 253                         return Simantics.applySCLRead(graph, parameter, parameter2);\r
 254                 }\r
 255         \r
 256     }\r
 257     \r
 258     public static Object unaryQuery(ReadGraph graph, Function1<Object,Object> fn, Object value) throws DatabaseException {\r
 259         return graph.syncRequest(new SCLUnaryRead(fn, value));\r
 260     }\r
 261 \r
 262     public static Object unaryQueryCached(ReadGraph graph, Function1<Object,Object> fn, Object value) throws DatabaseException {\r
 263         return graph.syncRequest(new SCLUnaryRead(fn, value), TransientCacheAsyncListener.<Object>instance());\r
 264     }\r
 265     \r
 266 }\r