Implement Component Criteria Stratifiers

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

@@ -1,20 +1,10 @@
 package org.opencds.cqf.fhir.cr.measure.common;
 
+import jakarta.annotation.Nonnull;
 import java.util.List;
+import java.util.StringJoiner;
 
-public class ConceptDef {
-
-    private final List<CodeDef> codes;
-    private final String text;
-
-    public ConceptDef(List<CodeDef> codes, String text) {
-        this.codes = codes;
-        this.text = text;
-    }
-
-    public List<CodeDef> codes() {
-        return this.codes;
-    }
+public record ConceptDef(List<CodeDef> codes, String text) {
 
     public boolean isEmpty() {
         return this.codes.isEmpty();
@@ -28,7 +18,12 @@ public CodeDef first() {
         return this.codes.get(0);
     }
 
-    public String text() {
-        return this.text;
+    @Override
+    @Nonnull
+    public String toString() {
+        return new StringJoiner(", ", ConceptDef.class.getSimpleName() + "[", "]")
+                .add("codes=" + codes)
+                .add("text='" + text + "'")
+                .toString();
     }
 }

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

@@ -69,7 +69,7 @@ public static void processResults(
             }
         }
 
-        evaluator.postEvaluation(measureDef);
+        MeasureMultiSubjectEvaluator.postEvaluationMultiSubject(measureDef);
     }
 
     /**
@@ -126,6 +126,7 @@ public static <T extends ICompositeType> CompositeEvaluationResultsPerMeasure ge
                             libraryVersionedIdentifier, evaluationResultsForMultiLib);
                     var evaluationResult = evaluationResultsForMultiLib.getResultFor(libraryVersionedIdentifier);
 
+                    // LUKETODO:  add functionality for warnings versus errors from CQL results and some clear tests
                     var measureDefs =
                             multiLibraryIdMeasureEngineDetails.getMeasureDefsForLibrary(libraryVersionedIdentifier);
 

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

@@ -7,6 +7,7 @@
 import java.util.Objects;
 import java.util.Set;
 import java.util.stream.Collectors;
+import org.opencds.cqf.fhir.cr.measure.r4.utils.R4ResourceIdUtils;
 
 public class PopulationDef {
 
@@ -62,6 +63,12 @@ public Set<String> getSubjects() {
         return this.getSubjectResources().keySet();
     }
 
+    public Set<String> getSubjectsWithPatientQualifier() {
+        return getSubjects().stream()
+                .map(R4ResourceIdUtils::addPatientQualifier)
+                .collect(Collectors.toUnmodifiableSet());
+    }
+
     public void retainAllResources(Set<Object> resourcesToRetain) {
         getSubjectResources().forEach((key, value) -> value.retainAll(resourcesToRetain));
     }

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

@@ -3,6 +3,7 @@
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
+import java.util.StringJoiner;
 
 public class StratifierComponentDef {
     private final String id;
@@ -40,4 +41,14 @@ public Map<String, CriteriaResult> getResults() {
 
         return this.results;
     }
+
+    @Override
+    public String toString() {
+        return new StringJoiner(", ", StratifierComponentDef.class.getSimpleName() + "[", "]")
+                .add("id='" + id + "'")
+                .add("code=" + code)
+                .add("expression='" + expression + "'")
+                .add("results=" + results)
+                .toString();
+    }
 }

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

@@ -43,4 +43,6 @@ public Set<StratumValueDef> getValueDefs() {
     public List<String> getSubjectIds() {
         return subjectIds;
     }
+
+    // LUKETODO: toString
 }

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

@@ -1,5 +1,7 @@
 package org.opencds.cqf.fhir.cr.measure.common;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Objects;
 import java.util.Set;
 import java.util.stream.Collectors;
@@ -14,6 +16,10 @@ public class StratumPopulationDef {
 
     private final String id;
     private final Set<String> subjectsQualifiedOrUnqualified;
+    // Temporary:  this needs to be captured as number of intersected resources
+    private int count = 0;
+    // Temporary:  figure out what to do with this
+    private List<String> resourceIds = new ArrayList<>();
 
     public StratumPopulationDef(String id, Set<String> subjectsQualifiedOrUnqualified) {
         this.id = id;
@@ -24,16 +30,40 @@ public String getId() {
         return id;
     }
 
-    // LUKETODO:  javadoc
+    /**
+     * @return The subjectIds as they are, whether they are qualified with a resource
+     * (ex: [Patient/pat1, Patient/pat2] or [pat1, pat2]
+     */
     public Set<String> getSubjectsQualifiedOrUnqualified() {
         return subjectsQualifiedOrUnqualified;
     }
 
-    // LUKETODO:  javadoc
+    /**
+     * @return The subjectIds without a FHIR resource qualifier, whether they previously had a
+     * qualifier or not
+     */
     public Set<String> getSubjectsUnqualified() {
         return subjectsQualifiedOrUnqualified.stream()
                 .filter(Objects::nonNull)
                 .map(R4ResourceIdUtils::stripAnyResourceQualifier)
                 .collect(Collectors.toUnmodifiableSet());
     }
+
+    public int getCount() {
+        return count;
+    }
+
+    public void setCount(int count) {
+        this.count = count;
+    }
+
+    public List<String> getResourceIds() {
+        return resourceIds;
+    }
+
+    public void addAllResourceIds(List<String> resourceIds) {
+        this.resourceIds.addAll(resourceIds);
+    }
+
+    // LUKETODO: toString
 }

cqf-fhir-cr/src/main/java/org/opencds/cqf/fhir/cr/measure/r4/R4MeasureReportScorer.java

@@ -84,6 +84,9 @@
  * <p> (v3.18.0 and below) Previous calculation of measure score from MeasureReport only interpreted Numerator, Denominator membership since exclusions and exceptions were already applied. Now exclusions and exceptions are present in Denominator and Numerator populations, the measure scorer calculation has to take into account additional population membership to determine Final-Numerator and Final-Denominator values</p>
  */
 @SuppressWarnings("squid:S1135")
+// LUKETODO:  we does this have to be an R4 class at all?   why can't we base this entirely off defs?
+// LUKETODO:  as a migration path, why can't we push up logic gradually to the BaseMeasureReportScorer, moving away from
+// FHIR-version specific logic
 public class R4MeasureReportScorer extends BaseMeasureReportScorer<MeasureReport> {
 
     private static final Logger logger = LoggerFactory.getLogger(R4MeasureReportScorer.class);
@@ -176,6 +179,9 @@ protected void scoreGroup(
 
         switch (measureScoring) {
             case PROPORTION, RATIO:
+                // LUKETODO:  here, we're taking the counts from the R4 populations, but why do we have to store them
+                // there?
+                // why can't we put the counts in the population defs?
                 var score = calcProportionScore(
                         getCountFromGroupPopulation(mrgc.getPopulation(), NUMERATOR)
                                 - getCountFromGroupPopulation(mrgc.getPopulation(), NUMERATOR_EXCLUSION),

cqf-fhir-cr/src/main/java/org/opencds/cqf/fhir/cr/measure/r4/R4PopulationBasisValidator.java

@@ -17,6 +17,7 @@
 import org.opencds.cqf.cql.engine.execution.EvaluationResult;
 import org.opencds.cqf.cql.engine.runtime.Code;
 import org.opencds.cqf.fhir.cr.measure.MeasureStratifierType;
+import org.opencds.cqf.fhir.cr.measure.common.CodeDef;
 import org.opencds.cqf.fhir.cr.measure.common.GroupDef;
 import org.opencds.cqf.fhir.cr.measure.common.MeasureDef;
 import org.opencds.cqf.fhir.cr.measure.common.PopulationBasisValidator;
@@ -127,16 +128,22 @@ private void validateExpressionResultType(
         }
 
         var resultClasses = StratifierUtils.extractClassesFromSingleOrListResult(expressionResult.value());
-        var groupPopulationBasisCode = groupDef.getPopulationBasis().code();
+        var groupPopulationBasis = groupDef.getPopulationBasis();
 
         if (MeasureStratifierType.CRITERIA == stratifierDef.getStratifierType()) {
+            // LUKETODO:  refine this error handling because we may get an empty expression result, as opposed to a
+            // non-empty wrong expression result
             if (resultClasses.stream()
-                    .map(Class::getSimpleName)
-                    .noneMatch(simpleName -> simpleName.equals(groupPopulationBasisCode))) {
+                    .noneMatch(
+                            resourceClass -> doesResourceMatchPopulationBasis(resourceClass, groupPopulationBasis))) {
 
                 throw new InvalidRequestException(
                         "criteria-based stratifier is invalid for expression: [%s] due to mismatch between population basis: [%s] and result types: %s for measure URL: %s"
-                                .formatted(expression, groupPopulationBasisCode, prettyClassNames(resultClasses), url));
+                                .formatted(
+                                        expression, groupPopulationBasis.code(), prettyClassNames(resultClasses), url));
+
+                // LUKETODO:  add validation for component criteria stratifiers, which needs the initial population
+                // resources as well
             }
 
             // skip validation below since for criteria-based stratifier, the boolean basis test is irrelevant
@@ -153,13 +160,18 @@ private void validateExpressionResultType(
                     "stratifier expression criteria results for expression: [%s] must fall within accepted types for population-basis: [%s] for Measure: [%s] due to mismatch between total result classes: %s and matching result classes: %s"
                             .formatted(
                                     expression,
-                                    groupPopulationBasisCode,
+                                    groupPopulationBasis.code(),
                                     url,
                                     prettyClassNames(resultClasses),
                                     prettyClassNames(resultMatchingClasses)));
         }
     }
 
+    // LUKETODO:  refine this to deal with all kinds of different basis types
+    private boolean doesResourceMatchPopulationBasis(Class<?> resourceClass, CodeDef groupPopulationBasisCode) {
+        return resourceClass.getSimpleName().equalsIgnoreCase(groupPopulationBasisCode.code());
+    }
+
     private Optional<Class<?>> extractResourceType(String groupPopulationBasisCode) {
         if (BOOLEAN_BASIS.equals(groupPopulationBasisCode)) {
             return Optional.of(Boolean.class);