feat: File processing.

src/main/java/eu/ztsh/lfr/model/Averages.java

@@ -0,0 +1,13 @@
+package eu.ztsh.lfr.model;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Averages extends HashMap<String, List<Average>> {
+
+    public Averages(Map<String, List<Average>> m) {
+        super(m);
+    }
+
+}

src/main/java/eu/ztsh/lfr/model/DataRow.java

@@ -0,0 +1,5 @@
+package eu.ztsh.lfr.model;
+
+public record DataRow(String city, int year, double temperature) {
+
+}

src/main/java/eu/ztsh/lfr/model/FileProcessingException.java

@@ -0,0 +1,9 @@
+package eu.ztsh.lfr.model;
+
+public class FileProcessingException extends RuntimeException {
+
+    public FileProcessingException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+}

src/main/java/eu/ztsh/lfr/model/Temperatures.java

@@ -0,0 +1,33 @@
+package eu.ztsh.lfr.model;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.stream.Collectors;
+
+public class Temperatures extends ConcurrentHashMap<String, ConcurrentMap<Integer, YearDataAccumulator>> {
+
+    public void addData(DataRow dataRow) {
+        putIfAbsent(dataRow.city(), new ConcurrentHashMap<>());
+        var city = get(dataRow.city());
+        city.putIfAbsent(dataRow.year(), new YearDataAccumulator());
+        city.get(dataRow.year()).add(dataRow.temperature());
+    }
+
+    public Averages getAverages() {
+        var computed = entrySet().stream()
+            .map(entry -> {
+                var newEntry = entry.getValue().entrySet().stream()
+                    .map(yearEntry -> {
+                        var average = new Average();
+                        average.setYear(yearEntry.getKey().toString());
+                        average.setAverageTemperature(yearEntry.getValue().getAverage());
+                        return average;
+                    })
+                    .toList();
+                return Map.entry(entry.getKey(), newEntry);
+            }).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+        return new Averages(computed);
+    }
+
+}

src/main/java/eu/ztsh/lfr/model/YearDataAccumulator.java

@@ -0,0 +1,25 @@
+package eu.ztsh.lfr.model;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.DoubleAdder;
+
+public class YearDataAccumulator {
+
+    private final DoubleAdder sum = new DoubleAdder();
+    private final AtomicInteger counter = new AtomicInteger();
+
+    public void add(double value) {
+        synchronized (this) {
+            sum.add(value);
+            counter.incrementAndGet();
+        }
+    }
+
+    public BigDecimal getAverage() {
+        return BigDecimal.valueOf(sum.sum()).setScale(2, RoundingMode.HALF_UP)
+            .divide(BigDecimal.valueOf(counter.get()), RoundingMode.HALF_UP);
+    }
+
+}

src/main/java/eu/ztsh/lfr/model/events/FileProcessedEvent.java

@@ -0,0 +1,7 @@
+package eu.ztsh.lfr.model.events;
+
+import eu.ztsh.lfr.model.Averages;
+
+public record FileProcessedEvent(Averages averages) {
+
+}