bundles/org.simantics.db.impl/src/org/simantics/db/impl/query/URIToResource.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 gnu.trove.map.hash.TObjectIntHashMap;
  15
  16 import java.util.concurrent.Semaphore;
  17
  18 import org.simantics.databoard.util.URIStringUtils;
  19 import org.simantics.db.common.exception.DebugException;
  20 import org.simantics.db.impl.graph.ReadGraphImpl;
  21 import org.simantics.db.impl.procedure.InternalProcedure;
  22 import org.simantics.db.procedure.ListenerBase;
  23
  24 public class URIToResource extends StringQuery<InternalProcedure<Integer>> {
  25
  26 //    public ArrayList<InternalProcedure<Integer>> procs = null;
  27
  28     private URIToResource(final String id) {
  29         super(id);
  30     }
  31
  32     final static URIToResource entry(final QueryProcessor provider, final String id) {
  33         return (URIToResource)provider.uriToResourceMap.get(id);
  34     }
  35
  36     final static void runner(ReadGraphImpl graph, final String id, CacheEntry parent, final ListenerBase listener, final InternalProcedure<Integer> procedure) {
  37
  38         QueryProcessor processor = graph.processor;
  39
  40         URIToResource entry = (URIToResource)processor.uriToResourceMap.get(id);
  41         if(entry == null) {
  42
  43                 entry = new URIToResource(id);
  44                 entry.setPending();
  45                 entry.clearResult(processor.querySupport);
  46                 entry.putEntry(processor);
  47
  48                 processor.performForEach(graph, entry, parent, listener, procedure);
  49
  50         } else {
  51
  52             if(entry.isPending()) {
  53                 synchronized(entry) {
  54                     if(entry.isPending()) {
  55                         throw new IllegalStateException();
  56 //                      if(entry.procs == null) entry.procs = new ArrayList<InternalProcedure<Integer>>();
  57 //                        entry.procs.add(procedure);
  58 //                        processor.registerDependencies(graph, entry, parent, listener, procedure, false);
  59 //                        return;
  60                     }
  61                 }
  62             }
  63
  64             processor.performForEach(graph, entry, parent, listener, procedure);
  65
  66         }
  67
  68     }
  69
  70     final public static void queryEach(ReadGraphImpl graph, final String id, final CacheEntry parent, final ListenerBase listener, final InternalProcedure<Integer> procedure) {
  71
  72         assert(id != null);
  73
  74         if(graph.parent == null && listener == null) {
  75                 URIToResource.computeForEach(graph, id, null, procedure);
  76         } else {
  77             runner(graph, id, parent, listener, procedure);
  78         }
  79
  80     }
  81
  82     @Override
  83     public URIToResource getEntry(QueryProcessor provider) {
  84         return provider.uriToResourceMap.get(id);
  85     }
  86
  87     @Override
  88     public void putEntry(QueryProcessor provider) {
  89         provider.uriToResourceMap.put(id, this);
  90     }
  91
  92     @Override
  93     final public void removeEntry(QueryProcessor provider) {
  94         provider.uriToResourceMap.remove(id);
  95     }
  96
  97     private void lookup(ReadGraphImpl graph, final QueryProcessor processor, final InternalProcedure<Integer> procedure, final String namespace, final String name) {
  98
  99         NamespaceIndex.queryEach(graph, namespace, processor, this, null, new InternalProcedure<TObjectIntHashMap<String>>() {
 100
 101             @Override
 102             public void execute(ReadGraphImpl graph, TObjectIntHashMap<String> index) {
 103
 104                 if(index != null) {
 105                     int result = index.get(name);
 106                     if(result != 0) {
 107                         addOrSet(graph, processor, result);
 108                         procedure.execute(graph, result);
 109                         return;
 110                     }
 111                 }
 112
 113                 addOrSet(graph, processor, new Integer(0));
 114                 procedure.execute(graph, new Integer(0));
 115
 116             }
 117
 118             @Override
 119             public void exception(ReadGraphImpl graph, Throwable t) {
 120                 except(t);
 121                 procedure.exception(graph, t);
 122             }
 123
 124         });
 125
 126     }
 127
 128     private static void lookup(ReadGraphImpl graph, final URIToResource entry, final InternalProcedure<Integer> procedure, final String namespace, final String name) {
 129
 130         NamespaceIndex.queryEach(graph, namespace, graph.processor, entry, null, new InternalProcedure<TObjectIntHashMap<String>>() {
 131
 132             @Override
 133             public void execute(ReadGraphImpl graph, TObjectIntHashMap<String> index) {
 134
 135                 if(index != null) {
 136                     int result = index.get(name);
 137                     if(result != 0) {
 138                         if(entry != null) entry.addOrSet(graph, graph.processor, result);
 139                         procedure.execute(graph, result);
 140                         return;
 141                     }
 142                 }
 143
 144                 Integer zero = 0;
 145                 if(entry != null) entry.addOrSet(graph, graph.processor, zero);
 146                 procedure.execute(graph, zero);
 147
 148             }
 149
 150             @Override
 151             public void exception(ReadGraphImpl graph, Throwable t) {
 152                 if(entry != null) entry.except(t);
 153                 procedure.exception(graph, t);
 154             }
 155
 156         });
 157
 158     }
 159
 160     @Override
 161     public void computeForEach(ReadGraphImpl graph, final QueryProcessor processor, final InternalProcedure<Integer> procedure) {
 162
 163 //      new Exception("URIToResource " + id).printStackTrace();
 164
 165         if("http://".equals(id) || "http:/".equals(id)) {
 166
 167             addOrSet(graph, processor, processor.getRootLibrary());
 168             procedure.execute(graph, processor.getRootLibrary());
 169
 170         } else {
 171
 172             final String[] parts = URIStringUtils.splitURI(id);
 173             if (parts != null) {
 174                 lookup(graph, processor, procedure, parts[0], parts[1]);
 175             } else {
 176                 lookup(graph, processor, procedure, "http://", id.replaceFirst("http://", ""));
 177             }
 178
 179         }
 180
 181     }
 182
 183     final private static void computeForEach(ReadGraphImpl graph, String id, final URIToResource entry, final InternalProcedure<Integer> procedure) {
 184
 185         if("http://".equals(id) || "http:/".equals(id)) {
 186
 187                 QueryProcessor processor = graph.processor;
 188             if(entry != null) entry.addOrSet(graph, processor, processor.getRootLibrary());
 189             procedure.execute(graph, processor.getRootLibrary());
 190
 191         } else {
 192
 193             final String[] parts = URIStringUtils.splitURI(id);
 194             if (parts != null) {
 195                 lookup(graph, entry, procedure, parts[0], parts[1]);
 196             } else {
 197                 lookup(graph, entry, procedure, "http://", id.replaceFirst("http://", ""));
 198             }
 199
 200         }
 201
 202     }
 203
 204     public void addOrSet(ReadGraphImpl graph, QueryProcessor provider, Integer result) {
 205
 206         assert(isPending());
 207
 208 //        ArrayList<InternalProcedure<Integer>> p = null;
 209
 210         synchronized(this) {
 211
 212             setResult(result);
 213             setReady();
 214 //            p = procs;
 215 //            procs = null;
 216
 217         }
 218
 219 //        if(p != null)
 220 //              for(InternalProcedure<Integer> proc : p) proc.execute(graph, result);
 221
 222     }
 223
 224     @Override
 225     public String toString() {
 226         return "URIToResource[" + id + "]";
 227     }
 228
 229     @Override
 230     public void performFromCache(ReadGraphImpl graph, QueryProcessor provider, InternalProcedure<Integer> procedure) {
 231
 232         assert(isReady());
 233
 234         if(handleException(graph, procedure)) return;
 235
 236         if(isExcepted()) {
 237                 procedure.exception(graph, (Throwable)statusOrException);
 238         } else {
 239             procedure.execute(graph, (Integer)getResult());
 240         }
 241
 242     }
 243
 244     @Override
 245     public void recompute(ReadGraphImpl graph, QueryProcessor provider) {
 246
 247         final Semaphore s = new Semaphore(0);
 248
 249         computeForEach(graph, provider, new InternalProcedure<Integer>() {
 250
 251             @Override
 252             public void execute(ReadGraphImpl graph, Integer result) {
 253                 s.release();
 254             }
 255
 256             @Override
 257             public void exception(ReadGraphImpl graph, Throwable t) {
 258                 if(DebugException.DEBUG) new DebugException(t).printStackTrace();
 259                 throw new Error("Error in recompute.", t);
 260             }
 261
 262         });
 263
 264         while(!s.tryAcquire()) {
 265                 provider.resume(graph);
 266         }
 267
 268     }
 269
 270 }