@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; } }
@Override public void addSubExpressions(Expression... subExpressions) { if (this.subExpressions.size() > 0) { log.warn("Overwriting subExpression of Negation!"); } super.addSubExpressions(subExpressions); if (subExpressions.length > 1) { log.warn("Tried to add multiple expressions to Negation! Only first subExpression written."); } }
/** * 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 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())); }
private boolean isInputEmpty(List<Expression> inputExpressions) { return expressions.size() == 1 && expressions.get(0).getExpressionName().equals(KEY_EMPTY) && inputExpressions.size() == 0; }
@Override public Expression parseExpression(String expression) { expression = expression.trim(); Expression exp; int indexOfOpening = expression.indexOf("("); int indexOfClosing = expression.lastIndexOf(")"); if (indexOfOpening > -1 && indexOfClosing > -1) { String tmp = expression.substring(0, indexOfOpening); exp = new Expression(tmp.trim()); try { String subExpressions = expression.substring(indexOfOpening + 1, indexOfClosing); List<Expression> expressions = parseExpressions(subExpressions); exp.setSubExpressions(expressions); } catch (Exception e) { log.error("Error while parsing Expression: %s, indexOfOpening: %s, indexOfClosing: %s, message: %s", expression, indexOfOpening, indexOfClosing, e.getLocalizedMessage()); } } else { exp = new Expression(expression); } return expressionFactory.getExpression(exp); }
public Unknown(String value) { super(value, Collections.singletonList(new Expression("unknown", new Expression(value))), null); } }
@Override public void extractAllValues(Expression exp, List<Value> ret) { if (exp instanceof Value) { ret.add((Value) exp); } else { Expression[] values = exp.getSubExpressions(); Arrays.stream(values).forEach(value -> { if (!(value instanceof Value)) { extractAllValues(value, ret); } else { ret.add((Value) value); } }); } } }
public Expression safeClone() { try { Object clone = this.clone(); return (Expression) clone; } catch (CloneNotSupportedException e) { log.error("Cloning error!", e); } return null; }
public Boolean containsExpressionWithName(String expressionName) { return getAllExpressionsWithNames(expressionName).size() > 0; }
@Override public boolean equals(Object o) { if (this == o) return true; if (isNumeric() && o instanceof Value) { Value value = (Value) o; return value.toDouble().equals(this.toDouble()); } return super.equals(o); } }
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()); } } }
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; }
@Override public List<IDictionary.IWord> getWords() { String[] splitPhrase = value.split(" "); List<IDictionary.IWord> words = new LinkedList<>(); Arrays.stream(splitPhrase).forEach(word -> { Expression unusedExp = new Expression("unused", new Expression(word)); words.add(new Word(word, Collections.singletonList(unusedExp), null, 0, true)); }); return words; }
@Override public Object clone() throws CloneNotSupportedException { Expression ret = (Expression) super.clone(); LinkedList<Expression> tmp = new LinkedList<Expression>(); for (Expression exp : subExpressions) { Expression subExpClone = (Expression) exp.clone(); tmp.add(subExpClone); } ret.subExpressions = tmp; return ret; }
@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)); }