Migrate SDE accumulation logic from DSTU3/R4 to SdeDef (#982)

* First round of changes to migrate SDE accumulation logic from R4 builder specific logic to SdeDef.   Get Dstu3 to use StratumValueWrapper instead of rolling its own.

* Get rid of SdeAccumulator and its tests, and roll the tests into a new MeasureEvaluationResultHandlerTest.

* Make the SdeDef accumulation code more self-contained and readable.   Get rid of lazily instantiated collections in the class state.  Get rid of isAccumulated().

* Error handling if a SDE expression was not found.

---------

Co-authored-by: c-schuler <hoofschu@gmail.com>
Co-authored-by: JP <jonathan.percival@smilecdr.com>

Author: 3 people

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

@@ -1,8 +1,12 @@
 package org.opencds.cqf.fhir.cr.measure.common;
 
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashSet;
+import java.util.List;
+import java.util.Objects;
 import java.util.Set;
+import java.util.stream.StreamSupport;
 
 public class CriteriaResult {
     private final Object value;
@@ -46,6 +50,22 @@ public Set<Object> evaluatedResources() {
         return this.evaluatedResources;
     }
 
+    /**
+     * Returns the value(s) as a list with nulls filtered out.
+     * Handles single values, iterables, and null values uniformly.
+     */
+    public List<Object> nonNullValues() {
+        if (this.value == null) {
+            return Collections.emptyList();
+        }
+        if (this.value instanceof Iterable<?> iterable) {
+            return StreamSupport.stream(iterable.spliterator(), false)
+                    .filter(Objects::nonNull)
+                    .collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
+        }
+        return List.of(this.value);
+    }
+
     private Set<Object> buildSet(Iterable<Object> iterable) {
         return new HashSetForFhirResourcesAndCqlTypes<>(iterable);
     }

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

@@ -0,0 +1,11 @@
+package org.opencds.cqf.fhir.cr.measure.common;
+
+/**
+ * Capture a post CQL evaluation error in which an expression result was not found when expected.
+ */
+public class ExpressionResultNotFoundException extends RuntimeException {
+    public ExpressionResultNotFoundException(String expressionType, String expressionName) {
+        super("Expression result for type: '%s' and expression name: '%s' not found"
+                .formatted(expressionType, expressionName));
+    }
+}

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

@@ -664,6 +664,9 @@ protected Object evaluateDateOfCompliance(PopulationDef populationDef, Evaluatio
     protected void evaluateSdes(String subjectId, List<SdeDef> sdes, EvaluationResult evaluationResult) {
         for (SdeDef sde : sdes) {
             var expressionResult = evaluationResult.get(sde.expression());
+            if (expressionResult == null) {
+                throw new ExpressionResultNotFoundException("SDE", sde.expression());
+            }
             Object result = expressionResult.getValue();
             // TODO: This is a hack-around for an cql engine bug. Need to investigate.
             if ((result instanceof List<?> list) && (list.size() == 1) && list.get(0) == null) {

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

@@ -119,6 +119,11 @@ public static void postEvaluationMultiSubject(FhirContext fhirContext, MeasureDe
                 stratifierDef.addAllStratum(stratumDefs);
             }
         }
+
+        // Accumulate SDE results across subjects (version-agnostic)
+        for (SdeDef sde : measureDef.sdes()) {
+            sde.accumulate();
+        }
     }
 
     private static List<StratumDef> buildCriteriaStrata(

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

@@ -1,16 +1,23 @@
 package org.opencds.cqf.fhir.cr.measure.common;
 
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
 
 public class SdeDef {
 
     private final String id;
     private final ConceptDef code;
     private final String expression;
     private final String description;
-    private Map<String, CriteriaResult> results;
+    private final Map<String, CriteriaResult> results = new HashMap<>();
+
+    // Pre-accumulated state (populated by MeasureMultiSubjectEvaluator)
+    private final Map<StratumValueWrapper, Long> accumulatedValues = new HashMap<>();
+    private final Set<Object> allEvaluatedResources = new HashSet<>();
 
     public SdeDef(String id, ConceptDef code, String expression) {
         this(id, code, expression, null);
@@ -40,14 +47,32 @@ public String description() {
     }
 
     public void putResult(String subject, Object value, Set<Object> evaluatedResources) {
-        this.getResults().put(subject, new CriteriaResult(value, evaluatedResources));
+        this.results.put(subject, new CriteriaResult(value, evaluatedResources));
+    }
+
+    public Map<StratumValueWrapper, Long> getAccumulatedValues() {
+        return this.accumulatedValues;
+    }
+
+    public Set<Object> getAllEvaluatedResources() {
+        return this.allEvaluatedResources;
     }
 
-    public Map<String, CriteriaResult> getResults() {
-        if (this.results == null) {
-            this.results = new HashMap<>();
+    /**
+     * Aggregates per-subject SDE results into value counts and a merged set of evaluated resources.
+     * Called by {@link MeasureMultiSubjectEvaluator#postEvaluationMultiSubject} for population reports.
+     */
+    public void accumulate() {
+        // Merge all evaluated resources across subjects
+        for (CriteriaResult result : results.values()) {
+            allEvaluatedResources.addAll(result.evaluatedResources());
         }
 
-        return this.results;
+        // Count occurrences of each distinct value across all subjects
+        Map<StratumValueWrapper, Long> counts = results.values().stream()
+                .flatMap(result -> result.nonNullValues().stream())
+                .map(StratumValueWrapper::new)
+                .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
+        accumulatedValues.putAll(counts);
     }
 }