cont-variable score fork

cqf-fhir-cr/src/main/java/org/opencds/cqf/fhir/cr/measure/common/CompositeEvaluationResultsPerMeasure.java

@@ -5,7 +5,6 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import org.hl7.fhir.instance.model.api.IIdType;
 import org.opencds.cqf.cql.engine.execution.EvaluationResult;
 
 /**
@@ -21,40 +20,35 @@
  */
 public class CompositeEvaluationResultsPerMeasure {
     // The same measure may have successful results AND errors, so account for both
-    private final Map<IIdType, Map<String, EvaluationResult>> resultsPerMeasure;
+    private final Map<MeasureDef, Map<String, EvaluationResult>> resultsPerMeasure;
     // We may get several errors for a given measure
-    private final Map<IIdType, List<String>> errorsPerMeasure;
+    private final Map<MeasureDef, List<String>> errorsPerMeasure;
 
     private CompositeEvaluationResultsPerMeasure(Builder builder) {
 
-        var resultsBuilder = ImmutableMap.<IIdType, Map<String, EvaluationResult>>builder();
+        var resultsBuilder = ImmutableMap.<MeasureDef, Map<String, EvaluationResult>>builder();
         builder.resultsPerMeasure.forEach((key, value) -> resultsBuilder.put(key, ImmutableMap.copyOf(value)));
         resultsPerMeasure = resultsBuilder.build();
 
-        var errorsBuilder = ImmutableMap.<IIdType, List<String>>builder();
+        var errorsBuilder = ImmutableMap.<MeasureDef, List<String>>builder();
         builder.errorsPerMeasure.forEach((key, value) -> errorsBuilder.put(key, List.copyOf(value)));
         errorsPerMeasure = errorsBuilder.build();
     }
 
     /**
      * Retrieves results and populates errors for a given measure.
      * This method uses direct map lookups for efficient data retrieval.
-     * measureDef will occasionally be prepended with the version, which means we need to parse it into an IIdType which
-     * is too much work, so pass in the measureId directly
      *
-     * @param measureId the ID of the measure to process
      * @param measureDef the MeasureDef to populate with errors
      *
      * @return a map of evaluation results per subject, or an empty map if none exist
      */
-    public Map<String, EvaluationResult> processMeasureForSuccessOrFailure(IIdType measureId, MeasureDef measureDef) {
-        var unqualifiedMeasureId = measureId.toUnqualifiedVersionless();
-
-        errorsPerMeasure.getOrDefault(unqualifiedMeasureId, List.of()).forEach(measureDef::addError);
+    public Map<String, EvaluationResult> processMeasureForSuccessOrFailure(MeasureDef measureDef) {
+        errorsPerMeasure.getOrDefault(measureDef, List.of()).forEach(measureDef::addError);
 
         // We are explicitly maintaining the logic of accepting the lack of any sort of results,
         // either errors or successes, and returning an empty map.
-        return resultsPerMeasure.getOrDefault(unqualifiedMeasureId, Map.of());
+        return resultsPerMeasure.getOrDefault(measureDef, Map.of());
     }
 
     /**
@@ -63,7 +57,7 @@ public Map<String, EvaluationResult> processMeasureForSuccessOrFailure(IIdType m
      * and associated EvaluationResult produced from CQL expression evaluation
      * @return {@code Map<IIdType, Map<String, EvaluationResult>>}
      */
-    public Map<IIdType, Map<String, EvaluationResult>> getResultsPerMeasure() {
+    public Map<MeasureDef, Map<String, EvaluationResult>> getResultsPerMeasure() {
         return this.resultsPerMeasure;
     }
 
@@ -72,7 +66,7 @@ public Map<IIdType, Map<String, EvaluationResult>> getResultsPerMeasure() {
      * When an error is produced while evaluating, we capture the errors generated in this object, which can be rendered per Measure evaluated.
      * @return {@code Map<IIdType, List<String>>}
      */
-    public Map<IIdType, List<String>> getErrorsPerMeasure() {
+    public Map<MeasureDef, List<String>> getErrorsPerMeasure() {
         return this.errorsPerMeasure;
     }
 
@@ -81,49 +75,59 @@ public static Builder builder() {
     }
 
     public static class Builder {
-        private final Map<IIdType, Map<String, EvaluationResult>> resultsPerMeasure = new HashMap<>();
-        private final Map<IIdType, List<String>> errorsPerMeasure = new HashMap<>();
+        private final Map<MeasureDef, Map<String, EvaluationResult>> resultsPerMeasure = new HashMap<>();
+        private final Map<MeasureDef, List<String>> errorsPerMeasure = new HashMap<>();
 
         public CompositeEvaluationResultsPerMeasure build() {
             return new CompositeEvaluationResultsPerMeasure(this);
         }
 
-        public void addResults(List<IIdType> measureIds, String subjectId, EvaluationResult evaluationResult) {
-            for (IIdType measureId : measureIds) {
-                addResult(measureId, subjectId, evaluationResult);
+        public void addResults(
+                List<MeasureDef> measureDefs,
+                String subjectId,
+                EvaluationResult evaluationResult,
+                List<MeasureObservationResult> measureObservationResults) {
+            for (MeasureDef measureDef : measureDefs) {
+                addResult(measureDef, subjectId, evaluationResult, measureObservationResults);
             }
         }
 
-        public void addResult(IIdType measureId, String subjectId, EvaluationResult evaluationResult) {
+        public void addResult(
+                MeasureDef measureDef,
+                String subjectId,
+                EvaluationResult evaluationResult,
+                List<MeasureObservationResult> measureObservationResults) {
+
             // if we have no results, we don't need to add anything
             if (evaluationResult == null || evaluationResult.expressionResults.isEmpty()) {
                 return;
             }
 
-            var resultPerMeasure =
-                    resultsPerMeasure.computeIfAbsent(measureId.toUnqualifiedVersionless(), k -> new HashMap<>());
+            // Mutate the evaluationResults to include continuous variable evaluation results
+            measureObservationResults.forEach(measureObservationResult -> evaluationResult.expressionResults.put(
+                    measureObservationResult.expressionName(), measureObservationResult.expressionResult()));
+
+            var resultPerMeasure = resultsPerMeasure.computeIfAbsent(measureDef, k -> new HashMap<>());
 
             resultPerMeasure.put(subjectId, evaluationResult);
         }
 
-        public void addErrors(List<? extends IIdType> measureIds, String error) {
+        public void addErrors(List<MeasureDef> measureDefs, String error) {
             if (error == null || error.isEmpty()) {
                 return;
             }
 
-            for (IIdType measureId : measureIds) {
-                addError(measureId, error);
+            for (MeasureDef measureDef : measureDefs) {
+                addError(measureDef, error);
             }
         }
 
-        public void addError(IIdType measureId, String error) {
+        public void addError(MeasureDef measureDef, String error) {
             if (error == null || error.isBlank()) {
                 return;
             }
 
-            errorsPerMeasure
-                    .computeIfAbsent(measureId.toUnqualifiedVersionless(), k -> new ArrayList<>())
-                    .add(error);
+            errorsPerMeasure.computeIfAbsent(measureDef, k -> new ArrayList<>()).add(error);
         }
     }
 }

cqf-fhir-cr/src/main/java/org/opencds/cqf/fhir/cr/measure/common/ContinuousVariableObservationAggregateMethod.java

@@ -0,0 +1,39 @@
+package org.opencds.cqf.fhir.cr.measure.common;
+
+import jakarta.annotation.Nullable;
+
+/**
+ * All continuous variable scoring aggregation methods.
+ */
+public enum ContinuousVariableObservationAggregateMethod {
+    AVG("avg"),
+    COUNT("count"),
+    MAX("max"),
+    MEDIAN("median"),
+    MIN("min"),
+    SUM("sum"),
+    N_A(null);
+
+    @Nullable
+    private final String text;
+
+    ContinuousVariableObservationAggregateMethod(@Nullable String text) {
+        this.text = text;
+    }
+
+    @Nullable
+    public String getText() {
+        return text;
+    }
+
+    @Nullable
+    public static ContinuousVariableObservationAggregateMethod fromString(@Nullable String text) {
+        for (ContinuousVariableObservationAggregateMethod value : values()) {
+            if (text.equals(value.getText())) {
+                return value;
+            }
+        }
+
+        return null;
+    }
+}