]> gerrit.simantics Code Review - simantics/platform.git/blob - bundles/org.simantics.db.impl/src/org/simantics/db/impl/query/CacheEntryBase.java
Fail safe import fixes made by Antti
[simantics/platform.git] / bundles / org.simantics.db.impl / src / org / simantics / db / impl / query / CacheEntryBase.java
1 /*******************************************************************************
2  * Copyright (c) 2007, 2010 Association for Decentralized Information Management
3  * in Industry THTH ry.
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
8  *
9  * Contributors:
10  *     VTT Technical Research Centre of Finland - initial API and implementation
11  *******************************************************************************/
12 package org.simantics.db.impl.query;
13
14 import java.util.ArrayList;
15 import java.util.Iterator;
16
17 import org.simantics.db.exception.DatabaseException;
18 import org.simantics.db.impl.DebugPolicy;
19 import org.simantics.db.impl.graph.ReadGraphImpl;
20 import org.simantics.db.impl.procedure.InternalProcedure;
21 import org.slf4j.Logger;
22 import org.slf4j.LoggerFactory;
23
24 abstract public class CacheEntryBase extends CacheEntry {
25
26     private static final Logger LOGGER = LoggerFactory.getLogger(CacheEntryBase.class);
27     
28         // Default level is something that is not quite a prospect but still allows for ordering within CacheCollectionResult 
29         public static final short UNDEFINED_LEVEL = 5;
30         
31         public short level = UNDEFINED_LEVEL;
32         public short age = 0;
33         public int GCStatus = 0;
34         
35     final public static CacheEntryBase[] NONE = new CacheEntryBase[0];
36
37         static private Object NO_RESULT = new Object();
38         static protected Object INVALID_RESULT = new Object();
39         
40         // Just created
41     static protected Object FRESH = new Object() { public String toString() { return "CREATED"; }};
42     // Result is computed - no exception
43     static protected Object READY = new Object() { public String toString() { return "READY"; }};
44     // Computation is under way
45     static protected Object PENDING = new Object() { public String toString() { return "PENDING"; }};
46     // Entry is discarded and is waiting for garbage collect
47     static protected Object DISCARDED = new Object() { public String toString() { return "DISCARDED"; }};
48     // The result has been invalidated
49     static protected Object REFUTED = new Object() { public String toString() { return "REFUTED"; }};
50     // The computation has excepted - the exception is in the result
51     static protected Object EXCEPTED = new Object() { public String toString() { return "EXCEPTED"; }};
52
53     // This indicates the status of the entry
54     public Object statusOrException = FRESH;
55     
56     private CacheEntry p1 = null;
57     private Object p2OrParents = null;
58     
59     private int hash = 0;
60     
61     @Override
62     final public int hashCode() {
63         if(hash == 0) hash = makeHash();
64         return hash;
65     }
66     
67     abstract int makeHash();
68     
69     // This can be tested to see if the result is finished
70     private Object result = NO_RESULT;
71     
72     final public boolean isFresh() {
73         return FRESH == statusOrException;
74     }
75
76     public void setReady() {
77         statusOrException = READY;
78     }
79
80     @Deprecated
81     final public boolean isReady() {
82         return READY == statusOrException || EXCEPTED == statusOrException;
83     }
84     
85     @Override
86     public void discard() {
87         if(DebugPolicy.QUERY_STATE) System.out.println("[QUERY STATE]: discarded " + this);
88         statusOrException = DISCARDED;
89     }
90     
91     @Override
92     final public boolean isDiscarded() {
93         return DISCARDED == statusOrException;
94     }
95     
96     @Override
97     final public void refute() {
98         if(DebugPolicy.QUERY_STATE) System.out.println("[QUERY STATE]: refuted " + this);
99         statusOrException = REFUTED;
100     }
101     
102     @Override
103     final public boolean isRefuted() {
104         return REFUTED == statusOrException;
105     }
106
107     @Override
108     final public void except(Throwable t) {
109         if(DebugPolicy.QUERY_STATE) System.out.println("[QUERY STATE]: excepted " + this);
110         if(statusOrException != DISCARDED) {
111                 statusOrException = EXCEPTED;
112                 result = t;
113         } else {
114                 LOGGER.warn("Cache entry got excepted status after being discarded: " + getClass().getSimpleName(), t);
115                 result = t;
116         }
117     }
118     
119     final public void checkAndThrow() throws DatabaseException {
120         if(isExcepted()) {
121             Throwable throwable = (Throwable)result;
122             if(throwable instanceof DatabaseException) throw (DatabaseException)throwable;
123             else throw new DatabaseException(throwable);
124         }
125     }
126     
127     @Override
128     final public boolean isExcepted() {
129         return EXCEPTED == statusOrException;
130     }
131
132     @Override
133     final public void setPending() {
134         statusOrException = PENDING;
135     }
136     
137     @Override
138     final public boolean isPending() {
139         return PENDING == statusOrException;
140     }
141     
142     final public boolean assertPending() {
143         boolean result = isPending();
144         if(!result) {
145                 LOGGER.warn("Assertion failed, expected pending, got " + statusOrException);
146         }
147         return result;
148     }
149
150     final public boolean assertNotPending() {
151         boolean result = !isPending();
152         if(!result) {
153                 new Exception(this +  ": Assertion failed, expected not pending, got " + statusOrException).printStackTrace();
154         }
155         return result;
156     }
157
158     final public boolean assertNotDiscarded() {
159         boolean result = !isDiscarded();
160         if(!result) {
161                 new Exception(this +  ": Assertion failed, expected not discarded, got " + statusOrException).printStackTrace();
162         }
163         return result;
164     }
165
166     @Override
167     public void setResult(Object result) {
168         this.result = result;
169     }
170     
171     @Override
172     final public <T> T getResult() {
173         assert(statusOrException != DISCARDED);
174         return (T)result;
175     }
176     
177     @Override
178     public void clearResult(QuerySupport support) {
179         setResult(NO_RESULT);
180     }
181     
182     @Override
183     final public void addParent(CacheEntry entry) {
184          
185         assert(entry != null);
186         
187         if(p1 == entry) {
188                 return;
189         }
190         if(p2OrParents == entry) {
191                 return;
192         }
193         if(p1 == null) {
194                 p1 = entry;
195         } else if(p2OrParents == null) {
196                 p2OrParents = entry;
197         } else if(p2OrParents instanceof QueryIdentityHashSet) {
198             ((QueryIdentityHashSet)p2OrParents).add(entry);
199             ((QueryIdentityHashSet)p2OrParents).purge();
200         } else {
201             CacheEntry tmp = (CacheEntry)p2OrParents;
202             p2OrParents = new QueryIdentityHashSet(2);
203             ((QueryIdentityHashSet)p2OrParents).add(tmp);
204             ((QueryIdentityHashSet)p2OrParents).add(entry);
205         }
206         
207     }
208
209     @Override
210     CacheEntry pruneFirstParents() {
211
212         if(p1 == null) {
213                 // No parents
214                 return null;
215         }
216         
217         if(!p1.isDiscarded()) {
218                 
219                 // First parent is still active
220                 return p1;
221                 
222         } else {
223                 
224                 // Clear p1
225                 p1 = null;
226                 
227                 // First parent is discarded => look for more parents
228                 if(p2OrParents instanceof QueryIdentityHashSet) {
229
230                         QueryIdentityHashSet set = (QueryIdentityHashSet)p2OrParents;
231                         CacheEntry entry = set.removeDiscarded();
232                         if(entry == null) p2OrParents = null;
233                         p1 = entry;
234                         return p1;
235
236                 } else if(p2OrParents instanceof CacheEntry) {
237                         
238                         CacheEntry entry = (CacheEntry)p2OrParents;
239                         if(entry.isDiscarded()) {
240                                 // Second entry is also discarded => all empty
241                                 p2OrParents = null;
242                                 return null;
243                         } else {
244                                 p1 = entry;
245                                 p2OrParents = null;
246                                 return p1;
247                         }
248                         
249                 } else {
250                 
251                         // Nothing left
252                         return null;
253                         
254                 }
255                 
256         }
257         
258     }
259     
260     @Override
261     final public void removeParent(CacheEntry entry) {
262        
263         if(p1 == null) {
264             if(p2OrParents != null) throw new Error("CacheEntryBase.removeParent: corrupted parents (p1 == null, while p2OrParents != null).");
265             else throw new Error("CacheEntryBase.removeParent: no parents.");
266         }
267         if(p1 == entry) {
268             if(p2OrParents == null) {
269                 p1 = null;
270             } else if(p2OrParents instanceof QueryIdentityHashSet) {
271                 QueryIdentityHashSet set = (QueryIdentityHashSet)p2OrParents;
272                 int size = set.size();
273                 if(size == 0) {
274                     p1 = null;
275                     p2OrParents = null;
276                 } else if (size == 1) {
277                     CacheEntry next = set.iterator().next();
278                     p1 = next;
279                     set = null;
280                 } else if(set.size() == 2) {
281                     Iterator<CacheEntry> iterator = set.iterator();
282                     p1 = iterator.next();
283                     p2OrParents = iterator.next();
284                 } else {
285                     p1 = set.iterator().next();
286                     set.remove(p1);
287                 }
288             } else {
289                 p1 = (CacheEntry)p2OrParents;
290                 p2OrParents = null;
291             }
292             
293         } else if(p2OrParents.getClass() == QueryIdentityHashSet.class) {
294             
295             QueryIdentityHashSet set = (QueryIdentityHashSet)p2OrParents;
296             boolean success = set.remove(entry);
297             if(!success) {
298                 throw new Error("CacheEntryBase.removeParent: parent was not found.");
299             }
300             assert(set.size() >= 1);
301             if(set.size() == 1) {
302                 p2OrParents = set.iterator().next();
303             }
304             
305         } else {
306             if(p2OrParents == entry) {
307                 p2OrParents = null;
308             } else {
309                 throw new Error("CacheEntryBase.removeParent: had 2 parents but neither was removed.");
310             }
311         }
312     }
313
314     @Override
315     final public boolean hasParents() {
316         assert(statusOrException != DISCARDED);
317         return p1 != null;
318     }
319     
320     @Override
321         final public Iterable<CacheEntry> getParents(QueryProcessor processor) {
322
323                 ArrayList<CacheEntry> result = new ArrayList<CacheEntry>();
324                 if(p1 != null) result.add(p1);
325                 if(p2OrParents != null) {
326                 if(p2OrParents instanceof QueryIdentityHashSet) {
327                         for(CacheEntry entry : (QueryIdentityHashSet)p2OrParents) {
328                                 result.add(entry);
329                         }
330                 } else {
331                         result.add((CacheEntry)p2OrParents);
332                 }
333                 }
334                 fillImpliedParents(processor, result);
335                 return result;
336                 
337         }
338     
339     @Override
340     CacheEntry getFirstParent(QueryProcessor processor) {
341         return p1;
342     }
343     
344     @Override
345     boolean moreThanOneParent(QueryProcessor processor) {
346         return p2OrParents != null;
347     }
348     
349     @Override
350     int parentCount(QueryProcessor processor) {
351         if(p2OrParents != null) {
352                 if(p2OrParents instanceof QueryIdentityHashSet) {
353                         return ((QueryIdentityHashSet)p2OrParents).size()+1;
354                 } else {
355                         return 2;
356                 }
357         } else {
358                 return p1 != null ? 1 : 0;
359         }
360         
361     }
362     
363     protected void fillImpliedParents(QueryProcessor processor, ArrayList<CacheEntry> result) {
364         
365     }
366     
367     protected String internalError() {
368         return toString() + " " + statusOrException + " " + result;
369     }
370
371     
372     protected boolean handleException(ReadGraphImpl graph, IntProcedure procedure) {
373         if(isExcepted()) {
374                 procedure.exception(graph, (Throwable)getResult());
375                 return true;
376         } else {
377                 return false;
378         }
379     }
380     
381     protected boolean handleException(ReadGraphImpl graph, TripleIntProcedure procedure) {
382         if(isExcepted()) {
383                 procedure.exception(graph, (Throwable)getResult());
384                 return true;
385         } else {
386                 return false;
387         }
388     }
389
390     protected <T> boolean handleException(ReadGraphImpl graph, InternalProcedure<T> procedure) {
391         if(isExcepted()) {
392                 procedure.exception(graph, (Throwable)getResult());
393                 return true;
394         } else {
395                 return false;
396         }
397     }
398     
399     @Override
400     boolean isImmutable(ReadGraphImpl graph) throws DatabaseException {
401         return false;
402     }
403     
404     @Override
405     boolean shouldBeCollected() {
406         return true;
407     }
408     
409     @Override
410     short getLevel() {
411         return level;
412     }
413     
414     @Override
415     short setLevel(short level) {
416         short existing = this.level;
417         this.level = level;
418         return existing;
419     }
420     
421     @Override
422     void prepareRecompute(QuerySupport querySupport) {
423                 setPending();
424                 clearResult(querySupport);
425     }
426     
427     /*
428      * 
429      * 
430      */
431     @Override
432     int getGCStatus() {
433         return GCStatus;
434     }
435     
436     @Override
437     int setGCStatus(int status) {
438         GCStatus = status;
439         return GCStatus;
440     }
441     
442     @Override
443     void setGCStatusFlag(int flag, boolean value) {
444         if(value) {
445                 GCStatus |= flag;
446         } else {
447                 GCStatus &= ~flag;
448         }
449     }
450     
451     @Override
452     public Object getOriginalRequest() {
453         // This is the original request for all built-in queries
454         return getQuery();
455     }
456     
457 }