1 /*******************************************************************************
2 * Copyright (c) 2007, 2010 Association for Decentralized Information Management
4 * All rights reserved. This program and the accompanying materials
5 * are made available under the terms of the Eclipse Public License v1.0
6 * which accompanies this distribution, and is available at
7 * http://www.eclipse.org/legal/epl-v10.html
10 * VTT Technical Research Centre of Finland - initial API and implementation
11 *******************************************************************************/
12 package org.simantics.db.impl.query;
14 import java.util.concurrent.Semaphore;
16 import org.simantics.db.RelationInfo;
17 import org.simantics.db.impl.graph.ReadGraphImpl;
18 import org.simantics.db.impl.procedure.IntProcedureAdapter;
19 import org.simantics.db.impl.procedure.InternalProcedure;
20 import org.simantics.db.procedure.ListenerBase;
23 final public class AssertedPredicates extends CollectionUnaryQuery<IntProcedure> {
25 public AssertedPredicates(final int r) {
29 public static AssertedPredicates newInstance(final int r) {
30 return new AssertedPredicates(r);
33 final static void runner(ReadGraphImpl graph, final int r, final QueryProcessor provider, final CacheEntry parent, final ListenerBase listener, final IntProcedure procedure) {
35 AssertedPredicates entry = (AssertedPredicates)provider.cache.assertedPredicatesMap.get(r);
38 entry = new AssertedPredicates(r);
40 entry.clearResult(provider.querySupport);
41 entry.putEntry(provider);
43 provider.performForEach(graph, entry, parent, listener, procedure);
47 if(!entry.isReady()) {
49 if(!entry.isReady()) {
50 throw new IllegalStateException();
51 // if(entry.procs == null) entry.procs = new ArrayList<IntProcedure>();
52 // entry.procs.add(procedure);
57 provider.performForEach(graph, entry, parent, listener, procedure);
62 final public static void queryEach(ReadGraphImpl graph, final int r, final QueryProcessor provider, final CacheEntry parent, final ListenerBase listener, final IntProcedure procedure) {
64 if(parent == null && listener == null) {
65 AssertedPredicates entry = (AssertedPredicates)provider.cache.assertedPredicatesMap.get(r);
66 if(entry != null && entry.isReady()) {
67 entry.performFromCache(graph, provider, procedure);
72 runner(graph, r, provider, parent, listener, procedure);
77 public UnaryQuery<IntProcedure> getEntry(QueryProcessor provider) {
78 return provider.cache.assertedPredicatesMap.get(id);
82 public void putEntry(QueryProcessor provider) {
83 provider.cache.assertedPredicatesMap.put(id, this);
87 final public void removeEntry(QueryProcessor provider) {
88 provider.cache.assertedPredicatesMap.remove(id);
91 void computeInheritedAssertions(ReadGraphImpl graph, int type, final QueryProcessor queryProvider, final IntProcedure proc, final boolean store) {
93 DirectObjects.queryEach(graph, type, queryProvider.getInherits(), queryProvider, this, null, new SyncIntProcedure() {
96 public void run(ReadGraphImpl graph) {
98 // finish(graph, queryProvider);
99 // proc.finished(graph);
104 public void execute(ReadGraphImpl graph,int inh) {
108 AssertedPredicates.queryEach(graph, inh, queryProvider, AssertedPredicates.this, null, new IntProcedure() {
111 public void execute(ReadGraphImpl graph, int ass) {
114 // proc.execute(graph, ass);
119 public void finished(ReadGraphImpl graph) {
124 public void exception(ReadGraphImpl graph, Throwable t) {
125 // proc.exception(graph, t);
133 public void finished(ReadGraphImpl graph) {
144 public Object computeForEach(ReadGraphImpl graph, final QueryProcessor queryProvider, final IntProcedure proc, final boolean store) {
146 computeInheritedAssertions(graph, id, queryProvider, proc, store);
148 DirectObjects.queryEach(graph, id, queryProvider.getAsserts(), queryProvider, this, null, new IntProcedure() {
151 public void execute(ReadGraphImpl graph, final int ass) {
153 DirectObjects.queryEach(graph, ass, queryProvider.getHasPredicate(), queryProvider, AssertedPredicates.this, null, new IntProcedure() {
156 public void execute(ReadGraphImpl graph, final int pred) {
158 addOrSetHiding(graph, pred, AssertedPredicates.this);
159 // proc.execute(graph, pred);
165 public void finished(ReadGraphImpl graph) {
169 public void exception(ReadGraphImpl graph, Throwable t) {
170 // proc.exception(graph, t);
178 public void finished(ReadGraphImpl graph) {
182 public void exception(ReadGraphImpl graph, Throwable t) {
183 // proc.exception(graph, t);
188 finish(graph, queryProvider);
190 performFromCache(graph, queryProvider, proc);
197 public String toString() {
198 return "AssertedPredicates[" + id + "]";
201 final public void finish(ReadGraphImpl graph, QueryProcessor provider) {
205 // ArrayList<IntProcedure> p = null;
216 // IntArray v = (IntArray)getResult();
217 // if(v.data == null) {
218 // if(v.sizeOrData != IntArray.NO_DATA) {
219 // for(IntProcedure proc : p) proc.execute(graph, v.sizeOrData);
222 // for(IntProcedure proc : p) {
223 // for(int i = 0;i < v.sizeOrData ; i++) proc.execute(graph, v.data[i]);
227 // for(IntProcedure proc : p) proc.finished(graph);
232 synchronized private void addOrSet(int add) {
236 IntArray value = (IntArray)getResult();
241 final static InternalProcedure<RelationInfo> ip = new InternalProcedure<RelationInfo>() {
244 public void execute(ReadGraphImpl graph, RelationInfo result) {
248 public void exception(ReadGraphImpl graph, Throwable throwable) {
253 final static InternalProcedure<IntSet> ip2 = new InternalProcedure<IntSet>() {
256 public void execute(ReadGraphImpl graph, IntSet result) {
260 public void exception(ReadGraphImpl graph, Throwable throwable) {
265 synchronized private void addOrSetHiding(ReadGraphImpl graph, int add, CacheEntry parent) {
269 IntArray value = (IntArray)getResult();
270 RelationInfo ri = RelationInfoQuery.queryEach(graph, add, graph.processor, parent, null, ip);
271 if(ri.isFunctional) {
272 // Replace existing functional predicate if found
274 IntSet supers = SuperRelations.queryEach2(graph, add, graph.processor, parent, null, ip2);
275 if(value.data == null) {
276 if(value.sizeOrData != IntArray.NO_DATA) {
277 if(supers.contains(value.sizeOrData)) {
278 value.sizeOrData = add;
283 for(int i = 0;i < value.sizeOrData ; i++) {
284 if(supers.contains(value.data[i])) {
290 } catch (Throwable e) {
296 // No replacement - append
302 public Object performFromCache(ReadGraphImpl graph, QueryProcessor provider, final IntProcedure procedure) {
306 if(handleException(graph, procedure)) return EXCEPTED;
308 final IntArray value = (IntArray)getResult();
309 if(value.data == null) {
310 if(value.sizeOrData != IntArray.NO_DATA) procedure.execute(graph, value.sizeOrData);
312 for(int i = 0;i < value.sizeOrData ; i++) procedure.execute(graph, value.data[i]);
315 procedure.finished(graph);
322 public void recompute(ReadGraphImpl graph, QueryProcessor provider) {
324 final Semaphore s = new Semaphore(0);
326 computeForEach(graph, provider, new IntProcedureAdapter() {
329 public void finished(ReadGraphImpl graph) {
334 public void exception(ReadGraphImpl graph, Throwable t) {
336 new Error("Error in recompute.", t).printStackTrace();
341 while(!s.tryAcquire()) {
342 provider.resume(graph);