/** * @inheritDoc */ @Override public void meet(Compare theOp) throws Exception { mBuffer.append("("); theOp.getLeftArg().visit(this); mBuffer.append(" ").append(theOp.getOperator().getSymbol()).append(" "); theOp.getRightArg().visit(this); mBuffer.append(")"); }
private static Compare compare(ValueExpr theLeft, ValueExpr theRight, Compare.CompareOp theOp) { return new Compare(theLeft, theRight, theOp); } }
@Override public void meet(final Compare n) { final QueryModelNode p = n.getParentNode(); final boolean par = p instanceof Not || p instanceof MathExpr; emitIf(par, "(").emit(n.getLeftArg()).emit(" ").emit(n.getOperator().getSymbol()) .emit(" ").emit(n.getRightArg()).emitIf(par, ")"); }
@Override public void meet(Compare compare) { super.meet(compare); if (compare.getOperator() == CompareOp.EQ) { ValueExpr leftArg = compare.getLeftArg(); ValueExpr rightArg = compare.getRightArg(); boolean leftIsVar = isVar(leftArg); boolean rightIsVar = isVar(rightArg); boolean leftIsResource = isResource(leftArg); boolean rightIsResource = isResource(rightArg); if (leftIsVar && rightIsResource || leftIsResource && rightIsVar || leftIsResource && rightIsResource) { SameTerm sameTerm = new SameTerm(leftArg, rightArg); compare.replaceWith(sameTerm); } } }
@Override public boolean equals(Object other) { if (other instanceof Compare && super.equals(other)) { Compare o = (Compare)other; return operator.equals(o.getOperator()); } return false; }
public Compare(ValueExpr leftArg, ValueExpr rightArg, CompareOp operator) { super(leftArg, rightArg); setOperator(operator); }
@Override public void meet(Compare node) { handleType(SeRQO.COMPARE); handleLiteral(SeRQO.OPERATOR, node.getOperator().name()); super.meet(node); }
@Override public void meet(Compare node) { if (predicate.equals(SeRQO.OPERATOR)) { Literal lit = (Literal) object; node.setOperator(CompareOp.valueOf(lit.getLabel())); } else { super.meet(node); } }
/** * @inheritDoc */ @Override public void meet(Compare theOp) throws Exception { mBuffer.append("("); theOp.getLeftArg().visit(this); mBuffer.append(" ").append(theOp.getOperator().getSymbol()).append(" "); theOp.getRightArg().visit(this); mBuffer.append(")"); }
@Override public void meet(final Compare n) { final QueryModelNode p = n.getParentNode(); final boolean par = p instanceof Not || p instanceof MathExpr; emitIf(par, "(").emit(n.getLeftArg()).emit(" ").emit(n.getOperator().getSymbol()) .emit(" ").emit(n.getRightArg()).emitIf(par, ")"); }
TreeMap<CustomObject,Integer> tmap = new TreeMap<CustomObject,Integer>(new Compare());
public Value evaluate(Compare node, BindingSet bindings) throws ValueExprEvaluationException, QueryEvaluationException { Value leftVal = evaluate(node.getLeftArg(), bindings); Value rightVal = evaluate(node.getRightArg(), bindings); return BooleanLiteral.valueOf(QueryEvaluationUtil.compare(leftVal, rightVal, node.getOperator())); }
ObjectMapper om = new ObjectMapper(); JSONObject(om.writeValueAsString(new Compare()))
private void extractNegatedProperties(final ValueExpr condition, final Set<URI> negatedProperties) { if (condition instanceof And) { final And and = (And) condition; extractNegatedProperties(and.getLeftArg(), negatedProperties); extractNegatedProperties(and.getRightArg(), negatedProperties); } else if (condition instanceof Compare) { final Compare compare = (Compare) condition; Preconditions.checkArgument(compare.getOperator() == CompareOp.NE); if (compare.getLeftArg() instanceof ValueConstant) { Preconditions.checkArgument(compare.getRightArg() instanceof Var); negatedProperties.add((URI) ((ValueConstant) compare.getLeftArg()).getValue()); } else if (compare.getRightArg() instanceof ValueConstant) { Preconditions.checkArgument(compare.getLeftArg() instanceof Var); negatedProperties .add((URI) ((ValueConstant) compare.getRightArg()).getValue()); } else { fail("Unsupported path expression. Check condition node: ", condition); } } }
this.dispose(); try { new Compare().C_Main(time_then); } catch (ParseException e) {
@Override public void meet(Compare cmp) throws RuntimeException { optypes.push(new OPTypeFinder(cmp).coerce()); cmp.getLeftArg().visit(this); builder.append(getSQLOperator(cmp.getOperator())); cmp.getRightArg().visit(this); optypes.pop(); }
@Override public Compare visit(ASTCompare node, Object data) throws VisitorException { ValueExpr leftArg = (ValueExpr)node.jjtGetChild(0).jjtAccept(this, null); ValueExpr rightArg = (ValueExpr)node.jjtGetChild(1).jjtAccept(this, null); return new Compare(leftArg, rightArg, node.getOperator()); }
private void extractNegatedProperties(final ValueExpr condition, final Set<URI> negatedProperties) { if (condition instanceof And) { final And and = (And) condition; extractNegatedProperties(and.getLeftArg(), negatedProperties); extractNegatedProperties(and.getRightArg(), negatedProperties); } else if (condition instanceof Compare) { final Compare compare = (Compare) condition; check(compare.getOperator() == CompareOp.NE, "Invalid path expression"); if (compare.getLeftArg() instanceof ValueConstant) { check(compare.getRightArg() instanceof Var, "Invalid path expression"); negatedProperties.add((URI) ((ValueConstant) compare.getLeftArg()).getValue()); } else if (compare.getRightArg() instanceof ValueConstant) { check(compare.getLeftArg() instanceof Var, "Invalid path expression"); negatedProperties .add((URI) ((ValueConstant) compare.getRightArg()).getValue()); } else { fail("Unsupported path expression. Check condition node: ", condition); } } }
public GroupBuilder<T, E> filter(String theVar, Compare.CompareOp theOp, Value theValue) { Compare aComp = new Compare(new Var(theVar), new ValueConstant(theValue), theOp); mGroup.addFilter(aComp); return this; }