bundles/org.simantics.db.layer0/src/org/simantics/db/layer0/variable/NodeValueRequest.java

   1 package org.simantics.db.layer0.variable;
   2
   3 import org.simantics.databoard.binding.Binding;
   4 import org.simantics.databoard.binding.error.BindingException;
   5 import org.simantics.databoard.binding.mutable.Variant;
   6 import org.simantics.databoard.util.ObjectUtils;
   7 import org.simantics.db.ReadGraph;
   8 import org.simantics.db.common.request.ParametrizedPrimitiveRead;
   9 import org.simantics.db.common.utils.Logger;
  10 import org.simantics.db.exception.DatabaseException;
  11 import org.simantics.db.procedure.Listener;
  12 import org.simantics.simulator.variable.exceptions.NodeIsNotValidAnymoreException;
  13 import org.simantics.simulator.variable.exceptions.NodeManagerException;
  14 import org.simantics.utils.datastructures.Pair;
  15
  16 @SuppressWarnings("rawtypes")
  17 class NodeValueRequest extends ParametrizedPrimitiveRead<Pair<VariableNode,Binding>, Variant> implements VariableNodeReadRunnable {
  18
  19     private Listener<Variant> listener = null;
  20     private Variant value = Variables.PENDING_NODE_VALUE;
  21     private boolean wasRun = false;
  22
  23     static class Probe implements Runnable {
  24
  25         private Pair<VariableNode,Binding> parameter;
  26                 public Variant result;
  27
  28         public Probe(Pair<VariableNode,Binding> parameter) {
  29                 this.parameter = parameter;
  30         }
  31
  32                 @SuppressWarnings("unchecked")
  33                 @Override
  34                 public void run() {
  35                         try {
  36                                 result = NodeValueRequest.get(parameter);
  37                                 parameter.first.support.valueCache.put(parameter.first.node, result, 1000000000L);
  38                         } catch (NodeManagerException e) {
  39                                 e.printStackTrace();
  40                         } catch (BindingException e) {
  41                                 e.printStackTrace();
  42                         }
  43                 }
  44
  45     }
  46
  47     public NodeValueRequest(VariableNode node) {
  48         super(Pair.<VariableNode, Binding>make(node, null));
  49     }
  50
  51     public NodeValueRequest(VariableNode node, Binding binding) {
  52         super(Pair.<VariableNode, Binding>make(node, binding));
  53     }
  54
  55     @SuppressWarnings("unchecked")
  56     @Override
  57     public void register(ReadGraph graph, final Listener<Variant> procedure) {
  58
  59         VariableNode node = parameter.first;
  60
  61         if(procedure.isDisposed()) {
  62
  63                 // We are not listening
  64                 Variant result = (Variant)node.support.valueCache.get(node.node);
  65
  66                 if(result != null) {
  67                         // Return cached value immediately
  68                         procedure.execute(result);
  69                 } else {
  70
  71 //
  72 //            listener = procedure;
  73 //
  74 //            if(graph.getSynchronous()) {
  75 //                try {
  76 //                    parameter.support.manager.getRealm().syncExec(this);
  77 //                } catch (InterruptedException e) {
  78 //                    if (!wasRun) procedure.exception(e);
  79 //                } catch (Throwable e) {
  80 //                    if (!wasRun) procedure.exception(e);
  81 //                }
  82 //            } else {
  83 //                parameter.support.manager.getRealm().asyncExec(this);
  84 //
  85 //                if(value == Variables.PENDING_NODE_VALUE) {
  86 //                    procedure.execute(Variables.PENDING_NODE_VALUE);
  87 //                }
  88 //            }
  89 //            return;
  90
  91                         NodeValueRequest.Probe probe = new Probe(parameter);
  92                         node.support.manager.getRealm().asyncExec(probe);
  93                         if(probe.result != null) {
  94                                 procedure.execute(probe.result);
  95                         } else {
  96                                 procedure.execute(Variables.PENDING_NODE_VALUE);
  97                         }
  98
  99                 }
 100
 101                 return;
 102         }
 103
 104         // We need to listen
 105         listener = procedure;
 106                 // Register listening
 107                 node.support.manager.addNodeListener(node.node, this);
 108                 synchronized(this) {
 109                         if(wasRun) {
 110                                 procedure.execute(value);
 111                         } else {
 112                                 Variant result = (Variant)node.support.valueCache.get(node.node);
 113                                 if(result != null) {
 114                                         procedure.execute(result);
 115                                 } else {
 116                         procedure.execute(Variables.PENDING_NODE_VALUE);
 117                                 }
 118                         }
 119                 }
 120
 121 //        if(listener != null) {
 122 //            throw new UnsupportedOperationException();
 123 //        }
 124 //        listener = procedure;
 125 //        if(graph.getSynchronous()) {
 126 //            try {
 127 //                parameter.support.manager.getRealm().syncExec(new VariableNodeReadRunnable() {
 128 //                    @Override
 129 //                    public void run() {
 130 //                        parameter.support.manager.addNodeListener(parameter.node, NodeValueRequest.this);
 131 //                    }
 132 //                    @Override
 133 //                    public String toString() {
 134 //                        return "NodeValueRequest.register.sync.addNodeListener @ " + System.identityHashCode(NodeValueRequest.this);
 135 //                    }
 136 //                });
 137 //
 138 //                if (!wasRun) procedure.exception(new InternalException("No invocation of listener from node manager " + parameter.support.manager.getClass().getName()));
 139 //            } catch (InterruptedException e) {
 140 //                if (!wasRun) procedure.exception(e);
 141 //            } catch (Throwable e) {
 142 //                if (!wasRun) procedure.exception(e);
 143 //            }
 144 //        } else {
 145 //            parameter.support.manager.addNodeListener(parameter.node, this);
 146 //            if(value == Variables.PENDING_NODE_VALUE) procedure.execute(Variables.PENDING_NODE_VALUE);
 147 //        }
 148
 149     }
 150
 151     static class NodeListener implements VariableNodeReadRunnable {
 152
 153         private VariableNode node;
 154         private NodeValueRequest request;
 155
 156         public NodeListener(VariableNode node, NodeValueRequest request) {
 157                 this.node = node;
 158                 this.request = request;
 159         }
 160
 161         @SuppressWarnings("unchecked")
 162         @Override
 163         public void run() {
 164             node.support.manager.addNodeListener(node.node, request);
 165         }
 166
 167     }
 168
 169
 170     @SuppressWarnings("unchecked")
 171     @Override
 172     public void unregistered() {
 173         VariableNode node = parameter.first;
 174         node.support.manager.removeNodeListener(node.node, this);
 175         node.support.valueCache.removeListening(node.node);
 176         listener = null;
 177     }
 178
 179     @SuppressWarnings("unchecked")
 180     public static Variant get(Pair<VariableNode,Binding> parameter) throws NodeManagerException, BindingException {
 181
 182         VariableNode node = parameter.first;
 183         Binding binding = parameter.second;
 184
 185         if (binding != null) {
 186                 Object raw = node.support.manager.getValue(node.node, binding);
 187                 if(raw == null) return null;
 188                 else return new Variant(binding, raw);
 189         } else {
 190                 return node.support.manager.getValue(node.node);
 191         }
 192
 193     }
 194
 195     @SuppressWarnings("unchecked")
 196     @Override
 197     public synchronized void run() {
 198
 199         VariableNode node = parameter.first;
 200
 201         try {
 202                 Variant newValue = get(parameter);
 203             if (wasRun && ObjectUtils.objectEquals(value, newValue)) {
 204                 //System.out.println("CACHE VALUE MATCH (" + newValue + ") for " + node.node);
 205                 return;
 206             }
 207             value = newValue;
 208             node.support.valueCache.put(node.node, value);
 209         } catch (Throwable e) {
 210             // Must catch everything to prevent DB client from getting stuck.
 211             if(!(e instanceof NodeIsNotValidAnymoreException))
 212                 Logger.defaultLogError(e);
 213             // Invoke the exception method of the listener
 214             Listener<Variant> listener = this.listener;
 215             if (listener != null) listener.exception(new DatabaseException("External data access error", e));
 216             wasRun = true;
 217             return;
 218         }
 219         // Must always invoke an existing listener, regardless of earlier errors.
 220         Listener<Variant> listener = this.listener;
 221         if (listener != null) {
 222             //System.out.println("LISTENER " + listener + " invoked with value " + value);
 223             listener.execute(value);
 224         }
 225         wasRun = true;
 226     }
 227
 228     @Override
 229     public String toString() {
 230         return "NodeValueRequest.run " + parameter.first.node + " " + parameter.first.support.manager + " " + System.identityHashCode(this);
 231     }
 232
 233 }