public void readNext() { if (function != null) { T oldValue = value; value = function.readValue(); changed = !Objects.equals(oldValue, value); } else { changed = false; } }
@Override @SuppressWarnings("unchecked") public List readValue() { List list = new ArrayList(); for (ReadFunction function : functions) { list.add(function.readValue()); } return list; }
@Override public List<String> readValue() { VStringArray value = function.readValue(); if (value == null) { return null; } else { return value.getData(); } }
@Override public String readValue() { VString value = function.readValue(); if (value == null) { return null; } else { return value.getValue(); } }
@Override public R readValue() { return function.calculate(arg.readValue()); } }, name);
static <T extends Time> Instant electReferenceTimeStamp(List<ReadFunction<List<T>>> collectors) { for (ReadFunction<List<T>> collector : collectors) { List<T> data = collector.readValue(); if (data.size() > 1) { Instant time = data.get(data.size() - 2).getTimestamp(); if (time != null) return time; } } return null; }
@Override public List<T> readValue() { List<T> list = arg.readValue(); List<T> newList = new ArrayList<T>(); for (T element : list) { if (!filter.innerFilter(previousValue, element)) { newList.add(element); previousValue = element; } } return newList; } }, name);
@Override public final R readValue() { List<A> data = collector.readValue(); if (data.size() > 0) { lastCalculatedValue = calculate(data); lastValue = data.get(data.size() - 1); } else if (lastValue != null) { lastCalculatedValue = calculate(Collections.singletonList(lastValue)); lastValue = null; } return lastCalculatedValue; }
@Override public T readValue() { Object obj = arg1.getFunction().readValue(); if (obj == null) { return null; } if (clazz.isInstance(obj)) { return clazz.cast(obj); } else { throw new RuntimeException(argName + " must be a " + clazz.getSimpleName() + " (was " + ValueUtil.typeOf(obj).getSimpleName() + ")"); } } }, arg1.getName());
@Override public void writeValue(T newValue) { synchronized(forwardFunction) { valueCache.writeValue(newValue); R forwardValue = forwardFunction.readValue(); forwardWriter.writeValue(forwardValue); } }
@Override public T readValue() { Object obj = arg.readValue(); if (obj == null) { return null; } if (clazz != null) { if (clazz.isInstance(obj)) { return clazz.cast(obj); } else { throw new RuntimeException(argName + " must be a " + clazz.getSimpleName() + " (was " + ValueUtil.typeOf(obj).getSimpleName() + ")"); } } else { for (Class<? extends T> aClass : classes) { if (aClass.isInstance(obj)) { return aClass.cast(obj); } } StringBuilder sb = new StringBuilder(); List<String> names = new ArrayList<>(); for (Class<? extends T> aClass : classes) { names.add(aClass.getSimpleName()); } throw new RuntimeException(argName + " must be one of " + names.toString() + " (was " + ValueUtil.typeOf(obj).getSimpleName() + ")"); } } }
@Override public void writeValue(String newValue) { argument.writeValue(format.parseObject(newValue, reference.readValue())); }
@Override public Map<String, T> readValue() { for (MapUpdate<T> mapUpdate : mapUpdateCollector.readValue()) { for (String name : mapUpdate.getExpressionsToDelete()) { functions.remove(name); } functions.putAll(mapUpdate.getReadFunctionsToAdd()); previousValue = null; } Map<String, T> map = new HashMap<String, T>(); for (Map.Entry<String, ReadFunction<T>> entry : functions.entrySet()) { String name = entry.getKey(); T value = entry.getValue().readValue(); if (value != null) { map.put(name, value); } } if (Objects.equals(previousValue, map)) { return previousValue; } previousValue = map; return map; }
@Override public VTable readValue() { VNumberArray xValues = xVDoubleArray.getFunction().readValue(); VNumberArray yValues = yVDoubleArray.getFunction().readValue(); if (xValues == null || yValues == null) { return null; } return ValueFactory.newVTable(Arrays.<Class<?>>asList(double.class, double.class), Arrays.asList("X", "Y"), Arrays.<Object>asList(new ListDoubleView(xValues.getData()), new ListDoubleView(yValues.getData()))); } }, "data");
@Override public VTable readValue() { VNumberArray values = yArray.getFunction().readValue(); VNumber offset = xInitialOffset.getFunction().readValue(); VNumber increment = xIncrementSize.getFunction().readValue(); if (values == null || offset == null || increment == null) { return null; } return ValueFactory.newVTable(Arrays.<Class<?>>asList(double.class, double.class), Arrays.asList("X", "Y"), Arrays.<Object>asList(ListNumbers.linearList(offset.getValue().doubleValue(), increment.getValue().doubleValue(), values.getData().size()), new ListDoubleView(values.getData()))); } }, "data");
@Override public VMultiDouble readValue() { Instant reference = electReferenceTimeStamp(collectors); if (reference == null) return null; TimeInterval allowedInterval = TimeInterval.around(tolerance, reference); List<VDouble> values = new ArrayList<VDouble>(collectors.size()); StringBuilder buffer = new StringBuilder(); for (ReadFunction<List<VDouble>> collector : collectors) { List<VDouble> data = collector.readValue(); if (log.isLoggable(Level.FINE)) { buffer.append(data.size()).append(", "); } VDouble value = closestElement(data, allowedInterval, reference); values.add(value); } if (log.isLoggable(Level.FINE)) { log.fine(buffer.toString()); } return ValueFactory.newVMultiDouble(values, ValueFactory.alarmNone(), ValueFactory.newTime(reference), ValueFactory.displayNone()); }
@Override public VString readValue() { VType value = argument.readValue(); if (forward != null) { forward.writeValue(value); } if (value == null) { return null; } String string = format.format(value); Alarm alarm = ValueUtil.alarmOf(value); if (alarm == null) { alarm = ValueFactory.alarmNone(); } Time time = ValueUtil.timeOf(value); if (time == null) { time = ValueFactory.timeNow(); } return ValueFactory.newVString(string, alarm, time); }
@Override public Graph2DResult readValue() { VNumberArray data = arrayData.readValue(); // Data must be available if (data == null) { return null; } // TODO: check array is one dimensional Cell1DDataset dataset = null; dataset = DatasetConversions.cell1DDatasetsFromVNumberArray(data); // Process all renderer updates for (AreaGraph2DRendererUpdate rendererUpdate : getUpdateQueue().readValue()) { renderer.update(rendererUpdate); } // If no size is set, don't calculate anything if (renderer.getImageHeight() == 0 && renderer.getImageWidth() == 0) return null; BufferedImage image = new BufferedImage(renderer.getImageWidth(), renderer.getImageHeight(), BufferedImage.TYPE_3BYTE_BGR); renderer.draw(image.createGraphics(), dataset); int index = -1; if (renderer.getFocusValueIndex() != null) { index = renderer.getFocusValueIndex(); } return new Graph2DResult(data, ValueUtil.toVImage(image), new GraphDataRange(renderer.getXPlotRange(), dataset.getXRange(), dataset.getXRange()), new GraphDataRange(renderer.getYPlotRange(), dataset.getStatistics().getRange(), renderer.getYAggregatedRange()), index); }
@Override public Graph2DResult readValue() { VNumberArray data = arrayData.readValue(); // Data must be available if (data == null) { return null; } List<IntensityGraph2DRendererUpdate> updates = getUpdateQueue().readValue(); // If data is old and no updates, return the previous result if (data == oldData && updates.isEmpty()) { return previousResult; } oldData = data; // TODO: check array is one dimensional Cell2DDataset dataset = DatasetConversions.cell2DDatasetsFromVNumberArray(data); // Process all renderer updates for (IntensityGraph2DRendererUpdate rendererUpdate : updates) { renderer.update(rendererUpdate); } // If no size is set, don't calculate anything if (renderer.getImageHeight() == 0 && renderer.getImageWidth() == 0) return null; GraphBuffer buffer = new GraphBuffer(renderer); renderer.draw(buffer, dataset); return new Graph2DResult(data, ValueUtil.toVImage(buffer.getImage()), new GraphDataRange(renderer.getXPlotRange(), dataset.getXRange(), dataset.getXRange()), new GraphDataRange(renderer.getYPlotRange(), dataset.getYRange(), dataset.getYRange()), -1, selectionData(data, renderer)); }