feat: register processors per component, add processor output

analysis/src/main/java/net/laprun/sustainability/power/analysis/MeanComponentProcessor.java

@@ -10,4 +10,18 @@ public void recordComponentValue(double value, long timestamp) {
         count++;
         mean = mean == 0 ? value : (previousSize * mean + value) / count;
     }
+
+    public double mean() {
+        return mean;
+    }
+
+    @Override
+    public String name() {
+        return "mean";
+    }
+
+    @Override
+    public String output() {
+        return "" + mean;
+    }
 }

analysis/src/test/java/ComputeTest.java

@@ -1,23 +1,22 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
-import java.util.List;
 import java.util.Random;
 import java.util.random.RandomGenerator;
 
 import org.junit.jupiter.api.Test;
 
 import net.laprun.sustainability.power.SensorMetadata;
 import net.laprun.sustainability.power.analysis.Compute;
+import net.laprun.sustainability.power.analysis.MeanComponentProcessor;
 import net.laprun.sustainability.power.measure.OngoingPowerMeasure;
+import net.laprun.sustainability.power.measure.PowerMeasure;
 
 public class ComputeTest {
-    private final static SensorMetadata metadata = new SensorMetadata(List.of(), null) {
-
-        @Override
-        public int componentCardinality() {
-            return 3;
-        }
-    };
+    private final static SensorMetadata metadata = SensorMetadata
+            .withNewComponent("cp1", null, true, null, false)
+            .withNewComponent("cp2", null, true, null, false)
+            .withNewComponent("cp3", null, true, null, false)
+            .build();
 
     @Test
     void standardDeviationShouldWork() {
@@ -79,6 +78,9 @@ void averageShouldWork() {
         final var m3c3 = 0.0;
 
         final var measure = new OngoingPowerMeasure(metadata);
+        measure.registerProcessorFor(0, new MeanComponentProcessor());
+        measure.registerProcessorFor(1, new MeanComponentProcessor());
+        measure.registerProcessorFor(2, new MeanComponentProcessor());
 
         final var components = new double[metadata.componentCardinality()];
         components[0] = m1c1;
@@ -102,9 +104,18 @@ void averageShouldWork() {
 
         assertEquals((m1c1 + m2c1 + m3c1) / 3, c1Avg, 0.0001,
                 "Average did not match the expected value");
+        final var processors = measure.processors();
+        assertEquals(c1Avg,
+                processors.processorFor(0, MeanComponentProcessor.class).map(MeanComponentProcessor::mean).orElseThrow());
         assertEquals((m1c2 + m2c2 + m3c2) / 3, c2Avg, 0.0001,
                 "Average did not match the expected value");
+        assertEquals(c2Avg,
+                processors.processorFor(1, MeanComponentProcessor.class).map(MeanComponentProcessor::mean).orElseThrow());
         assertEquals(0, c3Avg, 0.0001,
                 "Average did not match the expected value");
+        assertEquals(0,
+                processors.processorFor(2, MeanComponentProcessor.class).map(MeanComponentProcessor::mean).orElseThrow());
+
+        System.out.println(PowerMeasure.asString(measure));
     }
 }

if-manifest-export/src/main/java/net/laprun/sustainability/power/impactframework/export/IFExporter.java

@@ -2,10 +2,10 @@
 
 import java.time.Instant;
 import java.util.ArrayList;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.TreeMap;
 
 import net.laprun.sustainability.impactframework.manifest.Child;
 import net.laprun.sustainability.impactframework.manifest.Initialize;
@@ -14,7 +14,6 @@
 import net.laprun.sustainability.impactframework.manifest.Metadata;
 import net.laprun.sustainability.impactframework.manifest.Plugin;
 import net.laprun.sustainability.impactframework.manifest.Tree;
-import net.laprun.sustainability.power.SensorMetadata;
 import net.laprun.sustainability.power.measure.PowerMeasure;
 import net.laprun.sustainability.power.measure.StoppedPowerMeasure;
 
@@ -32,11 +31,13 @@ public static Manifest export(StoppedPowerMeasure measure) {
         final List<Input> inputs = new ArrayList<>(samples);
         final var sensorMetadata = measure.metadata();
         final int samplingFrequency = (int) measure.duration().dividedBy(samples).toMillis();
-
         final var components = sensorMetadata.components();
+        final String[] inputNames = new String[components.size()];
+        components.values().forEach(component -> inputNames[component.index()] = getInputValueName(component.name()));
+
         for (int i = 0; i < samples; i++) {
             final var values = measure.getNthTimestampedMeasures(i);
-            inputs.add(toInput(samplingFrequency, values, components));
+            inputs.add(toInput(samplingFrequency, values, inputNames));
         }
 
         return new Manifest(ifMetadata, defaultInitialize,
@@ -48,10 +49,12 @@ public static String getInputValueName(String componentName) {
     }
 
     private static Input toInput(int samplingFrequency, PowerMeasure.TimestampedMeasures values,
-            Map<String, SensorMetadata.ComponentMetadata> components) {
-        final var inputValues = new TreeMap<String, Object>();
-        components.values().forEach(
-                component -> inputValues.put(getInputValueName(component.name()), values.measures()[component.index()]));
+            String[] inputNames) {
+        final var inputValues = new LinkedHashMap<String, Object>(inputNames.length);
+        final var measures = values.measures();
+        for (int i = 0; i < inputNames.length; i++) {
+            inputValues.put(inputNames[i], measures[i]);
+        }
         return new Input(Instant.ofEpochMilli(values.timestamp()), samplingFrequency, inputValues);
     }
 }

measure/pom.xml

@@ -21,8 +21,6 @@
     <dependency>
       <groupId>org.assertj</groupId>
       <artifactId>assertj-core</artifactId>
-      <version>3.26.3</version>
-      <scope>test</scope>
     </dependency>
   </dependencies>
 

measure/src/main/java/net/laprun/sustainability/power/analysis/ComponentProcessor.java

@@ -3,4 +3,12 @@
 public interface ComponentProcessor {
     default void recordComponentValue(double value, long timestamp) {
     }
+
+    default String name() {
+        return this.getClass().getSimpleName();
+    }
+
+    default String output() {
+        return "";
+    }
 }

measure/src/main/java/net/laprun/sustainability/power/analysis/DefaultProcessors.java

@@ -0,0 +1,89 @@
+package net.laprun.sustainability.power.analysis;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+
+import net.laprun.sustainability.power.SensorMetadata;
+
+public class DefaultProcessors implements Processors {
+    private final List<ComponentProcessor>[] processors;
+    private ComponentProcessor totalProcessor;
+
+    @SuppressWarnings("unchecked")
+    public DefaultProcessors(int componentCardinality) {
+        this.processors = new List[componentCardinality];
+    }
+
+    @Override
+    public void recordMeasure(double[] components, long timestamp) {
+        for (var index = 0; index < components.length; index++) {
+            final var fIndex = index;
+            final var componentProcessors = processors[index];
+            if (componentProcessors != null) {
+                componentProcessors.forEach(proc -> proc.recordComponentValue(components[fIndex], timestamp));
+            }
+        }
+    }
+
+    @Override
+    public void registerProcessorFor(int componentIndex, ComponentProcessor processor) {
+        if (processor != null) {
+            var processorsForComponent = processors[componentIndex];
+            if (processorsForComponent == null) {
+                processorsForComponent = new ArrayList<>();
+                processors[componentIndex] = processorsForComponent;
+            }
+            processorsForComponent.add(processor);
+        }
+    }
+
+    @Override
+    public void registerTotalProcessor(ComponentProcessor processor) {
+        this.totalProcessor = processor;
+    }
+
+    @Override
+    public void recordTotal(double total, long timestamp) {
+        if (totalProcessor != null) {
+            totalProcessor.recordComponentValue(total, timestamp);
+        }
+    }
+
+    @Override
+    public Optional<ComponentProcessor> totalProcessor() {
+        return Optional.ofNullable(totalProcessor);
+    }
+
+    @Override
+    public List<ComponentProcessor> processorsFor(int componentIndex) {
+        final var componentProcessors = processors[componentIndex];
+        return Objects.requireNonNullElseGet(componentProcessors, List::of);
+    }
+
+    @Override
+    public <T extends ComponentProcessor> Optional<T> processorFor(int componentIndex, Class<T> expectedType) {
+        final var componentProcessors = processors[componentIndex];
+        if (componentProcessors != null) {
+            return componentProcessors.stream().filter(expectedType::isInstance).map(expectedType::cast).findFirst();
+        } else {
+            return Optional.empty();
+        }
+    }
+
+    @Override
+    public String output(SensorMetadata metadata) {
+        StringBuilder builder = new StringBuilder();
+        builder.append("# Processors\n");
+        for (int i = 0; i < processors.length; i++) {
+            final var name = metadata.metadataFor(i).name();
+            builder.append("  - ").append(name).append(" component:\n");
+            for (var processor : processorsFor(i)) {
+                builder.append("    * ").append(processor.name())
+                        .append(": ").append(processor.output()).append("\n");
+            }
+        }
+        return builder.toString();
+    }
+}

measure/src/main/java/net/laprun/sustainability/power/analysis/Processors.java

@@ -0,0 +1,39 @@
+package net.laprun.sustainability.power.analysis;
+
+import java.util.List;
+import java.util.Optional;
+
+import net.laprun.sustainability.power.SensorMetadata;
+
+public interface Processors {
+    Processors empty = new Processors() {
+    };
+
+    default void recordMeasure(double[] components, long timestamp) {
+    }
+
+    default void recordTotal(double total, long timestamp) {
+    }
+
+    default void registerProcessorFor(int componentIndex, ComponentProcessor processor) {
+    }
+
+    default void registerTotalProcessor(ComponentProcessor processor) {
+    }
+
+    default Optional<ComponentProcessor> totalProcessor() {
+        return Optional.empty();
+    }
+
+    default List<ComponentProcessor> processorsFor(int componentIndex) {
+        return List.of();
+    }
+
+    default <T extends ComponentProcessor> Optional<T> processorFor(int componentIndex, Class<T> expectedType) {
+        return Optional.empty();
+    }
+
+    default String output(SensorMetadata metadata) {
+        return "";
+    }
+}