bundles/org.simantics.db.impl/src/org/simantics/db/impl/query/SuperTypes.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.impl.graph.ReadGraphImpl;\r
  19 import org.simantics.db.impl.procedure.InternalProcedure;\r
  20 import org.simantics.db.procedure.ListenerBase;\r
  21 \r
  22 final public class SuperTypes extends UnaryQuery<InternalProcedure<IntSet>> {\r
  23     \r
  24 //      public ArrayList<InternalProcedure<IntSet>> procs = null;\r
  25         \r
  26     private SuperTypes(final int resource) {\r
  27         super(resource);\r
  28     }\r
  29     \r
  30     final static SuperTypes runner(ReadGraphImpl graph, final int r, final CacheEntry parent, final QueryProcessor provider, final ListenerBase listener, final InternalProcedure<IntSet> procedure) {\r
  31 \r
  32         SuperTypes entry = (SuperTypes)provider.superTypesMap.get(r);\r
  33         if(entry == null) {\r
  34                 \r
  35                 entry = new SuperTypes(r);\r
  36                 entry.setPending();\r
  37                 entry.clearResult(provider.querySupport);\r
  38                 entry.putEntry(provider);\r
  39                 \r
  40             provider.performForEach(graph, entry, parent, listener, procedure);\r
  41             \r
  42             return entry;\r
  43             \r
  44         } else {\r
  45                 \r
  46             if(!entry.isReady()) {\r
  47                 synchronized(entry) {\r
  48                     if(!entry.isReady()) {\r
  49                         throw new IllegalStateException();\r
  50 //                      if(entry.procs == null) entry.procs = new ArrayList<InternalProcedure<IntSet>>();\r
  51 //                      entry.procs.add(procedure);\r
  52 //                                              provider.registerDependencies(graph, entry, parent, listener, procedure, false);\r
  53 //                      return entry;\r
  54                     }\r
  55                 }\r
  56             }\r
  57             provider.performForEach(graph, entry, parent, listener, procedure);\r
  58         }\r
  59         \r
  60         return entry;\r
  61 \r
  62     }\r
  63     \r
  64     final public static SuperTypes queryEach(ReadGraphImpl graph, final int r, final QueryProcessor provider, final CacheEntry parent, final ListenerBase listener, final InternalProcedure<IntSet> procedure) {\r
  65     \r
  66         if(parent == null && listener == null) {\r
  67                 SuperTypes entry = (SuperTypes)provider.superTypesMap.get(r);\r
  68                 if(entry != null && entry.isReady()) { \r
  69                         entry.performFromCache(graph, provider, procedure);\r
  70                         return entry;\r
  71                 }\r
  72         }\r
  73         \r
  74         return runner(graph, r, parent, provider, listener, procedure);\r
  75          \r
  76     }\r
  77         \r
  78         @Override\r
  79         public UnaryQuery<InternalProcedure<IntSet>> getEntry(QueryProcessor provider) {\r
  80         return provider.superTypesMap.get(id);\r
  81         }\r
  82         \r
  83         @Override\r
  84         public void putEntry(QueryProcessor provider) {\r
  85         provider.superTypesMap.put(id, this);\r
  86         }\r
  87 \r
  88         @Override\r
  89         final public void removeEntry(QueryProcessor provider) {\r
  90                 provider.superTypesMap.remove(id);\r
  91         }\r
  92 \r
  93         @Override\r
  94         public Object computeForEach(ReadGraphImpl graph, final QueryProcessor provider, final InternalProcedure<IntSet> procedure, boolean store) {\r
  95 \r
  96         final int inherits = provider.getInherits();\r
  97         \r
  98         final CacheEntry parent = graph.parent;\r
  99         \r
 100         assert(graph.parent != this);\r
 101 \r
 102         final IntSet result = new IntSet(provider.querySupport);\r
 103         \r
 104         final TIntProcedure addToResult = new TIntProcedure() {\r
 105             @Override\r
 106             public boolean execute(int r) {\r
 107                 synchronized(result) {\r
 108                         result.add(r);\r
 109                 }\r
 110                 return true;\r
 111             }\r
 112         };\r
 113 \r
 114         DirectObjects.queryEach(graph, id, inherits, provider, this, null, new SyncIntProcedure() {\r
 115             \r
 116             @Override\r
 117             public void run(ReadGraphImpl graph) {\r
 118 \r
 119                 addOrSet(graph, result, provider);\r
 120                 procedure.execute(graph, result);\r
 121                 \r
 122             }\r
 123             \r
 124             @Override\r
 125             public void execute(ReadGraphImpl graph, final int i) {\r
 126                 \r
 127                 assert(graph.parent == parent);\r
 128                 \r
 129                 synchronized(result) {\r
 130                         result.add(i);\r
 131                 }\r
 132                 \r
 133                 inc();\r
 134 \r
 135                 SuperTypes.queryEach(graph, i, provider, SuperTypes.this, null, new InternalProcedure<IntSet>() {\r
 136 \r
 137                     @Override\r
 138                     public void execute(ReadGraphImpl graph, IntSet types) {\r
 139 \r
 140                         types.forEach(addToResult);\r
 141                         dec(graph);\r
 142                         \r
 143                     }\r
 144                                 \r
 145                                 @Override\r
 146                                 public void exception(ReadGraphImpl graph, Throwable t) {\r
 147                                         procedure.exception(graph, t);\r
 148                     }\r
 149 \r
 150                 });\r
 151                 \r
 152             }\r
 153 \r
 154             @Override\r
 155             public void finished(ReadGraphImpl graph) {\r
 156                 dec(graph);\r
 157             }\r
 158             \r
 159         });\r
 160         \r
 161         return result;\r
 162         \r
 163     }\r
 164     \r
 165     @Override\r
 166     public String toString() {\r
 167         return "SuperTypes2[" + id + "]";\r
 168     }\r
 169 \r
 170     private void addOrSet(ReadGraphImpl graph, final IntSet value, QueryProcessor provider) {\r
 171         \r
 172         assert(!isReady());\r
 173 \r
 174 //        ArrayList<InternalProcedure<IntSet>> p = null;\r
 175 \r
 176         synchronized(this) {\r
 177         \r
 178             value.trim();\r
 179             setResult(value);\r
 180             setReady();\r
 181 //            p = procs;\r
 182 //            procs = null; \r
 183         \r
 184         }\r
 185 \r
 186 //        if(p != null) {\r
 187 //              IntSet v = (IntSet)getResult();\r
 188 //              if(v != null) {\r
 189 //                  for(InternalProcedure<IntSet> proc : p) proc.execute(graph, v);\r
 190 //              }\r
 191 //        }\r
 192         \r
 193     }\r
 194 \r
 195     @Override\r
 196     public Object performFromCache(ReadGraphImpl graph, QueryProcessor provider, InternalProcedure<IntSet> procedure) {\r
 197         \r
 198         assert(isReady());\r
 199 \r
 200         if(handleException(graph, procedure)) return null;\r
 201         \r
 202         IntSet result = getResult();\r
 203         \r
 204         procedure.execute(graph, result);\r
 205         \r
 206         return result;\r
 207         \r
 208     }\r
 209     \r
 210     @Override\r
 211     public void recompute(ReadGraphImpl graph, QueryProcessor provider) {\r
 212         \r
 213         final Semaphore s = new Semaphore(0);\r
 214 \r
 215         computeForEach(graph, provider, new InternalProcedure<IntSet>() {\r
 216 \r
 217                 @Override\r
 218                 public void execute(ReadGraphImpl graph, IntSet result) {\r
 219                 s.release();\r
 220                 }\r
 221 \r
 222             @Override\r
 223             public void exception(ReadGraphImpl graph, Throwable t) {\r
 224                 s.release();\r
 225                 new Error("Error in recompute.", t).printStackTrace();\r
 226             }\r
 227 \r
 228         }, true);\r
 229 \r
 230         while(!s.tryAcquire()) {\r
 231                 provider.resume(graph);\r
 232         }\r
 233         \r
 234     }\r
 235     \r
 236     @Override\r
 237     boolean isImmutable(ReadGraphImpl graph) {\r
 238         return graph.processor.isImmutable(id);\r
 239     }\r
 240     \r
 241 }\r