1 package org.simantics.scl.db;
\r
3 import java.io.IOException;
\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
30 @SuppressWarnings({"rawtypes", "unchecked"})
\r
31 public class SCLFunctions {
\r
33 public static final String GRAPH = "graph";
\r
35 public static <T> T safeExec(final Function f) {
\r
37 return (T)f.apply(Tuple0.INSTANCE);
\r
38 } catch (Throwable t) {
\r
39 t.printStackTrace();
\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
50 Simantics.getSession().asyncRequest(new ReadRequest() {
\r
52 public void run(ReadGraph graph) throws DatabaseException {
\r
53 SCLContext.push(context);
\r
54 ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);
\r
56 f.apply(Tuple0.INSTANCE);
\r
58 context.put(GRAPH, oldGraph);
\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
72 return Simantics.getSession().syncRequest(new Read<T>() {
\r
74 public T perform(ReadGraph graph) throws DatabaseException {
\r
75 SCLContext.push(context);
\r
76 ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);
\r
78 return (T)f.apply(Tuple0.INSTANCE);
\r
80 context.put(GRAPH, oldGraph);
\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
94 Simantics.getSession().asyncRequest(new WriteRequest() {
\r
96 public void perform(WriteGraph graph) throws DatabaseException {
\r
97 SCLContext.push(context);
\r
98 ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);
\r
100 f.apply(Tuple0.INSTANCE);
\r
102 context.put(GRAPH, oldGraph);
\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
116 return Simantics.getSession().syncRequest(new WriteResultRequest<T>() {
\r
118 public T perform(WriteGraph graph) throws DatabaseException {
\r
119 SCLContext.push(context);
\r
120 ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);
\r
122 return (T)f.apply(Tuple0.INSTANCE);
\r
124 context.put(GRAPH, oldGraph);
\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
136 DelayedWriteRequest request = new DelayedWriteRequest() {
\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
143 dc.set((T)f.apply(Tuple0.INSTANCE));
\r
145 context.put(GRAPH, oldGraph);
\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
156 throw new DatabaseException("Caller is inside a read transaction.");
\r
159 Simantics.getSession().syncRequest(request);
\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
170 public T perform(WriteGraph graph) throws DatabaseException {
\r
171 SCLContext.push(context);
\r
172 ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);
\r
174 return (T)f.apply(Tuple0.INSTANCE);
\r
176 context.put(GRAPH, oldGraph);
\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
189 public T perform(WriteGraph graph) throws DatabaseException {
\r
190 SCLContext.push(context);
\r
191 ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);
\r
193 return (T)f.apply(Tuple0.INSTANCE);
\r
195 context.put(GRAPH, oldGraph);
\r
202 public static <T> T readValue(final String uri) throws DatabaseException {
\r
203 return Simantics.getSession().syncRequest(new Read<T>() {
\r
205 public T perform(ReadGraph graph) throws DatabaseException {
\r
206 return Variables.getVariable(graph, uri).getValue(graph);
\r
211 public static <T> void writeValue(final String uri, final T value) throws DatabaseException {
\r
212 Simantics.getSession().syncRequest(new WriteRequest() {
\r
214 public void perform(WriteGraph graph) throws DatabaseException {
\r
215 Variables.getVariable(graph, uri).setValue(graph, value);
\r
220 public static void activateOnce(Resource r) {
\r
221 Simantics.getSession().getService(IActivationManager.class).activateOnce(r);
\r
224 public static void syncActivateOnce(WriteGraph graph, Resource r) throws DatabaseException {
\r
225 graph.getService(IActivationManager.class).activateOnce(graph, r);
\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
233 public static void disableDependencies(WriteGraph graph) {
\r
234 Layer0Utils.setDependenciesIndexingDisabled(graph, true);
\r
237 public static void enableDependencies(WriteGraph graph) {
\r
238 Layer0Utils.setDependenciesIndexingDisabled(graph, false);
\r
241 public static void collectClusters() {
\r
242 Simantics.getSession().getService(ClusterControl.class).collectClusters(Integer.MAX_VALUE);
\r
245 public static class SCLUnaryRead extends BinaryRead<Function1<Object,Object>, Object, Object> {
\r
247 public SCLUnaryRead(Function1<Object, Object> parameter1, Object parameter2) {
\r
248 super(parameter1, parameter2);
\r
252 public Object perform(ReadGraph graph) throws DatabaseException {
\r
253 return Simantics.applySCLRead(graph, parameter, parameter2);
\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
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