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

   1 package org.simantics.scl.db;
   2
   3 import java.io.IOException;
   4
   5 import org.cojen.classfile.TypeDesc;
   6 import org.simantics.Simantics;
   7 import org.simantics.db.ReadGraph;
   8 import org.simantics.db.Resource;
   9 import org.simantics.db.VirtualGraph;
  10 import org.simantics.db.WriteGraph;
  11 import org.simantics.db.common.procedure.adapter.SyncListenerAdapter;
  12 import org.simantics.db.common.procedure.adapter.TransientCacheAsyncListener;
  13 import org.simantics.db.common.request.BinaryRead;
  14 import org.simantics.db.common.request.DelayedWriteRequest;
  15 import org.simantics.db.common.request.ReadRequest;
  16 import org.simantics.db.common.request.UnaryRead;
  17 import org.simantics.db.common.request.WriteRequest;
  18 import org.simantics.db.common.request.WriteResultRequest;
  19 import org.simantics.db.exception.DatabaseException;
  20 import org.simantics.db.layer0.util.Layer0Utils;
  21 import org.simantics.db.layer0.variable.Variables;
  22 import org.simantics.db.request.Read;
  23 import org.simantics.db.service.ClusterControl;
  24 import org.simantics.db.service.SerialisationSupport;
  25 import org.simantics.db.service.VirtualGraphSupport;
  26 import org.simantics.layer0.utils.triggers.IActivationManager;
  27 import org.simantics.scl.compiler.environment.specification.EnvironmentSpecification;
  28 import org.simantics.scl.compiler.errors.Failable;
  29 import org.simantics.scl.compiler.internal.codegen.types.JavaTypeTranslator;
  30 import org.simantics.scl.compiler.module.Module;
  31 import org.simantics.scl.compiler.module.repository.ImportFailureException;
  32 import org.simantics.scl.compiler.runtime.RuntimeEnvironment;
  33 import org.simantics.scl.compiler.types.Type;
  34 import org.simantics.scl.osgi.SCLOsgi;
  35 import org.simantics.scl.runtime.SCLContext;
  36 import org.simantics.scl.runtime.function.Function;
  37 import org.simantics.scl.runtime.function.Function1;
  38 import org.simantics.scl.runtime.tuple.Tuple;
  39 import org.simantics.scl.runtime.tuple.Tuple0;
  40 import org.simantics.utils.DataContainer;
  41 import org.slf4j.Logger;
  42 import org.slf4j.LoggerFactory;
  43
  44 @SuppressWarnings({"rawtypes", "unchecked"})
  45 public class SCLFunctions {
  46
  47     private static final Logger LOGGER = LoggerFactory.getLogger(SCLFunctions.class);
  48
  49     public static final String GRAPH = "graph";
  50
  51     public static <T> T safeExec(final Function f) {
  52         try {
  53             return (T)f.apply(Tuple0.INSTANCE);
  54         } catch (Throwable t) {
  55             LOGGER.error("safeExec caught exception", t);
  56             return null;
  57         }
  58     }
  59
  60     public static void asyncRead(final Function f) throws DatabaseException {
  61         final SCLContext context = SCLContext.createDerivedContext();
  62         Simantics.getSession().asyncRequest(new ReadRequest() {
  63             @Override
  64             public void run(ReadGraph graph) throws DatabaseException {
  65                 SCLContext.push(context);
  66                 context.put(GRAPH, graph);
  67                 try {
  68                     f.apply(Tuple0.INSTANCE);
  69                 } finally {
  70                     SCLContext.pop();
  71                 }
  72             }
  73         });
  74     }
  75
  76     public static <T> T syncRead(final Function f) throws DatabaseException {
  77         final SCLContext context = SCLContext.getCurrent();
  78         Object graph = context.get(GRAPH);
  79         if (graph != null) {
  80             return (T)f.apply(Tuple0.INSTANCE);
  81         } else {
  82             return Simantics.getSession().syncRequest(new Read<T>() {
  83                 @Override
  84                 public T perform(ReadGraph graph) throws DatabaseException {
  85                     SCLContext.push(context);
  86                     ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);
  87                     try {
  88                         return (T)f.apply(Tuple0.INSTANCE);
  89                     } finally {
  90                         context.put(GRAPH, oldGraph);
  91                         SCLContext.pop();
  92                     }
  93                 }
  94             });
  95         }
  96     }
  97
  98     public static void asyncWrite(final Function f) throws DatabaseException {
  99         SCLContext context = SCLContext.createDerivedContext();
 100         if (Simantics.peekSession() != null) {
 101             Simantics.getSession().asyncRequest(new WriteRequest() {
 102                 @Override
 103                 public void perform(WriteGraph graph) throws DatabaseException {
 104                     SCLContext.push(context);
 105                     context.put(GRAPH, graph);
 106                     try {
 107                         f.apply(Tuple0.INSTANCE);
 108                     } finally {
 109                         SCLContext.pop();
 110                     }
 111                 }
 112             });
 113         } else {
 114             LOGGER.warn("No session available for asynchronous write requests");
 115         }
 116     }
 117
 118     public static <T> T syncWrite(final Function f) throws DatabaseException {
 119         final SCLContext context = SCLContext.getCurrent();
 120         Object graph = context.get(GRAPH);
 121         if (graph != null) {
 122             return (T)f.apply(Tuple0.INSTANCE);
 123         } else {
 124             return Simantics.getSession().syncRequest(new WriteResultRequest<T>() {
 125                 @Override
 126                 public T perform(WriteGraph graph) throws DatabaseException {
 127                     SCLContext.push(context);
 128                     ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);
 129                     try {
 130                         return (T)f.apply(Tuple0.INSTANCE);
 131                     } finally {
 132                         context.put(GRAPH, oldGraph);
 133                         SCLContext.pop();
 134                     }
 135                 }
 136             });
 137         }
 138     }
 139
 140     public static <T> T delayedSyncWrite(final Function f) throws DatabaseException {
 141         final SCLContext context = SCLContext.getCurrent();
 142         final DataContainer<T> dc = new DataContainer<T>(null);
 143
 144         DelayedWriteRequest request = new DelayedWriteRequest() {
 145             @Override
 146             public void perform(WriteGraph graph) throws DatabaseException {
 147                 final SCLContext context = SCLContext.getCurrent();
 148                 SCLContext.push(context);
 149                 ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);
 150                 try {
 151                     dc.set((T)f.apply(Tuple0.INSTANCE));
 152                 } finally {
 153                     context.put(GRAPH, oldGraph);
 154                     SCLContext.pop();
 155                 }
 156             }
 157         };
 158
 159         Object graph = context.get(GRAPH);
 160         if (graph != null) {
 161             if (graph instanceof WriteGraph) {
 162                 ((WriteGraph)graph).syncRequest(request);
 163             } else {
 164                 throw new DatabaseException("Caller is inside a read transaction.");
 165             }
 166         } else {
 167             Simantics.getSession().syncRequest(request);
 168         }
 169         return dc.get();
 170     }
 171
 172     public static <T> T virtualSyncWriteMem(WriteGraph graph, String virtualGraphId, final Function f) throws DatabaseException {
 173         final SCLContext context = SCLContext.getCurrent();
 174         VirtualGraphSupport vgs = graph.getService(VirtualGraphSupport.class);
 175         VirtualGraph vg = vgs.getMemoryPersistent(virtualGraphId);
 176         return graph.syncRequest(new WriteResultRequest<T>(vg) {
 177             @Override
 178             public T perform(WriteGraph graph) throws DatabaseException {
 179                 SCLContext.push(context);
 180                 ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);
 181                 try {
 182                     return (T)f.apply(Tuple0.INSTANCE);
 183                 } finally {
 184                     context.put(GRAPH, oldGraph);
 185                     SCLContext.pop();
 186                 }
 187             }
 188         });
 189     }
 190
 191     public static <T> T virtualSyncWriteWS(WriteGraph graph, String virtualGraphId, final Function f) throws DatabaseException {
 192         final SCLContext context = SCLContext.getCurrent();
 193         VirtualGraphSupport vgs = graph.getService(VirtualGraphSupport.class);
 194         VirtualGraph vg = vgs.getWorkspacePersistent(virtualGraphId);
 195         return graph.syncRequest(new WriteResultRequest<T>(vg) {
 196             @Override
 197             public T perform(WriteGraph graph) throws DatabaseException {
 198                 SCLContext.push(context);
 199                 ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);
 200                 try {
 201                     return (T)f.apply(Tuple0.INSTANCE);
 202                 } finally {
 203                     context.put(GRAPH, oldGraph);
 204                     SCLContext.pop();
 205                 }
 206             }
 207         });
 208     }
 209
 210     public static <T> T readValue(final String uri) throws DatabaseException {
 211         return Simantics.getSession().syncRequest(new Read<T>() {
 212             @Override
 213             public T perform(ReadGraph graph) throws DatabaseException {
 214                 return Variables.getVariable(graph, uri).getValue(graph);
 215             }
 216         });
 217     }
 218
 219     public static <T> void writeValue(final String uri, final T value) throws DatabaseException {
 220         Simantics.getSession().syncRequest(new WriteRequest() {
 221             @Override
 222             public void perform(WriteGraph graph) throws DatabaseException {
 223                 Variables.getVariable(graph, uri).setValue(graph, value);
 224             }
 225         });
 226     }
 227
 228     public static void activateOnce(Resource r) {
 229         Simantics.getSession().getService(IActivationManager.class).activateOnce(r);
 230     }
 231
 232     public static void syncActivateOnce(WriteGraph graph, Resource r) throws DatabaseException {
 233         graph.getService(IActivationManager.class).activateOnce(graph, r);
 234     }
 235
 236     public static Resource resourceFromId(ReadGraph graph, long id) throws DatabaseException, IOException {
 237         SerialisationSupport ss = graph.getService(SerialisationSupport.class);
 238         return ss.getResource(id);
 239     }
 240
 241     public static void disableDependencies(WriteGraph graph) {
 242         Layer0Utils.setDependenciesIndexingDisabled(graph, true);
 243     }
 244
 245     public static void enableDependencies(WriteGraph graph) {
 246         Layer0Utils.setDependenciesIndexingDisabled(graph, false);
 247     }
 248
 249     public static void collectClusters() {
 250         Simantics.getSession().getService(ClusterControl.class).collectClusters(Integer.MAX_VALUE);
 251     }
 252
 253     public static class SCLUnaryRead extends BinaryRead<Function1<Object,Object>, Object, Object> {
 254
 255                 public SCLUnaryRead(Function1<Object, Object> parameter1, Object parameter2) {
 256                         super(parameter1, parameter2);
 257                 }
 258
 259                 @Override
 260                 public Object perform(ReadGraph graph) throws DatabaseException {
 261                         return Simantics.applySCLRead(graph, parameter, parameter2);
 262                 }
 263
 264     }
 265
 266     public static Object unaryQuery(ReadGraph graph, Function1<Object,Object> fn, Object value) throws DatabaseException {
 267         return graph.syncRequest(new SCLUnaryRead(fn, value));
 268     }
 269
 270     public static Object unaryQueryCached(ReadGraph graph, Function1<Object,Object> fn, Object value) throws DatabaseException {
 271         return graph.syncRequest(new SCLUnaryRead(fn, value), TransientCacheAsyncListener.<Object>instance());
 272     }
 273
 274
 275     private static class Subquery extends UnaryRead<Function, Object> {
 276
 277         public Subquery(Function q) {
 278             super(q);
 279         }
 280
 281         @Override
 282         public Object perform(ReadGraph graph) throws DatabaseException {
 283             return Simantics.applySCLRead(graph, parameter, Tuple0.INSTANCE);
 284         }
 285
 286     }
 287
 288     public static Object subquery(ReadGraph graph, Function q) throws DatabaseException {
 289         return graph.syncRequest(new Subquery(q));
 290     }
 291
 292     public static Object subqueryC(ReadGraph graph, Function q) throws DatabaseException {
 293         return graph.syncRequest(new Subquery(q), TransientCacheAsyncListener.<Object>instance());
 294     }
 295
 296     public static void subqueryL(ReadGraph graph, Function query, Function executeCallback, Function1<Throwable, Tuple> exceptionCallback, Function1<Tuple0, Boolean> isDisposedCallback) throws DatabaseException {
 297         graph.asyncRequest(new Subquery(query), new SyncListenerAdapter<Object>() {
 298             @Override
 299             public void execute(ReadGraph graph, Object result) throws DatabaseException {
 300                 Simantics.applySCLRead(graph, executeCallback, result);
 301             }
 302
 303             @Override
 304             public void exception(ReadGraph graph, Throwable t) throws DatabaseException {
 305                 Simantics.applySCLRead(graph, exceptionCallback, t);
 306             }
 307
 308             @Override
 309             public boolean isDisposed() {
 310                 return isDisposedCallback.apply(Tuple0.INSTANCE);
 311             }
 312         });
 313     }
 314
 315     public static Object possibleFromDynamic(Type expectedType, String moduleName, Object value) {
 316
 317         try {
 318
 319
 320             Failable<Module> failable = SCLOsgi.MODULE_REPOSITORY.getModule(moduleName);
 321             Module module = failable.getResult();
 322
 323                 RuntimeEnvironment env = SCLOsgi.MODULE_REPOSITORY.createRuntimeEnvironment(
 324                                 EnvironmentSpecification.of(moduleName, ""), module.getParentClassLoader());
 325
 326             JavaTypeTranslator tr = new JavaTypeTranslator(env.getEnvironment());
 327             TypeDesc desc = tr.toTypeDesc(expectedType);
 328             String className = desc.getFullName();
 329             Class<?> clazz = env.getMutableClassLoader().loadClass(className);
 330             if (!clazz.isAssignableFrom(value.getClass()))
 331                 return null;
 332
 333         } catch (ImportFailureException | ClassNotFoundException e) {
 334         }
 335         return value;
 336     }
 337
 338 }