/*
* Copyright 2016-present Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ui.chart;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
/**
* A simple model of time series chart data.
* <p>
* Note that this is not a full MVC type model; the expected usage pattern
* is to create an empty chart, add data points (by consulting the business
* model), and produce the list of data points which contain a label and a set
* of data values for all serials.
*/
public class ChartModel {
private final Set<String> seriesSet;
private final String[] seriesArray;
private final List<Object> labels = Lists.newArrayList();
private final List<DataPoint> dataPoints = Lists.newArrayList();
private final Map<String, Annot> annotations = new HashMap<>();
/**
* Constructs a chart model with initialized series set.
*
* @param series a set of series
*/
public ChartModel(String... series) {
checkNotNull(series, "series cannot be null");
checkArgument(series.length > 0, "must be at least one series");
seriesSet = Sets.newHashSet(series);
if (seriesSet.size() != series.length) {
throw new IllegalArgumentException("duplicate series detected");
}
this.seriesArray = Arrays.copyOf(series, series.length);
}
private void checkDataPoint(DataPoint dataPoint) {
checkArgument(dataPoint.size() == seriesCount(),
"data size should be equal to number of series");
}
/**
* Checks the validity of the given series.
*
* @param series series name
*/
private void checkSeries(String series) {
checkNotNull(series, "must provide a series name");
if (!seriesSet.contains(series)) {
throw new IllegalArgumentException("unknown series: " + series);
}
}
/**
* Returns the number of series in this chart model.
*
* @return number of series
*/
public int seriesCount() {
return seriesSet.size();
}
/**
* Adds a data point to the chart model.
*
* @param label label instance
* @return the data point, for chaining
*/
public DataPoint addDataPoint(Object label) {
DataPoint dp = new DataPoint();
labels.add(label);
dataPoints.add(dp);
return dp;
}
/**
* Returns all of series.
*
* @return an array of series
*/
public String[] getSeries() {
return seriesArray;
}
/**
* Returns all of data points in order.
*
* @return an array of data points
*/
public DataPoint[] getDataPoints() {
return dataPoints.toArray(new DataPoint[dataPoints.size()]);
}
/**
* Returns all of labels in order.
*
* @return an array of labels
*/
public Object[] getLabels() {
return labels.toArray(new Object[labels.size()]);
}
/**
* Returns the number of data points in this chart model.
*
* @return number of data points
*/
public int dataPointCount() {
return dataPoints.size();
}
/**
* Returns the last element inside all of data points.
*
* @return data point
*/
public DataPoint getLastDataPoint() {
return dataPoints.get(dataPoints.size() - 1);
}
/**
* Inserts a new annotation.
*
* @param key key of annotation
* @param value value of annotation
*/
public void addAnnotation(String key, Object value) {
annotations.put(key, new Annot(key, value));
}
/**
* Returns the annotations in this chart.
*
* @return annotations
*/
public Collection<Annot> getAnnotations() {
return new ArrayList<>(annotations.values());
}
/**
* Model of an annotation.
*/
public class Annot {
private final String key;
private final Object value;
/**
* Constructs an annotation with the given key and value.
*
* @param key the key
* @param value the value
*/
public Annot(String key, Object value) {
this.key = key;
this.value = value;
}
/**
* Returns the annotation's key.
*
* @return key
*/
public String key() {
return key;
}
/**
* Returns the annotation's value.
*
* @return value
*/
public Object value() {
return value;
}
/**
* Returns the value as a string.
* This default implementation uses the value's toString() method.
*
* @return the value as a string
*/
public String valueAsString() {
return value.toString();
}
}
/**
* A class of data point.
*/
public class DataPoint {
// values for all series
private final Map<String, Object> data = Maps.newHashMap();
/**
* Sets the data value for the given series of this data point.
*
* @param series series name
* @param value value to set
* @return self, for chaining
*/
public DataPoint data(String series, Object value) {
checkSeries(series);
data.put(series, value);
return this;
}
/**
* Returns the data value with the given series for this data point.
*
* @param series series name
* @return data value
*/
public Object get(String series) {
return data.get(series);
}
/**
* Return the data value with the same order of series.
*
* @return an array of ordered data values
*/
public Object[] getAll() {
Object[] value = new Object[getSeries().length];
int idx = 0;
for (String s : getSeries()) {
value[idx] = get(s);
idx++;
}
return value;
}
/**
* Returns the size of data point.
*
* @return the size of data point
*/
public int size() {
return data.size();
}
/**
* Returns the value of the data point as a string, using the
* formatter appropriate for the series.
*
* @param series series
* @return formatted data point value
*/
public String getAsString(String series) {
return get(series).toString();
}
/**
* Returns the row as an array of formatted strings.
*
* @return the string format of data points
*/
public String[] getAsStrings() {
List<String> formatted = new ArrayList<>(size());
for (String c : seriesArray) {
formatted.add(getAsString(c));
}
return formatted.toArray(new String[formatted.size()]);
}
}
}