@Override protected Data<CountValue> assembleData(CountDatasetEntity seriesEntity, DbQuery query, Session session) throws DataAccessException { Data<CountValue> result = new Data<>(); this.getConnector(seriesEntity) .getObservations(seriesEntity, query).stream() .map(entry -> assembleDataValue((CountDataEntity) entry, seriesEntity, query)) .forEach(entry -> result.addNewValue(entry)); return result; }
private QuantityValue[] getValueArray(Data<QuantityValue> timeseries) { return timeseries.getValues() .toArray(new QuantityValue[0]); }
private Data<QuantityValue> generalize(Data<QuantityValue> timeseries) { QuantityValue[] data = timeseries.getValues().toArray(new QuantityValue[0]); int dataLength = data.length; if ((maxOutputValues >= dataLength) || (maxOutputValues == 0)) { // nothing to do return timeseries; } return generalizeData(data, timeseries.getMetadata()); }
private Data<QuantityValue> generalize(Data<QuantityValue> timeseries) throws GeneralizerException { QuantityValue[] originalValues = getValueArray(timeseries); if ((originalValues.length < 3) || (toleranceValue <= 0)) { return timeseries; } if ((maxEntries != -1) && (originalValues.length > maxEntries)) { throw new GeneralizerException( "Maximum number of entries exceeded (" + originalValues.length + ">" + maxEntries + ")!"); } Data<QuantityValue> generalizedTimeseries = new Data<>(timeseries.getMetadata()); QuantityValue[] generalizedValues = recursiveGeneralize(timeseries); generalizedTimeseries.addValues(generalizedValues); // add first element if new list is empty if (generalizedValues.length == 0/* && originalValues.length > 0*/) { generalizedTimeseries.addNewValue(originalValues[0]); } // add the last one if not already contained! if (generalizedValues.length > 0/* && originalValues.length > 0*/) { QuantityValue lastOriginialValue = originalValues[originalValues.length - 1]; QuantityValue lastGeneralizedValue = generalizedValues[generalizedValues.length - 1]; if (!lastGeneralizedValue.getTimestamp().equals(lastOriginialValue.getTimestamp())) { generalizedTimeseries.addNewValue(lastOriginialValue); } } return generalizedTimeseries; }
} else { Data<QuantityValue> generalizedData = new Data<>(); Data<QuantityValue> firstPartToBeGeneralized = new Data<>(); Data<QuantityValue> restPartToBeGeneralized = new Data<>(); firstPartToBeGeneralized.addValues(Arrays.copyOfRange(values, 0, index)); restPartToBeGeneralized.addValues(Arrays.copyOfRange(values, index + 1, values.length)); generalizedData.addValues(recursiveGeneralize(firstPartToBeGeneralized)); generalizedData.addValues(recursiveGeneralize(restPartToBeGeneralized)); return getValueArray(generalizedData);
public Data<V> addData(Data<V> toAdd) { Data<V> data = new Data<>(metadata); data.values.addAll(Stream.concat(values.stream(), toAdd.values.stream()) .collect(Collectors.toList())); return data; }
private void addNodataValue(Data<QuantityValue> sampled, long timestamp) { sampled.addNewValue(new QuantityValue(timestamp, null)); }
@Override public HighchartDataCollection format(DataCollection<Data<QuantityValue>> toFormat) { HighchartDataCollection dataCollection = new HighchartDataCollection(); for (String timeseriesId : toFormat.getAllSeries().keySet()) { Data<QuantityValue> seriesToFormat = toFormat.getSeries(timeseriesId); HighchartData series = createHighchartSeries(timeseriesId, seriesToFormat); dataCollection.addNewSeries(timeseriesId, series); if (seriesToFormat.hasMetadata()) { DatasetMetadata<QuantityValue> metadata = seriesToFormat.getMetadata(); if (metadata.hasReferenceValues()) { Map<String, Data<QuantityValue>> referenceValues = metadata.getReferenceValues(); for (String referenceValueId : referenceValues.keySet()) { Data<QuantityValue> timeseriesData = metadata.getReferenceValues().get(referenceValueId); HighchartData referenceSeries = createHighchartSeries(referenceValueId, timeseriesData); dataCollection.addNewSeries(referenceValueId, referenceSeries); } } series.setValueBeforeTimespan(formatValue(metadata.getValueBeforeTimespan())); series.setValueAfterTimespan(formatValue(metadata.getValueAfterTimespan())); } } return dataCollection; }
configuration.setRenderer(createRenderer(style)); if (timeseriesData.hasReferenceValues()) { int referenceIndex = rendererCount; DatasetMetadata<QuantityValue> metadata = timeseriesData.getMetadata(); Map<String, Data<QuantityValue>> referenceValues = metadata.getReferenceValues(); for (Entry<String, Data<QuantityValue>> referencedTimeseries : referenceValues.entrySet()) {
private FlotData createFlotSeries(Data<QuantityValue> seriesToFormat) { FlotData flotSeries = new FlotData(); flotSeries.setValues(formatSeries(seriesToFormat)); if (seriesToFormat.hasMetadata()) { formatMetadata(seriesToFormat, flotSeries); } return flotSeries; }
private void formatMetadata(Data<QuantityValue> seriesToFormat, FlotData flotSeries) { DatasetMetadata<QuantityValue> metadata = seriesToFormat.getMetadata(); Map<String, Data<QuantityValue>> referenceValues = metadata.getReferenceValues(); for (String referenceValueId : referenceValues.keySet()) { Data<QuantityValue> referenceValueData = metadata.getReferenceValues().get(referenceValueId); flotSeries.addReferenceValues(referenceValueId, formatSeries(referenceValueData)); } flotSeries.setValueBeforeTimespan(formatValue(metadata.getValueBeforeTimespan())); flotSeries.setValueAfterTimespan(formatValue(metadata.getValueAfterTimespan())); }
private Data<QuantityValue> expandReferenceDataIfNecessary(QuantityDatasetEntity seriesEntity, DbQuery query, Session session) throws DataAccessException { Data<QuantityValue> result = new Data<>(); DataDao<QuantityDataEntity> dao = createDataDao(session); List<QuantityDataEntity> observations = dao.getAllInstancesFor(seriesEntity, query); if (!hasValidEntriesWithinRequestedTimespan(observations)) { QuantityValue lastValue = getLastValue(seriesEntity, session, query); result.addValues(expandToInterval(lastValue.getValue(), seriesEntity, query)); } if (hasSingleValidReferenceValue(observations)) { QuantityDataEntity entity = observations.get(0); result.addValues(expandToInterval(entity.getValue(), seriesEntity, query)); } return result; }
private Data<QuantityValue> assembleData(QuantityDatasetEntity seriesEntity, DbQuery query, DatasetMetadata<QuantityValue> metadata, Session session) throws DataAccessException { Data<QuantityValue> result = new Data<>(metadata); return assembleData(result, seriesEntity, query, session); }
private Data<QuantityValue> assembleData(Data<QuantityValue> result, QuantityDatasetEntity seriesEntity, DbQuery query, Session session) throws DataAccessException { DataDao<QuantityDataEntity> dao = createDataDao(session); List<QuantityDataEntity> observations = dao.getAllInstancesFor(seriesEntity, query); for (QuantityDataEntity observation : observations) { if (observation != null) { result.addNewValue(createSeriesValueFor(observation, seriesEntity, query)); } } return result; }
@Override protected Data<ProfileValue<BigDecimal>> assembleData(QuantityProfileDatasetEntity profileDatasetEntity, DbQuery query, Session session) throws DataAccessException { Data<ProfileValue<BigDecimal>> result = new Data<>(); this.getConnector(profileDatasetEntity) .getObservations(profileDatasetEntity, query) .stream() .map(entry -> assembleDataValue((ProfileDataEntity) entry, profileDatasetEntity, query)) .forEach(entry -> result.addNewValue(entry)); return result; }
@Override protected Data<QuantityValue> assembleData(QuantityDatasetEntity seriesEntity, DbQuery query, Session session) throws DataAccessException { Data<QuantityValue> result = new Data<>(); return assembleData(result, seriesEntity, query, session); }
private boolean hasValues(Data<QuantityValue> timeseriesData) { return timeseriesData.getValues() .size() > 0; }
@Override protected Data<TextValue> assembleData(TextDatasetEntity seriesEntity, DbQuery query, Session session) throws DataAccessException { Data<TextValue> result = new Data<>(); this.getConnector(seriesEntity) .getObservations(seriesEntity, query).stream() .map(entry -> assembleDataValue((TextDataEntity) entry, seriesEntity, query)) .forEach(entry -> result.addNewValue(entry)); return result; }
private boolean haveToExpandReferenceData(Data<QuantityValue> referenceSeriesData) { return referenceSeriesData.getValues() .size() <= 1; }
@Override protected Data<QuantityValue> assembleData(QuantityDatasetEntity seriesEntity, DbQuery query, Session session) throws DataAccessException { Data<QuantityValue> result = new Data<>(); this.getConnector(seriesEntity) .getObservations(seriesEntity, query).stream() .map(entry -> assembleDataValue((QuantityDataEntity) entry, seriesEntity, query)) .forEach(entry -> result.addNewValue(entry)); return result; }