bundles/org.simantics.db.impl/src/org/simantics/db/impl/query/ExternalReadEntry.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.LinkedList;
  16
  17 import org.simantics.db.impl.graph.ReadGraphImpl;
  18 import org.simantics.db.procedure.Procedure;
  19 import org.simantics.db.request.ExternalRead;
  20 import org.simantics.db.request.RequestFlags;
  21
  22 final public class ExternalReadEntry<T> extends CacheEntryBase {
  23
  24     final LinkedList<T> items = new LinkedList<T>();
  25
  26     protected ExternalRead<T> request;
  27
  28     @Override
  29     int makeHash() {
  30         return request.hashCode();
  31     }
  32
  33     @Override
  34     public Object getOriginalRequest() {
  35         return request;
  36     }
  37
  38     @Override
  39     public void clearResult(QuerySupport support) {
  40     }
  41
  42     @Override
  43     public void discard() {
  44         request.unregistered();
  45         request = null;
  46         super.discard();
  47     }
  48
  49     public ExternalReadEntry(ExternalRead<T> request) {
  50         assert request != null;
  51         this.request = request;
  52     }
  53
  54     final public void queue(T item) {
  55         synchronized(items) {
  56                 items.addLast(item);
  57                 // TODO: implement flags/logic in ExternalRead to state that all but the latest request result can be evaporated
  58                 // In some cases where data is produced really fast this might be necessary but currently this queueing will do.
  59         }
  60     }
  61
  62     final public void addOrSet(QueryProcessor processor, Object item) {
  63
  64         try {
  65
  66             assert(isPending());
  67
  68             ArrayList<Procedure<T>> p = null;
  69
  70             synchronized(this) {
  71
  72                 setResult(item);
  73                 setReady();
  74 //                p = procs;
  75 //                procs = null;
  76
  77             }
  78
  79 //            if(p != null)
  80 //                for(Procedure proc : p) {
  81 //                    proc.execute((T)item);
  82 //                }
  83
  84         } catch (Throwable t) {
  85             t.printStackTrace();
  86         }
  87
  88     }
  89
  90     @Override
  91     final public Query getQuery() {
  92
  93         return new Query() {
  94
  95                         @Override
  96                         public void recompute(ReadGraphImpl graph, Object provider, CacheEntry entry) {
  97
  98                             final QueryProcessor qp = (QueryProcessor)provider;
  99                             synchronized(items) {
 100
 101                                 if(entry.isExcepted()) {
 102
 103                                         // Exception persists
 104
 105                                 } else {
 106
 107                                         // Update
 108                                         if(!items.isEmpty()) {
 109                                                 setResult(items.removeFirst());
 110                                         }
 111                                         // Reschedule
 112                                             if(!items.isEmpty()) {
 113                                                 qp.updatePrimitive(request);
 114                                             }
 115
 116                                             setReady();
 117
 118                                 }
 119
 120                             }
 121
 122                         }
 123
 124                         @Override
 125                         public void removeEntry(QueryProcessor processor) {
 126                                 processor.cache.externalReadMap.remove(request);
 127                         }
 128
 129                         @Override
 130                         public int type() {
 131                                 return RequestFlags.IMMEDIATE_UPDATE;
 132                         }
 133
 134                         @Override
 135                         public String toString() {
 136                                 if(request == null) return "DISCARDED ExternalRead";
 137                                 else return request.toString();
 138                         }
 139
 140         };
 141
 142     }
 143
 144         public Object performFromCache(Object procedure) {
 145
 146         Procedure<T> proc = (Procedure<T>)procedure;
 147
 148             if(isExcepted()) {
 149
 150             proc.exception((Throwable)getResult());
 151
 152         } else {
 153
 154             proc.execute((T)getResult());
 155
 156         }
 157
 158             return getResult();
 159
 160         }
 161
 162         @Override
 163         public String toString() {
 164                 if(request == null) return "DISCARDED ExternalRead " + System.identityHashCode(this);
 165                 else return request.toString() + " " + + System.identityHashCode(this);
 166         }
 167
 168     @Override
 169     public Object performFromCache(ReadGraphImpl graph, Object provider, Object procedure) {
 170         return performFromCache(procedure);
 171     }
 172
 173     @Override
 174     public void setReady() {
 175         super.setReady();
 176     }
 177
 178     @Override
 179     void prepareRecompute(QuerySupport querySupport) {
 180         // Do nothing - the state is already set and cannot be recomputed on demand
 181     }
 182
 183 }