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() { List<Class<?>> types = new ArrayList<Class<?>>(); List<Object> values = new ArrayList<Object>(); for (List<ReadFunction<?>> columnFunctions : functions) { List<Object> columnValues = new ArrayList<Object>(); Class<?> columnType = null; // Extract all values and determine column type for (ReadFunction<?> function : columnFunctions) { Object value = function.readValue(); columnType = validateType(value, columnType, names.get(types.size())); columnValues.add(value); } // If no type is found, the column will be empty. // Default to an array of Strings if (columnType == null) columnType = String.class; // Prepare column array Object data = java.lang.reflect.Array.newInstance(columnType, columnValues.size()); for (int i = 0; i < columnValues.size(); i++) { arrayAdders.get(columnType).addValue(data, i, columnValues.get(i)); } // Done with this column types.add(columnType); values.add(arrayAdders.get(columnType).finalizeData(data)); } return ValueFactory.newVTable(types, names, values); }
@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()); }
try { newValue = readFunction.readValue(); if (newValue != null) { NotificationSupport.findNotificationSupportFor(newValue);
for (DesiredRateExpression<?> desiredRateExpression : currentExpressions) { if (desiredRateExpression != null) { Object value = desiredRateExpression.getFunction().readValue(); if (value != null && !(value instanceof VType)) { throw new IllegalArgumentException("Only VTypes allowed in value tables");