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

   1 /*******************************************************************************
   2  * Copyright (c) 2007, 2018 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 org.simantics.db.AsyncReadGraph;
  15 import org.simantics.db.exception.DatabaseException;
  16 import org.simantics.db.impl.graph.ReadGraphImpl;
  17 import org.simantics.db.procedure.AsyncProcedure;
  18 import org.simantics.db.request.Read;
  19 import org.simantics.db.request.ReadExt;
  20 import org.simantics.db.request.RequestFlags;
  21 import org.slf4j.Logger;
  22 import org.slf4j.LoggerFactory;
  23
  24 public final class ReadEntry<T> extends CacheEntryBase<AsyncProcedure<T>> implements AsyncProcedure<T> {
  25
  26     private static final Logger LOGGER = LoggerFactory.getLogger(ReadEntry.class);
  27
  28     protected Read<T> request;
  29
  30     public ReadEntry(Read<T> request) {
  31         this.request = request;
  32     }
  33
  34     @Override
  35     int makeHash() {
  36         return request.hashCode();
  37     }
  38
  39     @Override
  40     public Object getOriginalRequest() {
  41         return request;
  42     }
  43
  44     @Override
  45     public void discard() {
  46         super.discard();
  47         setResult(null);
  48     }
  49
  50     @Override
  51     final public Query getQuery() {
  52
  53         return new Query() {
  54
  55             @Override
  56             public void recompute(ReadGraphImpl graph) {
  57
  58                 try {
  59
  60                     T result = request.perform(graph);
  61                     setResult(result);
  62                     setReady();
  63
  64                 } catch (Throwable t) {
  65
  66                     except(t);
  67
  68                 }
  69
  70             }
  71
  72             @Override
  73             public void removeEntry(QueryProcessor processor) {
  74                 processor.cache.remove(ReadEntry.this);
  75             }
  76
  77             @Override
  78             public int type() {
  79                 if (request instanceof ReadExt) {
  80                     return ((ReadExt) request).getType();
  81                 } else {
  82                     return RequestFlags.INVALIDATE;
  83                 }
  84             }
  85
  86             @Override
  87             public String toString() {
  88                 if (request == null)
  89                     return "DISCARDED";
  90                 else
  91                     return request.toString() + statusOrException;
  92             }
  93
  94         };
  95
  96     }
  97
  98     public static <T> void computeForEach(ReadGraphImpl graph, Read<T> request, ReadEntry<T> entry,
  99             AsyncProcedure<T> procedure_) throws DatabaseException {
 100
 101         AsyncProcedure<T> procedure = entry != null ? entry : procedure_;
 102
 103         ReadGraphImpl queryGraph = entry != null ? graph.withParent(entry) : graph;
 104
 105         try {
 106
 107             T result = request.perform(queryGraph);
 108             procedure.execute(graph, result);
 109
 110         } catch (DatabaseException e) {
 111
 112             procedure.exception(graph, e);
 113
 114         } catch (Throwable t) {
 115
 116             DatabaseException dbe = new DatabaseException(t);
 117             procedure.exception(graph, dbe);
 118
 119         }
 120
 121         if (entry != null)
 122             entry.performFromCache(queryGraph, procedure_);
 123
 124     }
 125
 126     public Object performFromCache(ReadGraphImpl graph, AsyncProcedure<T> procedure) {
 127
 128         AsyncProcedure<T> proc = (AsyncProcedure<T>) procedure;
 129
 130         if (proc != null) {
 131             if (isExcepted()) {
 132                 try {
 133                     proc.exception(graph, (Throwable) getResult());
 134                 } catch (Throwable t) {
 135                     LOGGER.error("performFromCache proc.exception failed", t);
 136                 }
 137             } else {
 138                 try {
 139                     proc.execute(graph, (T) getResult());
 140                 } catch (Throwable t) {
 141                     LOGGER.error("performFromCache proc.execute failed", t);
 142                 }
 143             }
 144         }
 145
 146         return (T) getResult();
 147
 148     }
 149
 150     @Override
 151     public String toString() {
 152         if (request == null)
 153             return "DISCARDED";
 154         else
 155             return request.toString() + " - " + statusOrException;
 156     }
 157
 158     public Object get(ReadGraphImpl graph, AsyncProcedure<T> procedure) throws DatabaseException {
 159         if (procedure != null)
 160             performFromCache(graph, procedure);
 161         checkAndThrow();
 162         return getResult();
 163     }
 164
 165     @Override
 166     boolean isImmutable(ReadGraphImpl graph) throws DatabaseException {
 167         if (request instanceof ReadExt) {
 168             return ((ReadExt) request).isImmutable(graph);
 169         }
 170         return false;
 171     }
 172
 173     @Override
 174     public void execute(AsyncReadGraph graph, T result) {
 175         setResult(result);
 176         setReady();
 177     }
 178
 179     @Override
 180     public void exception(AsyncReadGraph graph, Throwable throwable) {
 181         except(throwable);
 182     }
 183
 184 }