@Override public String getResolvedDescription(OperatorKind item, String language) { if (item != null) { return item.getName(); } else { return null; } }
@Override public String getResolvedName(OperatorKind item, String language) { if (item != null) { return item.getSymbol(); } else { return null; } }
if (expressionItem instanceof BinaryExpression) { BinaryExpression binaryExpression = (BinaryExpression) expressionItem; if (OperatorKind.EXPONENT.equals(binaryExpression.getOperator())) { sb.append("(double) Math.pow("); sb.append(getArithmeticExpressionStr(elementMap, sb.append("(") .append(getArithmeticExpressionStr(elementMap, binaryExpression.getLeft(), stats, binaryExpression)); sb.append(binaryExpression.getOperator().getSymbol()); sb.append(getArithmeticExpressionStr(elementMap, binaryExpression.getRight(), stats, binaryExpression)) .append(")");
String rmType = archetypeElementVO.getType(); if (OpenEHRDataValues.DV_TEXT.equals(rmType) && (OperatorKind.IS_A.equals(binaryExpression.getOperator()) || OperatorKind.IS_NOT_A.equals(binaryExpression.getOperator()))) { rmType = OpenEHRDataValues.DV_CODED_TEXT; airl.addChildRuleLine(wepedrl); wepedrl.getArchetypeElementRuleLineDefinitionElement().setValue(archetypeElementVO); wepedrl.getExistenceOperatorRuleLineElement().setValue(binaryExpression.getOperator().getSymbol() + "null");
@Override public String getResolvedName(OperatorKind item, String language) { if (item != null) { return item.getSymbol(); } else { return null; } }
@Override public String getResolvedDescription(OperatorKind item, String language) { if (item != null) { return item.getName(); } else { return null; } }
private static String formatConstantValue( Map<String, ArchetypeElementVO> elementMap, ConstantExpression exp, ExpressionItem parentExpressionItem) { String value = exp.getValue(); if (value.contains(",")) { String units = StringUtils.substringAfter(value, ","); if (isUcumTime(units)) { OperatorKind operatorKind = getOperatorKind(parentExpressionItem); if (operatorKind == null) { throw new RuntimeException(format("Operator kind not defined in expression : %s", parentExpressionItem)); } if (hasLeftVariableName(parentExpressionItem)) { String temporalVariableName = getLeftVariableNameFromExpression(elementMap, parentExpressionItem); value = format("DVUtil.calculateDuration(\"%s\",%s,\"%s\")", value, temporalVariableName, operatorKind.getSymbol()); } else { value = format("DVUtil.calculateDuration(\"%s\",\"%s\")", value, operatorKind.getSymbol()); } } else { throw new IllegalArgumentException(format("Unknown time units in value '%s'", value)); } } else if (exp instanceof MathConstant) { if (Constant.E.equals(((MathConstant) exp).getConstant())) { value = "(double) " + Math.E; } } return "(" + value + ")"; }
public static boolean checkMaxMin(DataValue originalDv, DataValue checkDv, String opSymbol, ArchetypeReference originalAr, ArchetypeReference checkAr) { if (!(originalDv instanceof DvOrdered) || !(checkDv instanceof DvOrdered)) { return false; } if (!areDomainsCompatible(originalAr.getIdDomain(), checkAr.getIdDomain())) { return false; } if (comparingGeneratedArWithRealAr(originalAr, checkAr)) { return true; } if (comparingRealArWithGeneratedAr(originalAr, checkAr)) { return false; } int comp = compare(originalDv, checkDv); if (OperatorKind.MAX.getSymbol().equals(opSymbol)) { return comp < 0; } else if (OperatorKind.MIN.getSymbol().equals(opSymbol)) { return comp > 0; } else { throw new IllegalArgumentException(format("Operator for predicate '%s' is not valid.", opSymbol)); } }
@Override public String getResolvedName(OperatorKind operatorKind, String lang) { if (OperatorKind.FIRED.equals(operatorKind)) { return CDSLanguageManager.getMessageWithLanguage("HasBeenFiredRLE", lang); } else if (OperatorKind.NOT_FIRED.equals(operatorKind)) { return CDSLanguageManager.getMessageWithLanguage("HasNotBeenFiredRLE", lang); } else { throw new RuntimeException("Unknown operator '" + operatorKind + "'"); } }
@Override public String getPredicateDescription() { StringBuilder sb = new StringBuilder(); ArchetypeElementRuleLineDefinitionElement aerlde = getArchetypeElementRuleLineDefinitionElement(); if (aerlde != null) { ArchetypeElementVO archetypeElementVO = aerlde.getValue(); if (archetypeElementVO != null) { OperatorKind operator = getExistenceOperatorRuleLineElement().getOperator(); String opStr = "??"; if (operator != null) { opStr = operator.getSymbol(); } String name = aerlde.getArchetypeManager().getArchetypeElements().getText(archetypeElementVO, getLanguage()); sb.append(name).append(opStr).append("null"); } else { LoggerFactory.getLogger(ArchetypeReference.class).warn("Unknown predicate for AR '" + aerlde.toString() + "'"); sb.append("*UNKNOWN PREDICATE*"); } } return sb.toString(); } }
private Integer getComparisonNumber(PredicateGeneratedElementInstance pred) { if (OperatorKind.IS_A.equals(pred.getOperatorKind())) { return 0; } else if (OperatorKind.IS_NOT_A.equals(pred.getOperatorKind())) { return 1; } else if (OperatorKind.EQUALITY.equals(pred.getOperatorKind())) { return 2; } else if (OperatorKind.INEQUAL.equals(pred.getOperatorKind())) { return 3; } else if (OperatorKind.GREATER_THAN_OR_EQUAL.equals(pred.getOperatorKind())) { return 4; } else if (OperatorKind.LESS_THAN_OR_EQUAL.equals(pred.getOperatorKind())) { return 5; } else if (OperatorKind.GREATER_THAN.equals(pred.getOperatorKind())) { return 6; } else if (OperatorKind.LESS_THAN.equals(pred.getOperatorKind())) { return 7; } else if (OperatorKind.MAX.equals(pred.getOperatorKind())) { return 8; } else if (OperatorKind.MIN.equals(pred.getOperatorKind())) { return 9; } return 0; }
@Override public String getPredicateDescription() { StringBuilder sb = new StringBuilder(); PredicateArchetypeElementAttributeRuleLineElement paearle = getArchetypeElementAttributeRuleLineDefinitionElement(); PredicateAttributeComparisonOperatorRuleLineElement pacorl = getComparisonOperatorRuleLineElement(); ExpressionRuleLineElement ere = getExpressionRuleLineElement(); if (paearle != null) { ArchetypeElementVO archetypeElementVO = paearle.getValue(); String attribute = paearle.getAttribute(); if (archetypeElementVO != null && pacorl.getValue() != null) { String name = getArchetypeManager().getArchetypeElements().getText(archetypeElementVO, getLanguage()); sb.append(name).append(".").append(attribute).append(" ").append(pacorl.getValue().getSymbol()).append(" ").append(ere.toString()); } else { LoggerFactory.getLogger(ArchetypeReference.class).warn("Unknown predicate for AR '" + paearle.toString() + "'"); sb.append("*UNKNOWN PREDICATE*"); } } return sb.toString(); } }
public static DataValue resolvePredicate(DataValue dv, OperatorKind op, Collection<Guide> guides, Calendar date) { if (OperatorKind.IS_A.equals(op)) { if (dv instanceof DvCodedText) { DvCodedText dvCodedText = (DvCodedText) dv; return getResolvedCodedText(dvCodedText, guides); } else if (dv instanceof DvOrdinal) { return dv; } else { LoggerFactory.getLogger(ElementInstanceCollectionManager.class).warn("Not a coded text '" + dv + "'"); return null; } } else if (dv instanceof CurrentTimeExpressionDataValue) { return getResolvedCurrentDateTime(dv, date); } else { return dv; } }
public static String toString(RuleLineElementWithValue<ExpressionItem> ruleLineElement, ExpressionItem expressionItem, String language) { if (expressionItem instanceof Variable) { return getVariableName(ruleLineElement, (Variable) expressionItem, language); } else if (expressionItem instanceof BinaryExpression) { BinaryExpression be = (BinaryExpression) expressionItem; return "(" + toString(ruleLineElement, be.getLeft(), language) + " " + be.getOperator().getSymbol() + " " + toString(ruleLineElement, be.getRight(), language) + ")"; } else if (expressionItem instanceof UnaryExpression) { UnaryExpression ue = (UnaryExpression) expressionItem; return ue.getOperator().getSymbol() + "(" + toString(ruleLineElement, ue.getOperand(), language) + ")"; } else if (expressionItem instanceof FunctionalExpression) { FunctionalExpression fe = (FunctionalExpression) expressionItem; StringBuilder sb = new StringBuilder(); String postFix = ""; for (ExpressionItem ei : fe.getItems()) { sb.append(postFix) .append(toString(ruleLineElement, ei, language)); postFix = ","; } return "(" + fe.getFunction().toString() + "(" + sb.toString() + "))"; } else if (expressionItem instanceof StringConstant) { return expressionItem.toString(); } else { return expressionItem != null ? expressionItem.toString().replace(",", " ") : null; } }
protected void processUnaryExpression( RuleLineCollection ruleLines, RuleLine parentRuleLine, UnaryExpression unaryExpression) throws InternalErrorException { OperatorKind operator = unaryExpression.getOperator(); if (OperatorKind.FIRED.equals(operator) || OperatorKind.NOT_FIRED.equals(operator)) { processFiredRuleCondition(ruleLines, parentRuleLine, unaryExpression); } else if (OperatorKind.NOT.equals(operator)) { NotOperatorRuleLine notOperatorRuleLine = new NotOperatorRuleLine(); processExpressionItem(ruleLines, notOperatorRuleLine, unaryExpression.getOperand()); addRuleLine(notOperatorRuleLine, ruleLines, parentRuleLine); } else { throw new InternalErrorException(new Exception("Unknown operator '" + operator + "'")); } }
public static String getEditableExpressionString(ExpressionItem expressionItem) { if (expressionItem instanceof Variable) { Variable var = (Variable) expressionItem; String attributePostfix = var.getAttribute() != null ? "." + var.getAttribute() : ""; return "$" + var.getCode() + attributePostfix; } else if (expressionItem instanceof BinaryExpression) { BinaryExpression be = (BinaryExpression) expressionItem; return "(" + getEditableExpressionString(be.getLeft()) + " " + be.getOperator().getSymbol() + " " + getEditableExpressionString(be.getRight()) + ")"; } else if (expressionItem instanceof UnaryExpression) { UnaryExpression ue = (UnaryExpression) expressionItem; return ue.getOperator().getSymbol() + "(" + getEditableExpressionString(ue.getOperand()) + ")"; } else if (expressionItem instanceof FunctionalExpression) { FunctionalExpression fe = (FunctionalExpression) expressionItem; StringBuilder sb = new StringBuilder(); String postFix = ""; for (ExpressionItem ei : fe.getItems()) { sb.append(postFix) .append(getEditableExpressionString(ei)); postFix = ", "; } return "(" + fe.getFunction().toString() + "(" + sb.toString() + "))"; } else { return expressionItem.toString(); } } }