refactor: abstract away value store

measure/src/main/java/net/laprun/sustainability/power/measure/DescriptiveStatisticsMeasureStore.java

@@ -0,0 +1,46 @@
+package net.laprun.sustainability.power.measure;
+
+import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics;
+
+class DescriptiveStatisticsMeasureStore implements MeasureStore {
+    private final DescriptiveStatistics[] measures;
+    private final DescriptiveStatistics total;
+
+    public DescriptiveStatisticsMeasureStore(int componentsNumber, int initialWindow) {
+        total = new DescriptiveStatistics(initialWindow);
+        this.measures = new DescriptiveStatistics[componentsNumber];
+        for (int i = 0; i < measures.length; i++) {
+            measures[i] = new DescriptiveStatistics(initialWindow);
+        }
+    }
+
+    @Override
+    public void recordComponentValue(int component, double value) {
+        measures[component].addValue(value);
+    }
+
+    @Override
+    public void recordTotal(double value) {
+        total.addValue(value);
+    }
+
+    @Override
+    public double getMeasuredTotal() {
+        return total.getSum();
+    }
+
+    @Override
+    public double getComponentStandardDeviation(int component) {
+        return measures[component].getStandardDeviation();
+    }
+
+    @Override
+    public double getTotalStandardDeviation() {
+        return total.getStandardDeviation();
+    }
+
+    @Override
+    public double[] getComponentRawValues(int component) {
+        return measures[component].getValues();
+    }
+}

measure/src/main/java/net/laprun/sustainability/power/measure/MeasureStore.java

@@ -0,0 +1,15 @@
+package net.laprun.sustainability.power.measure;
+
+interface MeasureStore {
+    void recordComponentValue(int component, double value);
+
+    void recordTotal(double value);
+
+    double getMeasuredTotal();
+
+    double getComponentStandardDeviation(int component);
+
+    double getTotalStandardDeviation();
+
+    double[] getComponentRawValues(int component);
+}

measure/src/main/java/net/laprun/sustainability/power/measure/OngoingPowerMeasure.java

@@ -4,17 +4,15 @@
 import java.util.HashSet;
 import java.util.Set;
 
-import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics;
-
 import net.laprun.sustainability.power.SensorMetadata;
 
 public class OngoingPowerMeasure implements PowerMeasure {
     private final SensorMetadata sensorMetadata;
-    private final DescriptiveStatistics[] measures;
-    private final DescriptiveStatistics total;
+    private final MeasureStore measures;
     private final long startedAt;
     private final double[] averages;
     private final Set<Integer> nonZeroComponents;
+    private final int[] totalComponents;
     private double minTotal = Double.MAX_VALUE;
     private double maxTotal;
     private int samples;
@@ -26,13 +24,10 @@ public OngoingPowerMeasure(SensorMetadata sensorMetadata, Duration duration, Dur
         averages = new double[numComponents];
 
         final var initialWindow = (int) (duration.toMillis() / frequency.toMillis());
-        total = new DescriptiveStatistics(initialWindow);
-        this.measures = new DescriptiveStatistics[numComponents];
-        for (int i = 0; i < measures.length; i++) {
-            measures[i] = new DescriptiveStatistics(initialWindow);
-        }
+        measures = new DescriptiveStatisticsMeasureStore(numComponents, initialWindow);
 
         nonZeroComponents = new HashSet<>(numComponents);
+        totalComponents = sensorMetadata.totalComponents();
     }
 
     @Override
@@ -54,14 +49,14 @@ public void recordMeasure(double[] components) {
             if (componentValue != 0) {
                 nonZeroComponents.add(component);
             }
-            measures[component].addValue(componentValue);
+            measures.recordComponentValue(component, componentValue);
             averages[component] = averages[component] == 0 ? componentValue
                     : (previousSize * averages[component] + componentValue) / samples;
         }
 
         // record min / max totals
-        final var recordedTotal = PowerMeasure.sumOfSelectedComponents(components, metadata().totalComponents());
-        total.addValue(recordedTotal);
+        final var recordedTotal = PowerMeasure.sumOfSelectedComponents(components, totalComponents);
+        measures.recordTotal(recordedTotal);
         if (recordedTotal < minTotal) {
             minTotal = recordedTotal;
         }
@@ -72,7 +67,7 @@ public void recordMeasure(double[] components) {
 
     @Override
     public double total() {
-        return total.getSum();
+        return measures.getMeasuredTotal();
     }
 
     public Duration duration() {
@@ -99,13 +94,13 @@ public StdDev standardDeviations() {
         final var stdDevs = new double[cardinality];
         nonZeroComponents.stream()
                 .parallel()
-                .forEach(component -> stdDevs[component] = measures[component].getStandardDeviation());
+                .forEach(component -> stdDevs[component] = measures.getComponentStandardDeviation(component));
 
-        return new StdDev(total.getStandardDeviation(), stdDevs);
+        return new StdDev(measures.getTotalStandardDeviation(), stdDevs);
     }
 
     @Override
     public double[] getMeasuresFor(int component) {
-        return measures[component].getValues();
+        return measures.getComponentRawValues(component);
     }
 }

server/src/main/java/net/laprun/sustainability/power/sensors/macos/powermetrics/MacOSPowermetricsSensor.java

@@ -4,7 +4,6 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
-import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;