bundles/org.simantics.db.impl/src/org/simantics/db/impl/query/Predicates.java

   1 /*******************************************************************************\r
   2  * Copyright (c) 2007, 2010 Association for Decentralized Information Management\r
   3  * in Industry THTH ry.\r
   4  * All rights reserved. This program and the accompanying materials\r
   5  * are made available under the terms of the Eclipse Public License v1.0\r
   6  * which accompanies this distribution, and is available at\r
   7  * http://www.eclipse.org/legal/epl-v10.html\r
   8  *\r
   9  * Contributors:\r
  10  *     VTT Technical Research Centre of Finland - initial API and implementation\r
  11  *******************************************************************************/\r
  12 package org.simantics.db.impl.query;\r
  13 \r
  14 import gnu.trove.procedure.TIntProcedure;\r
  15 \r
  16 import java.util.concurrent.Semaphore;\r
  17 \r
  18 import org.simantics.db.common.exception.DebugException;\r
  19 import org.simantics.db.impl.graph.ReadGraphImpl;\r
  20 import org.simantics.db.procedure.ListenerBase;\r
  21 import org.simantics.db.request.RequestFlags;\r
  22 \r
  23 final public class Predicates extends UnaryQuery<IntProcedure> {\r
  24         \r
  25 //      public ArrayList<IntProcedure> procs;\r
  26 \r
  27         public Predicates(final int r) {\r
  28         super(r);\r
  29     }\r
  30 \r
  31     public static Predicates newInstance(final int r) {\r
  32         return new Predicates(r);\r
  33     }\r
  34     \r
  35     final static Predicates entry(final QueryProcessor provider, final int r) {\r
  36         \r
  37         return (Predicates)provider.predicatesMap.get(r);\r
  38 \r
  39     }\r
  40     \r
  41     final static void runner(ReadGraphImpl graph, final int r, final QueryProcessor provider, Predicates cached, final CacheEntry parent, final ListenerBase listener, final IntProcedure procedure) {\r
  42 \r
  43         Predicates entry = cached != null ? cached : (Predicates)provider.predicatesMap.get(r); \r
  44         if(entry == null) {\r
  45                 \r
  46                 entry = new Predicates(r);\r
  47                 entry.setPending();\r
  48                 entry.clearResult(provider.querySupport);\r
  49                 entry.putEntry(provider);\r
  50                 \r
  51             provider.performForEach(graph, entry, parent, listener, procedure);\r
  52             \r
  53         } else {\r
  54                 \r
  55             if(entry.isPending()) {\r
  56                 synchronized(entry) {\r
  57                     if(entry.isPending()) {\r
  58                         throw new IllegalStateException();\r
  59                     }\r
  60                 }\r
  61             }\r
  62             provider.performForEach(graph, entry, parent, listener, procedure);\r
  63         }\r
  64 \r
  65     }\r
  66 \r
  67     final static IntSet runner2(ReadGraphImpl graph, final int r, final QueryProcessor provider, final CacheEntry parent) throws Throwable {\r
  68 \r
  69         Predicates entry = (Predicates)provider.predicatesMap.get(r); \r
  70         if(entry == null) {\r
  71                 \r
  72                 entry = new Predicates(r);\r
  73                 entry.setPending();\r
  74                 entry.clearResult(provider.querySupport);\r
  75                 entry.putEntry(provider);\r
  76                 \r
  77             return (IntSet)provider.performForEach2(graph, entry, parent, null, null);\r
  78             \r
  79         } else {\r
  80                 \r
  81             if(entry.isPending()) {\r
  82                 synchronized(entry) {\r
  83                     if(entry.isPending()) {\r
  84                         throw new IllegalStateException();\r
  85                     }\r
  86                 }\r
  87             }\r
  88             return (IntSet)provider.performForEach(graph, entry, parent, null, null);\r
  89             \r
  90         }\r
  91 \r
  92     }\r
  93     \r
  94     final public static void queryEach(ReadGraphImpl graph, final int r, final QueryProcessor provider, final CacheEntry parent, final ListenerBase listener, final IntProcedure procedure) {\r
  95         \r
  96         assert(r != 0);\r
  97         \r
  98         final Predicates entry = (Predicates)provider.predicatesMap.get(r);\r
  99         \r
 100         if(parent == null && listener == null) {\r
 101                 if(entry != null && entry.isReady()) { \r
 102                         entry.performFromCache(graph, provider, procedure);\r
 103                         return;\r
 104                 }\r
 105         }\r
 106 \r
 107         runner(graph, r, provider, entry, parent, listener, procedure);\r
 108          \r
 109     }\r
 110 \r
 111     final public static IntSet queryEach2(ReadGraphImpl graph, final int r, final QueryProcessor provider, final CacheEntry parent) throws Throwable {\r
 112         \r
 113         if(parent == null) {\r
 114                 final Predicates entry = (Predicates)provider.predicatesMap.get(r);\r
 115                 if(entry != null && entry.isReady()) {\r
 116                         return (IntSet)entry.get(graph, provider, null);\r
 117                 }\r
 118         }\r
 119 \r
 120         return runner2(graph, r, provider, parent);\r
 121          \r
 122     }\r
 123     \r
 124     @Override\r
 125     public UnaryQuery<IntProcedure> getEntry(QueryProcessor provider) {\r
 126         return provider.predicatesMap.get(id);\r
 127     }\r
 128         \r
 129         @Override\r
 130         public void putEntry(QueryProcessor provider) {\r
 131             provider.predicatesMap.put(id, this);\r
 132         }\r
 133 \r
 134         @Override\r
 135         final public void removeEntry(QueryProcessor provider) {\r
 136         provider.predicatesMap.remove(id);\r
 137         }\r
 138     \r
 139     final private void forAssertions(ReadGraphImpl graph, final QueryProcessor queryProvider, final IntProcedure procedure, final boolean store) {\r
 140 \r
 141         PrincipalTypes.queryEach(graph, id, queryProvider, store ? Predicates.this : null, null, new SyncIntProcedure() {\r
 142             \r
 143             @Override\r
 144             public void run(ReadGraphImpl graph) {\r
 145                 \r
 146                 finish(graph, queryProvider);\r
 147                 procedure.finished(graph);\r
 148                 \r
 149             }\r
 150             \r
 151             IntProcedure proc = new IntProcedure() {\r
 152 \r
 153                 @Override\r
 154                 public void execute(ReadGraphImpl graph, int i) {\r
 155                     if(addOrSet(queryProvider, i))\r
 156                         procedure.execute(graph, i);\r
 157                 }\r
 158 \r
 159                 @Override\r
 160                 public void finished(ReadGraphImpl graph) {\r
 161                     dec(graph);\r
 162                 }\r
 163                                 \r
 164                                 @Override\r
 165                                 public void exception(ReadGraphImpl graph, Throwable t) {\r
 166                     if(DebugException.DEBUG) new DebugException(t).printStackTrace();\r
 167                                         procedure.exception(graph, t);\r
 168                     }\r
 169 \r
 170             }; \r
 171 \r
 172             @Override\r
 173             public void execute(ReadGraphImpl graph, int type) {\r
 174 \r
 175                 inc();\r
 176                 \r
 177                 AssertedPredicates.queryEach(graph, type, queryProvider, store ? Predicates.this : null, null, proc);\r
 178                 \r
 179             }\r
 180             \r
 181             @Override\r
 182             public void finished(ReadGraphImpl graph) {\r
 183                 dec(graph);       \r
 184             }\r
 185             \r
 186         });\r
 187         \r
 188 \r
 189     }\r
 190 \r
 191     @Override\r
 192     public Object computeForEach(ReadGraphImpl graph, final QueryProcessor provider, final IntProcedure procedure, final boolean store) {\r
 193 \r
 194                 DirectPredicates.queryEach(graph, id, provider, store ? Predicates.this : null, null, new IntProcedure() {\r
 195 \r
 196                         @Override\r
 197                         public void execute(ReadGraphImpl graph, final int pred) {\r
 198 \r
 199                                 if(addOrSet(provider, pred))\r
 200                                         procedure.execute(graph, pred);\r
 201 \r
 202                         }\r
 203 \r
 204                         @Override\r
 205                         public void finished(ReadGraphImpl graph) {\r
 206 \r
 207                                 forAssertions(graph, provider, procedure, store);\r
 208 \r
 209                         }\r
 210 \r
 211                         @Override\r
 212                         public void exception(ReadGraphImpl graph, Throwable t) {\r
 213                                 procedure.exception(graph, t);\r
 214                         }\r
 215 \r
 216                 });\r
 217                 \r
 218                 return getResult();\r
 219         \r
 220     }\r
 221     \r
 222     @Override\r
 223     public String toString() {\r
 224         return "Predicates2[" + id + "]";\r
 225     }\r
 226 \r
 227     final public void finish(final ReadGraphImpl graph, QueryProcessor provider) {\r
 228         \r
 229 //        ArrayList<IntProcedure> p = null;\r
 230 \r
 231         synchronized(this) {\r
 232 \r
 233                 setReady();\r
 234 //            p = procs;\r
 235 //            procs = null; \r
 236         \r
 237         }\r
 238         \r
 239 //        if(p != null) {\r
 240 //        \r
 241 //              final ArrayList<IntProcedure> finalP = p;\r
 242 //\r
 243 //              IntSet v = (IntSet)getResult();\r
 244 //              v.forEach(new TIntProcedure() {\r
 245 //\r
 246 //                      @Override\r
 247 //                      public boolean execute(int arg0) {\r
 248 //                              for(IntProcedure proc : finalP) proc.execute(graph, arg0);\r
 249 //                              return true;\r
 250 //                      }\r
 251 //\r
 252 //              });\r
 253 //\r
 254 //              for(IntProcedure proc : p) proc.finished(graph);\r
 255 //        \r
 256 //        }\r
 257 \r
 258     }\r
 259 \r
 260     synchronized private boolean addOrSet(QueryProcessor processor, int add) {\r
 261 \r
 262         if(!isPending()) {\r
 263                 setResult(new IntSet(null));\r
 264         }\r
 265         \r
 266         IntSet value = (IntSet)getResult();\r
 267         return value.add(add);\r
 268         \r
 269     }\r
 270 \r
 271     @Override\r
 272     public void clearResult(QuerySupport support) {\r
 273         setResult(new IntSet(support));\r
 274     }\r
 275     \r
 276     @Override\r
 277     public Object performFromCache(final ReadGraphImpl graph, QueryProcessor provider, final IntProcedure procedure) {\r
 278         \r
 279         assert(isReady());\r
 280 \r
 281         if(handleException(graph, procedure)) return EXCEPTED;\r
 282         \r
 283         IntSet v = getResult();\r
 284         if(procedure != null) {\r
 285                 v.forEach(new TIntProcedure() {\r
 286 \r
 287                         @Override\r
 288                         public boolean execute(int arg0) {\r
 289                                 procedure.execute(graph, arg0);                                         \r
 290                                 return true;\r
 291                         }\r
 292                 });\r
 293             procedure.finished(graph);\r
 294         }\r
 295         \r
 296         return v;\r
 297         \r
 298     }\r
 299     \r
 300     @Override\r
 301     public void recompute(ReadGraphImpl graph, QueryProcessor provider) {\r
 302         \r
 303         final Semaphore s = new Semaphore(0);\r
 304         \r
 305         computeForEach(graph, provider, new IntProcedure() {\r
 306 \r
 307             @Override\r
 308             public void finished(ReadGraphImpl graph) {\r
 309                 s.release();\r
 310             }\r
 311                         \r
 312                         @Override\r
 313                         public void exception(ReadGraphImpl graph, Throwable t) {\r
 314                                 throw new Error("Error in recompute.", t);\r
 315             }\r
 316 \r
 317                         @Override\r
 318                         public void execute(ReadGraphImpl graph, int i) {\r
 319                         }\r
 320 \r
 321         }, true);\r
 322         \r
 323         while(!s.tryAcquire()) {\r
 324                 provider.resume(graph);\r
 325         }\r
 326         \r
 327     }\r
 328     \r
 329     @Override\r
 330     public int type() {\r
 331         return RequestFlags.IMMEDIATE_UPDATE;\r
 332     }\r
 333 \r
 334 \r
 335     @Override\r
 336     boolean isImmutable(ReadGraphImpl graph) {\r
 337         return graph.processor.isImmutable(id);\r
 338     }\r
 339     \r
 340 }\r