*******************************************************************************/
package org.simantics.db.impl.query;
-import java.util.concurrent.Semaphore;
-import java.util.concurrent.atomic.AtomicBoolean;
-
import org.simantics.db.RelationInfo;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.impl.graph.ReadGraphImpl;
import org.simantics.db.impl.procedure.InternalProcedure;
-import org.simantics.db.procedure.ListenerBase;
import org.simantics.db.request.RequestFlags;
final public class RelationInfoQuery extends UnaryQuery<InternalProcedure<RelationInfo>> {
- private RelationInfoQuery(final int resource) {
+ RelationInfoQuery(final int resource) {
super(resource);
}
- final static RelationInfo runner(ReadGraphImpl graph, final int r, final QueryProcessor provider, final CacheEntry parent, final ListenerBase listener, final InternalProcedure<RelationInfo> procedure) {
-
- RelationInfoQuery entry = (RelationInfoQuery)provider.cache.relationInfoMap.get(r);
- if(entry == null) {
-
- entry = new RelationInfoQuery(r);
- entry.setPending();
- entry.clearResult(provider.querySupport);
- entry.putEntry(provider);
-
- provider.performForEach(graph, entry, parent, listener, procedure);
-
- return entry.getResult();
-
- } else {
-
- if(!entry.isReady()) {
- synchronized(entry) {
- if(!entry.isReady()) {
- throw new IllegalStateException();
-// if(entry.procs == null) entry.procs = new ArrayList<InternalProcedure<RelationInfo>>();
-// entry.procs.add(procedure);
-// provider.registerDependencies(graph, entry, parent, listener, procedure, false);
-// return entry.getResult();
- }
- }
- }
- provider.performForEach(graph, entry, parent, listener, procedure);
-
- return entry.getResult();
-
- }
-
- }
-
- final public static RelationInfo queryEach(ReadGraphImpl graph, final int r, final QueryProcessor provider, final CacheEntry parent, final ListenerBase listener, final InternalProcedure<RelationInfo> procedure) {
-
- RelationInfoQuery entry = (RelationInfoQuery)provider.cache.relationInfoMap.get(r);
- if(entry != null && entry.isReady()) {
- entry.performFromCache(graph, provider, procedure);
- return entry.getResult();
- }
-
- return runner(graph, r, provider, parent, listener, procedure);
-
- }
-
- final public static RelationInfoQuery probe(ReadGraphImpl graph, int resource) {
-
- final int thread = graph.thread(resource);
- RelationInfoQuery entry = (RelationInfoQuery)graph.processor.cache.relationInfoMap.get(resource);
- if(entry != null && entry.isReady()) {
- return entry;
- } else {
- return null;
- }
-
- }
-
- @Override
- public UnaryQuery<InternalProcedure<RelationInfo>> getEntry(QueryProcessor provider) {
- return provider.cache.relationInfoMap.get(id);
- }
-
- @Override
- public void putEntry(QueryProcessor provider) {
- provider.cache.relationInfoMap.put(id, this);
- }
-
@Override
final public void removeEntry(QueryProcessor provider) {
- provider.cache.relationInfoMap.remove(id);
+ provider.cache.remove(this);
}
- private void computeAssertions(ReadGraphImpl graph, final boolean isFinal, final boolean isFunctional, final QueryProcessor queryProvider, final InternalProcedure<RelationInfo> proc) {
+ private static void computeAssertions(ReadGraphImpl graph, int r, final boolean isFinal, final boolean isFunctional, RelationInfoQuery entry, final InternalProcedure<RelationInfo> proc) throws DatabaseException {
- final int isUsedInAssertion = queryProvider.getHasPredicateInverse();
+ QueryProcessor processor = graph.processor;
+
+ final int isUsedInAssertion = processor.getHasPredicateInverse();
assert(isUsedInAssertion != 0);
- DirectObjects.queryEach(graph, id, isUsedInAssertion, queryProvider, this, null, new IntProcedure() {
+ QueryCache.runnerDirectObjects(graph, r, isUsedInAssertion, entry, null, new IntProcedure() {
- AtomicBoolean done = new AtomicBoolean(false);
+ boolean done = false;
@Override
- public void execute(ReadGraphImpl graph, int i) {
- if(done.compareAndSet(false, true)) {
-// System.err.println("Assertions for relation " + id);
- RelationInfo result = new RelationInfo(id, isFunctional, isFinal, true);
- addOrSet(graph, result, queryProvider);
- proc.execute(graph, result);
- }
+ public void execute(ReadGraphImpl graph, int i) throws DatabaseException {
+ done = true;
+ RelationInfo result = new RelationInfo(r, isFunctional, isFinal, true);
+ if(entry != null) entry.setResult(result);
+ proc.execute(graph, result);
}
@Override
- public void finished(ReadGraphImpl graph) {
- if(done.compareAndSet(false, true)) {
-// System.err.println("No assertions for relation " + id);
- RelationInfo result = new RelationInfo(id, isFunctional, isFinal, false);
- addOrSet(graph, result, queryProvider);
+ public void finished(ReadGraphImpl graph) throws DatabaseException {
+ if(!done) {
+ done = true;
+ RelationInfo result = new RelationInfo(r, isFunctional, isFinal, false);
+ if(entry != null) entry.setResult(result);
proc.execute(graph, result);
}
}
@Override
- public void exception(ReadGraphImpl graph, Throwable throwable) {
- if(done.compareAndSet(false, true)) {
+ public void exception(ReadGraphImpl graph, Throwable throwable) throws DatabaseException {
+ if(!done) {
+ done = true;
DatabaseException e = new DatabaseException("Internal error in RelationInfoQuery");
- except(e);
+ if(entry != null) entry.except(e);
proc.exception(graph, e);
}
}
});
-// Types.queryEach(callerThread, id, queryProvider, this, null, new InternalProcedure<IntSet>() {
-//
-// @Override
-// public void execute(int callerThread, IntSet types) {
-// computeAssertions(callerThread, isFinal, isFunctional, queryProvider, proc);
-////
-////
-////// System.out.println("RelationInfoQuery: computeTypes execute " + types);
-////
-//// RelationInfo result = new RelationInfo(id, types.contains(queryProvider.getFunctionalRelation()), isFinal);
-////
-//// addOrSet(callerThread, result, queryProvider);
-////
-//// proc.execute(callerThread, result);
-////
-// }
-//
-// @Override
-// public void exception(int callerThread, Throwable t) {
-// proc.exception(callerThread, t);
-// }
-//
-// });
-
}
- private void computeTypes(ReadGraphImpl graph, final boolean isFinal, final QueryProcessor queryProvider, final InternalProcedure<RelationInfo> proc) {
-
-// System.out.println("RelationInfoQuery: computeTypes " + id);
-
- Types.queryEach(graph, id, queryProvider, this, null, new InternalProcedure<IntSet>() {
-
- @Override
- public void execute(ReadGraphImpl graph, IntSet types) {
- computeAssertions(graph, isFinal, types.contains(queryProvider.getFunctionalRelation()), queryProvider, proc);
-//
-//// System.out.println("RelationInfoQuery: computeTypes execute " + types);
-//
-// RelationInfo result = new RelationInfo(id, types.contains(queryProvider.getFunctionalRelation()), isFinal);
-//
-// addOrSet(callerThread, result, queryProvider);
-//
-// proc.execute(callerThread, result);
-//
- }
-
- @Override
- public void exception(ReadGraphImpl graph, Throwable t) {
- proc.exception(graph, t);
- }
-
- });
-
- }
-
- @Override
- public Object computeForEach(ReadGraphImpl graph, final QueryProcessor provider, final InternalProcedure<RelationInfo> procedure, boolean store) {
-
-// System.out.println("RelationInfoQuery computeForEach begin " + id + " " + getResult() + " " + statusOrException);
-
+ public static void computeForEach(ReadGraphImpl graph, int r, RelationInfoQuery entry, InternalProcedure<RelationInfo> procedure) throws DatabaseException {
+
+ QueryProcessor provider = graph.processor;
+
final int superRelationOf = provider.getSuperrelationOf();
assert(superRelationOf != 0);
- DirectPredicates.queryEach(graph, id, provider, this, null, new IntProcedure() {
-
- boolean found = false;
-
- @Override
- public void execute(ReadGraphImpl graph, int i) {
-// System.out.println("RelationInfoQuery: execute " + i + " super = " + superRelationOf);
- if(i == superRelationOf) {
- computeTypes(graph, false, provider, procedure);
- found = true;
- }
- }
-
- @Override
- public void finished(ReadGraphImpl graph) {
-// System.out.println("RelationInfoQuery: finished");
- if(!found) {
- computeTypes(graph, true, provider, procedure);
- }
- }
-
- @Override
- public void exception(ReadGraphImpl graph, Throwable t) {
-// System.out.println("RelationInfoQuery: exception");
- procedure.exception(graph, t);
- }
-
- });
+ IntSet direct = QueryCache.resultDirectPredicates(graph, r, entry, null, QueryCache.emptyProcedureDirectPredicates);
+ IntSet types = QueryCache.resultTypes(graph, r, entry, null, QueryCache.emptyProcedureTypes);
- return getResult();
+ computeAssertions(graph, r, !direct.contains(superRelationOf), types.contains(graph.processor.getFunctionalRelation()), entry, procedure);
- }
+ }
+
+ @Override
+ public Object compute(ReadGraphImpl graph, final InternalProcedure<RelationInfo> procedure) throws DatabaseException {
+ computeForEach(graph, id, this, procedure);
+ return getResult();
+ }
@Override
public String toString() {
return "RelationInfoQuery[" + id + "]";
}
- public void addOrSet(ReadGraphImpl graph, final RelationInfo result, final QueryProcessor provider) {
-
- assert(isPending());
-
-// ArrayList<InternalProcedure<RelationInfo>> p = null;
-
- synchronized(this) {
-
- setResult(result);
- setReady();
-
-// p = procs;
-// procs = null;
-
- }
-
-// if(p != null) {
-// for(InternalProcedure<RelationInfo> proc : p)
-// proc.execute(graph, (RelationInfo)result);
+// public void addOrSet(ReadGraphImpl graph, final RelationInfo result, final QueryProcessor provider) {
+//
+// assert(isPending());
+//
+// synchronized(this) {
+//
+// setResult(result);
+// setReady();
+//
// }
-
- }
+//
+// }
+
+ @Override
+ public void setResult(Object result) {
+ super.setResult(result);
+ if(!(result instanceof RelationInfo) && !(result == NO_RESULT))
+ System.err.println("foo");
+ setReady();
+ }
@Override
- public Object performFromCache(ReadGraphImpl graph, QueryProcessor provider, InternalProcedure<RelationInfo> procedure) {
+ public Object performFromCache(ReadGraphImpl graph, InternalProcedure<RelationInfo> procedure) throws DatabaseException {
assert(isReady());
}
@Override
- public void recompute(ReadGraphImpl graph, QueryProcessor provider) {
-
- final Semaphore s = new Semaphore(0);
-
- computeForEach(graph, provider, new InternalProcedure<RelationInfo>() {
+ public int type() {
+ return RequestFlags.IMMEDIATE_UPDATE;
+ }
+
+ @Override
+ public void recompute(ReadGraphImpl graph) throws DatabaseException {
+
+ compute(graph, new InternalProcedure<RelationInfo>() {
@Override
public void execute(ReadGraphImpl graph, RelationInfo result) {
- s.release();
}
@Override
throw new Error("Error in recompute.", t);
}
- }, true);
-
- while(!s.tryAcquire()) {
- provider.resume(graph);
- }
-// try {
-// s.acquire();
-// } catch (InterruptedException e) {
-// throw new Error(e);
-// }
-
- }
-
- @Override
- public int type() {
- return RequestFlags.IMMEDIATE_UPDATE;
- }
+ });
+
+ }
}
Code Review / simantics / platform.git / blobdiff