X-Git-Url: https://gerrit.simantics.org/r/gitweb?p=simantics%2Fplatform.git;a=blobdiff_plain;f=bundles%2Forg.simantics.db.impl%2Fsrc%2Forg%2Fsimantics%2Fdb%2Fimpl%2Fquery%2FExternalReadEntry.java;h=2980b9b15f72e9a54b00a96fe06a397ef60b59b6;hp=a411fa7730be1c5ed874719c00093d2c331971c9;hb=HEAD;hpb=969bd23cab98a79ca9101af33334000879fb60c5 diff --git a/bundles/org.simantics.db.impl/src/org/simantics/db/impl/query/ExternalReadEntry.java b/bundles/org.simantics.db.impl/src/org/simantics/db/impl/query/ExternalReadEntry.java index a411fa773..2980b9b15 100644 --- a/bundles/org.simantics.db.impl/src/org/simantics/db/impl/query/ExternalReadEntry.java +++ b/bundles/org.simantics.db.impl/src/org/simantics/db/impl/query/ExternalReadEntry.java @@ -1,183 +1,240 @@ -/******************************************************************************* - * Copyright (c) 2007, 2010 Association for Decentralized Information Management - * in Industry THTH ry. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the Eclipse Public License v1.0 - * which accompanies this distribution, and is available at - * http://www.eclipse.org/legal/epl-v10.html - * - * Contributors: - * VTT Technical Research Centre of Finland - initial API and implementation - *******************************************************************************/ -package org.simantics.db.impl.query; - -import java.util.ArrayList; -import java.util.LinkedList; - -import org.simantics.db.impl.graph.ReadGraphImpl; -import org.simantics.db.procedure.Procedure; -import org.simantics.db.request.ExternalRead; -import org.simantics.db.request.RequestFlags; - -final public class ExternalReadEntry extends CacheEntryBase { - - final LinkedList items = new LinkedList(); - -// public ArrayList> procs; - - protected ExternalRead request; - - @Override - int makeHash() { - return request.hashCode(); - } - - @Override - public Object getOriginalRequest() { - return request; - } - - @Override - public void clearResult(QuerySupport support) { - } - - @Override - public void discard() { - request.unregistered(); - request = null; - super.discard(); - } - - public ExternalReadEntry(ExternalRead request) { - assert request != null; - this.request = request; - } - - final public void queue(T item) { - synchronized(items) { - items.addLast(item); - // TODO: implement flags/logic in ExternalRead to state that all but the latest request result can be evaporated - // In some cases where data is produced really fast this might be necessary but currently this queueing will do. - } - } - - final public void addOrSet(QueryProcessor processor, Object item) { - - try { - - assert(isPending()); - - ArrayList> p = null; - - synchronized(this) { - - setResult(item); - setReady(); -// p = procs; -// procs = null; - - } - -// if(p != null) -// for(Procedure proc : p) { -// proc.execute((T)item); -// } - - } catch (Throwable t) { - t.printStackTrace(); - } - - } - - @Override - final public Query getQuery() { - - return new Query() { - - @Override - public void recompute(ReadGraphImpl graph, Object provider, CacheEntry entry) { - - final QueryProcessor qp = (QueryProcessor)provider; - synchronized(items) { - - if(entry.isExcepted()) { - - // Exception persists - - } else { - - // Update - if(!items.isEmpty()) { - setResult(items.removeFirst()); - } - // Reschedule - if(!items.isEmpty()) { - qp.updatePrimitive(request); - } - - setReady(); - - } - - } - - } - - @Override - public void removeEntry(QueryProcessor processor) { - processor.externalReadMap.remove(request); - } - - @Override - public int type() { - return RequestFlags.IMMEDIATE_UPDATE; - } - - @Override - public String toString() { - if(request == null) return "DISCARDED ExternalRead"; - else return request.toString(); - } - - }; - - } - - public void performFromCache(Object procedure) { - - Procedure proc = (Procedure)procedure; - - if(isExcepted()) { - - proc.exception((Throwable)getResult()); - - } else { - - proc.execute((T)getResult()); - - } - - } - - @Override - public String toString() { - if(request == null) return "DISCARDED ExternalRead " + System.identityHashCode(this); - else return request.toString() + " " + + System.identityHashCode(this); - } - - @Override - public void performFromCache(ReadGraphImpl graph, Object provider, Object procedure) { - performFromCache(procedure); - } - - @Override - public void setReady() { - super.setReady(); - } - - @Override - void prepareRecompute(QuerySupport querySupport) { - // Do nothing - the state is already set and cannot be recomputed on demand - } - -} +/******************************************************************************* + * Copyright (c) 2007, 2018 Association for Decentralized Information Management + * in Industry THTH ry. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * VTT Technical Research Centre of Finland - initial API and implementation + *******************************************************************************/ +package org.simantics.db.impl.query; + +import java.util.LinkedList; + +import org.simantics.databoard.Bindings; +import org.simantics.db.DevelopmentKeys; +import org.simantics.db.exception.DatabaseException; +import org.simantics.db.impl.graph.ReadGraphImpl; +import org.simantics.db.procedure.AsyncProcedure; +import org.simantics.db.procedure.Listener; +import org.simantics.db.request.ExternalRead; +import org.simantics.db.request.RequestFlags; +import org.simantics.utils.Development; + +final public class ExternalReadEntry extends CacheEntryBase> implements Listener { + + final LinkedList items = new LinkedList(); + + protected ExternalRead id; + protected QueryProcessor processor; + protected boolean registered = false; + + @Override + int makeHash() { + return id.hashCode(); + } + + @Override + public Object getOriginalRequest() { + return id; + } + + @Override + public void clearResult(QuerySupport support) { + } + + @Override + public void discard() { + id.unregistered(); + id = null; + processor = null; + super.discard(); + } + + @Override + public void setPending(QuerySupport querySupport) { + //if(result != NO_RESULT) { + //new Exception("result = " + result).printStackTrace(); + //} + statusOrException = PENDING; + result = REQUIRES_COMPUTATION; + } + + public ExternalReadEntry(ExternalRead request, ReadGraphImpl graph) { + assert request != null; + this.id = request; + this.processor = graph.processor; + } + + @Override + public void except(Throwable t) { + + if (Development.DEVELOPMENT) { + if(Development.getProperty(DevelopmentKeys.CACHE_ENTRY_STATE, Bindings.BOOLEAN)) { + System.err.println("[QUERY STATE]: excepted " + this); + } + } + + if(statusOrException != DISCARDED) { + statusOrException = EXCEPTED; + result = t; + } else { + result = t; + } + + assert(isExcepted()); + + } + + @Override + public void setResult(Object result) { + + super.setResult(result); + assert(!(result instanceof Throwable)); + assert(!isExcepted()); + + } + + @Override + public void setReady() { + super.setReady(); + } + + @Override + final public Query getQuery() { + + return new Query() { + + @Override + public void recompute(ReadGraphImpl graph) { + + synchronized(items) { + + // Update + if(!items.isEmpty()) { + setReady(); + setResult(items.removeFirst()); + } + // Reschedule + if(!items.isEmpty()) { + graph.processor.updatePrimitive(id); + } + + } + + } + + @Override + public void removeEntry(QueryProcessor processor) { + processor.cache.remove(ExternalReadEntry.this); + } + + @Override + public int type() { + return RequestFlags.IMMEDIATE_UPDATE; + } + + @Override + public String toString() { + if(id == null) return "DISCARDED ExternalRead"; + else return id.toString(); + } + + }; + + } + + @Override + public String toString() { + if(id == null) return "DISCARDED ExternalRead " + System.identityHashCode(this); + else return id.toString() + " " + + System.identityHashCode(this); + } + + @Override + public Object performFromCache(ReadGraphImpl graph, AsyncProcedure procedure) { + + AsyncProcedure proc = (AsyncProcedure)procedure; + + if(isExcepted()) { + + proc.exception(graph, (Throwable)getResult()); + + } else { + + proc.execute(graph, (T)getResult()); + + } + + return getResult(); + + } + + @Override + void prepareRecompute(QuerySupport querySupport) { + // Do nothing - the state is already set and cannot be recomputed on demand + } + + public Object compute(ReadGraphImpl graph, AsyncProcedure procedure) throws DatabaseException { + + try { + + ReadGraphImpl queryGraph = graph.withParent(this, null, true); + + if(!registered) { + id.register(graph, this); + registered = true; + } + + queryGraph.asyncBarrier.waitBarrier(id, graph); + + } catch (Throwable t) { + + except(t); + + } + + performFromCache(graph, procedure); + + return getResult(); + + } + + @Override + public void execute(T result) { + + if(this.result == REQUIRES_COMPUTATION) { + + setResult(result); + setReady(); + + } else { + + synchronized(items) { + items.addLast(result); + processor.updatePrimitive(id); + // TODO: implement flags/logic in ExternalRead to state that all but the latest request result can be evaporated + // In some cases where data is produced really fast this might be necessary but currently this queueing will do. + } + + } + + } + + @Override + public void exception(Throwable t) { + except(t); + } + + @Override + public boolean isDisposed() { + return registered && (isDiscarded() || !processor.isBound(this)); + } + + @Override + public String classId() { + return null; + } + +}