private boolean isInputEmpty(List<Expression> inputExpressions) { return expressions.size() == 1 && expressions.get(0).getExpressionName().equals(KEY_EMPTY) && inputExpressions.size() == 0; }
@Override public boolean equals(Object o) { if (this == o) return true; if (!(o instanceof Expression)) return false; Expression that = (Expression) o; return expressionName.equals("*") || that.getExpressionName().equals("*") || (expressionName.equals(that.getExpressionName()) && getSubExpressions().length == that.getSubExpressions().length && Arrays.equals(getSubExpressions(), that.getSubExpressions())); }
public static List<Solution> extractExpressions(List<RawSolution> rawSolutions, boolean includeUnused, boolean includeUnknown) { List<Solution> solutionExpressions = new ArrayList<>(); for (RawSolution rawSolution : rawSolutions) { List<Expression> expressions = convertDictionaryEntriesToExpressions(rawSolution.getDictionaryEntries()); expressions = expressions.stream(). filter(expression -> includeUnused || !expression.getExpressionName().equals("unused")). filter(expression -> includeUnknown || !expression.getExpressionName().equals("unknown")). collect(Collectors.toList()); solutionExpressions.add(new Solution(StringUtilities.joinStrings(", ", expressions))); } return solutionExpressions; }
private void extractMeanings(List<String> meanings, Value value, Expression expression) { if (expression.getSubExpressions().length > 0) { meanings.add(expression.getExpressionName()); extractMeanings(meanings, value, expression.getSubExpressions()[0]); } else { value.setExpressionName(expression.getExpressionName()); } } }
@Override public List<PropertyEntry> extractProperties(List<Expression> expressions) { return expressions.stream(). filter(expression -> PROPERTY_EXPRESSION.equals(expression.getExpressionName()) && expression.getSubExpressions().length > 0). map(expression -> { List<String> meanings = new LinkedList<>(); Value value = new Value(); extractMeanings(meanings, value, expression.getSubExpressions()[0]); return new PropertyEntry(meanings, value.getExpressionName()); }).collect(Collectors.toCollection(LinkedList::new)); }
/** * Returns a list of expressions that have the given expressionName. * * @param expressionNames * @return list of expressions matching of of the expression names of the param */ public List<Expression> getAllExpressionsWithNames(String... expressionNames) { List<Expression> result = new ArrayList<Expression>(); for (String expressionName : expressionNames) { if (getExpressionName().equals(expressionName)) { result.add(this); } if (this.getSubExpressions().length != 0) { for (Expression subExp : getSubExpressions()) result.addAll(subExp.getAllExpressionsWithNames(expressionName)); } } return result; }
@Override public Expression getExpression(Expression exp) { try { if (exp != null) { if (expressions.containsKey(exp.getExpressionName())) { Expression tmpExp = exp; exp = (Expression) expressions.get(exp.getExpressionName()).clone(); exp.setSubExpressions(tmpExp.getSubExpressions()); } else { if (exp.getSubExpressions().length == 0 && CharacterUtilities.isNumber(exp.getExpressionName(), false)) { exp = new Value(exp.getExpressionName()); } else { exp = new Expression(exp.getExpressionName(), exp.getSubExpressions()); } } exp.setDomain(exp.getDomain()); } } catch (CloneNotSupportedException e) { log.error(e.getLocalizedMessage(), e); } return exp; } }