This is an automated email from the ASF dual-hosted git repository. andy pushed a commit to branch main in repository https://gitbox.apache.org/repos/asf/jena.git
commit ca35fdad2cfcb5161bfae7616c32a066b343f98f Author: Andy Seaborne <[email protected]> AuthorDate: Fri Feb 6 09:19:23 2026 +0000 Tidy semicolons in sparql/expr --- .../java/org/apache/jena/sparql/expr/E_Call.java | 4 +- .../org/apache/jena/sparql/expr/E_OneOfBase.java | 4 +- .../java/org/apache/jena/sparql/expr/E_Regex.java | 6 +- .../apache/jena/sparql/expr/E_StrSubstring.java | 2 +- .../java/org/apache/jena/sparql/expr/Expr.java | 60 +++++----- .../org/apache/jena/sparql/expr/ExprBuild.java | 14 +-- .../apache/jena/sparql/expr/ExprEvalException.java | 10 +- .../jena/sparql/expr/ExprEvalTypeException.java | 8 +- .../org/apache/jena/sparql/expr/ExprException.java | 10 +- .../org/apache/jena/sparql/expr/ExprFunction0.java | 2 +- .../org/apache/jena/sparql/expr/ExprFunction2.java | 97 +++++++-------- .../org/apache/jena/sparql/expr/ExprFunctionN.java | 6 +- .../apache/jena/sparql/expr/ExprFunctionOp.java | 8 +- .../java/org/apache/jena/sparql/expr/ExprLib.java | 38 +++--- .../java/org/apache/jena/sparql/expr/ExprList.java | 130 ++++++++++----------- .../java/org/apache/jena/sparql/expr/ExprNone.java | 20 ++-- .../sparql/expr/ExprNotComparableException.java | 2 +- .../org/apache/jena/sparql/expr/ExprTransform.java | 22 ++-- .../apache/jena/sparql/expr/ExprTransformBase.java | 22 ++-- .../apache/jena/sparql/expr/ExprTransformCopy.java | 82 ++++++------- .../jena/sparql/expr/ExprTransformSubstitute.java | 4 +- .../apache/jena/sparql/expr/ExprTransformer.java | 20 ++-- .../apache/jena/sparql/expr/ExprTripleTerm.java | 10 +- .../apache/jena/sparql/expr/ExprTypeException.java | 8 +- .../jena/sparql/expr/ExprUndefException.java | 8 +- .../apache/jena/sparql/expr/ExprUndefFunction.java | 2 +- .../java/org/apache/jena/sparql/expr/ExprVars.java | 58 ++++----- .../org/apache/jena/sparql/expr/ExprVisitor.java | 24 ++-- .../jena/sparql/expr/ExprVisitorFunction.java | 12 +- .../org/apache/jena/sparql/expr/FunctionLabel.java | 6 +- .../org/apache/jena/sparql/expr/NVCompare.java | 96 +++++++-------- .../java/org/apache/jena/sparql/expr/NVOps.java | 4 +- .../org/apache/jena/sparql/expr/RegexEngine.java | 2 +- .../org/apache/jena/sparql/expr/ValueSpace.java | 44 +++---- .../sparql/expr/VariableNotBoundException.java | 8 +- .../sparql/expr/aggregate/AggSampleDistinct.java | 2 +- .../jena/sparql/expr/aggregate/Aggregator.java | 2 +- .../jena/sparql/expr/nodevalue/NodeFunctions.java | 54 ++++----- .../sparql/expr/urifunctions/SPARQLFuncOp.java | 4 +- 39 files changed, 460 insertions(+), 455 deletions(-) diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_Call.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_Call.java index 462a54f05f..5edf92011e 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_Call.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_Call.java @@ -93,9 +93,9 @@ public class E_Call extends ExprFunctionN { throw new ExprEvalException("CALL: Function identifier unbound"); if ( func.isIRI() ) { ExprList a = new ExprList(); - for ( int i = 1 ; i < args.size() ; i++ ) + for ( int i = 1; i < args.size(); i++ ) a.add(args.get(i)); - // Expr e = null ; + // Expr e = null; Expr e = new E_Function(func.getNode().getURI(), a); // Calling this may throw an error which we will just let bubble up return e.eval(null, env); diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_OneOfBase.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_OneOfBase.java index 9d04f9ff08..a87b83bf15 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_OneOfBase.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_OneOfBase.java @@ -60,8 +60,8 @@ public abstract class E_OneOfBase extends ExprFunctionN { return possibleValues; } -// public Expr getLHS() { return expr ; } -// public ExprList getRHS() { return possibleValues ; } +// public Expr getLHS() { return expr; } +// public ExprList getRHS() { return possibleValues; } protected boolean evalOneOf(Binding binding, FunctionEnv env) { // Special form. diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_Regex.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_Regex.java index dfb1a54d88..3e7a56e7d5 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_Regex.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_Regex.java @@ -117,13 +117,13 @@ public class E_Regex extends ExprFunctionN { } // /** @return Returns the expr of the regex */ -// public final Expr getRegexExpr() { return expr1 ; } +// public final Expr getRegexExpr() { return expr1; } // // /** @return Returns the pattern. */ -// public final Expr getPattern() { return expr2 ; } +// public final Expr getPattern() { return expr2; } // // /** @return Returns the flags. */ -// public final Expr getFlags() { return expr3 ; } +// public final Expr getFlags() { return expr3; } @Override public Expr copy(ExprList newArgs) { diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_StrSubstring.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_StrSubstring.java index 0f847755d1..9739ab64da 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_StrSubstring.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_StrSubstring.java @@ -38,7 +38,7 @@ public class E_StrSubstring extends ExprFunctionN { if ( args.size() == 2 ) return XSDFuncOp.substring(args.get(0), args.get(1)); - // return NodeFunctions.substring(args.get(0), args.get(1), args.get(2)) ; + // return NodeFunctions.substring(args.get(0), args.get(1), args.get(2)); return XSDFuncOp.substring(args.get(0), args.get(1), args.get(2)); } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/Expr.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/Expr.java index 0c51c46b8c..ad85c98f3a 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/Expr.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/Expr.java @@ -21,25 +21,25 @@ package org.apache.jena.sparql.expr; -import java.util.Set ; +import java.util.Set; -import javax.xml.datatype.DatatypeConstants ; +import javax.xml.datatype.DatatypeConstants; -import org.apache.jena.sparql.core.Var ; -import org.apache.jena.sparql.engine.binding.Binding ; -import org.apache.jena.sparql.function.FunctionEnv ; +import org.apache.jena.sparql.core.Var; +import org.apache.jena.sparql.engine.binding.Binding; +import org.apache.jena.sparql.function.FunctionEnv; import org.apache.jena.sparql.graph.NodeTransform; public interface Expr { - public static final Expr NONE = ExprNone.NONE0 ; + public static final Expr NONE = ExprNone.NONE0; - public static final int CMP_GREATER = DatatypeConstants.GREATER ; - public static final int CMP_EQUAL = DatatypeConstants.EQUAL ; - public static final int CMP_LESS = DatatypeConstants.LESSER ; + public static final int CMP_GREATER = DatatypeConstants.GREATER; + public static final int CMP_EQUAL = DatatypeConstants.EQUAL; + public static final int CMP_LESS = DatatypeConstants.LESSER; - public static final int CMP_UNEQUAL = -9 ; - public static final int CMP_INDETERMINATE = DatatypeConstants.INDETERMINATE ; + public static final int CMP_UNEQUAL = -9; + public static final int CMP_INDETERMINATE = DatatypeConstants.INDETERMINATE; /** * Test whether a constraint is satisfied, given a set of bindings. Includes @@ -51,55 +51,55 @@ public interface Expr * @param execCxt FunctionEnv * @return true or false */ - public boolean isSatisfied(Binding binding, FunctionEnv execCxt) ; + public boolean isSatisfied(Binding binding, FunctionEnv execCxt); /** * Variables used by this expression. * @see ExprVars#getVarNamesMentioned * @see ExprVars#getNonOpVarNamesMentioned */ - public Set<Var> getVarsMentioned() ; + public Set<Var> getVarsMentioned(); /** * Evaluate this expression against the binding * @param binding * @param env */ - public NodeValue eval(Binding binding, FunctionEnv env) ; + public NodeValue eval(Binding binding, FunctionEnv env); /** Deep copy with substitution */ - public Expr copySubstitute(Binding binding) ; + public Expr copySubstitute(Binding binding); /** * Rewrite, applying a node{@literal ->}node transformation */ - public Expr applyNodeTransform(NodeTransform transform) ; + public Expr applyNodeTransform(NodeTransform transform); /** Deep copy */ - public Expr deepCopy() ; + public Expr deepCopy(); /** Answer whether this is a variable. */ - public boolean isVariable() ; + public boolean isVariable(); /** Variable name (returns null if not a variable) */ - public String getVarName() ; + public String getVarName(); /** Variable (or null) */ - public ExprVar getExprVar() ; + public ExprVar getExprVar(); /** Convert to a Var variable.*/ - public Var asVar() ; + public Var asVar(); /** Answer whether this is a constant expression - false includes "don't know" * No constant folding so "false" from an expression that evaluates to a constant */ - public boolean isConstant() ; + public boolean isConstant(); /** NodeValue constant (returns null if not a constant) */ - public NodeValue getConstant() ; + public NodeValue getConstant(); /** Answer whether this is a function. */ - public boolean isFunction() ; + public boolean isFunction(); /** Get the function (returns null if not a function) */ - public ExprFunction getFunction() ; + public ExprFunction getFunction(); - public void visit(ExprVisitor visitor) ; + public void visit(ExprVisitor visitor); /** * <code>Expr</code> are used in both syntax and algebra. There is no syntax @@ -123,13 +123,13 @@ public interface Expr * Hence, different {@code hashCode} {@literal =>} not {@code equalsBySyntax}. */ @Override - public int hashCode() ; + public int hashCode(); @Override - public boolean equals(Object other) ; + public boolean equals(Object other); - public boolean equalsBySyntax(Expr other) ; + public boolean equalsBySyntax(Expr other); /** General equality operation - consider this to be 'protected' */ - public boolean equals(Expr other, boolean bySyntax) ; + public boolean equals(Expr other, boolean bySyntax); } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprBuild.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprBuild.java index 95662926a1..2bd10570e6 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprBuild.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprBuild.java @@ -21,17 +21,17 @@ package org.apache.jena.sparql.expr; -import org.apache.jena.sparql.engine.OpEval ; -import org.apache.jena.sparql.util.Context ; +import org.apache.jena.sparql.engine.OpEval; +import org.apache.jena.sparql.util.Context; /** Visitor class to run over expressions and initialise them */ public class ExprBuild extends ExprVisitorBase { - private Context context ; - private OpEval opExec ; + private Context context; + private OpEval opExec; public ExprBuild(Context context) { - this.context = context ; + this.context = context; } @Override @@ -40,8 +40,8 @@ public class ExprBuild extends ExprVisitorBase if ( func instanceof E_Function ) { // Causes unbindable functions to complain now, not later. - E_Function f = (E_Function)func ; - f.buildFunction(context) ; + E_Function f = (E_Function)func; + f.buildFunction(context); } } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprEvalException.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprEvalException.java index 64fd367775..6faf701144 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprEvalException.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprEvalException.java @@ -33,10 +33,10 @@ public class ExprEvalException extends ExprException // exception. But if we are using exception for flow control, we don't // need the stack trace. - @Override public Throwable fillInStackTrace() { return this ; } + @Override public Throwable fillInStackTrace() { return this; } - public ExprEvalException() { super() ; } - public ExprEvalException(Throwable cause) { super(cause) ; } - public ExprEvalException(String msg) { super(msg) ; } - public ExprEvalException(String msg, Throwable cause) { super(msg, cause) ; } + public ExprEvalException() { super(); } + public ExprEvalException(Throwable cause) { super(cause); } + public ExprEvalException(String msg) { super(msg); } + public ExprEvalException(String msg, Throwable cause) { super(msg, cause); } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprEvalTypeException.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprEvalTypeException.java index f67564c2a9..522af0895a 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprEvalTypeException.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprEvalTypeException.java @@ -25,8 +25,8 @@ package org.apache.jena.sparql.expr; public class ExprEvalTypeException extends ExprEvalException { - public ExprEvalTypeException() { super() ; } - public ExprEvalTypeException(Throwable cause) { super(cause) ; } - public ExprEvalTypeException(String msg) { super(msg) ; } - public ExprEvalTypeException(String msg, Throwable cause) { super(msg, cause) ; } + public ExprEvalTypeException() { super(); } + public ExprEvalTypeException(Throwable cause) { super(cause); } + public ExprEvalTypeException(String msg) { super(msg); } + public ExprEvalTypeException(String msg, Throwable cause) { super(msg, cause); } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprException.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprException.java index 9c1309c889..79ed3895f1 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprException.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprException.java @@ -20,16 +20,16 @@ */ package org.apache.jena.sparql.expr; -import org.apache.jena.query.QueryException ; +import org.apache.jena.query.QueryException; /** The root of all expression exceptions */ public class ExprException extends QueryException { - public ExprException() { super() ; } - public ExprException(Throwable cause) { super(cause) ; } - public ExprException(String msg) { super(msg) ; } - public ExprException(String msg, Throwable cause) { super(msg, cause) ; } + public ExprException() { super(); } + public ExprException(Throwable cause) { super(cause); } + public ExprException(String msg) { super(msg); } + public ExprException(String msg, Throwable cause) { super(msg, cause); } private static final long serialVersionUID = 1L; // Unused } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunction0.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunction0.java index 4db12c875c..4546b0d166 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunction0.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunction0.java @@ -51,7 +51,7 @@ public abstract class ExprFunction0 extends ExprFunction return eval(env); } - public abstract NodeValue eval(FunctionEnv env) ; + public abstract NodeValue eval(FunctionEnv env); @Override final public Expr applyNodeTransform(NodeTransform transform) { diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunction2.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunction2.java index 1ec772b50f..afaa1db503 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunction2.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunction2.java @@ -21,9 +21,9 @@ package org.apache.jena.sparql.expr; -import org.apache.jena.atlas.lib.Lib ; -import org.apache.jena.sparql.engine.binding.Binding ; -import org.apache.jena.sparql.function.FunctionEnv ; +import org.apache.jena.atlas.lib.Lib; +import org.apache.jena.sparql.engine.binding.Binding; +import org.apache.jena.sparql.function.FunctionEnv; import org.apache.jena.sparql.graph.NodeTransform; @@ -31,83 +31,88 @@ import org.apache.jena.sparql.graph.NodeTransform; public abstract class ExprFunction2 extends ExprFunction { - protected final Expr expr1 ; - protected final Expr expr2 ; + protected final Expr expr1; + protected final Expr expr2; - protected ExprFunction2(Expr expr1, Expr expr2, String fName) { this(expr1, expr2, fName, null) ; } + protected ExprFunction2(Expr expr1, Expr expr2, String fName) { this(expr1, expr2, fName, null); } - protected ExprFunction2(Expr expr1, Expr expr2, String fName, String opSign) - { - super(fName, opSign) ; - this.expr1 = expr1 ; - this.expr2 = expr2 ; + protected ExprFunction2(Expr expr1, Expr expr2, String fName, String opSign) { + super(fName, opSign); + this.expr1 = expr1; + this.expr2 = expr2; } - public Expr getArg1() { return expr1 ; } - public Expr getArg2() { return expr2 ; } + public Expr getArg1() { + return expr1; + } + + public Expr getArg2() { + return expr2; + } @Override - public Expr getArg(int i) - { + public Expr getArg(int i) { if ( i == 1 ) - return expr1 ; + return expr1; if ( i == 2 ) - return expr2 ; - return null ; + return expr2; + return null; } @Override - public int numArgs() { return 2 ; } + public int numArgs() { + return 2; + } // ---- Evaluation @Override - public int hashCode() - { - return getFunctionSymbol().hashCode() ^ - Lib.hashCodeObject(expr1) ^ - Lib.hashCodeObject(expr2) ; + public int hashCode() { + return getFunctionSymbol().hashCode() ^ Lib.hashCodeObject(expr1) ^ Lib.hashCodeObject(expr2); } @Override - final public NodeValue eval(Binding binding, FunctionEnv env) - { - NodeValue s = evalSpecial(binding, env) ; + final public NodeValue eval(Binding binding, FunctionEnv env) { + NodeValue s = evalSpecial(binding, env); if ( s != null ) - return s ; + return s; - NodeValue x = eval(binding, env, expr1) ; - NodeValue y = eval(binding, env, expr2) ; - return eval(x, y, env) ; + NodeValue x = eval(binding, env, expr1); + NodeValue y = eval(binding, env, expr2); + return eval(x, y, env); } /** Special form evaluation (example, don't eval the arguments first) */ - protected NodeValue evalSpecial(Binding binding, FunctionEnv env) { return null ; } + protected NodeValue evalSpecial(Binding binding, FunctionEnv env) { + return null; + } - public NodeValue eval(NodeValue x, NodeValue y, FunctionEnv env) { return eval(x,y) ; } + public NodeValue eval(NodeValue x, NodeValue y, FunctionEnv env) { + return eval(x, y); + } - public abstract NodeValue eval(NodeValue x, NodeValue y) ; + public abstract NodeValue eval(NodeValue x, NodeValue y); @Override - final public Expr copySubstitute(Binding binding) - { - Expr e1 = (expr1 == null ? null : expr1.copySubstitute(binding)) ; - Expr e2 = (expr2 == null ? null : expr2.copySubstitute(binding)) ; - return copy(e1, e2) ; + final public Expr copySubstitute(Binding binding) { + Expr e1 = (expr1 == null ? null : expr1.copySubstitute(binding)); + Expr e2 = (expr2 == null ? null : expr2.copySubstitute(binding)); + return copy(e1, e2); } @Override - final public Expr applyNodeTransform(NodeTransform transform) - { - Expr e1 = (expr1 == null ? null : expr1.applyNodeTransform(transform)) ; - Expr e2 = (expr2 == null ? null : expr2.applyNodeTransform(transform)) ; - return copy(e1, e2) ; + final public Expr applyNodeTransform(NodeTransform transform) { + Expr e1 = (expr1 == null ? null : expr1.applyNodeTransform(transform)); + Expr e2 = (expr2 == null ? null : expr2.applyNodeTransform(transform)); + return copy(e1, e2); } - public abstract Expr copy(Expr arg1, Expr arg2) ; + public abstract Expr copy(Expr arg1, Expr arg2); @Override - public void visit(ExprVisitor visitor) { visitor.visit(this) ; } + public void visit(ExprVisitor visitor) { + visitor.visit(this); + } public Expr apply(ExprTransform transform, Expr arg1, Expr arg2) { return transform.transform(this, arg1, arg2); diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunctionN.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunctionN.java index 9988ee989b..c5a0a8c18f 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunctionN.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunctionN.java @@ -67,7 +67,7 @@ public abstract class ExprFunctionN extends ExprFunction @Override public Expr copySubstitute(Binding binding) { ExprList newArgs = new ExprList(); - for ( int i = 1 ; i <= numArgs() ; i++ ) { + for ( int i = 1; i <= numArgs(); i++ ) { Expr e = getArg(i); e = e.copySubstitute(binding); newArgs.add(e); @@ -78,7 +78,7 @@ public abstract class ExprFunctionN extends ExprFunction @Override public Expr applyNodeTransform(NodeTransform transform) { ExprList newArgs = new ExprList(); - for ( int i = 1 ; i <= numArgs() ; i++ ) { + for ( int i = 1; i <= numArgs(); i++ ) { Expr e = getArg(i); e = e.applyNodeTransform(transform); newArgs.add(e); @@ -96,7 +96,7 @@ public abstract class ExprFunctionN extends ExprFunction return s; List<NodeValue> argsEval = new ArrayList<>(); - for ( int i = 1 ; i <= numArgs() ; i++ ) { + for ( int i = 1; i <= numArgs(); i++ ) { NodeValue x = eval(binding, env, getArg(i)); argsEval.add(x); } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunctionOp.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunctionOp.java index 1deb89d67c..25b07bc67a 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunctionOp.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunctionOp.java @@ -83,7 +83,7 @@ public abstract class ExprFunctionOp extends ExprFunction @Override public Expr copySubstitute(Binding binding) { - Op op2 = Substitute.substitute(getGraphPattern(), binding) ; + Op op2 = Substitute.substitute(getGraphPattern(), binding); Element elt = getElement(); Element elt2 = null; if (elt != null) { @@ -93,12 +93,12 @@ public abstract class ExprFunctionOp extends ExprFunction ExprTransform exprTransform = new ExprTransformNodeElement(nodeTransform, eltTransform); elt2 = ElementTransformer.transform(elt, eltTransform, exprTransform); } - return copy(elt2, op2) ; + return copy(elt2, op2); } @Override public Expr applyNodeTransform(NodeTransform nodeTransform) { - Op op2 = NodeTransformLib.transform(nodeTransform, getGraphPattern()) ; + Op op2 = NodeTransformLib.transform(nodeTransform, getGraphPattern()); Element elt = getElement(); Element elt2 = null; if (elt != null) { @@ -106,7 +106,7 @@ public abstract class ExprFunctionOp extends ExprFunction ExprTransform exprTransform = new ExprTransformNodeElement(nodeTransform, eltTransform); elt2 = ElementTransformer.transform(elt, eltTransform, exprTransform); } - return copy(elt2, op2) ; + return copy(elt2, op2); } protected abstract Expr copy(Element elt, Op op); diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprLib.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprLib.java index 7ceaec6989..0f1420b4a7 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprLib.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprLib.java @@ -21,14 +21,14 @@ package org.apache.jena.sparql.expr; -import org.apache.jena.graph.Node ; +import org.apache.jena.graph.Node; import org.apache.jena.graph.Triple; -import org.apache.jena.sparql.ARQInternalErrorException ; -import org.apache.jena.sparql.algebra.optimize.ExprTransformConstantFold ; -import org.apache.jena.sparql.algebra.walker.Walker ; -import org.apache.jena.sparql.core.Var ; -import org.apache.jena.sparql.engine.binding.Binding ; -import org.apache.jena.sparql.function.FunctionEnv ; +import org.apache.jena.sparql.ARQInternalErrorException; +import org.apache.jena.sparql.algebra.optimize.ExprTransformConstantFold; +import org.apache.jena.sparql.algebra.walker.Walker; +import org.apache.jena.sparql.core.Var; +import org.apache.jena.sparql.engine.binding.Binding; +import org.apache.jena.sparql.function.FunctionEnv; public class ExprLib { @@ -39,14 +39,14 @@ public class ExprLib */ public static NodeValue evalOrNull(Expr expr, Binding binding, FunctionEnv functionEnv) { - return evalOrElse(expr, binding, functionEnv, null) ; + return evalOrElse(expr, binding, functionEnv, null); } /** evaluate or throw an exception */ // This post dates a lot of code that uses expr.eval directly. // Placeholder for now. private static NodeValue evalOrException(Expr expr, Binding binding, FunctionEnv functionEnv) { - return expr.eval(binding, functionEnv) ; + return expr.eval(binding, functionEnv); } private static NodeValue evalOrElse(Expr expr, Binding binding, FunctionEnv functionEnv, NodeValue exceptionValue) { @@ -67,21 +67,21 @@ public class ExprLib if ( expr.isConstant() ) // Easy case. - return expr.getConstant() ; + return expr.getConstant(); if ( expr.isVariable() ) { // The case of the expr being a single variable. - Var v = expr.asVar() ; - Node n = binding.get(v) ; + Var v = expr.asVar(); + Node n = binding.get(v); if ( n == null ) - return exceptionValue ; - NodeValue nv = NodeValue.makeNode(n) ; - return nv ; + return exceptionValue; + NodeValue nv = NodeValue.makeNode(n); + return nv; } try { - return expr.eval(binding, functionEnv) ; + return expr.eval(binding, functionEnv); } catch (ExprEvalException ex) { - return exceptionValue ; + return exceptionValue; } } @@ -91,7 +91,7 @@ public class ExprLib * @return Expression */ public static Expr foldConstants(Expr expr) { - return ExprTransformer.transform(new ExprTransformConstantFold(), expr) ; + return ExprTransformer.transform(new ExprTransformConstantFold(), expr); } /** transform an expression that may involve aggregates into one that just uses the variable for the aggregate */ @@ -103,7 +103,7 @@ public class ExprLib // /** transform expressions that may involve aggregates into one that just uses the variable for the aggregate */ // public static ExprList replaceAggregateByVariable(ExprList exprs) // { -// return ExprTransformer.transform(replaceAgg, exprs) ; +// return ExprTransformer.transform(replaceAgg, exprs); //} private static ExprTransform replaceAgg = new ExprTransformCopy() { diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprList.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprList.java index 5971b85240..1849007bc6 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprList.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprList.java @@ -21,66 +21,66 @@ package org.apache.jena.sparql.expr; -import java.util.* ; +import java.util.*; -import org.apache.jena.sparql.algebra.walker.Walker ; -import org.apache.jena.sparql.core.Var ; -import org.apache.jena.sparql.engine.ExecutionContext ; -import org.apache.jena.sparql.engine.binding.Binding ; +import org.apache.jena.sparql.algebra.walker.Walker; +import org.apache.jena.sparql.core.Var; +import org.apache.jena.sparql.engine.ExecutionContext; +import org.apache.jena.sparql.engine.binding.Binding; import org.apache.jena.sparql.graph.NodeTransform; -import org.apache.jena.sparql.util.Context ; +import org.apache.jena.sparql.util.Context; public class ExprList implements Iterable<Expr> { - private final List<Expr> expressions ; + private final List<Expr> expressions; /** Create a copy which does not share the list of expressions with the original */ - public static ExprList copy(ExprList other) { return new ExprList(other) ; } + public static ExprList copy(ExprList other) { return new ExprList(other); } /** Create an ExprList that contains the expressions */ public static ExprList create(Collection<Expr> exprs) { - ExprList exprList = new ExprList() ; - exprs.forEach(exprList::add) ; - return exprList ; + ExprList exprList = new ExprList(); + exprs.forEach(exprList::add); + return exprList; } /** Create an ExprList from a number of Expr or an array. */ public static ExprList create(Expr...exprs) { - ExprList exprList = new ExprList() ; + ExprList exprList = new ExprList(); for (Expr expr : exprs) exprList.add(expr); - return exprList ; + return exprList; } /** Empty, immutable ExprList */ - public static final ExprList emptyList = new ExprList(Collections.emptyList()) ; + public static final ExprList emptyList = new ExprList(Collections.emptyList()); - public ExprList() { expressions = new ArrayList<>() ; } + public ExprList() { expressions = new ArrayList<>(); } private ExprList(ExprList other) { - this() ; - expressions.addAll(other.expressions) ; + this(); + expressions.addAll(other.expressions); } public ExprList(Expr expr) { - this() ; - expressions.add(expr) ; + this(); + expressions.add(expr); } - public ExprList(List<Expr> x) { expressions = x ; } + public ExprList(List<Expr> x) { expressions = x; } public boolean isSatisfied(Binding binding, ExecutionContext execCxt) { for (Expr expr : expressions) { if ( !expr.isSatisfied(binding, execCxt) ) - return false ; + return false; } - return true ; + return true; } - public Expr get(int idx) { return expressions.get(idx) ; } - public int size() { return expressions.size() ; } - public boolean isEmpty() { return expressions.isEmpty() ; } - public ExprList subList(int fromIdx, int toIdx) { return new ExprList(expressions.subList(fromIdx, toIdx)) ; } - public ExprList tail(int fromIdx) { return subList(fromIdx, expressions.size()) ; } + public Expr get(int idx) { return expressions.get(idx); } + public int size() { return expressions.size(); } + public boolean isEmpty() { return expressions.isEmpty(); } + public ExprList subList(int fromIdx, int toIdx) { return new ExprList(expressions.subList(fromIdx, toIdx)); } + public ExprList tail(int fromIdx) { return subList(fromIdx, expressions.size()); } public Set<Var> getVarsMentioned() { return ExprVars.getVarsMentioned(this); @@ -90,88 +90,88 @@ public class ExprList implements Iterable<Expr> * Rewrite, applying a node{@literal ->}node transformation */ public ExprList applyNodeTransform(NodeTransform transform) { - ExprList x = new ExprList() ; + ExprList x = new ExprList(); for ( Expr e : expressions) x.add(e.applyNodeTransform(transform)); - return x ; + return x; } public ExprList copySubstitute(Binding binding) { - ExprList x = new ExprList() ; + ExprList x = new ExprList(); for (Expr expr : expressions ) { - expr = expr.copySubstitute(binding) ; - x.add(expr) ; + expr = expr.copySubstitute(binding); + x.add(expr); } - return x ; + return x; } - public void addAll(ExprList exprs) { expressions.addAll(exprs.getList()) ; } - public void add(Expr expr) { expressions.add(expr) ; } - public List<Expr> getList() { return Collections.unmodifiableList(expressions) ; } + public void addAll(ExprList exprs) { expressions.addAll(exprs.getList()); } + public void add(Expr expr) { expressions.add(expr); } + public List<Expr> getList() { return Collections.unmodifiableList(expressions); } /** Use only while building ExprList */ - public List<Expr> getListRaw() { return expressions ; } + public List<Expr> getListRaw() { return expressions; } @Override - public Iterator<Expr> iterator() { return expressions.iterator() ; } + public Iterator<Expr> iterator() { return expressions.iterator(); } public void prepareExprs(Context context) { - ExprBuild build = new ExprBuild(context) ; + ExprBuild build = new ExprBuild(context); // Give each expression the chance to set up (bind functions) for (Expr expr : expressions) - Walker.walk(expr, build) ; + Walker.walk(expr, build); } @Override public String toString() - { return expressions.toString() ; } + { return expressions.toString(); } @Override - public int hashCode() { return expressions.hashCode() ; } + public int hashCode() { return expressions.hashCode(); } public boolean equals(ExprList other, boolean bySyntax) { - if ( this == other ) return true ; + if ( this == other ) return true; if (expressions.size() != other.expressions.size()) return false; - for ( int i = 0 ; i < expressions.size() ; i++ ) { - Expr e1 = expressions.get(i) ; - Expr e2 = other.expressions.get(i) ; + for ( int i = 0; i < expressions.size(); i++ ) { + Expr e1 = expressions.get(i); + Expr e2 = other.expressions.get(i); if ( ! e1.equals(e2, bySyntax) ) - return false ; + return false; } - return true ; + return true; } @Override public boolean equals(Object other) { - if ( this == other ) return true ; - if ( ! ( other instanceof ExprList ) ) return false ; - ExprList exprs = (ExprList)other ; - //return expressions.equals(exprs.expressions) ; - return equals((ExprList)other, false) ; + if ( this == other ) return true; + if ( ! ( other instanceof ExprList ) ) return false; + ExprList exprs = (ExprList)other; + //return expressions.equals(exprs.expressions); + return equals((ExprList)other, false); } public static ExprList splitConjunction(ExprList exprList1) { - ExprList exprList2 = new ExprList() ; + ExprList exprList2 = new ExprList(); for (Expr expr : exprList1) - split(exprList2, expr) ; - return exprList2 ; + split(exprList2, expr); + return exprList2; } private static ExprList splitConjunction(Expr expr) { - ExprList exprList = new ExprList() ; - split(exprList, expr) ; - return exprList ; + ExprList exprList = new ExprList(); + split(exprList, expr); + return exprList; } private static void split(ExprList exprList, Expr expr) { // Explode &&-chain to exprlist. while (expr instanceof E_LogicalAnd) { - E_LogicalAnd x = (E_LogicalAnd)expr ; - Expr left = x.getArg1() ; - Expr right = x.getArg2() ; - split(exprList, left) ; - expr = right ; + E_LogicalAnd x = (E_LogicalAnd)expr; + Expr left = x.getArg1(); + Expr right = x.getArg2(); + split(exprList, left); + expr = right; } // Drop through and add remaining - exprList.add(expr) ; + exprList.add(expr); } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprNone.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprNone.java index 5e3a52c63c..d1272a46d6 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprNone.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprNone.java @@ -23,24 +23,24 @@ package org.apache.jena.sparql.expr; import java.util.Set; -import org.apache.jena.atlas.lib.InternalErrorException ; +import org.apache.jena.atlas.lib.InternalErrorException; import org.apache.jena.sparql.core.Var; -import org.apache.jena.sparql.engine.binding.Binding ; -import org.apache.jena.sparql.function.FunctionEnv ; -import org.apache.jena.sparql.graph.NodeTransform ; +import org.apache.jena.sparql.engine.binding.Binding; +import org.apache.jena.sparql.function.FunctionEnv; +import org.apache.jena.sparql.graph.NodeTransform; /** * Marker, used in place of a null. This may be tested for using {@code ==} */ public class ExprNone extends ExprNode { - /*package*/ static Expr NONE0 = new ExprNone() ; + /*package*/ static Expr NONE0 = new ExprNone(); private ExprNone() {} @Override public void visit(ExprVisitor visitor) { visitor.visit(this); } @Override public NodeValue eval(Binding binding, FunctionEnv env) { - throw new InternalErrorException("Attempt to eval ExprNone") ; + throw new InternalErrorException("Attempt to eval ExprNone"); } @Override @@ -50,21 +50,21 @@ public class ExprNone extends ExprNode { @Override public int hashCode() { - return -999999 ; + return -999999; } @Override public boolean equals(Expr other, boolean bySyntax) { - return other == this ; + return other == this; } @Override public Expr copySubstitute(Binding binding) { - return this ; + return this; } @Override public Expr applyNodeTransform(NodeTransform transform) { - return this ; + return this; } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprNotComparableException.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprNotComparableException.java index 8f8cfbaa94..c00e0dd72d 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprNotComparableException.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprNotComparableException.java @@ -24,5 +24,5 @@ package org.apache.jena.sparql.expr; public class ExprNotComparableException extends ExprEvalException { - public ExprNotComparableException(String msg) { super(msg) ; } + public ExprNotComparableException(String msg) { super(msg); } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprTransform.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprTransform.java index 0b67f17275..6901b59470 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprTransform.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprTransform.java @@ -22,18 +22,18 @@ package org.apache.jena.sparql.expr; import org.apache.jena.graph.Node; -import org.apache.jena.sparql.algebra.Op ; +import org.apache.jena.sparql.algebra.Op; import org.apache.jena.sparql.core.Var; public interface ExprTransform { - public Expr transform(ExprFunction0 func) ; - public Expr transform(ExprFunction1 func, Expr expr1) ; - public Expr transform(ExprFunction2 func, Expr expr1, Expr expr2) ; - public Expr transform(ExprFunction3 func, Expr expr1, Expr expr2, Expr expr3) ; - public Expr transform(ExprFunctionN func, ExprList args) ; - public Expr transform(ExprFunctionOp funcOp, ExprList args, Op opArg) ; - public Expr transform(NodeValue nv) ; + public Expr transform(ExprFunction0 func); + public Expr transform(ExprFunction1 func, Expr expr1); + public Expr transform(ExprFunction2 func, Expr expr1, Expr expr2); + public Expr transform(ExprFunction3 func, Expr expr1, Expr expr2, Expr expr3); + public Expr transform(ExprFunctionN func, ExprList args); + public Expr transform(ExprFunctionOp funcOp, ExprList args, Op opArg); + public Expr transform(NodeValue nv); public default Expr transform(Node node) { if ( Var.isVar(node) ) { @@ -44,7 +44,7 @@ public interface ExprTransform return transform(nv); } - public Expr transform(ExprNone exprNone) ; - public Expr transform(ExprVar exprVar) ; - public Expr transform(ExprAggregator eAgg) ; + public Expr transform(ExprNone exprNone); + public Expr transform(ExprVar exprVar); + public Expr transform(ExprAggregator eAgg); } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprTransformBase.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprTransformBase.java index cc9e905486..da065624a0 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprTransformBase.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprTransformBase.java @@ -21,18 +21,18 @@ package org.apache.jena.sparql.expr; -import org.apache.jena.sparql.algebra.Op ; +import org.apache.jena.sparql.algebra.Op; public class ExprTransformBase implements ExprTransform { - @Override public Expr transform(ExprFunction0 func) { return func ; } - @Override public Expr transform(ExprFunction1 func, Expr expr1) { return func ; } - @Override public Expr transform(ExprFunction2 func, Expr expr1, Expr expr2) { return func ; } - @Override public Expr transform(ExprFunction3 func, Expr expr1, Expr expr2, Expr expr3) { return func ; } - @Override public Expr transform(ExprFunctionN func, ExprList args) { return func ; } - @Override public Expr transform(ExprFunctionOp funcOp, ExprList args, Op opArg) { return funcOp ; } - @Override public Expr transform(NodeValue nv) { return nv ; } - @Override public Expr transform(ExprNone exprNone) { return exprNone ; } - @Override public Expr transform(ExprVar ev) { return ev ; } - @Override public Expr transform(ExprAggregator eAgg) { return eAgg ; } + @Override public Expr transform(ExprFunction0 func) { return func; } + @Override public Expr transform(ExprFunction1 func, Expr expr1) { return func; } + @Override public Expr transform(ExprFunction2 func, Expr expr1, Expr expr2) { return func; } + @Override public Expr transform(ExprFunction3 func, Expr expr1, Expr expr2, Expr expr3) { return func; } + @Override public Expr transform(ExprFunctionN func, ExprList args) { return func; } + @Override public Expr transform(ExprFunctionOp funcOp, ExprList args, Op opArg) { return funcOp; } + @Override public Expr transform(NodeValue nv) { return nv; } + @Override public Expr transform(ExprNone exprNone) { return exprNone; } + @Override public Expr transform(ExprVar ev) { return ev; } + @Override public Expr transform(ExprAggregator eAgg) { return eAgg; } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprTransformCopy.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprTransformCopy.java index 091e82ab6c..597af9ef0a 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprTransformCopy.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprTransformCopy.java @@ -21,128 +21,128 @@ package org.apache.jena.sparql.expr; -import java.util.List ; +import java.util.List; -import org.apache.jena.sparql.algebra.Op ; +import org.apache.jena.sparql.algebra.Op; public class ExprTransformCopy implements ExprTransform { - public static final boolean COPY_ALWAYS = true ; - public static final boolean COPY_ONLY_ON_CHANGE = false ; - private boolean alwaysCopy = false ; + public static final boolean COPY_ALWAYS = true; + public static final boolean COPY_ONLY_ON_CHANGE = false; + private boolean alwaysCopy = false; - public ExprTransformCopy() { this(COPY_ONLY_ON_CHANGE) ; } - public ExprTransformCopy(boolean alwaysDuplicate) { this.alwaysCopy = alwaysDuplicate ; } + public ExprTransformCopy() { this(COPY_ONLY_ON_CHANGE); } + public ExprTransformCopy(boolean alwaysDuplicate) { this.alwaysCopy = alwaysDuplicate; } @Override public Expr transform(ExprFunction0 func) - { return xform(func) ; } + { return xform(func); } @Override public Expr transform(ExprFunction1 func, Expr expr1) - { return xform(func, expr1) ; } + { return xform(func, expr1); } @Override public Expr transform(ExprFunction2 func, Expr expr1, Expr expr2) - { return xform(func, expr1, expr2) ; } + { return xform(func, expr1, expr2); } @Override public Expr transform(ExprFunction3 func, Expr expr1, Expr expr2, Expr expr3) - { return xform(func, expr1, expr2, expr3) ; } + { return xform(func, expr1, expr2, expr3); } @Override public Expr transform(ExprFunctionN func, ExprList args) - { return xform(func, args) ; } + { return xform(func, args); } @Override public Expr transform(ExprFunctionOp funcOp, ExprList args, Op opArg) - { return xform(funcOp, args, opArg) ; } + { return xform(funcOp, args, opArg); } @Override public Expr transform(NodeValue nv) - { return xform(nv) ; } + { return xform(nv); } @Override public Expr transform(ExprNone exprNone) - { return xform(exprNone) ; } + { return xform(exprNone); } @Override public Expr transform(ExprVar exprVar) - { return xform(exprVar) ; } + { return xform(exprVar); } @Override public Expr transform(ExprAggregator eAgg) - { return xform(eAgg) ; } + { return xform(eAgg); } private Expr xform(ExprFunction0 func) { if ( !alwaysCopy ) - return func ; - return func.copy() ; + return func; + return func.copy(); } private Expr xform(ExprFunction1 func, Expr expr1) { if ( !alwaysCopy && expr1 == func.getArg() ) - return func ; - return func.copy(expr1) ; + return func; + return func.copy(expr1); } private Expr xform(ExprFunction2 func, Expr expr1, Expr expr2) { if ( !alwaysCopy && expr1 == func.getArg1() && expr2 == func.getArg2() ) - return func ; - return func.copy(expr1, expr2) ; + return func; + return func.copy(expr1, expr2); } private Expr xform(ExprFunction3 func, Expr expr1, Expr expr2, Expr expr3) { if ( !alwaysCopy && expr1 == func.getArg1() && expr2 == func.getArg2() && expr3 == func.getArg3() ) - return func ; - return func.copy(expr1, expr2, expr3) ; + return func; + return func.copy(expr1, expr2, expr3); } private Expr xform(ExprFunctionN func, ExprList args) { if ( !alwaysCopy && equals1(func.getArgs(), args.getList()) ) - return func ; - return func.copy(args) ; + return func; + return func.copy(args); } private boolean equals1(List<Expr> list1, List<Expr> list2) { if ( list1 == null && list2 == null ) - return true ; + return true; if ( list1 == null ) - return false ; + return false; if ( list2 == null ) - return false ; + return false; if ( list1.size() != list2.size() ) - return false ; - for ( int i = 0 ; i < list1.size() ; i++ ) { + return false; + for ( int i = 0; i < list1.size(); i++ ) { if ( list1.get(i) != list2.get(i) ) - return false ; + return false; } - return true ; + return true; } private Expr xform(ExprFunctionOp funcOp, ExprList args, Op opArg) { if ( !alwaysCopy && equals1(funcOp.getArgs(), args.getList()) && funcOp.getGraphPattern() == opArg ) - return funcOp ; - return funcOp.copy(args, opArg) ; + return funcOp; + return funcOp.copy(args, opArg); } private Expr xform(NodeValue nv) { - return nv ; + return nv; } private Expr xform(ExprNone exprNone) { - return exprNone ; + return exprNone; } private Expr xform(ExprVar exprVar) { - return exprVar ; + return exprVar; } private Expr xform(ExprAggregator eAgg) { if ( !alwaysCopy ) - return eAgg ; + return eAgg; - return eAgg.copy(eAgg.getVar()) ; + return eAgg.copy(eAgg.getVar()); } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprTransformSubstitute.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprTransformSubstitute.java index 5d876c1457..4662b2ff79 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprTransformSubstitute.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprTransformSubstitute.java @@ -23,8 +23,8 @@ package org.apache.jena.sparql.expr; import java.util.HashMap; import java.util.Map; -import org.apache.jena.sparql.core.Var ; -import org.apache.jena.sparql.function.user.UserDefinedFunction ; +import org.apache.jena.sparql.core.Var; +import org.apache.jena.sparql.function.user.UserDefinedFunction; /** * An expression transformer that substitutes another expression in place of variables diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprTransformer.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprTransformer.java index 3f0fc2f915..3e0e4ba184 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprTransformer.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprTransformer.java @@ -21,27 +21,27 @@ package org.apache.jena.sparql.expr; -import org.apache.jena.sparql.algebra.walker.Walker ; +import org.apache.jena.sparql.algebra.walker.Walker; public class ExprTransformer { /** Transform an expression */ public static Expr transform(ExprTransform transform, Expr expr) - { return Walker.transform(expr, transform) ;} + { return Walker.transform(expr, transform);} /** Transform an expression list */ public static ExprList transform(ExprTransform transform, ExprList exprList) { - ExprList exprList2 = new ExprList() ; - boolean changed = false ; + ExprList exprList2 = new ExprList(); + boolean changed = false; for ( Expr e : exprList ) { - Expr e2 = transform(transform, e) ; - exprList2.add(e2) ; + Expr e2 = transform(transform, e); + exprList2.add(e2); if ( e != e2 ) - changed = true ; - } ; + changed = true; + }; if ( changed ) - return exprList2 ; + return exprList2; else - return exprList ; + return exprList; } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprTripleTerm.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprTripleTerm.java index f9d3d399ca..6b8c1c3aa6 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprTripleTerm.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprTripleTerm.java @@ -29,9 +29,9 @@ import org.apache.jena.graph.Node_Triple; import org.apache.jena.graph.Triple; import org.apache.jena.sparql.ARQInternalErrorException; import org.apache.jena.sparql.core.Substitute; -import org.apache.jena.sparql.engine.binding.Binding ; -import org.apache.jena.sparql.function.FunctionEnv ; -import org.apache.jena.sparql.graph.NodeTransform ; +import org.apache.jena.sparql.engine.binding.Binding; +import org.apache.jena.sparql.function.FunctionEnv; +import org.apache.jena.sparql.graph.NodeTransform; /** * RDF 1.2 triple term in an expression. @@ -43,7 +43,7 @@ public class ExprTripleTerm extends ExprNode { public ExprTripleTerm(Node node) { if ( ! node.isTripleTerm() ) - throw new ARQInternalErrorException("Not a triple term "+node) ; + throw new ARQInternalErrorException("Not a triple term "+node); Node_Triple tripleTerm = (Node_Triple)node; this.tripleTerm = tripleTerm; this.nvTripleTerm = ( tripleTerm.isConcrete() ) ? NodeValue.makeNode(tripleTerm) : null; @@ -65,7 +65,7 @@ public class ExprTripleTerm extends ExprNode { Node tripleTerm2 = NodeFactory.createTripleTerm(t2); return NodeValue.makeNode(tripleTerm2); } - throw new VariableNotBoundException("Not concrete: triple "+tripleTerm) ; + throw new VariableNotBoundException("Not concrete: triple "+tripleTerm); } public Node getNode() { diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprTypeException.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprTypeException.java index 1ed17cf4ca..555cf9ba1e 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprTypeException.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprTypeException.java @@ -25,10 +25,10 @@ package org.apache.jena.sparql.expr; public class ExprTypeException extends ExprEvalException { - public ExprTypeException() { super() ; } - public ExprTypeException(Throwable cause) { super(cause) ; } - public ExprTypeException(String msg) { super(msg) ; } - public ExprTypeException(String msg, Throwable cause) { super(msg, cause) ; } + public ExprTypeException() { super(); } + public ExprTypeException(Throwable cause) { super(cause); } + public ExprTypeException(String msg) { super(msg); } + public ExprTypeException(String msg, Throwable cause) { super(msg, cause); } private static final long serialVersionUID = 1L; // Unused } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprUndefException.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprUndefException.java index 4144a0108e..91a7e328a2 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprUndefException.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprUndefException.java @@ -24,8 +24,8 @@ package org.apache.jena.sparql.expr; /** Exception for an undefined expression (including unbound variable) */ public class ExprUndefException extends ExprEvalException { - public ExprUndefException() { super() ; } - public ExprUndefException(Throwable cause) { super(cause) ; } - public ExprUndefException(String msg) { super(msg) ; } - public ExprUndefException(String msg, Throwable cause) { super(msg, cause) ; } + public ExprUndefException() { super(); } + public ExprUndefException(Throwable cause) { super(cause); } + public ExprUndefException(String msg) { super(msg); } + public ExprUndefException(String msg, Throwable cause) { super(msg, cause); } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprUndefFunction.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprUndefFunction.java index 9e144f7bd7..7368f6249b 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprUndefFunction.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprUndefFunction.java @@ -27,7 +27,7 @@ public class ExprUndefFunction extends ExprEvalException { private final String fnName; - public ExprUndefFunction(String msg, String fnName) { super(msg) ; this.fnName = fnName;} + public ExprUndefFunction(String msg, String fnName) { super(msg); this.fnName = fnName;} public String getFunctionName() { return fnName; diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprVars.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprVars.java index aa75853ed6..0bbb7019ba 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprVars.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprVars.java @@ -21,21 +21,21 @@ package org.apache.jena.sparql.expr; -import java.util.Collection ; -import java.util.HashSet ; -import java.util.Set ; +import java.util.Collection; +import java.util.HashSet; +import java.util.Set; import org.apache.jena.graph.Node; import org.apache.jena.graph.Triple; -import org.apache.jena.query.SortCondition ; -import org.apache.jena.sparql.algebra.OpVars ; -import org.apache.jena.sparql.algebra.walker.Walker ; -import org.apache.jena.sparql.core.Var ; +import org.apache.jena.query.SortCondition; +import org.apache.jena.sparql.algebra.OpVars; +import org.apache.jena.sparql.algebra.walker.Walker; +import org.apache.jena.sparql.core.Var; public class ExprVars { @FunctionalInterface - interface Action<T> { void var(Collection<T> acc, Var var) ; } + interface Action<T> { void var(Collection<T> acc, Var var); } // Collect variables / ExprList @@ -56,7 +56,7 @@ public class ExprVars return acc; } - private static Action<Var> accVar = (a, var) -> a.add(var) ; + private static Action<Var> accVar = (a, var) -> a.add(var); public static void varsMentioned(Collection<Var> acc, Expr expr) { //Java21 - switch + type pattern @@ -68,13 +68,13 @@ public class ExprVars } - ExprVarsWorker<Var> vv = new ExprVarsWorker<>(acc, accVar) ; - Walker.walk(expr, vv) ; + ExprVarsWorker<Var> vv = new ExprVarsWorker<>(acc, accVar); + Walker.walk(expr, vv); } public static void nonOpVarsMentioned(Collection<Var> acc, Expr expr) { - ExprNoOpVarsWorker<Var> vv = new ExprNoOpVarsWorker<>(acc, accVar) ; - Walker.walk(expr, vv) ; + ExprNoOpVarsWorker<Var> vv = new ExprNoOpVarsWorker<>(acc, accVar); + Walker.walk(expr, vv); } // Collect variables / ExprList @@ -102,15 +102,15 @@ public class ExprVars // Names variants public static Set<String> getVarNamesMentioned(Expr expr) { - Set<String> acc = new HashSet<>() ; - varNamesMentioned(acc, expr) ; - return acc ; + Set<String> acc = new HashSet<>(); + varNamesMentioned(acc, expr); + return acc; } public static Set<String> getNonOpVarNamesMentioned(Expr expr) { - Set<String> acc = new HashSet<>() ; - nonOpVarNamesMentioned(acc, expr) ; - return acc ; + Set<String> acc = new HashSet<>(); + nonOpVarNamesMentioned(acc, expr); + return acc; } private static Action<String> accVarName = (a, var) -> a.add(var.getVarName()); @@ -132,9 +132,9 @@ public class ExprVars } public static Set<Var> getVarsMentioned(Collection<SortCondition> sortConditions) { - Set<Var> acc = new HashSet<>() ; - varsMentioned(acc, sortConditions) ; - return acc ; + Set<Var> acc = new HashSet<>(); + varsMentioned(acc, sortConditions); + return acc; } public static void varsMentioned(Collection<Var> acc, SortCondition sortCondition) { @@ -143,20 +143,20 @@ public class ExprVars public static void varsMentioned(Collection<Var> acc, Collection<SortCondition> sortConditions) { for (SortCondition sc : sortConditions ) - varsMentioned(acc, sc) ; + varsMentioned(acc, sc); } static class ExprNoOpVarsWorker<T> extends ExprVisitorBase { - protected final Collection<T> acc ; - protected final Action<T> action ; + protected final Collection<T> acc; + protected final Action<T> action; public ExprNoOpVarsWorker(Collection<T> acc, Action<T> action) - { this.acc = acc ; this.action = action ; } + { this.acc = acc; this.action = action; } @Override public void visit(ExprVar nv) - { action.var(acc, nv.asVar()) ; } + { action.var(acc, nv.asVar()); } @Override public void visit(ExprTripleTerm exTripleTerm) @@ -191,9 +191,9 @@ public class ExprVars @Override public void visit(ExprFunctionOp funcOp) { - Collection<Var> vars = OpVars.visibleVars(funcOp.getGraphPattern()) ; + Collection<Var> vars = OpVars.visibleVars(funcOp.getGraphPattern()); for ( Var v : vars ) - action.var(acc, v) ; + action.var(acc, v); } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprVisitor.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprVisitor.java index fa5e2172ba..8e84989849 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprVisitor.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprVisitor.java @@ -23,16 +23,16 @@ package org.apache.jena.sparql.expr; public interface ExprVisitor { - //void visit(ExprFunction func) ; - public void visit(ExprFunction0 func) ; - public void visit(ExprFunction1 func) ; - public void visit(ExprFunction2 func) ; - public void visit(ExprFunction3 func) ; - public void visit(ExprFunctionN func) ; - public void visit(ExprFunctionOp funcOp) ; - public void visit(ExprTripleTerm tripleTerm) ; - public void visit(NodeValue nv) ; - public void visit(ExprVar nv) ; - public void visit(ExprAggregator eAgg) ; - public void visit(ExprNone exprNone) ; + //void visit(ExprFunction func); + public void visit(ExprFunction0 func); + public void visit(ExprFunction1 func); + public void visit(ExprFunction2 func); + public void visit(ExprFunction3 func); + public void visit(ExprFunctionN func); + public void visit(ExprFunctionOp funcOp); + public void visit(ExprTripleTerm tripleTerm); + public void visit(NodeValue nv); + public void visit(ExprVar nv); + public void visit(ExprAggregator eAgg); + public void visit(ExprNone exprNone); } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprVisitorFunction.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprVisitorFunction.java index 649e536a58..7d01f07ad3 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprVisitorFunction.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprVisitorFunction.java @@ -25,15 +25,15 @@ package org.apache.jena.sparql.expr; public abstract class ExprVisitorFunction implements ExprVisitor { @Override - public void visit(ExprFunction0 func) { visitExprFunction(func) ; } + public void visit(ExprFunction0 func) { visitExprFunction(func); } @Override - public void visit(ExprFunction1 func) { visitExprFunction(func) ; } + public void visit(ExprFunction1 func) { visitExprFunction(func); } @Override - public void visit(ExprFunction2 func) { visitExprFunction(func) ; } + public void visit(ExprFunction2 func) { visitExprFunction(func); } @Override - public void visit(ExprFunction3 func) { visitExprFunction(func) ; } + public void visit(ExprFunction3 func) { visitExprFunction(func); } @Override - public void visit(ExprFunctionN func) { visitExprFunction(func) ; } + public void visit(ExprFunctionN func) { visitExprFunction(func); } - protected abstract void visitExprFunction(ExprFunction func) ; + protected abstract void visitExprFunction(ExprFunction func); } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/FunctionLabel.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/FunctionLabel.java index 7700246b13..5db91b07bc 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/FunctionLabel.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/FunctionLabel.java @@ -21,10 +21,10 @@ package org.apache.jena.sparql.expr; -import org.apache.jena.sparql.util.Symbol ; +import org.apache.jena.sparql.util.Symbol; public class FunctionLabel extends Symbol { - public FunctionLabel(String name) { super(name) ; } - public FunctionLabel(FunctionLabel other) { super(other) ; } + public FunctionLabel(String name) { super(name); } + public FunctionLabel(FunctionLabel other) { super(other); } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/NVCompare.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/NVCompare.java index 21aa732574..b9f17cb6b6 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/NVCompare.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/NVCompare.java @@ -161,14 +161,14 @@ class NVCompare { return false; case VSPACE_CDT_LIST : { - final LiteralLabel lit1 = nv1.asNode().getLiteral() ; - final LiteralLabel lit2 = nv2.asNode().getLiteral() ; - return CompositeDatatypeList.datatype().isEqual(lit1, lit2) ; + final LiteralLabel lit1 = nv1.asNode().getLiteral(); + final LiteralLabel lit2 = nv2.asNode().getLiteral(); + return CompositeDatatypeList.datatype().isEqual(lit1, lit2); } case VSPACE_CDT_MAP : { - final LiteralLabel lit1 = nv1.asNode().getLiteral() ; - final LiteralLabel lit2 = nv2.asNode().getLiteral() ; - return CompositeDatatypeMap.datatype().isEqual(lit1, lit2) ; + final LiteralLabel lit1 = nv1.asNode().getLiteral(); + final LiteralLabel lit2 = nv2.asNode().getLiteral(); + return CompositeDatatypeMap.datatype().isEqual(lit1, lit2); } } @@ -230,7 +230,7 @@ class NVCompare { if ( nv2 == null ) return CMP_GREATER; - ValueSpace compType = classifyValueOp(nv1, nv2) ; + ValueSpace compType = classifyValueOp(nv1, nv2); if ( nv1.hasNode() && nv2.hasNode() @@ -251,55 +251,55 @@ class NVCompare { // Not value compatible. if ( sortOrderingCompare ) return NodeCmp.compareRDFTerms(nv1.asNode(), nv2.asNode()); - raise(new ExprNotComparableException("Can't compare (incompatible value spaces) "+nv1+" and "+nv2)) ; - throw new ARQInternalErrorException("NodeValue.raise returned") ; + raise(new ExprNotComparableException("Can't compare (incompatible value spaces) "+nv1+" and "+nv2)); + throw new ARQInternalErrorException("NodeValue.raise returned"); case VSPACE_DATETIME: case VSPACE_DATE: case VSPACE_TIME: if ( sortOrderingCompare ) - return XSDFuncOp.compareDateTimeFO(nv1, nv2) ; + return XSDFuncOp.compareDateTimeFO(nv1, nv2); // Must be same URI if ( nv1.getDatatypeURI().equals(nv2.getDatatypeURI()) ) // Indeterminate possible. return XSDFuncOp.compareDateTime(nv1, nv2); - raise(new ExprNotComparableException("Can't compare (incompatible temporal value spaces) "+nv1+" and "+nv2)) ; + raise(new ExprNotComparableException("Can't compare (incompatible temporal value spaces) "+nv1+" and "+nv2)); // case VSPACE_DURATION_DAYTIME: // case VSPACE_DURATION_YEARMONTH: case VSPACE_DURATION: { - int x = XSDFuncOp.compareDuration(nv1, nv2) ; + int x = XSDFuncOp.compareDuration(nv1, nv2); // Fix up - Java (Oracle java7 at least) returns "equals" for // "P1Y"/"P365D" and "P1M"/"P28D", and others split over // YearMonth/DayTime. // OR return CMP_INDETERMINATE ?? if ( x == CMP_EQUAL ) { - Duration d1 = nv1.getDuration() ; - Duration d2 = nv2.getDuration() ; + Duration d1 = nv1.getDuration(); + Duration d2 = nv2.getDuration(); if ( ( XSDFuncOp.isDayTime(d1) && XSDFuncOp.isYearMonth(d2) ) || ( XSDFuncOp.isDayTime(d2) && XSDFuncOp.isYearMonth(d1) ) ) - x = CMP_INDETERMINATE ; + x = CMP_INDETERMINATE; } return x; } case VSPACE_NUM: - return XSDFuncOp.compareNumeric(nv1, nv2) ; + return XSDFuncOp.compareNumeric(nv1, nv2); case VSPACE_SORTKEY : return nv1.getSortKey().compareTo(nv2.getSortKey()); case VSPACE_BOOLEAN: - return XSDFuncOp.compareBoolean(nv1, nv2) ; + return XSDFuncOp.compareBoolean(nv1, nv2); case VSPACE_LANG: { // Two literals, both with language tags. // Compare by lang tag then by lexical form. - Node node1 = nv1.asNode() ; - Node node2 = nv2.asNode() ; + Node node1 = nv1.asNode(); + Node node2 = nv2.asNode(); - int x = StrUtils.strCompareIgnoreCase(node1.getLiteralLanguage(), node2.getLiteralLanguage()) ; + int x = StrUtils.strCompareIgnoreCase(node1.getLiteralLanguage(), node2.getLiteralLanguage()); if ( x != CMP_EQUAL ) { // Different lang tags if ( !sortOrderingCompare ) @@ -309,21 +309,21 @@ class NVCompare { } // same lang tag (case insensitive) - x = strcompare(node1.getLiteralLexicalForm(), node2.getLiteralLexicalForm()) ; + x = strcompare(node1.getLiteralLexicalForm(), node2.getLiteralLexicalForm()); if ( x != CMP_EQUAL ) - return x ; + return x; // Same lexical forms, same lang tag by value // Try to split by syntactic lang tags. - x = StrUtils.strCompare(node1.getLiteralLanguage(), node2.getLiteralLanguage()) ; + x = StrUtils.strCompare(node1.getLiteralLanguage(), node2.getLiteralLanguage()); // Maybe they are the same after all! // Should be node.equals by now. if ( x == CMP_EQUAL && ! NodeFunctions.sameTerm(node1, node2) ) - throw new ARQInternalErrorException("Looks like the same (lang tags) but not node equals") ; - return x ; + throw new ARQInternalErrorException("Looks like the same (lang tags) but not node equals"); + return x; } case VSPACE_STRING: { - int x = XSDFuncOp.compareString(nv1, nv2) ; + int x = XSDFuncOp.compareString(nv1, nv2); //if ( JenaRuntime.isRDF11 ) return x; @@ -331,8 +331,8 @@ class NVCompare { // // RDF 1.0 legacy note. // // Split plain literals and xsd:strings for sorting purposes. // // Same by string value. -// String dt1 = nv1.asNode().getLiteralDatatypeURI() ; -// String dt2 = nv2.asNode().getLiteralDatatypeURI() ; +// String dt1 = nv1.asNode().getLiteralDatatypeURI(); +// String dt2 = nv2.asNode().getLiteralDatatypeURI(); // if ( dt1 == null && dt2 != null ) // return CMP_LESS; // if ( dt2 == null && dt1 != null ) @@ -358,7 +358,7 @@ class NVCompare { int x = compareRepresentations(label1, label2, sortOrderingCompare); if ( x != CMP_INDETERMINATE ) return x; - raise(new ExprNotComparableException("Can't compare blank nodes as values "+nv1+" and "+nv2)) ; + raise(new ExprNotComparableException("Can't compare blank nodes as values "+nv1+" and "+nv2)); } case VSPACE_URI : { @@ -367,7 +367,7 @@ class NVCompare { int x = compareRepresentations(uri1, uri2, sortOrderingCompare); if ( x != CMP_INDETERMINATE ) return x; - raise(new ExprNotComparableException("Can't compare URIs as values "+nv1+" and "+nv2)) ; + raise(new ExprNotComparableException("Can't compare URIs as values "+nv1+" and "+nv2)); } case VSPACE_VARIABLE : { String name1 = nv1.asNode().getName(); @@ -375,50 +375,50 @@ class NVCompare { int x = compareRepresentations(name1, name2, sortOrderingCompare); if ( x != CMP_INDETERMINATE ) return x; - raise(new ExprNotComparableException("Can't compare valiables as values "+nv1+" and "+nv2)) ; + raise(new ExprNotComparableException("Can't compare valiables as values "+nv1+" and "+nv2)); } case VSPACE_CDT_LIST : { - final LiteralLabel lit1 = nv1.asNode().getLiteral() ; - final LiteralLabel lit2 = nv2.asNode().getLiteral() ; + final LiteralLabel lit1 = nv1.asNode().getLiteral(); + final LiteralLabel lit2 = nv2.asNode().getLiteral(); try { - return CompositeDatatypeList.compare(lit1, lit2, sortOrderingCompare) ; + return CompositeDatatypeList.compare(lit1, lit2, sortOrderingCompare); } catch( final ExprNotComparableException e ) { - raise(e) ; + raise(e); } } case VSPACE_CDT_MAP : { - final LiteralLabel lit1 = nv1.asNode().getLiteral() ; - final LiteralLabel lit2 = nv2.asNode().getLiteral() ; + final LiteralLabel lit1 = nv1.asNode().getLiteral(); + final LiteralLabel lit2 = nv2.asNode().getLiteral(); try { - return CompositeDatatypeMap.compare(lit1, lit2, sortOrderingCompare) ; + return CompositeDatatypeMap.compare(lit1, lit2, sortOrderingCompare); } catch( final ExprNotComparableException e ) { - raise(e) ; + raise(e); } } case VSPACE_UNKNOWN : { // One or two unknown value spaces. - Node node1 = nv1.asNode() ; - Node node2 = nv2.asNode() ; + Node node1 = nv1.asNode(); + Node node2 = nv2.asNode(); // Two unknown literals can be equal. if ( NodeFunctions.sameTerm(node1, node2) ) - return CMP_EQUAL ; + return CMP_EQUAL; if ( sortOrderingCompare ) - return NodeCmp.compareRDFTerms(node1, node2) ; + return NodeCmp.compareRDFTerms(node1, node2); - raise(new ExprNotComparableException("Can't compare "+nv1+" and "+nv2)) ; - throw new ARQInternalErrorException("NodeValue.raise returned") ; + raise(new ExprNotComparableException("Can't compare "+nv1+" and "+nv2)); + throw new ARQInternalErrorException("NodeValue.raise returned"); } case VSPACE_DIFFERENT: - raise(new ExprNotComparableException("Can't compare "+nv1+" and "+nv2)) ; + raise(new ExprNotComparableException("Can't compare "+nv1+" and "+nv2)); } - throw new ARQInternalErrorException("Compare failure "+nv1+" and "+nv2) ; + throw new ARQInternalErrorException("Compare failure "+nv1+" and "+nv2); } /** @@ -526,7 +526,7 @@ class NVCompare { } private static int strcompare(String string1, String string2) { - // StrUtils.strCompare(string1, string2) ; + // StrUtils.strCompare(string1, string2); return result(string1.compareTo(string2)); } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/NVOps.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/NVOps.java index b534f2c2ce..8ed61848e7 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/NVOps.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/NVOps.java @@ -140,14 +140,14 @@ class NVOps { static boolean isDayTimeDuration(Duration duration) { return checkDurationField(duration, DatatypeConstants.YEARS, false) && - checkDurationField(duration, DatatypeConstants.MONTHS, false) ; + checkDurationField(duration, DatatypeConstants.MONTHS, false); } static boolean isYearMonthDuration(Duration duration) { return checkDurationField(duration, DatatypeConstants.DAYS, false) && checkDurationField(duration, DatatypeConstants.HOURS, false) && checkDurationField(duration, DatatypeConstants.MINUTES, false) && - checkDurationField(duration, DatatypeConstants.SECONDS, false) ; + checkDurationField(duration, DatatypeConstants.SECONDS, false); } /** Check the set/undefined status of a field value in a Duration. */ diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/RegexEngine.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/RegexEngine.java index d960667bd4..2734668154 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/RegexEngine.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/RegexEngine.java @@ -100,7 +100,7 @@ public abstract class RegexEngine { if ( modifiers == null ) return 0; int newMask = 0; - for ( int i = 0 ; i < modifiers.length() ; i++ ) { + for ( int i = 0; i < modifiers.length(); i++ ) { switch (modifiers.charAt(i)) { case 'i' -> { newMask |= Pattern.UNICODE_CASE; diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ValueSpace.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ValueSpace.java index 5ffee427dc..3735da75da 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ValueSpace.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ValueSpace.java @@ -130,51 +130,51 @@ public enum ValueSpace { public static ValueSpace valueSpace(NodeValue nv) { // Maybe code getValueSpace into type hierarchy. if ( nv == null ) return VSPACE_UNDEF; - if ( nv.isNumber() ) return VSPACE_NUM ; - if ( nv.isDateTime() ) return VSPACE_DATETIME ; - if ( nv.isString()) return VSPACE_STRING ; - if ( nv.isLangString()) return VSPACE_LANG ; - if ( nv.isBoolean()) return VSPACE_BOOLEAN ; + if ( nv.isNumber() ) return VSPACE_NUM; + if ( nv.isDateTime() ) return VSPACE_DATETIME; + if ( nv.isString()) return VSPACE_STRING; + if ( nv.isLangString()) return VSPACE_LANG; + if ( nv.isBoolean()) return VSPACE_BOOLEAN; - //if ( ! nv.isLiteral() ) return VSPACE_NODE ; + //if ( ! nv.isLiteral() ) return VSPACE_NODE; if ( ! SystemARQ.ValueExtensions ) - return VSPACE_UNKNOWN ; + return VSPACE_UNKNOWN; // Datatypes and their value spaces that are an extension of minimal SPARQL 1.1 - if ( nv.isDate() ) return VSPACE_DATE ; - if ( nv.isTime() ) return VSPACE_TIME ; + if ( nv.isDate() ) return VSPACE_DATE; + if ( nv.isTime() ) return VSPACE_TIME; // These compare (sort) via their implied dateTime. - if ( nv.isGYear() ) return VSPACE_DATETIME ; - if ( nv.isGYearMonth() ) return VSPACE_DATETIME ; - if ( nv.isGMonth() ) return VSPACE_DATETIME ; - if ( nv.isGMonthDay() ) return VSPACE_DATETIME ; - if ( nv.isGDay() ) return VSPACE_DATETIME ; + if ( nv.isGYear() ) return VSPACE_DATETIME; + if ( nv.isGYearMonth() ) return VSPACE_DATETIME; + if ( nv.isGMonth() ) return VSPACE_DATETIME; + if ( nv.isGMonthDay() ) return VSPACE_DATETIME; + if ( nv.isGDay() ) return VSPACE_DATETIME; // Dynamically classify yearMonth and dateTime, if ( nv.isDuration() ) return VSPACE_DURATION; // if ( nv.isDayTimeDuration() ) return VSPACE_DURATION_DAYTIME; // if ( nv.isYearMonthDuration() ) return VSPACE_DURATION_YEARMONTH; - if ( nv.isSortKey() ) return VSPACE_SORTKEY ; + if ( nv.isSortKey() ) return VSPACE_SORTKEY; if ( nv.isLiteral() ) { - String dtURI = nv.getDatatypeURI() ; - if ( CompositeDatatypeList.uri.equals(dtURI) ) return VSPACE_CDT_LIST ; - if ( CompositeDatatypeMap.uri.equals(dtURI) ) return VSPACE_CDT_MAP ; + String dtURI = nv.getDatatypeURI(); + if ( CompositeDatatypeList.uri.equals(dtURI) ) return VSPACE_CDT_LIST; + if ( CompositeDatatypeMap.uri.equals(dtURI) ) return VSPACE_CDT_MAP; } - //if ( nv.isLiteral() ) return VSPACE_UNKNOWN ; + //if ( nv.isLiteral() ) return VSPACE_UNKNOWN; if ( nv.isBlank() ) return VSPACE_BLANKNODE; if ( nv.isIRI() ) return VSPACE_URI; if ( nv.isVariable() ) return VSPACE_VARIABLE; - if ( nv.isTripleTerm()) return VSPACE_TRIPLE_TERM ; + if ( nv.isTripleTerm()) return VSPACE_TRIPLE_TERM; if ( NodeUtils.hasLang(nv.asNode()) ) - return VSPACE_LANG ; + return VSPACE_LANG; // Includes unrecognized datatypes. - return VSPACE_UNKNOWN ; + return VSPACE_UNKNOWN; } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/VariableNotBoundException.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/VariableNotBoundException.java index d1b8395584..8c45251c1b 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/VariableNotBoundException.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/VariableNotBoundException.java @@ -24,8 +24,8 @@ package org.apache.jena.sparql.expr; /** Exception for an undefined expression (including unbound variable) */ public class VariableNotBoundException extends ExprUndefException { - public VariableNotBoundException() { super() ; } - public VariableNotBoundException(Throwable cause) { super(cause) ; } - public VariableNotBoundException(String msg) { super(msg) ; } - public VariableNotBoundException(String msg, Throwable cause) { super(msg, cause) ; } + public VariableNotBoundException() { super(); } + public VariableNotBoundException(Throwable cause) { super(cause); } + public VariableNotBoundException(String msg) { super(msg); } + public VariableNotBoundException(String msg, Throwable cause) { super(msg, cause); } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/aggregate/AggSampleDistinct.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/aggregate/AggSampleDistinct.java index dd5a32b6c6..3ae75b5d87 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/aggregate/AggSampleDistinct.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/aggregate/AggSampleDistinct.java @@ -62,7 +62,7 @@ public class AggSampleDistinct extends AggregatorBase // it does not need the group to made made distinct. private NodeValue sampleSoFar = null; - public AccSampleDistict(Expr expr) { super(expr, false) ; } + public AccSampleDistict(Expr expr) { super(expr, false); } @Override public void accumulate(NodeValue nv, Binding binding, FunctionEnv functionEnv) { diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/aggregate/Aggregator.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/aggregate/Aggregator.java index de75b72b6f..575dba3bd3 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/aggregate/Aggregator.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/aggregate/Aggregator.java @@ -40,7 +40,7 @@ public interface Aggregator /** Value if there are no groups : return null for no result */ public Node getValueEmpty(); - public String toPrefixString() ; + public String toPrefixString(); // Key to identify an aggregator as syntax for duplicate use in a query. public String key(); diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/nodevalue/NodeFunctions.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/nodevalue/NodeFunctions.java index 73217f224a..b94aa966b3 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/nodevalue/NodeFunctions.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/nodevalue/NodeFunctions.java @@ -32,9 +32,9 @@ import javax.xml.datatype.DatatypeConstants; import javax.xml.datatype.DatatypeConstants.Field; import javax.xml.datatype.Duration; -import org.apache.jena.datatypes.xsd.XSDDatatype ; -import org.apache.jena.graph.Node ; -import org.apache.jena.graph.NodeFactory ; +import org.apache.jena.datatypes.xsd.XSDDatatype; +import org.apache.jena.graph.Node; +import org.apache.jena.graph.NodeFactory; import org.apache.jena.graph.TextDirection; import org.apache.jena.graph.Triple; import org.apache.jena.irix.IRIException; @@ -146,8 +146,8 @@ public class NodeFunctions { return NodeValue.FALSE; } - boolean b = NodeValue.sameValueAs(x, y) ; - return NodeValue.booleanReturn(b) ; + boolean b = NodeValue.sameValueAs(x, y); + return NodeValue.booleanReturn(b); } /** Test whether the argument is a NaN, either as a double or as a float. */ @@ -240,11 +240,11 @@ public class NodeFunctions { return "<< " + f.apply(t.getSubject()) + " " + f.apply(t.getPredicate()) + " " + f.apply(t.getObject()) + " >>"; } if ( node.isBlank() ) - NodeValue.raise(new ExprEvalException("Blank node: " + node)) ; + NodeValue.raise(new ExprEvalException("Blank node: " + node)); if ( node.isTripleTerm()) - NodeValue.raise(new ExprEvalException("Triple term: " + node)) ; - NodeValue.raise(new ExprEvalException("Not valid for STR(): " + node)) ; - return "[undef]" ; + NodeValue.raise(new ExprEvalException("Triple term: " + node)); + NodeValue.raise(new ExprEvalException("Not valid for STR(): " + node)); + return "[undef]"; } // -------- sort key (collation) @@ -283,7 +283,7 @@ public class NodeFunctions { // -------- lang public static NodeValue hasLang(NodeValue nv) { - return NodeValue.booleanReturn(hasLang(nv.asNode())) ; + return NodeValue.booleanReturn(hasLang(nv.asNode())); } public static boolean hasLang(Node node) { @@ -291,7 +291,7 @@ public class NodeFunctions { } public static NodeValue hasLangDir(NodeValue nv) { - return NodeValue.booleanReturn(hasLangDir(nv.asNode())) ; + return NodeValue.booleanReturn(hasLangDir(nv.asNode())); } public static boolean hasLangDir(Node node) { @@ -313,24 +313,24 @@ public class NodeFunctions { String s = node.getLiteralLanguage(); if ( s == null ) - return "" ; - return s ; + return ""; + return s; } public static NodeValue langdir(NodeValue nv) { if ( nv.isLangString() ) - return NodeValue.makeString(nv.getLangDir()) ; + return NodeValue.makeString(nv.getLangDir()); if ( nv.isLiteral() ) - return NodeValue.nvEmptyString ; - NodeValue.raise(new ExprTypeException("lang: Not a literal: " + nv.asQuotedString())) ; + return NodeValue.nvEmptyString; + NodeValue.raise(new ExprTypeException("lang: Not a literal: " + nv.asQuotedString())); return null; } public static String langdir(Node node) { if ( !node.isLiteral() ) - NodeValue.raise(new ExprTypeException("lang: Not a literal: " + FmtUtils.stringForNode(node))) ; + NodeValue.raise(new ExprTypeException("lang: Not a literal: " + FmtUtils.stringForNode(node))); - TextDirection textDir = node.getLiteralBaseDirection() ; + TextDirection textDir = node.getLiteralBaseDirection(); if ( textDir == null ) return ""; return textDir.direction(); @@ -574,26 +574,26 @@ public class NodeFunctions { public static NodeValue strLangDir(NodeValue v1, NodeValue v2, NodeValue v3) { if ( !v1.isString() ) - throw new ExprEvalException("Not a string (arg 1): " + v1) ; + throw new ExprEvalException("Not a string (arg 1): " + v1); if ( !v2.isString() ) - throw new ExprEvalException("Not a string (arg 2): " + v2) ; + throw new ExprEvalException("Not a string (arg 2): " + v2); if ( !v2.isString() ) - throw new ExprEvalException("Not a string (arg 3): " + v2) ; - String lex = v1.asString() ; - String lang = v2.asString() ; + throw new ExprEvalException("Not a string (arg 3): " + v2); + String lex = v1.asString(); + String lang = v2.asString(); if ( lang.isEmpty() ) - throw new ExprEvalException("Empty lang tag") ; + throw new ExprEvalException("Empty lang tag"); String textDirStr = v3.asString(); if ( textDirStr.isEmpty() ) - throw new ExprEvalException("Empty base direction") ; + throw new ExprEvalException("Empty base direction"); TextDirection textDir = TextDirection.createOrNull(v3.asString()); if ( textDir == null ) - throw new ExprEvalException("Invalid base direction: '"+textDirStr+"'") ; + throw new ExprEvalException("Invalid base direction: '"+textDirStr+"'"); return NodeValue.makeDirLangString(lex, lang, textDir); } /** Canonical duration of 0 -- "PT0S" */ - private static Duration zeroDuration = NodeValue.xmlDatatypeFactory.newDuration(true, null, null, null, null, null, BigDecimal.ZERO) ; + private static Duration zeroDuration = NodeValue.xmlDatatypeFactory.newDuration(true, null, null, null, null, null, BigDecimal.ZERO); /** A duration, tided */ public static Duration duration(int seconds) { if ( seconds == 0 ) diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/urifunctions/SPARQLFuncOp.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/urifunctions/SPARQLFuncOp.java index 2380c40d7b..c39d10b98c 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/urifunctions/SPARQLFuncOp.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/urifunctions/SPARQLFuncOp.java @@ -258,8 +258,8 @@ public class SPARQLFuncOp { public static NodeValue sparql_struuid() { return NodeFunctions.struuid(); } public static NodeValue sparql_strlen(NodeValue nv) { return XSDFuncOp.strlen(nv); } - public static NodeValue sparql_substr(NodeValue nv1, NodeValue nv2) { return XSDFuncOp.substring(nv1, nv2) ; } - public static NodeValue sparql_substr(NodeValue nv1, NodeValue nv2, NodeValue nv3) { return XSDFuncOp.substring(nv1, nv2, nv3) ; } + public static NodeValue sparql_substr(NodeValue nv1, NodeValue nv2) { return XSDFuncOp.substring(nv1, nv2); } + public static NodeValue sparql_substr(NodeValue nv1, NodeValue nv2, NodeValue nv3) { return XSDFuncOp.substring(nv1, nv2, nv3); } public static NodeValue sparql_ucase(NodeValue nv) { return XSDFuncOp.strUpperCase(nv); } public static NodeValue sparql_lcase(NodeValue nv) { return XSDFuncOp.strLowerCase(nv); }
