/*******************************************************************************
- * Copyright (c) 2007, 2010 Association for Decentralized Information Management
+ * Copyright (c) 2007, 2018 Association for Decentralized Information Management
* in Industry THTH ry.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.Semaphore;
+import java.util.function.Consumer;
import org.simantics.db.AsyncReadGraph;
import org.simantics.db.AsyncRequestProcessor;
import org.simantics.db.ReadGraph;
-import org.simantics.db.RequestProcessor;
import org.simantics.db.Resource;
import org.simantics.db.Session;
-import org.simantics.db.VirtualGraph;
import org.simantics.db.WriteGraph;
import org.simantics.db.common.procedure.adapter.AsyncMultiProcedureAdapter;
import org.simantics.db.common.procedure.adapter.ProcedureAdapter;
+import org.simantics.db.common.procedure.adapter.SyncMultiProcedureAdapter;
import org.simantics.db.common.procedure.wrapper.NoneToAsyncProcedure;
import org.simantics.db.common.request.ReadRequest;
import org.simantics.db.common.request.WriteRequest;
import org.simantics.db.request.MultiRead;
import org.simantics.db.request.Read;
import org.simantics.db.request.ReadInterface;
-import org.simantics.db.request.UndoTraits;
import org.simantics.db.request.Write;
import org.simantics.db.request.WriteInterface;
import org.simantics.db.request.WriteOnly;
import org.simantics.db.request.WriteOnlyResult;
import org.simantics.db.request.WriteResult;
import org.simantics.utils.DataContainer;
-import org.simantics.utils.datastructures.Callback;
import org.simantics.utils.datastructures.Pair;
-public class MergingGraphRequestProcessor implements RequestProcessor {
+public class MergingGraphRequestProcessor implements AsyncRequestProcessor {
private static class SyncWriteRequestAdapter implements Write {
throw new RuntimeException("See cause for the real exception.", exception);
}
- @Override
- public VirtualGraph getProvider() {
- return null;
- }
-
-// @Override
-// public void fillMetadata(Map<String, String> metadata) {
-// }
-
public void acquire() {
try {
semaphore.acquire();
semaphore.release();
}
- @Override
- public UndoTraits getUndoTraits() {
- return null;
- }
-
@Override
public String toString() {
return "SyncWriteRequestAdapter " + request;
Logger.defaultLogError(t);
- if(currentRequest.second instanceof AsyncProcedure<?>) {
- ((AsyncProcedure<?>)currentRequest.second).exception(graph, t);
- } else {
- ((AsyncMultiProcedure<?>)currentRequest.second).exception(graph, t);
- }
+// if(currentRequest.second instanceof AsyncProcedure<?>) {
+// ((AsyncProcedure<?>)currentRequest.second).exception(graph, t);
+// } else {
+// ((AsyncMultiProcedure<?>)currentRequest.second).exception(graph, t);
+// }
}
if(currentRequest.second instanceof AsyncProcedure<?>) {
if(currentRequest.first instanceof AsyncRead) {
AsyncRead req = (AsyncRead)currentRequest.first;
- graph.asyncRequest(req, (AsyncProcedure<?>)currentRequest.second);
+ graph.syncRequest(req, (AsyncProcedure<?>)currentRequest.second);
} else {
Read req = (Read)currentRequest.first;
- graph.asyncRequest(req, (AsyncProcedure<?>)currentRequest.second);
+ graph.syncRequest(req, (AsyncProcedure<?>)currentRequest.second);
}
} else {
AsyncMultiRead req = (AsyncMultiRead)currentRequest.first;
- graph.asyncRequest(req, (AsyncMultiProcedure<?>)currentRequest.second);
+ graph.syncRequest(req, (AsyncMultiProcedure<?>)currentRequest.second);
}
} catch(Throwable t) {
Logger.defaultLogError(t);
- if(currentRequest.second instanceof AsyncProcedure<?>) {
- ((AsyncProcedure<?>)currentRequest.second).exception(graph, t);
- } else {
- ((AsyncMultiProcedure<?>)currentRequest.second).exception(graph, t);
- }
+// if(currentRequest.second instanceof AsyncProcedure<?>) {
+// ((AsyncProcedure<?>)currentRequest.second).exception(graph, t);
+// } else {
+// ((AsyncMultiProcedure<?>)currentRequest.second).exception(graph, t);
+// }
}
}
}
@SuppressWarnings("unchecked")
- Callback<Throwable> callback = (Callback<Throwable>)currentRequest.second;
+ Consumer<Throwable> callback = (Consumer<Throwable>)currentRequest.second;
if (currentRequest.first.getClass().equals(SyncWriteRequestAdapter.class)) {
try {
// System.out.println("merg.sync " + adapter);
graph.syncRequest(adapter);
- if(callback != null) callback.run(null);
+ if(callback != null) callback.accept(null);
} catch(Throwable t) {
Logger.defaultLogError(t);
- if(callback != null) callback.run(t);
+ if(callback != null) callback.accept(t);
}
adapter.release();
try {
if(currentRequest.first instanceof Write) graph.syncRequest((Write)currentRequest.first);
else if(currentRequest.first instanceof DelayedWrite) graph.syncRequest((DelayedWrite)currentRequest.first);
- if(callback != null) callback.run(null);
+ if(callback != null) callback.accept(null);
} catch(Throwable t) {
Logger.defaultLogError(t);
- if(callback != null) callback.run(t);
+ if(callback != null) callback.accept(t);
}
}
// System.out.println(this + " asyncRequest(ReadGraphRequest<QueryProcedure4<T>> request, QueryProcedure4<T> procedure)");
- if (requestSet.contains(request))
+ Pair<Object, Object> pair = Pair.make(request, procedure);
+ if (requestSet.contains(pair))
return;
- Pair<Object, Object> pair = new Pair<Object, Object>(request, procedure);
requestQueue.add(pair);
requestSet.add(pair);
// System.out.println(this + " asyncRequest(ReadGraphRequest<SingleQueryProcedure4<T>> request, SingleQueryProcedure4<T> procedure) " + this);
- if (requestSet.contains(request))
+ Pair<Object, Object> pair = Pair.make(request, procedure);
+ if (requestSet.contains(pair))
return;
- Pair<Object, Object> pair = new Pair<Object, Object>(request, procedure);
requestQueue.add(pair);
requestSet.add(pair);
}
@Override
- public synchronized void asyncRequest(Write request, Callback<DatabaseException> callback) {
+ public synchronized void asyncRequest(Write request, Consumer<DatabaseException> callback) {
// System.out.println(this + " asyncRequest(WriteGraphRequest request)");
- if (requestSet.contains(request))
+ Pair<Object, Object> pair = Pair.make(request, callback);
+ if (requestSet.contains(pair))
return;
- Pair<Object, Object> pair = new Pair<Object, Object>(request, callback);
requestQueue.add(pair);
requestSet.add(pair);
}
@Override
- public synchronized void asyncRequest(DelayedWrite request, Callback<DatabaseException> callback) {
+ public synchronized void asyncRequest(DelayedWrite request, Consumer<DatabaseException> callback) {
// System.out.println(this + " asyncRequest(WriteGraphRequest request)");
- if (requestSet.contains(request))
+ Pair<Object, Object> pair = Pair.make(request, callback);
+ if (requestSet.contains(pair))
return;
- Pair<Object, Object> pair = new Pair<Object, Object>(request, callback);
requestQueue.add(pair);
requestSet.add(pair);
}
@Override
- public synchronized void asyncRequest(WriteOnly request, Callback<DatabaseException> callback) {
+ public synchronized void asyncRequest(WriteOnly request, Consumer<DatabaseException> callback) {
// System.out.println(this + " asyncRequest(WriteGraphRequest request)");
- if (requestSet.contains(request))
+ Pair<Object, Object> pair = Pair.make(request, callback);
+ if (requestSet.contains(pair))
return;
- Pair<Object, Object> pair = new Pair<Object, Object>(request, callback);
requestQueue.add(pair);
requestSet.add(pair);
public synchronized <T> void asyncRequest(Read<T> request,
AsyncProcedure<T> procedure) {
- if (requestSet.contains(request))
+ Pair<Object, Object> pair = Pair.make(request, procedure);
+ if (requestSet.contains(pair))
return;
- Pair<Object, Object> pair = new Pair<Object, Object>(request, procedure);
requestQueue.add(pair);
requestSet.add(pair);
final ArrayList<T> result = new ArrayList<T>();
final DataContainer<Throwable> exception = new DataContainer<Throwable>();
- syncRequest(request, new AsyncMultiProcedureAdapter<T>() {
+ syncRequest(request, new SyncMultiProcedureAdapter<T>() {
@Override
- public void execute(AsyncReadGraph graph, T t) {
+ public void execute(ReadGraph graph, T t) {
synchronized(result) {
result.add(t);
}
}
@Override
- public void exception(AsyncReadGraph graph, Throwable t) {
+ public void exception(ReadGraph graph, Throwable t) {
exception.set(t);
}
return result;
}
- @Override
- public <T> Collection<T> syncRequest(MultiRead<T> request, AsyncMultiProcedure<T> procedure) {
- throw new UnsupportedOperationException("Not implemented");
- }
-
@Override
public <T> Collection<T> syncRequest(MultiRead<T> request, MultiProcedure<T> procedure) {
throw new UnsupportedOperationException("Not implemented");
throw new UnsupportedOperationException("Not implemented");
}
- @Override
- public <T> void asyncRequest(MultiRead<T> request, AsyncMultiProcedure<T> procedure) {
- throw new UnsupportedOperationException("Not implemented");
- }
-
@Override
public <T> void asyncRequest(MultiRead<T> request, MultiProcedure<T> procedure) {
throw new UnsupportedOperationException("Not implemented");
}
- @Override
- public <T> Collection<T> syncRequest(MultiRead<T> arg0, AsyncMultiListener<T> arg1) {
- throw new UnsupportedOperationException("Not implemented.");
-
- }
-
@Override
public <T> Collection<T> syncRequest(MultiRead<T> arg0, SyncMultiListener<T> arg1) {
throw new UnsupportedOperationException("Not implemented.");
}
- @Override
- public <T> void asyncRequest(MultiRead<T> arg0, AsyncMultiListener<T> arg1) {
- throw new UnsupportedOperationException("Not implemented.");
-
- }
-
@Override
public <T> void asyncRequest(MultiRead<T> arg0, SyncMultiListener<T> arg1) {
throw new UnsupportedOperationException("Not implemented.");