public void setCategory(String category) { this.domain = category; if (getSubExpressions().length > 0) getSubExpressions()[0].setDomain(category); } }
public void setDomain(String domain) { this.domain = domain; for (Expression exp : subExpressions) exp.setDomain(domain); } }
public void setConnector(Expression connector) { this.expressionName = connector.toString(); }
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 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 ExpressionFactory() { // expressions.put("", new Parentheses()); expressions.put("*", new AnyValue()); expressions.put("all", new AllValue()); expressions.put("ignored", new Ignored()); expressions.put("negation", new Negation()); expressions.put("and", new Connector(Connector.AND)); expressions.put("or", new Connector(Connector.OR)); }
@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); }
private boolean isInputEmpty(List<Expression> inputExpressions) { return expressions.size() == 1 && expressions.get(0).getExpressionName().equals(KEY_EMPTY) && inputExpressions.size() == 0; }
public Unknown(String value) { super(value, Collections.singletonList(new Expression("unknown", new Expression(value))), null); } }
public Expression safeClone() { try { Object clone = this.clone(); return (Expression) clone; } catch (CloneNotSupportedException e) { log.error("Cloning error!", e); } return null; }
public Connector(Value connectorType) { setConnector(connectorType); }
@Override public void setSubExpressions(Expression... subExpressions) { if (subExpressions.length > 0) super.setSubExpressions(subExpressions[0]); if (subExpressions.length > 1) { log.warn("Tried to add multiple expressions to Negation! Only first subExpression written."); } }
public Boolean containsExpressionWithName(String expressionName) { return getAllExpressionsWithNames(expressionName).size() > 0; }
public void removeSubExpression(Integer index) { if (index > this.subExpressions.size()) return; Expression expToRemove = this.subExpressions.get(index); removeSubExpressions(expToRemove); }
public String getGUIString() { StringBuilder ret = new StringBuilder(); for (Expression subExp : subExpressions) { ret.append(subExp.getGUIString()); } return ret.toString(); } }
@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."); } }
@Override public Expression[] getExpression(Expression... expressions) { List<Expression> l = new LinkedList<Expression>(); for (Expression exp : expressions) l.add(getExpression(exp)); return l.toArray(new Expression[l.size()]); }
@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; }