// // // Data points // public void saveDataPoint(DataPointVO point) { stopDataPoint(point.getId()); // Since the point's data type may have changed, we must ensure that the other attrtibutes are // still ok with // it. int dataType = point.getPointLocator().getDataTypeId(); // Chart renderer if (point.getChartRenderer() != null && !point.getChartRenderer().getDef().supports(dataType)) // Return to a default renderer point.setChartRenderer(null); // Text renderer if (point.getTextRenderer() != null && !point.getTextRenderer().getDef().supports(dataType)) // Return to a default renderer point.defaultTextRenderer(); // Event detectors Iterator<PointEventDetectorVO> peds = point.getEventDetectors().iterator(); while (peds.hasNext()) { PointEventDetectorVO ped = peds.next(); if (!ped.getDef().supports(dataType)) // Remove the detector. peds.remove(); } new DataPointDao().saveDataPoint(point); if (point.isEnabled()) startDataPoint(point); }
private void startDataPoint(DataPointVO vo) { synchronized (dataPoints) { Assert.isTrue(vo.isEnabled()); // Only add the data point if its data source is enabled. DataSourceRT ds = getRunningDataSource(vo.getDataSourceId()); if (ds != null) { // Change the VO into a data point implementation. DataPointRT dataPoint = new DataPointRT(vo, vo.getPointLocator().createRuntime()); // Add/update it in the data image. dataPoints.put(dataPoint.getId(), dataPoint); // Initialize it. dataPoint.initialize(); DataPointListener l = getDataPointListeners(vo.getId()); if (l != null) l.pointInitialized(); // Add/update it in the data source. ds.addDataPoint(dataPoint); } } }
@Override public int getDataTypeId() { return vo.getPointLocator().getDataTypeId(); }
private void savePointValue( PointValueTime newValue, SetPointSource source, boolean async, boolean saveToDatabase) { // Null values are not very nice, and since they don't have a specific meaning they are hereby // ignored. if (newValue == null) return; // Check the data type of the value against that of the locator, just for fun. int valueDataType = DataTypes.getDataType(newValue.getValue()); if (valueDataType != DataTypes.UNKNOWN && valueDataType != vo.getPointLocator().getDataTypeId()) // This should never happen, but if it does it can have serious downstream consequences. Also, // we need // to know how it happened, and the stack trace here provides the best information. throw new ShouldNeverHappenException( "Data type mismatch between new value and point locator: newValue=" + DataTypes.getDataType(newValue.getValue()) + ", locator=" + vo.getPointLocator().getDataTypeId()); // Check if this value qualifies for discardation. if (vo.isDiscardExtremeValues() && DataTypes.getDataType(newValue.getValue()) == DataTypes.NUMERIC) { double newd = newValue.getDoubleValue(); if (newd < vo.getDiscardLowLimit() || newd > vo.getDiscardHighLimit()) // Discard the value return; } if (newValue.getTime() > System.currentTimeMillis() + SystemSettingsDao.getFutureDateLimit()) { // Too far future dated. Toss it. But log a message first. LOG.warn( "Future dated value detected: pointId=" + vo.getId() + ", value=" + newValue.getStringValue() + ", type=" + vo.getPointLocator().getDataTypeId() + ", ts=" + newValue.getTime(), new Exception()); return; } boolean backdated = pointValue != null && newValue.getTime() < pointValue.getTime(); // Determine whether the new value qualifies for logging. boolean logValue; // ... or even saving in the cache. boolean saveValue = true; switch (vo.getLoggingType()) { case DataPointVO.LoggingTypes.ON_CHANGE: if (pointValue == null) logValue = true; else if (backdated) // Backdated. Ignore it logValue = false; else { if (newValue.getValue() instanceof NumericValue) { // Get the new double double newd = newValue.getDoubleValue(); // See if the new value is outside of the tolerance. double diff = toleranceOrigin - newd; if (diff < 0) diff = -diff; if (diff > vo.getTolerance()) { toleranceOrigin = newd; logValue = true; } else logValue = false; } else logValue = !ObjectUtils.equals(newValue.getValue(), pointValue.getValue()); } saveValue = logValue; break; case DataPointVO.LoggingTypes.ALL: logValue = true; break; case DataPointVO.LoggingTypes.ON_TS_CHANGE: if (pointValue == null) logValue = true; else if (backdated) // Backdated. Ignore it logValue = false; else logValue = newValue.getTime() != pointValue.getTime(); saveValue = logValue; break; case DataPointVO.LoggingTypes.INTERVAL: if (!backdated) intervalSave(newValue); default: logValue = false; } if (!saveToDatabase) logValue = false; if (saveValue) valueCache.savePointValue(newValue, source, logValue, async); // add annotation to newValue before firing events so event detectors can // fetch the annotation if (source != null) { newValue = new AnnotatedPointValueTime( newValue.getValue(), newValue.getTime(), source.getSetPointSourceMessage()); } // Ignore historical values. if (pointValue == null || newValue.getTime() >= pointValue.getTime()) { PointValueTime oldValue = pointValue; pointValue = newValue; fireEvents(oldValue, newValue, source != null, false); } else fireEvents(null, newValue, false, true); }