import org.apache.jena.sparql.expr.ExprList; //导入依赖的package包/类
/**
 * Makes the plan for a SPARQL SELECTOR clause.
 *
 * @param elementIterator the SPARQL SELECTOR
 * @return -
 */
static IteratorPlan makeIteratorPlan(
        final ElementIterator elementIterator)
        throws SPARQLGenerateException {
    Objects.requireNonNull(elementIterator, "The Iterator must not be null");

    Var var = elementIterator.getVar();
    Expr expr = elementIterator.getExpr();

    Objects.requireNonNull(var, "The variable of the Iterator must not be null");
    Objects.requireNonNull(expr, "The Expr in the iterator must not be null");
    checkIsTrue(expr.isFunction(), "Iterator should be a function:"
            + " <iri>(...) AS ?var");

    ExprFunction function = expr.getFunction();
    String iri = function.getFunctionIRI();

    IteratorFunctionFactory factory = sr.get(iri);
    if (factory == null) {
        throw new SPARQLGenerateException("Unknown Iterator Function: " + iri);
    }
    IteratorFunction iterator = factory.create(iri);
    ExprList exprList = new ExprList(function.getArgs());
    iterator.build(exprList);
    return new IteratorPlanImpl(iterator, exprList, var);
}
 

import org.apache.jena.sparql.expr.ExprList; //导入依赖的package包/类
@Override
public void exec(
        Binding binding, ExprList args, FunctionEnv env, Consumer<List<NodeValue>> nodeValuesStream) {
    this.env = env;
    if (args == null) {
        throw new ARQInternalErrorException("IteratorFunctionBase:"
                + " Null args list");
    }

    List<NodeValue> evalArgs = new ArrayList<>();
    for (Expr e : args) {
        NodeValue x = e.eval(binding, env);
        evalArgs.add(x);
    }

    exec(evalArgs, nodeValuesStream);
    arguments = null;
}
 

import org.apache.jena.sparql.expr.ExprList; //导入依赖的package包/类
private Expr normalize(ExprFunctionN func) {
    ExprList args = new ExprList();
    for (Expr expr : func.getArgs()) {
        Expr arg = normalize(expr);
        args.add(arg);
    }
    return func.copy(args);
}
 

import org.apache.jena.sparql.expr.ExprList; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public void checkBuild(ExprList args) {
    if (args.size() != 1) {
        throw new QueryBuildException("Selector '"
                + this.getClass().getName() + "' takes one argument");
    }
}
 

import org.apache.jena.sparql.expr.ExprList; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public void checkBuild(ExprList args) {
    if (args.size() != 3) {
        throw new QueryBuildException("Selector '"
                + this.getClass().getName() + "' takes three arguments");
    }
}
 

import org.apache.jena.sparql.expr.ExprList; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public void checkBuild(ExprList args) {
    if (args.size() != 0) {
        throw new QueryBuildException("Iterator function '"
                + this.getClass().getName() + "' takes no arguments");
    }
}
 

import org.apache.jena.sparql.expr.ExprList; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public void checkBuild(ExprList args) {
    if (args.size() != 5) {
        throw new QueryBuildException("Selector '"
                + this.getClass().getName() + "' takes 5 arguments");
    }
}
 

import org.apache.jena.sparql.expr.ExprList; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public void checkBuild(ExprList args) {
    if (args.size() != 2) {
        throw new QueryBuildException("Selector '"
                + this.getClass().getName() + "' takes two arguments");
    }
}
 

import org.apache.jena.sparql.expr.ExprList; //导入依赖的package包/类
/** Execute a BGP (and filters) on a LDF graph, which may be in default storage or it may be a named graph */
private static QueryIterator executeBGP(LinkedDataFragmentGraph graph, OpBGP opBGP, QueryIterator input, ExprList exprs,
                                        ExecutionContext execCxt)
{
    // Execute a BGP on the real default graph
    return optimizeExecuteTriples(graph, input, opBGP.getPattern(), exprs, execCxt) ;
}
 

import org.apache.jena.sparql.expr.ExprList; //导入依赖的package包/类
/** Function called on each row in a group */
@Override
public void accumulate(Binding binding, FunctionEnv functionEnv) {
    ExprList exprList = agg.getExprList() ;
    for(Expr expr: exprList) {
        try {
            NodeValue nv = expr.eval(binding, functionEnv) ;
            // Evaluation succeeded.
            if ( nv.isLiteral())
                count ++ ;
        } catch (ExprEvalException ex) {}
    }
}
 

import org.apache.jena.sparql.expr.ExprList; //导入依赖的package包/类
@Override
public NodeValue exec(Binding binding, ExprList args, String uri, FunctionEnv env) {
	if (args == null) {
		throw new ARQInternalErrorException("ExpandPrefixFunction: Null args list");
	}
	if (args.size() != 1) {
		throw new ExprEvalException("ExpandPrefixFunction: Wrong number of arguments: Wanted 1, got " + args.size());
	}
       return exec(args.get(0).eval(binding, env), env.getContext());
}
 

import org.apache.jena.sparql.expr.ExprList; //导入依赖的package包/类
public boolean addExprToExprList() {
    ((ExprList) peek(1)).add((Expr) pop());
    return true;
}
 

import org.apache.jena.sparql.expr.ExprList; //导入依赖的package包/类
@Override
public void checkBuild(String uri, ExprList args) {
    if (args.size() != 6) {
        throw new QueryBuildException("Function '" + Lib.className(this) + "' takes two arguments");
    }
}
 

import org.apache.jena.sparql.expr.ExprList; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public void checkBuild(ExprList args) {
}
 

import org.apache.jena.sparql.expr.ExprList; //导入依赖的package包/类
@Override
   public void build(String uri, ExprList args) {
}
 

import org.apache.jena.sparql.expr.ExprList; //导入依赖的package包/类
@Override
public void build(String uri, ExprList args) {
	if (args.size() != 1) {
		throw new QueryBuildException("Function '" + Lib.className(this) + "' takes one argument");
	}
}
 

import org.apache.jena.sparql.expr.ExprList; //导入依赖的package包/类
/**
 * The constructor.
 *
 * @param s - The SPARQL-Generate iterator function.
 * @param e - The list of expressions on which to evaluate the
 * iterator function.
 * @param v - The variable that will be bound to each result of the iterator
 *  function evaluation.
 */
public IteratorPlanImpl(
        final IteratorFunction s,
        final ExprList e,
        final Var v) {
    this.iterator = s;
    this.exprList = e;
    this.var = v;
}
 

import org.apache.jena.sparql.expr.ExprList; //导入依赖的package包/类
/**
 * Called during query plan construction immediately after the construction
 * of the extension instance. Can throw ExprBuildException if something is
 * wrong (like wrong number of arguments).
 *
 * @param args The parsed arguments
 */
void build(ExprList args);
 

import org.apache.jena.sparql.expr.ExprList; //导入依赖的package包/类
/**
 * Test a list of values - argument will not be null but may have the wrong
 * number of arguments. FunctionBase provides a more convenient way to
 * implement a function. Can throw ExprEvalsException if something goes
 * wrong.
 *
 * @param binding The current solution
 * @param args A list of unevaluated expressions
 * @param env The execution context
 * @param nodeValuesStream where to emit new values
 */
void exec(Binding binding, ExprList args, FunctionEnv env, Consumer<List<NodeValue>> nodeValuesStream);
 

import org.apache.jena.sparql.expr.ExprList; //导入依赖的package包/类
/**
 * Build a iterator function execution with the given arguments,
 * and operate a check of the build.
 * @param args -
 * @throws QueryBuildException if the iterator function cannot be
 * executed with the
 * given arguments.
 */
@Override
public final void build(ExprList args) {
    arguments = args;
    checkBuild(args);
}