ExpressionItem convertToExpressionItem(List<RuleLine> ruleLines, int index) throws IllegalStateException { if (ruleLines != null && ruleLines.size() > index) { ExpressionRuleLine expressionRuleLine = (ExpressionRuleLine) ruleLines.get(index); if (expressionRuleLine != null) { ExpressionItem expressionItem = expressionRuleLine.toExpressionItem(); if (index == ruleLines.size() - 1) { return expressionItem; } else { return new BinaryExpression(expressionItem, convertToExpressionItem(ruleLines, ++index), OperatorKind.AND); } } } LoggerFactory.getLogger(ElementAttributeComparisonConditionRuleLine.class).warn("Element instance not found for" + this.toString()); return null; } }
private void addSimpleConditionsFromExpressionItems(ExpressionItem expressionItem, Collection<BinaryExpression> simpleConditionsExpressionItems) { if (expressionItem instanceof BinaryExpression) { BinaryExpression binaryExpression = (BinaryExpression) expressionItem; if (OperatorKind.AND.equals(binaryExpression.getOperator()) || OperatorKind.OR.equals(binaryExpression.getOperator())) { addSimpleConditionsFromExpressionItems(binaryExpression.getLeft(), simpleConditionsExpressionItems); addSimpleConditionsFromExpressionItems(binaryExpression.getRight(), simpleConditionsExpressionItems); return; } else { if (isArithmeticOperator(binaryExpression.getOperator())) { addSimpleConditionsFromComplexExpressions(binaryExpression.getLeft(), simpleConditionsExpressionItems); addSimpleConditionsFromComplexExpressions(binaryExpression.getRight(), simpleConditionsExpressionItems); } if (!(binaryExpression.getLeft() instanceof Variable) || !(binaryExpression.getRight() instanceof ConstantExpression)) { return; //Skip conditions that are not like format 'variable op constant' } } simpleConditionsExpressionItems.add(binaryExpression); } else if (expressionItem instanceof AssignmentExpression) { AssignmentExpression assignmentExpression = (AssignmentExpression) expressionItem; addSimpleConditionsFromExpressionItems(assignmentExpression.getAssignment(), simpleConditionsExpressionItems); } }
@Override public boolean equals(Object obj) { if (this == obj) { return true; } if (!(obj instanceof GuideBinaryExpressionItem)) { return false; } GuideBinaryExpressionItem that = (GuideBinaryExpressionItem) obj; return binaryExpression.equals(that.binaryExpression) && guideId.equals(that.guideId); }
private static void addGTCodesInReads(ExpressionItem expressionItem, Set<String> gtCodes) { if (expressionItem instanceof BinaryExpression) { BinaryExpression binaryExpression = (BinaryExpression) expressionItem; addGTCodesInReads(binaryExpression.getLeft(), gtCodes); addGTCodesInReads(binaryExpression.getRight(), gtCodes); } else if (expressionItem instanceof UnaryExpression) { UnaryExpression unaryExpression = (UnaryExpression) expressionItem; addGTCodesInReads(unaryExpression.getOperand(), gtCodes); } else if (expressionItem instanceof FunctionalExpression) { FunctionalExpression functionalExpression = (FunctionalExpression) expressionItem; for (ExpressionItem expressionItemAux : functionalExpression.getItems()) { addGTCodesInReads(expressionItemAux, gtCodes); } } else if (expressionItem instanceof AssignmentExpression) { AssignmentExpression assignmentExpression = (AssignmentExpression) expressionItem; addGTCodesInReads(assignmentExpression.getAssignment(), gtCodes); } else if (expressionItem instanceof MultipleAssignmentExpression) { MultipleAssignmentExpression multipleAssignmentExpression = (MultipleAssignmentExpression) expressionItem; for (AssignmentExpression assignmentExpression : multipleAssignmentExpression.getAssignmentExpressions()) { addGTCodesInReads(assignmentExpression, gtCodes); } } else if (expressionItem instanceof Variable) { Variable variable = (Variable) expressionItem; gtCodes.add(variable.getCode()); } else if (expressionItem instanceof ConstantExpression) { //Do nothing } else { throw new RuntimeException("Unkown expression '" + expressionItem.getClass().getName() + "'"); } }
private static boolean hasLeftVariableName( ExpressionItem parentExpressionItem) { return (parentExpressionItem instanceof BinaryExpression) && ((BinaryExpression) parentExpressionItem).getLeft() instanceof Variable; }
private static OperatorKind getOperatorKind(ExpressionItem parentExpressionItem) { if (parentExpressionItem instanceof BinaryExpression) { return ((BinaryExpression) parentExpressionItem).getOperator(); } else { return null; } }
@Override public int hashCode() { int result = guideId.hashCode(); result = 31 * result + binaryExpression.hashCode(); return result; }
private static String getLeftVariableNameFromExpression( Map<String, ArchetypeElementVO> elementMap, ExpressionItem parentExpressionItem) { if (parentExpressionItem instanceof BinaryExpression) { ExpressionItem left = ((BinaryExpression) parentExpressionItem).getLeft(); if (left instanceof Variable) { return getLeftVariable(elementMap, (Variable) left); } } throw new RuntimeException(format("Invalid expression %s", parentExpressionItem)); }
private void addExpressionNodes(String guideId, ExpressionItem currentExpressionItem, GraphNode graphNode) throws InternalErrorException { if (currentExpressionItem instanceof BinaryExpression) { BinaryExpression binaryExpression = (BinaryExpression) currentExpressionItem; if (OperatorKind.OR.equals(binaryExpression.getOperator()) || OperatorKind.AND.equals(binaryExpression.getOperator())) { addExpressionNodes(guideId, binaryExpression.getLeft(), graphNode); addExpressionNodes(guideId, binaryExpression.getRight(), graphNode); return; } else if (isArithmeticOperator(binaryExpression.getOperator())) { addSimpleConditionsFromComplexExpressions(guideId, binaryExpression.getLeft(), graphNode); addSimpleConditionsFromComplexExpressions(guideId, binaryExpression.getRight(), graphNode); } } else if (currentExpressionItem instanceof AssignmentExpression) { AssignmentExpression assignmentExpression = (AssignmentExpression) currentExpressionItem; addExpressionNodes(guideId, assignmentExpression.getAssignment(), graphNode); } addExpressionToNode(guideId, currentExpressionItem, graphNode); }
private void addSimpleConditionsFromComplexExpressions(ExpressionItem expressionItem, Collection<BinaryExpression> simpleConditionsExpressionItems) { if (expressionItem instanceof BinaryExpression) { addSimpleConditionsFromExpressionItems(expressionItem, simpleConditionsExpressionItems); } else if (expressionItem instanceof Variable) { Variable variable = (Variable) expressionItem; simpleConditionsExpressionItems.add(new BinaryExpression(variable, new ConstantExpression("null"), OperatorKind.INEQUAL)); } }
private Map<String, Collection<GuideBinaryExpressionItem>> generateAllConditionsByElementIdMap() { Map<String, Collection<GuideBinaryExpressionItem>> allConditionsByElementId = new HashMap<>(); for (Guide guide : guideMap.values()) { if (guide.getDefinition() != null) { for (Rule rule : guide.getDefinition().getRules().values()) { Collection<BinaryExpression> simpleConditionsFromExpressionItems = getSimpleConditionsFromExpressionItems(guide, rule); for (BinaryExpression binaryExpression : simpleConditionsFromExpressionItems) { if (binaryExpression.getLeft() instanceof Variable) { Variable variable = (Variable) binaryExpression.getLeft(); RuleReference ruleReference = new RuleReference(guide.getId(), variable.getCode()); ElementInstance elementInstance = getElementInstanceByRuleReferenceMap().get(ruleReference); if (elementInstance == null) { if (!OpenEHRConst.CURRENT_DATE_TIME_ID.equals(ruleReference.getGtCode())) { logger.warn("ElementInstance not found for " + ruleReference); } } else { Collection<GuideBinaryExpressionItem> guideBinaryExpressionItems = allConditionsByElementId.computeIfAbsent(elementInstance.getId(), k -> new ArrayList<>()); guideBinaryExpressionItems.add(new GuideBinaryExpressionItem(guide.getId(), binaryExpression)); } } } } } } return allConditionsByElementId; }
protected void processBinaryExpression( RuleLineCollection ruleLines, RuleLine parentRuleLine, BinaryExpression binaryExpression) { if (OperatorKind.OR.equals(binaryExpression.getOperator())) { OrOperatorRuleLine orOperatorRuleLine = new OrOperatorRuleLine(); processExpressionItem(ruleLines, orOperatorRuleLine.getLeftRuleLineBranch(), binaryExpression.getLeft()); processExpressionItem(ruleLines, orOperatorRuleLine.getRightRuleLineBranch(), binaryExpression.getRight()); addRuleLine(orOperatorRuleLine, ruleLines, parentRuleLine); } else if (OperatorKind.AND.equals(binaryExpression.getOperator())) { processExpressionItem(ruleLines, parentRuleLine, binaryExpression.getLeft()); processExpressionItem(ruleLines, parentRuleLine, binaryExpression.getRight()); } else if (OperatorKind.EQUALITY.equals(binaryExpression.getOperator()) || OperatorKind.INEQUAL.equals(binaryExpression.getOperator()) || OperatorKind.IS_A.equals(binaryExpression.getOperator()) || OperatorKind.IS_NOT_A.equals(binaryExpression.getOperator()) || OperatorKind.GREATER_THAN.equals(binaryExpression.getOperator()) || OperatorKind.GREATER_THAN_OR_EQUAL.equals(binaryExpression.getOperator()) || OperatorKind.LESS_THAN.equals(binaryExpression.getOperator()) || OperatorKind.LESS_THAN_OR_EQUAL.equals(binaryExpression.getOperator())) { processComparisonExpression(ruleLines, parentRuleLine, binaryExpression); } else { throw new InternalErrorException(new Exception("Unknown operator '" + binaryExpression.getOperator() + "'")); } }
private void addSimpleConditionsFromComplexExpressions(String guideId, ExpressionItem expressionItem, GraphNode graphNode) throws InternalErrorException { if (expressionItem instanceof BinaryExpression) { addExpressionNodes(guideId, expressionItem, graphNode); } else if (expressionItem instanceof Variable) { Variable variable = (Variable) expressionItem; BinaryExpression binaryExpression = new BinaryExpression(variable, new ConstantExpression("null"), OperatorKind.INEQUAL); addExpressionToNode(guideId, binaryExpression, graphNode); } }
DateTime dateTime, boolean resolvePredicates, BinaryExpression expressionItem) { BinaryExpression be = expressionItem; ExpressionItem left = be.getLeft(); ExpressionItem right = be.getRight(); if (left instanceof Variable) { String path = ((Variable) left).getPath(); PredicateGeneratedElementInstance ei = generateElementInstanceForPredicate(ar, be.getOperator(), idElement, dv, guide, dateTime, resolvePredicates); String gtCode = getGTCodeForPredicate(archetypeBinding, path, dv); if (gtCode != null) { String idElement = archetypeBinding.getArchetypeId() + path; DataValue dv = new CurrentTimeExpressionDataValue(right, attribute); generateElementInstanceForPredicate(ar, be.getOperator(), idElement, dv, guide, dateTime, resolvePredicates);
public ExpressionItem toExpressionItem() { return new BinaryExpression( convertToExpressionItem(getLeftRuleLineBranch().getChildrenRuleLines().getRuleLines(), 0), convertToExpressionItem(getRightRuleLineBranch().getChildrenRuleLines().getRuleLines(), 0), OperatorKind.OR); }
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; } }
public ExpressionItem toExpressionItem() throws IllegalStateException { ArchetypeElementVO archetypeElementVO = getArchetypeElement(); if (archetypeElementVO != null) { String path = archetypeElementVO.getPath(); OperatorKind operatorKind = getExistenceOperatorRuleLineElement().getOperator(); if (operatorKind == null) { throw new IllegalStateException("No operator set"); } String name = getArchetypeManager().getArchetypeElements().getText(archetypeElementVO, getLanguage()); return new BinaryExpression( new Variable(null, name, path), new ConstantExpression(NULL_STR), operatorKind); } else { throw new IllegalStateException("Element instance not found for" + this.toString()); } }
if (expressionItem instanceof BinaryExpression) { BinaryExpression binaryExpression = (BinaryExpression) expressionItem; if (OperatorKind.EXPONENT.equals(binaryExpression.getOperator())) { sb.append("(double) Math.pow("); sb.append(getArithmeticExpressionStr(elementMap, binaryExpression.getLeft(), stats, binaryExpression)); sb.append(","); sb.append(getArithmeticExpressionStr(elementMap, binaryExpression.getRight(), stats, binaryExpression)); sb.append(")"); } else { sb.append("(") .append(getArithmeticExpressionStr(elementMap, binaryExpression.getLeft(), stats, binaryExpression)); sb.append(binaryExpression.getOperator().getSymbol()); sb.append(getArithmeticExpressionStr(elementMap, binaryExpression.getRight(), stats, binaryExpression)) .append(")");
public ExpressionItem toExpressionItem() throws IllegalStateException { if (archetypeElementAttributeRuleLineElement != null && getArchetypeElementAttributeRuleLineElement().getValue() != null) { String gtCode = getArchetypeElementAttributeRuleLineElement().getValue().getValue().getValue(); ExpressionRuleLineElement expressionRuleLineElement = getExpressionRuleLineElement(); OperatorKind operatorKind = getComparisonOperatorRuleLineElement().getValue(); if (operatorKind == null) { throw new IllegalStateException("No operator kind set"); } Variable var = new Variable(gtCode, null, null, getArchetypeElementAttributeRuleLineElement().getAttribute()); if (expressionRuleLineElement.getValue() == null) { throw new IllegalStateException("No expression set"); } return new BinaryExpression( var, expressionRuleLineElement.getValue(), operatorKind); } else { throw new IllegalStateException("Element instance not found for" + this.toString()); } }
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(); } } }