import org.openrdf.query.algebra.Slice; //导入依赖的package包/类
public CloseableIteration evaluate(Slice slice, BindingSet bindings)
        throws QueryEvaluationException {
    CloseableIteration result = evaluate(slice.getArg(), bindings);
    if (slice.hasOffset()) {
        result = new OffsetIteration(result, slice.getOffset());
    }
    if (slice.hasLimit()) {
        result = new LimitIteration(result, slice.getLimit());
    }
    return result;
}
 

import org.openrdf.query.algebra.Slice; //导入依赖的package包/类
@Override
public void meet(Slice arg0) throws SparqlParserException
{
   /*
    * Basically this method does nothing. It just passes the next TupleExpr
    * to the next handler. Query modifiers have been handled when constructing
    * the SelectQuery object initially.
    */
   arg0.getArg().visit(this);
}
 

import org.openrdf.query.algebra.Slice; //导入依赖的package包/类
private void addModifiersIfExist(ParsedQuery query)
{
   TupleExpr expr = query.getTupleExpr();
   if (expr instanceof Slice) {
      Slice sliceExpr = (Slice) expr;
      mQueryModifiers.setLimit((int) sliceExpr.getLimit());
      mQueryModifiers.setOffset((int) sliceExpr.getOffset());
   }
}
 

import org.openrdf.query.algebra.Slice; //导入依赖的package包/类
@Override
public void meet(Slice node) throws RuntimeException {
    if(node.hasLimit())
        limit = node.getLimit();
    if(node.hasOffset())
        offset = node.getOffset();
}
 

import org.openrdf.query.algebra.Slice; //导入依赖的package包/类
@Override
public void meet(Slice node) throws RuntimeException {
	setSeen(node);
	super.meet(node);
}
 

import org.openrdf.query.algebra.Slice; //导入依赖的package包/类
@Override
public void meet(Slice node) throws RuntimeException {
	check(node);
	super.meet(node);
}
 

import org.openrdf.query.algebra.Slice; //导入依赖的package包/类
@Override
public void meet(final Slice node) {
    cardinality = node.getLimit();
}
 

import org.openrdf.query.algebra.Slice; //导入依赖的package包/类
@Override
public CloseableIteration<BindingSet, QueryEvaluationException> evaluate(final Slice expr,
        final BindingSet bindings) throws QueryEvaluationException {
    return delegate(expr, bindings);
}
 

import org.openrdf.query.algebra.Slice; //导入依赖的package包/类
@Override
public void meet(final Slice n) {
    emit(Query.create(n, null, SPARQLRenderer.this.forceSelect));
}
 

import org.openrdf.query.algebra.Slice; //导入依赖的package包/类
private static List<UnaryTupleOperator> extractQueryNodes(final TupleExpr rootNode,
        final boolean haltOnGroup) {
    final List<UnaryTupleOperator> nodes = Lists.newArrayList();

    TupleExpr queryNode = rootNode;
    while (queryNode instanceof UnaryTupleOperator) {
        nodes.add((UnaryTupleOperator) queryNode);
        queryNode = ((UnaryTupleOperator) queryNode).getArg();
    }

    boolean describeFound = false;
    boolean modifierFound = false;
    boolean projectionFound = false;
    boolean groupFound = false;
    boolean orderFound = false;
    boolean sliceFound = false;
    boolean extensionFound = false;

    int index = 0;
    while (index < nodes.size()) {
        final UnaryTupleOperator node = nodes.get(index);
        if (node instanceof DescribeOperator && !describeFound) {
            describeFound = true;

        } else if ((node instanceof Distinct || node instanceof Reduced) && !modifierFound
                && !projectionFound) {
            modifierFound = true;

        } else if ((node instanceof Projection || node instanceof MultiProjection)
                && !projectionFound) {
            projectionFound = true;

        } else if (node instanceof Group && !groupFound && !haltOnGroup) {
            groupFound = true;

        } else if (node instanceof Order && !orderFound) {
            orderFound = true;

        } else if (node instanceof Slice && !sliceFound) {
            sliceFound = true;

        } else if (node instanceof Filter && !groupFound && !haltOnGroup) {
            int i = index + 1;
            for (; i < nodes.size() && nodes.get(i) instanceof Extension;) {
                ++i;
            }
            if (i < nodes.size() && nodes.get(i) instanceof Group) {
                groupFound = true;
                index = i;
            } else {
                break;
            }

        } else if (node instanceof Extension && !extensionFound) {
            extensionFound = true;

        } else if (!(node instanceof QueryRoot) || index > 0) {
            break;
        }
        ++index;
    }

    return nodes.subList(0, index);
}
 

import org.openrdf.query.algebra.Slice; //导入依赖的package包/类
@Override
public void meet(Slice arg0) throws Exception {
	arg0.visitChildren(this);
}