@Override public void visit(OpAssign op) { processExtend(op, op.getSubOp(), op.getVarExprList()); }
@Override public Op transform(OpAssign opAssign, Op subOp) { if (subOp instanceof OpAssign) { // If a variable is assigned twice, don't do anything. // (assign (?x 2) (assign (?x 1) op)) => leave alone. // This is the safest option in a rare case. // It would be OK if addAll does a replacement without checking // but having it check and complain about duplicates adds robustness. // In OpExtend, it's actually illegal. OpAssign x = (OpAssign)subOp ; VarExprList outerVarExprList = opAssign.getVarExprList() ; VarExprList innerVarExprList = new VarExprList(x.getVarExprList()) ; // Copy Op r = OpAssign.assign(x.getSubOp(), innerVarExprList) ; // This contains an "if already (assign)" test. r = OpAssign.assign(r, outerVarExprList) ; return r ; } return super.transform(opAssign, subOp); }
@Override public void visit(OpAssign opAssign) { VarExprList varExpr = opAssign.getVarExprList() ; VarExprList varExpr2 = collect(varExpr) ; OpAssign opAssign2 = opAssign ; if ( varExpr != varExpr2 ) opAssign2 = OpAssign.create(opAssign.getSubOp(), varExpr2) ; visit1(opAssign2) ; }
/** Create an OpAssign or add to an existing one. * This cooperation collapses what would otherwise be stacks * of OpExtend. */ static public Op assign(Op op, Var var, Expr expr) { if ( !(op instanceof OpAssign) ) return create(op, var, expr) ; OpAssign opAssign = (OpAssign)op ; if ( opAssign.assignments.contains(var) ) // Same variable : // Layer one assignment over the top of another return create(op, var, expr) ; opAssign.add(var, expr) ; return opAssign ; }
@Override public void visit(OpAssign opAssign) { // Unknown position unknownAcc.addAll(opAssign.getVarExprList().getVars()) ; }
/** * rewrites the subop of assign. */ @Override public void visit(final OpAssign opAssign) { if (LOG.isDebugEnabled()) { LOG.debug("Starting visiting OpAssign"); } addOp(OpAssign.assign(rewriteOp1(opAssign), opAssign.getVarExprList())); }
@Override public Op transform(OpAssign opAssign, Op subOp) { VarExprList assignments = processAssignments(opAssign); if (assignments == null) return super.transform(opAssign, subOp); // Rewrite appropriately if (this.topmostOnly) { // If topmost only ignore any transformations lower down the tree // hence call getSubOp() rather than using the provided subOp if (assignments.size() > 0) { return OpAssign.assign(opAssign.getSubOp(), assignments); } else { return opAssign.getSubOp(); } } else { // Otherwise preserve any transformations from lower down the tree if (assignments.size() > 0) { return OpAssign.assign(subOp, assignments); } else { return subOp; } } }
@Override public Op1 copy(Op subOp) { OpAssign op = new OpAssign(subOp, new VarExprList(getVarExprList())) ; return op ; }
private static Op subst(Op subOp, Var find, Var replace) { Op op = Substitute.substitute(subOp, find, replace); return OpAssign.assign(op, find, new ExprVar(replace)); } }
/** Create an v or add to an existing one. * This operation collapses what would otherwise be stacks * of OpAssign. */ static public Op assign(Op op, VarExprList exprs) { if ( !(op instanceof OpAssign) ) return create(op, exprs) ; OpAssign opAssign = (OpAssign)op ; for (Var var : exprs.getVars()) { if ( opAssign.assignments.contains(var) ) return create(op, exprs) ; } opAssign.assignments.addAll(exprs) ; return opAssign ; }
@Override public OpExtendAssign copy(Op subOp, VarExprList varExprList) { return new OpAssign(subOp, varExprList) ; } }
private static void processAssigns(List<OpAssign> assigns, BiConsumer<Var, Expr> action) { assigns.forEach(assign->{ assign.getVarExprList().forEachExpr(action) ; }); }
@Override public Op transform(OpAssign opAssign, Op subOp) { VarExprList varExprList2 = transformVarExprList(opAssign.getVarExprList()); if ( varExprList2.isEmpty() ) return subOp; return OpAssign.assign(subOp, varExprList2); }
@Override public void visit(OpAssign opAssign) { Element e = asElement(opAssign.getSubOp()) ; // If (assign ... (table unit)), and first in group, don't add the empty group. insertIntoGroup(currentGroup(), e) ; processAssigns(Arrays.asList(opAssign), (var,expr)->{ currentGroup().addElement(new ElementAssign(var,expr)) ; }) ; }
private static Op subst(Op subOp, Var find, Var replace) { Op op = Substitute.substitute(subOp, find, replace); return OpAssign.assign(op, find, new ExprVar(replace)); } }
@Override public Op make(ItemList list) { BuilderLib.checkLength(3, list, "assign") ; VarExprList x = BuilderExpr.buildNamedExprOrExprList(list.get(1)) ; Op sub ; if ( list.size() == 2 ) sub = OpTable.unit() ; else sub = build(list, 2) ; return OpAssign.create(sub, x) ; } } ;
/** Make a OpAssign - this does not aggregate (assign .. (assign ...)) */ public static OpAssign create(Op op, VarExprList exprs) { return new OpAssign(op, exprs) ; }
public Op getApplicableViews(OpAssign op, RestrictionManagerImpl _restrictions) { Op result = processOpExtend(op.getSubOp(), op.getVarExprList(), _restrictions); return result; }
@Override public void visit(OpAssign opAssign) { opAssign.getSubOp().visit(this); push(OpAssign.assign(pop(), rewrite(opAssign.getVarExprList()))); }