com.loadcoder.load.chart.sampling.SampleGroup Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of loadcoder-chart Show documentation
Show all versions of loadcoder-chart Show documentation
This project contains the chart feature of Loadcoder
/*******************************************************************************
* Copyright (C) 2018 Stefan Vahlgren at Loadcoder
*
* This file is part of Loadcoder.
*
* Loadcoder is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Loadcoder is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see samples = new HashMap();
private Map samplesUnupdated = new HashMap();
YCalculator yCalculatorToUse = YCalculator.avg;
public SampleGroup(long sampleLength, XYSeriesExtension series, boolean locked) {
this.locked = locked;
this.sampleLengthBase = sampleLength;
this.series = series;
}
public String toString() {
return String.format("{samples:%s, samplesUnupdated:%s}", samples.size(), samplesUnupdated.size());
}
public Sample getEarliestSample() {
return earliestSample;
}
protected Map getSamples() {
return samples;
}
public Map getSamplesUnupdated() {
return samplesUnupdated;
}
public void remove(Sample s) {
samples.remove(s.getFirstTs());
}
public static class ConcaternationResult{
List concaternated;
Sample newSample;
ConcaternationResult(List concaternated, Sample newSample){
this.concaternated = concaternated;
this.newSample = newSample;
}
public List getConcatenated(){
return concaternated;
}
public void fixPointsForSeries(XYSeriesExtension series){
for(Sample toBeConcaternated : concaternated){
XYDataItemExtension first = toBeConcaternated.getFirst();
if(first != null){
series.remove(first.getX());
}
if(SampleStatics.USE_TWO_SAMPLE_POINTS){
XYDataItemExtension last = toBeConcaternated.getLast();
if(last != null){
series.remove(last.getX());
}
}
}
if (!newSample.isEmpty()) {
newSample.initDataItems();
XYDataItemExtension first = newSample.getFirst();
series.add(first, false, true);
if(SampleStatics.USE_TWO_SAMPLE_POINTS) {
XYDataItemExtension last = newSample.getLast();
series.add(last, false, true);
}
}
}
}
public ConcaternationResult concaternate(SampleConcaternator concater) {
long start = concater.getOldRange().getStart();
Range oldRange = concater.getOldRange();
long oldSampleLength = oldRange.getSampleLength();
int amountToConcaternate = concater.getAmountToConcaternate();
long tsIterator = start;
List newPoints = new ArrayList();
int newAmountOfFails = 0;
long pointsSum =0;
long pointsAmount =0;
List concaternated = new ArrayList();
for (int i = 0; i < amountToConcaternate; i++) {
Sample toBeConcaternated = getExistingSample(tsIterator, oldSampleLength);
if (toBeConcaternated != null) {
concaternated.add(toBeConcaternated);
newAmountOfFails += toBeConcaternated.getAmountOfFails();
remove(toBeConcaternated);
pointsSum = pointsSum + toBeConcaternated.getPointsSum();
pointsAmount = pointsAmount + toBeConcaternated.getAmountOfPoints();
newPoints.addAll(toBeConcaternated.scrapThisSampleAndGetPoints());
}
tsIterator += oldSampleLength;
}
Range newRange = concater.getNewRange();
long newSampleLength = newRange.getSampleLength();
Sample newSample = createSample(start, "", newSampleLength);
newSample.setFails(newAmountOfFails);
newSample.setPoints(newPoints);
newSample.setPointsSum(pointsSum);
newSample.setPointsAmount(pointsAmount);
if (! newSample.isEmpty()) {
newSample.calculateY(yCalculatorToUse);
}
ConcaternationResult concaternationResult = new ConcaternationResult(concaternated, newSample);
return concaternationResult;
}
private Sample createSample(long first, Comparable name) {
return createSample(first, name, sampleLengthBase);
}
private Sample createSample(long first, Comparable name, long sampleLength) {
Sample s = new Sample(first, sampleLength, name, locked);
samples.put(first, s);
long previousFirst = first - sampleLength;
Sample previousSample = samples.get(previousFirst);
if (previousSample != null)
s.setPreviousSample(previousSample);
long nextFirst = first + sampleLength;
Sample nextSample = samples.get(nextFirst);
if (nextSample != null)
nextSample.setPreviousSample(s);
return s;
}
public Sample getAndCreateSample_old(long ts, Comparable name, long sampleLength) {
long first = calculateFirstTs(ts, sampleLength);
Sample s = samples.get(first);
if (s == null) {
s = createSample(first, name);
}
return s;
}
public Sample getAndCreateSample(long ts, Comparable name, long sampleLength) {
long first = calculateFirstTs(ts, sampleLength);
Sample s = samples.get(first);
if (s == null) {
s = createSample(first, name);
}
return s;
}
public Sample getExistingSample(long ts, long sampleLength) {
long first = calculateFirstTs(ts, sampleLength);
Sample s = samples.get(first);
return s;
}
public Sample getExistingAndRemoveSample(long ts, long sampleLength) {
long first = calculateFirstTs(ts, sampleLength);
Sample s = samples.remove(first);
return s;
}
}