import com.hp.hpl.jena.sparql.algebra.op.Op2; //导入依赖的package包/类
private void wrapInCurrentFilterAndRecurse(Op2 op2) {
	List<Expr> retainedFilterExpr = new ArrayList<Expr>(filterExpr);
	filterExpr.clear();
	Op left = null;
	if (op2.getLeft() != null) {
		op2.getLeft().visit(this);
		left = stack.pop();
	}
	Op right = null;
	if (op2.getRight() != null) {
		op2.getRight().visit(this);
		right = stack.pop();
	}
	wrapInFilter(op2.apply(copy, left, right), retainedFilterExpr);
	filterExpr = retainedFilterExpr;
}
 

import com.hp.hpl.jena.sparql.algebra.op.Op2; //导入依赖的package包/类
@Override
   protected void visit2(Op2 op) {
if (op.getLeft() != null)
    op.getLeft().visit(this);
if (op.getRight() != null)
    op.getRight().visit(this);
op.visit(visitor);
   }
 

import com.hp.hpl.jena.sparql.algebra.op.Op2; //导入依赖的package包/类
@Override
protected void visit2(Op2 op)
{
	if ( topDown ) op.visit(visitor);
	if ( op.getLeft() != null ) op.getLeft().visit(this);
	if ( op.getRight() != null ) op.getRight().visit(this);
	if ( !topDown ) op.visit(visitor);
}
 

import com.hp.hpl.jena.sparql.algebra.op.Op2; //导入依赖的package包/类
/**
 * Checks first if a filterexpression can be moved down. And after visits
 * the operator
 */
private void checkMoveDownFilterExprAndVisitOpDiff(Op2 opDiff) {
	Op left = null;
	Op right = null;
	Op newOp;
	List<Expr> filterExprBeforeOpUnionOpJoin, filterExprAfterOpUnionOpJoin, notMoveableFilterExpr;

	// contains the filterexpressions that are valid before this op2
	filterExprBeforeOpUnionOpJoin = new ArrayList<Expr>(this.filterExpr);
	// contains the filterexpressions that are valid after this op2
	// this is needed because during the bottom-up-stepping all
	// filterexpressions
	// which could not be transformed down, must be inserted by means of an
	// OpFilter
	// above this op2
	filterExprAfterOpUnionOpJoin = new ArrayList<Expr>();

	// check left subtree
	if ((left = opDiff.getLeft()) != null) {
		// calculate the set of filterexpressions that are also valid for
		// the
		// left subtree
		this.filterExpr = calcValidFilterExpr(
				filterExprBeforeOpUnionOpJoin, left);
		filterExprAfterOpUnionOpJoin.addAll(this.filterExpr);
		// step down
		opDiff.getLeft().visit(this);
		left = stack.pop();
	}

	// check the right subtree
	if ((right = opDiff.getRight()) != null) {
		// calculate the set of filterexpressions that are also valid for
		// the
		// right subtree
		this.filterExpr = calcValidFilterExpr(
				filterExprBeforeOpUnionOpJoin, right);
		filterExprAfterOpUnionOpJoin.addAll(this.filterExpr);
		// step down
		opDiff.getRight().visit(this);
		right = stack.pop();
	}

	// note: filterExprAfterOpUnion contains now all filterexpressions which
	// could
	// be moved down
	// now calculate all filterexpressions which were not moveable
	notMoveableFilterExpr = new ArrayList<Expr>(
			filterExprBeforeOpUnionOpJoin);
	notMoveableFilterExpr.removeAll(filterExprAfterOpUnionOpJoin);

	// if there are some filterexpressions which could not be moved down,
	// an opFilter must be inserted that contains this filterexpressions
	if (!notMoveableFilterExpr.isEmpty()) {
		// create the filter
		newOp = OpFilter.filter(OpDiff.create(left, right));
		// add the conditions
		((OpFilter) newOp).getExprs().getList()
				.addAll(notMoveableFilterExpr);
	} else {
		// nothing must be done
		newOp = opDiff;
	}

	// restore filterexpressions
	this.filterExpr = filterExprBeforeOpUnionOpJoin;

	this.stack.push(newOp);
}
 

import com.hp.hpl.jena.sparql.algebra.op.Op2; //导入依赖的package包/类
private Op substitute(Op2 op, Op left, Op right) {
	if (op.getLeft() == left && op.getRight() == right)
		return op;
	return op.copy(left, right);
}