org.opencds.cqf.cql.execution.Context Java Examples

@Override
protected Object internalEvaluate(Context context) {
    if (this.getContext() != null) {
        context.enterContext(this.getContext());
    }
    try {
        if (context.isExpressionCachingEnabled() && context.isExpressionInCache(this.getName())) {
            return context.getExpressionResultFromCache(this.getName());
        }

        Object result = this.getExpression().evaluate(context);

        if (context.isExpressionCachingEnabled() && !context.isExpressionInCache(this.getName())) {
            context.addExpressionToCache(this.getName(), result);
        }

        return result;
    }
    finally {
        if (this.getContext() != null) {
            context.exitContext();
        }
    }
}
 

@Override
protected Object internalEvaluate(Context context) {
    Object left = getOperand().get(0).evaluate(context);
    Object right = getOperand().get(1).evaluate(context);
    String precision = getPrecision() == null ? null : getPrecision().value();

    if (left == null && right == null) {
        return null;
    }

    // null left operand case
    if (getOperand().get(0) instanceof AsEvaluator) {
        if (((AsEvaluator) getOperand().get(0)).getAsTypeSpecifier() instanceof IntervalTypeSpecifier) {
            return InEvaluator.in(right, left, precision);
        }
        else {
            return InEvaluator.in(right, left, null);
        }
    }

    return contains(left, right, precision);
}
 

public Object evaluateInContext(DomainResource instance, String cql, String patientId) {
    Iterable<CanonicalType> libraries = getLibraryReferences(instance);

    String source = String.format(
            "library LocalLibrary using FHIR version '4.0.0' include FHIRHelpers version '4.0.0' called FHIRHelpers %s parameter %s %s parameter \"%%context\" %s define Expression: %s",
            buildIncludes(libraries), instance.fhirType(), instance.fhirType(), instance.fhirType(), cql);
    
    LibraryLoader libraryLoader = LibraryHelper.createLibraryLoader(this.getLibraryResourceProvider());
    
    org.cqframework.cql.elm.execution.Library library = TranslatorHelper.translateLibrary(source,
            libraryLoader.getLibraryManager(), libraryLoader.getModelManager());
    
    // resolve execution context
    Context context = setupContext(instance, patientId, libraryLoader, library);
    return context.resolveExpressionRef("Expression").evaluate(context);
}
 

@Override
protected Object internalEvaluate(Context context) {
    Object target = null;

    if (this.getSource() != null) {
        target = getSource().evaluate(context);
        // Tuple element access
        if (target instanceof Tuple) {
          // NOTE: translator will throw error if Tuple does not contain the specified element -- no need for x.containsKey() check
          return ((Tuple)target).getElements().get(this.getPath());
        }
    }
    else if (this.getScope() != null) {
        target = context.resolveVariable(this.getScope(), true).getValue();
    }

    if (target == null) {
        return null;
    }

    if (target instanceof Iterable) {

    }

    return context.resolvePath(target, this.getPath());
}
 

@Override
protected Object internalEvaluate(Context context) {
    Expression operand = getOperand();

    // Special case to handle literals of the minimum Integer value
    // since usual implementation would try to cast 2147483648 as a
    // signed 32 bit signed integer and throw
    // java.lang.NumberFormatException: For input string: "2147483648".
    if (operand instanceof LiteralEvaluator && ((LiteralEvaluator)operand).getValue().equals("2147483648"))
    {
        return Integer.MIN_VALUE;
    }

    Object source = operand.evaluate(context);

    return negate(source);
}
 

public MeasureReport evaluatePatientMeasure(Measure measure, Context context, String patientId) {
    logger.info("Generating individual report");

    if (patientId == null) {
        return evaluatePopulationMeasure(measure, context);
    }

    Patient patient = registry.getResourceDao(Patient.class).read(new IdType(patientId));
    // Iterable<Object> patientRetrieve = provider.retrieve("Patient", "id",
    // patientId, "Patient", null, null, null, null, null, null, null, null);
    // Patient patient = null;
    // if (patientRetrieve.iterator().hasNext()) {
    // patient = (Patient) patientRetrieve.iterator().next();
    // }

    return evaluate(measure, context,
            patient == null ? Collections.emptyList() : Collections.singletonList(patient),
            MeasureReport.MeasureReportType.INDIVIDUAL);
}
 

@Override
protected Object internalEvaluate(Context context) {
    String type = this.getValueType().getLocalPart();
    if (type == null) {
        return null;
    }

    if (type.endsWith("Integer")) {
        return Value.MIN_INT;
    }
    if (type.endsWith("Decimal")) {
        return Value.MIN_DECIMAL;
    }
    if (type.endsWith("Date")) {
        return new Date(1, 1, 1).setPrecision(Precision.DAY);
    }
    if (type.endsWith("DateTime")) {
        return new DateTime(TemporalHelper.zoneToOffset(context.getEvaluationDateTime().getDateTime().getOffset()), 1, 1, 1, 0, 0, 0, 0).withEvaluationOffset(context.getEvaluationDateTime().getDateTime().getOffset());
    }
    if (type.endsWith("Time")) {
        return new Time(TemporalHelper.zoneToOffset(context.getEvaluationDateTime().getDateTime().getOffset()), 0, 0, 0, 0).withEvaluationOffset(context.getEvaluationDateTime().getDateTime().getOffset());
    }

    throw new InvalidOperatorArgument(String.format("The Minimum operator is not implemented for type %s", type));
}
 

public void TestCMS9v4_CQM() throws IOException, JAXBException {
      File xmlFile = new File(URLDecoder.decode(TestFhirLibrary.class.getResource("CMS9v4_CQM.xml").getFile(), "UTF-8"));
      Library library = CqlLibraryReader.read(xmlFile);

      Context context = new Context(library);

      FhirContext fhirContext = FhirContext.forDstu3();

Dstu3FhirModelResolver modelResolver = new Dstu3FhirModelResolver();
RestFhirRetrieveProvider retrieveProvider = new RestFhirRetrieveProvider(new SearchParameterResolver(fhirContext),  fhirContext.newRestfulGenericClient("http://fhirtest.uhn.ca/baseDstu3"));
CompositeDataProvider provider = new CompositeDataProvider(modelResolver, retrieveProvider);
      //BaseFhirDataProvider provider = new FhirDataProviderStu3().setEndpoint("http://fhirtest.uhn.ca/baseDstu3");
      //BaseFhirDataProvider provider = new FhirDataProviderStu3().setEndpoint("http://fhir3.healthintersections.com.au/open/");
      //BaseFhirDataProvider provider = new FhirDataProviderStu3().setEndpoint("http://wildfhir.aegis.net/fhir");
      context.registerDataProvider("http://hl7.org/fhir", provider);

      Object result = context.resolveExpressionRef("Breastfeeding Intention Assessment").evaluate(context);
      assertThat(result, instanceOf(Iterable.class));
      for (Object element : (Iterable)result) {
          assertThat(element, instanceOf(RiskAssessment.class));
      }
  }
 

/**
 * ExpressionProcessor constructor.
 * @param expression Expression to evaluate for each future set of parameters.
 * @param paramTypeMap Map of parameter names to their corresponding CQL types.
 */
public ExpressionProcessor(String expression, Map<String,String> paramTypeMap) {
  this.cqlParamMap = HashBiMap.create();
  this.paramTypeMap = paramTypeMap;
  
  String cleanExpression = replaceParameters(expression);
  String wrappedExpression = convertParameterizedExpressionToCql(cleanExpression);

  // Compile our constructed CQL expression into elm once for execution
  this.elm = cqlToElm(wrappedExpression);
  try {
    this.library = CqlLibraryReader.read(new ByteArrayInputStream(
        elm.getBytes(StandardCharsets.UTF_8)));
  } catch (IOException | JAXBException ex) {
    throw new RuntimeException(ex);
  }
  this.context = new Context(library);
  this.expression = expression;
}
 

@Override
protected Object internalEvaluate(Context context) {
    Object left = getOperand().get(0).evaluate(context);
    Object right = getOperand().get(1).evaluate(context);
    String precision = getPrecision() == null ? null : getPrecision().value();

    return ends(left, right, precision);
}
 

@Override
protected Object internalEvaluate(Context context) {
    Object source = getSource().evaluate(context);
    Object element = getElement().evaluate(context);
    String scope = getScope();

    return repeat(source, element, scope);
}
 

@Override
protected Object internalEvaluate(Context context) {
    Object left = getOperand().get(0).evaluate(context);
    Object right = getOperand().get(1).evaluate(context);
    String precision = getPrecision() == null ? null : getPrecision().value();

    return starts(left, right, precision);
}
 

public Object evaluateInContext(DomainResource instance, String cql, String patientId, Boolean aliasedExpression) {
    Iterable<CanonicalType> libraries = getLibraryReferences(instance);
    if (aliasedExpression) {
        Object result = null;
        for (CanonicalType reference : libraries) {
            Library lib =this.libraryResourceProvider.resolveLibraryById(CanonicalHelper.getId(reference));
            if (lib == null)
            {
                throw new RuntimeException("Library with id " + reference.getIdBase() + "not found");
            }
            LibraryLoader libraryLoader = LibraryHelper.createLibraryLoader(this.getLibraryResourceProvider());
            // resolve primary library
            org.cqframework.cql.elm.execution.Library library = LibraryHelper.resolveLibraryById(lib.getId(), libraryLoader, this.libraryResourceProvider);

            // resolve execution context
            Context context = setupContext(instance, patientId, libraryLoader, library);
            result = context.resolveExpressionRef(cql).evaluate(context);
            if (result != null) {
                return result;
            }
        }
        throw new RuntimeException("Could not find Expression in Referenced Libraries");
    }
    else {
        return evaluateInContext(instance, cql, patientId);
    }
}
 

@Override
protected Object internalEvaluate(Context context) {
    Object left = getOperand().get(0).evaluate(context);
    Object right = getOperand().get(1).evaluate(context);
    String precision = getPrecision() != null ? getPrecision().value() : null;

    return properContains(left, right, precision);
}
 

public Object forEach(Object source, Object element, Context context) {
    if (source == null || element == null) {
        return null;
    }

    List<Object> retVal = new ArrayList<>();
    for (Object o : (Iterable) source) {
        retVal.add(context.resolvePath(o, element.toString()));
    }
    return retVal;
}
 

@Override
protected Object internalEvaluate(Context context) {
    Object left = getOperand().get(0).evaluate(context);
    Object right = getOperand().get(1).evaluate(context);
    String precision = getPrecision() == null ? null : getPrecision().value();

    return overlapsAfter(left, right, precision);
}
 

@Override
protected Object internalEvaluate(Context context) {
    Object source = getSource().evaluate(context);
    Boolean condition = (Boolean) getCondition().evaluate(context);
    String code = (String) getCode().evaluate(context);
    String severity = (String) getSeverity().evaluate(context);
    String message = (String) getMessage().evaluate(context);

    return message(source, condition, code, severity, message);
}
 

public Object evaluate(Context context) throws CqlException
{
    try {
        return internalEvaluate(context);
    }
    catch (Exception e) {
        if (e instanceof CqlException) {
            throw e;
        }
        else {
            throw new CqlException(e);
        }
    }
}
 

@Override
protected Object internalEvaluate(Context context)
{
    Iterable<Interval> list = (Iterable<Interval>) getOperand().get(0).evaluate(context);
    Quantity per = (Quantity) getOperand().get(1).evaluate(context);

    return expand(list, per);
}
 

@Override
protected Object internalEvaluate(Context context) {
    String argument = (String) getOperand().get(0).evaluate(context);
    String suffix = (String) getOperand().get(1).evaluate(context);

    return endsWith(argument, suffix);
}
 

@Override
protected Object internalEvaluate(Context context) {
    Object left = getOperand().get(0).evaluate(context);
    Object right = getOperand().get(1).evaluate(context);
    String precision = getPrecision().value();

    return difference(left, right, Precision.fromString(precision));
}
 

@Override
protected Object internalEvaluate(Context context) {

    String name = this.getName();

    if (name == null) {
        return null;
    }

    return context.resolveIdentifierRef(name);
}
 

@Override
protected Object internalEvaluate(Context context) {
    Object left = getOperand().get(0).evaluate(context);
    Object right = getOperand().get(1).evaluate(context);

    return less(left, right);
}
 

@Override
protected Object internalEvaluate(Context context) {
    Object left = getOperand().get(0).evaluate(context);
    Object right = getOperand().get(1).evaluate(context);

    return equal(left, right);
}
 

@Override
protected Object internalEvaluate(Context context) {
    Object low = getLow() != null ? getLow().evaluate(context) : null;
    Boolean lowClosed = getLowClosedExpression() != null ? (Boolean)getLowClosedExpression().evaluate(context) : this.lowClosed;
    Object high = getHigh() != null ? getHigh().evaluate(context) : null;
    Boolean highClosed = getHighClosedExpression() != null ? (Boolean)getHighClosedExpression().evaluate(context) : this.highClosed;

    // An interval with no boundaries is not an interval
    // TODO: the spec states that it is possible to have an interval with null boundaries, but the ELM is not providing a way to get the Interval type
    if (low == null && high == null) {
        return null;
    }

    return new org.opencds.cqf.cql.runtime.Interval(low, lowClosed == null ? true : lowClosed, high, highClosed == null ? true : highClosed);
}
 

@Override
protected Object internalEvaluate(Context context) {
    Object left = getOperand().get(0).evaluate(context);
    Object right = getOperand().get(1).evaluate(context);
    String precision = getPrecision() == null ? null : getPrecision().value();

    return meetsBefore(left, right, precision);
}
 

@Override
protected Object internalEvaluate(Context context) {
    Object source = this.getSource().evaluate(context);
    String separator = this.getSeparator() == null ? "" : (String) this.getSeparator().evaluate(context);

    return combine(source, separator);
}
 

@Override
protected Object internalEvaluate(Context context)
{
    Object left = getOperand().get(0).evaluate(context);
    Object right = getOperand().get(1).evaluate(context);

    return intersect(left, right);
}
 

@Override
protected Object internalEvaluate(Context context) {
    Object source = getSource().evaluate(context);
    Object elementToFind = getElement().evaluate(context);

    return indexOf(source, elementToFind);
}
 

@Override
protected Object internalEvaluate(Context context) {
    ArrayList<Object> arguments = new ArrayList<>();
    for (Expression operand : this.getOperand()) {
        arguments.add(operand.evaluate(context));
    }

    boolean enteredLibrary = context.enterLibrary(this.getLibraryName());
    try {
        // TODO: Use type specifiers from the operands here if they are available
        FunctionDef functionDef = context.resolveFunctionRef(this.getName(), arguments, this.getLibraryName());
        if (Optional.ofNullable(functionDef.isExternal()).orElse(false)) {
            return context.getExternalFunctionProvider().evaluate(functionDef.getName(), arguments);
        }
        else {
            context.pushWindow();
            try {
                for (int i = 0; i < arguments.size(); i++) {
                    context.push(new Variable().withName(functionDef.getOperand().get(i).getName()).withValue(arguments.get(i)));
                }
                return functionDef.getExpression().evaluate(context);
            }
            finally {
                context.popWindow();
            }
        }
    }
    finally {
        context.exitLibrary(enteredLibrary);
    }
}