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 e7567d88067cefbfdaccb05baf4befe0e54ce5b7
Author: Andy Seaborne <a...@apache.org>
AuthorDate: Tue Aug 20 21:59:33 2024 +0100
Update white space
---
.../org/apache/jena/sparql/expr/ExprFunction0.java | 60 ++++---
.../org/apache/jena/sparql/expr/ExprFunction1.java | 70 ++++-----
.../org/apache/jena/sparql/expr/ExprFunction2.java | 34 ++--
.../org/apache/jena/sparql/expr/ExprFunction3.java | 118 +++++++-------
.../org/apache/jena/sparql/expr/ExprFunctionN.java | 119 +++++++-------
.../apache/jena/sparql/expr/ExprFunctionOp.java | 78 ++++-----
.../ApplyElementTransformVisitor.java | 174 ++++++++++-----------
.../ElementTransformCleanGroupsOfOne.java | 66 ++++----
.../syntaxtransform/ElementTransformCopyBase.java | 88 +++++------
.../syntaxtransform/ElementTransformIdentity.java | 50 +++---
.../syntaxtransform/ElementTransformSubst.java | 112 ++++++-------
.../syntax/syntaxtransform/ElementTransformer.java | 38 ++---
.../ExprTransformApplyElementTransform.java | 22 +--
.../syntaxtransform/ExprTransformNodeElement.java | 4 +-
.../syntax/syntaxtransform/NodeTransformSubst.java | 20 +--
.../syntax/syntaxtransform/QueryTransformOps.java | 10 +-
.../syntaxtransform/TransformElementLib.java | 52 +++---
.../syntax/syntaxtransform/UpdateTransformOps.java | 170 ++++++++++----------
18 files changed, 624 insertions(+), 661 deletions(-)
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 8175b1279b..e92e2b33b7 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
@@ -18,56 +18,52 @@
package org.apache.jena.sparql.expr;
-import org.apache.jena.sparql.engine.binding.Binding ;
-import org.apache.jena.sparql.function.FunctionEnv ;
+import org.apache.jena.sparql.engine.binding.Binding;
+import org.apache.jena.sparql.function.FunctionEnv;
import org.apache.jena.sparql.graph.NodeTransform;
/** An expression that is constant (does not depend on evaluating a sub
expression). */
public abstract class ExprFunction0 extends ExprFunction
{
- protected ExprFunction0(String fName) { this(fName, null) ; }
-
- protected ExprFunction0(String fName, String opSign)
- {
- super(fName, opSign) ;
+ protected ExprFunction0(String fName) { this(fName, null); }
+
+ protected ExprFunction0(String fName, String opSign) {
+ super(fName, opSign);
}
@Override
- public Expr getArg(int i) { return null ; }
-
+ public Expr getArg(int i) { return null; }
+
@Override
- public int hashCode() { return getFunctionSymbol().hashCode() ; }
+ public int hashCode() { return getFunctionSymbol().hashCode(); }
@Override
- public int numArgs() { return 0 ; }
-
+ public int numArgs() { return 0; }
+
// ---- Evaluation
-
+
@Override
- final public NodeValue eval(Binding binding, FunctionEnv env)
- {
- return eval(env) ;
+ final public NodeValue eval(Binding binding, FunctionEnv env) {
+ return eval(env);
}
-
- public abstract NodeValue eval(FunctionEnv env) ;
-
+
+ public abstract NodeValue eval(FunctionEnv env) ;
+
@Override
- final public Expr applyNodeTransform(NodeTransform transform)
- {
- // Nothing to transform.
- return copy() ;
+ final public Expr applyNodeTransform(NodeTransform transform) {
+ // Nothing to transform.
+ return copy();
}
-
- public abstract Expr copy() ;
-
+
+ public abstract Expr copy();
+
@Override
- final public Expr copySubstitute(Binding binding)
- {
- return copy() ;
+ final public Expr copySubstitute(Binding binding) {
+ return copy();
}
-
+
@Override
- public void visit(ExprVisitor visitor) { visitor.visit(this) ; }
- public Expr apply(ExprTransform transform) { return
transform.transform(this) ; }
+ public void visit(ExprVisitor visitor) { visitor.visit(this); }
+ public Expr apply(ExprTransform transform) { return
transform.transform(this); }
}
diff --git
a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunction1.java
b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunction1.java
index 433552e68b..d0d0bef80d 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunction1.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunction1.java
@@ -18,81 +18,75 @@
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;
/** A function that has a single argument */
public abstract class ExprFunction1 extends ExprFunction
{
- protected final Expr expr ;
+ protected final Expr expr;
- protected ExprFunction1(Expr expr, String fName) { this(expr, fName, null)
; }
+ protected ExprFunction1(Expr expr, String fName) { this(expr, fName,
null); }
- protected ExprFunction1(Expr expr, String fName, String opSign)
- {
- super(fName, opSign) ;
- this.expr = expr ;
+ protected ExprFunction1(Expr expr, String fName, String opSign) {
+ super(fName, opSign);
+ this.expr = expr;
}
- public Expr getArg() { return expr ; }
+ public Expr getArg() { return expr; }
@Override
- public Expr getArg(int i)
- {
+ public Expr getArg(int i) {
if ( i == 1 )
- return expr ;
- return null ;
+ return expr;
+ return null;
}
@Override
- public int hashCode()
- {
- return getFunctionSymbol().hashCode() ^ Lib.hashCodeObject(expr) ;
+ public int hashCode() {
+ return getFunctionSymbol().hashCode() ^ Lib.hashCodeObject(expr);
}
@Override
- public int numArgs() { return 1 ; }
+ public int numArgs() { return 1; }
// ---- Evaluation
@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, expr) ;
- return eval(x, env) ;
+ NodeValue x = eval(binding, env, expr);
+ return eval(x, env);
}
// Ideally, we would only have the FunctionEnv form but that break
compatibility.
- public NodeValue eval(NodeValue v, FunctionEnv env) { return eval(v) ; }
- public abstract NodeValue eval(NodeValue nv) ;
+ public NodeValue eval(NodeValue v, FunctionEnv env) { return eval(v); }
+ public abstract NodeValue eval(NodeValue nv);
// Allow special cases.
- protected NodeValue evalSpecial(Binding binding, FunctionEnv env) { return
null ; }
+ protected NodeValue evalSpecial(Binding binding, FunctionEnv env) { return
null; }
@Override
- final public Expr copySubstitute(Binding binding)
- {
- Expr e = (expr == null ? null : expr.copySubstitute(binding)) ;
- return copy(e) ;
+ final public Expr copySubstitute(Binding binding) {
+ Expr e = (expr == null ? null : expr.copySubstitute(binding));
+ return copy(e);
}
@Override
- final public Expr applyNodeTransform(NodeTransform transform)
- {
- Expr e = (expr == null ? null : expr.applyNodeTransform(transform)) ;
- return copy(e) ;
+ final public Expr applyNodeTransform(NodeTransform transform) {
+ Expr e = (expr == null ? null : expr.applyNodeTransform(transform));
+ return copy(e);
}
- public abstract Expr copy(Expr expr) ;
+ public abstract Expr copy(Expr expr);
@Override
- public void visit(ExprVisitor visitor) { visitor.visit(this) ; }
- public Expr apply(ExprTransform transform, Expr sub) { return
transform.transform(this, sub) ; }
+ public void visit(ExprVisitor visitor) { visitor.visit(this); }
+ public Expr apply(ExprTransform transform, Expr sub) { return
transform.transform(this, sub); }
}
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 06cb6ea40f..4688bde81a 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
@@ -25,39 +25,39 @@ import org.apache.jena.sparql.graph.NodeTransform;
/** A function of two arguments */
-
+
public abstract class ExprFunction2 extends ExprFunction
{
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, String
opSign)
{
super(fName, opSign) ;
this.expr1 = expr1 ;
this.expr2 = expr2 ;
}
-
+
public Expr getArg1() { return expr1 ; }
public Expr getArg2() { return expr2 ; }
-
+
@Override
public Expr getArg(int i)
{
if ( i == 1 )
- return expr1 ;
+ return expr1 ;
if ( i == 2 )
- return expr2 ;
+ return expr2 ;
return null ;
}
-
+
@Override
public int numArgs() { return 2 ; }
-
+
// ---- Evaluation
-
+
@Override
public int hashCode()
{
@@ -72,18 +72,18 @@ public abstract class ExprFunction2 extends ExprFunction
NodeValue s = evalSpecial(binding, env) ;
if ( s != null )
return s ;
-
+
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 abstract NodeValue eval(NodeValue x, NodeValue y) ;
+ public abstract NodeValue eval(NodeValue x, NodeValue y) ;
@Override
final public Expr copySubstitute(Binding binding)
@@ -92,7 +92,6 @@ public abstract class ExprFunction2 extends ExprFunction
Expr e2 = (expr2 == null ? null : expr2.copySubstitute(binding)) ;
return copy(e1, e2) ;
}
-
@Override
final public Expr applyNodeTransform(NodeTransform transform)
@@ -102,11 +101,12 @@ public abstract class ExprFunction2 extends ExprFunction
return copy(e1, e2) ;
}
-
public abstract Expr copy(Expr arg1, Expr arg2) ;
@Override
public void visit(ExprVisitor visitor) { visitor.visit(this) ; }
- public Expr apply(ExprTransform transform, Expr arg1, Expr arg2) { return
transform.transform(this, arg1, arg2) ; }
+ 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/ExprFunction3.java
b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunction3.java
index d003ed2566..61eee256ab 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunction3.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunction3.java
@@ -18,105 +18,99 @@
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;
/** A function of three arguments */
-
+
public abstract class ExprFunction3 extends ExprFunction
{
- protected final Expr expr1 ;
- protected final Expr expr2 ;
- protected final Expr expr3 ;
+ protected final Expr expr1;
+ protected final Expr expr2;
+ protected final Expr expr3;
+
+ protected ExprFunction3(Expr expr1, Expr expr2, Expr expr3, String fName)
{ this(expr1, expr2, expr3, fName, null); }
- protected ExprFunction3(Expr expr1, Expr expr2, Expr expr3, String fName)
{ this(expr1, expr2, expr3, fName, null) ; }
-
protected ExprFunction3(Expr expr1, Expr expr2, Expr expr3, String fName,
String opSign)
{
- super(fName, opSign) ;
- this.expr1 = expr1 ;
- this.expr2 = expr2 ;
- this.expr3 = expr3 ;
+ super(fName, opSign);
+ this.expr1 = expr1;
+ this.expr2 = expr2;
+ this.expr3 = expr3;
}
-
- public Expr getArg1() { return expr1 ; }
- public Expr getArg2() { return expr2 ; }
- public Expr getArg3() { return expr3 ; }
-
+
+ public Expr getArg1() { return expr1; }
+ public Expr getArg2() { return expr2; }
+ public Expr getArg3() { return expr3; }
+
@Override
public Expr getArg(int i)
{
if ( i == 1 )
- return expr1 ;
+ return expr1;
if ( i == 2 )
- return expr2 ;
+ return expr2;
if ( i == 3 )
- return expr3 ;
- return null ;
+ return expr3;
+ return null;
}
-
+
@Override
- public int numArgs() { return 3 ; }
-
+ public int numArgs() { return 3; }
+
// ---- Evaluation
-
+
@Override
- public int hashCode()
- {
+ public int hashCode() {
return getFunctionSymbol().hashCode() ^
Lib.hashCodeObject(expr1) ^
Lib.hashCodeObject(expr2) ^
- Lib.hashCodeObject(expr3) ;
+ Lib.hashCodeObject(expr3);
}
@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 ;
-
- NodeValue x = eval(binding, env, expr1) ;
- NodeValue y = eval(binding, env, expr2) ;
- NodeValue z = eval(binding, env, expr3) ;
- return eval(x, y, z, env) ;
+ return s;
+
+ NodeValue x = eval(binding, env, expr1);
+ NodeValue y = eval(binding, env, expr2);
+ NodeValue z = eval(binding, env, expr3);
+ return eval(x, y, z, env);
}
-
+
/** Special form evaluation (example, don't eval the arguments first) */
- protected NodeValue evalSpecial(Binding binding, FunctionEnv env) { return
null ; }
-
- public NodeValue eval(NodeValue x, NodeValue y, NodeValue z, FunctionEnv
env) { return eval(x,y, z) ; }
+ protected NodeValue evalSpecial(Binding binding, FunctionEnv env) { return
null; }
- public abstract NodeValue eval(NodeValue x, NodeValue y, NodeValue z) ;
+ public NodeValue eval(NodeValue x, NodeValue y, NodeValue z, FunctionEnv
env) { return eval(x,y, z); }
+
+ public abstract NodeValue eval(NodeValue x, NodeValue y, NodeValue z);
// ---- Duplication
-
+
@Override
- final public Expr copySubstitute(Binding binding)
- {
- Expr e1 = (expr1 == null ? null : expr1.copySubstitute(binding)) ;
- Expr e2 = (expr2 == null ? null : expr2.copySubstitute(binding)) ;
- Expr e3 = (expr3 == null ? null : expr3.copySubstitute(binding)) ;
- return copy(e1, e2, e3) ;
+ final public Expr copySubstitute(Binding binding) {
+ Expr e1 = (expr1 == null ? null : expr1.copySubstitute(binding));
+ Expr e2 = (expr2 == null ? null : expr2.copySubstitute(binding));
+ Expr e3 = (expr3 == null ? null : expr3.copySubstitute(binding));
+ return copy(e1, e2, e3);
}
-
@Override
- final public Expr applyNodeTransform(NodeTransform transform)
- {
- Expr e1 = (expr1 == null ? null : expr1.applyNodeTransform(transform))
;
- Expr e2 = (expr2 == null ? null : expr2.applyNodeTransform(transform))
;
- Expr e3 = (expr3 == null ? null : expr3.applyNodeTransform(transform))
;
- return copy(e1, e2, e3) ;
+ final public Expr applyNodeTransform(NodeTransform transform) {
+ Expr e1 = (expr1 == null ? null : expr1.applyNodeTransform(transform));
+ Expr e2 = (expr2 == null ? null : expr2.applyNodeTransform(transform));
+ Expr e3 = (expr3 == null ? null : expr3.applyNodeTransform(transform));
+ return copy(e1, e2, e3);
}
- public abstract Expr copy(Expr arg1, Expr arg2, Expr arg3) ;
-
- @Override
- public void visit(ExprVisitor visitor) { visitor.visit(this) ; }
- public Expr apply(ExprTransform transform, Expr arg1, Expr arg2, Expr
arg3) { return transform.transform(this, arg1, arg2, arg3) ; }
+ public abstract Expr copy(Expr arg1, Expr arg2, Expr arg3);
+ @Override
+ public void visit(ExprVisitor visitor) { visitor.visit(this); }
+ public Expr apply(ExprTransform transform, Expr arg1, Expr arg2, Expr
arg3) { return transform.transform(this, arg1, arg2, arg3); }
}
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 e9916ee42c..d553f391f3 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
@@ -18,106 +18,97 @@
package org.apache.jena.sparql.expr;
-import java.util.ArrayList ;
-import java.util.List ;
-import org.apache.jena.sparql.engine.binding.Binding ;
-import org.apache.jena.sparql.function.FunctionEnv ;
+import java.util.ArrayList;
+import java.util.List;
+import org.apache.jena.sparql.engine.binding.Binding;
+import org.apache.jena.sparql.function.FunctionEnv;
import org.apache.jena.sparql.graph.NodeTransform;
/** A function which takes N arguments (N may be variable e.g. regex) */
-
+
public abstract class ExprFunctionN extends ExprFunction
{
- protected ExprList args = null ;
-
- protected ExprFunctionN(String fName, Expr... args)
- {
- this(fName, argList(args)) ;
+ protected ExprList args = null;
+
+ protected ExprFunctionN(String fName, Expr...args) {
+ this(fName, argList(args));
}
-
- protected ExprFunctionN(String fName, ExprList args)
- {
- super(fName) ;
- this.args = args ;
+
+ protected ExprFunctionN(String fName, ExprList args) {
+ super(fName);
+ this.args = args;
}
- private static ExprList argList(Expr[] args)
- {
- ExprList exprList = new ExprList() ;
+ private static ExprList argList(Expr[] args) {
+ ExprList exprList = new ExprList();
for ( Expr e : args )
if ( e != null )
- exprList.add(e) ;
- return exprList ;
+ exprList.add(e);
+ return exprList;
}
@Override
- public Expr getArg(int i)
- {
- i = i-1 ;
+ public Expr getArg(int i) {
+ i = i-1;
if ( i >= args.size() )
- return null ;
- return args.get(i) ;
+ return null;
+ return args.get(i);
}
@Override
- public int numArgs() { return args.size() ; }
-
+ public int numArgs() { return args.size(); }
+
@Override
- public List<Expr> getArgs() { return args.getList() ; }
+ public List<Expr> getArgs() { return args.getList(); }
@Override
- public Expr copySubstitute(Binding binding)
- {
- ExprList newArgs = new ExprList() ;
- for ( int i = 1 ; i <= numArgs() ; i++ )
+ public Expr copySubstitute(Binding binding) {
+ ExprList newArgs = new ExprList();
+ for ( int i = 1; i <= numArgs(); i++ )
{
- Expr e = getArg(i) ;
- e = e.copySubstitute(binding) ;
- newArgs.add(e) ;
+ Expr e = getArg(i);
+ e = e.copySubstitute(binding);
+ newArgs.add(e);
}
return copy(newArgs);
}
@Override
- public Expr applyNodeTransform(NodeTransform transform)
- {
- ExprList newArgs = new ExprList() ;
- for ( int i = 1 ; i <= numArgs() ; i++ )
- {
- Expr e = getArg(i) ;
- e = e.applyNodeTransform(transform) ;
- newArgs.add(e) ;
+ public Expr applyNodeTransform(NodeTransform transform) {
+ ExprList newArgs = new ExprList();
+ for ( int i = 1 ; i <= numArgs() ; i++ ) {
+ Expr e = getArg(i);
+ e = e.applyNodeTransform(transform);
+ newArgs.add(e);
}
- return copy(newArgs) ;
+ return copy(newArgs);
}
-
+
/** 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; }
@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 ;
-
- List<NodeValue> argsEval = new ArrayList<>() ;
- for ( int i = 1 ; i <= numArgs() ; i++ )
- {
- NodeValue x = eval(binding, env, getArg(i)) ;
- argsEval.add(x) ;
+ return s;
+
+ List<NodeValue> argsEval = new ArrayList<>();
+ for ( int i = 1 ; i <= numArgs() ; i++ ) {
+ NodeValue x = eval(binding, env, getArg(i));
+ argsEval.add(x);
}
- return eval(argsEval, env) ;
+ return eval(argsEval, env);
}
-
- public NodeValue eval(List<NodeValue> args, FunctionEnv env) { return
eval(args) ; }
- public abstract NodeValue eval(List<NodeValue> args) ;
+ public NodeValue eval(List<NodeValue> args, FunctionEnv env) { return
eval(args); }
+
+ public abstract NodeValue eval(List<NodeValue> args);
+
+ public abstract Expr copy(ExprList newArgs);
- public abstract Expr copy(ExprList newArgs) ;
-
@Override
- public void visit(ExprVisitor visitor) { visitor.visit(this) ; }
- public Expr apply(ExprTransform transform, ExprList exprList) { return
transform.transform(this, exprList) ; }
+ public void visit(ExprVisitor visitor) { visitor.visit(this); }
+ public Expr apply(ExprTransform transform, ExprList exprList) { return
transform.transform(this, exprList); }
}
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 ad0239c459..896e2679a5 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
@@ -18,82 +18,70 @@
package org.apache.jena.sparql.expr;
-import org.apache.jena.sparql.algebra.Op ;
-import org.apache.jena.sparql.engine.ExecutionContext ;
-import org.apache.jena.sparql.engine.QueryIterator ;
-import org.apache.jena.sparql.engine.binding.Binding ;
-import org.apache.jena.sparql.engine.iterator.QueryIterSingleton ;
-import org.apache.jena.sparql.engine.iterator.QueryIteratorCheck ;
-import org.apache.jena.sparql.engine.main.QC ;
-import org.apache.jena.sparql.function.FunctionEnv ;
-import org.apache.jena.sparql.syntax.Element ;
+import org.apache.jena.sparql.algebra.Op;
+import org.apache.jena.sparql.engine.ExecutionContext;
+import org.apache.jena.sparql.engine.QueryIterator;
+import org.apache.jena.sparql.engine.binding.Binding;
+import org.apache.jena.sparql.engine.iterator.QueryIterSingleton;
+import org.apache.jena.sparql.engine.iterator.QueryIteratorCheck;
+import org.apache.jena.sparql.engine.main.QC;
+import org.apache.jena.sparql.function.FunctionEnv;
+import org.apache.jena.sparql.syntax.Element;
/** A "function" that executes over a pattern */
public abstract class ExprFunctionOp extends ExprFunction
{
- private final Op op ;
- private Op opRun = null ;
- private final Element element ;
+ private final Op op;
+ private Op opRun = null;
+ private final Element element;
- protected ExprFunctionOp(String fName, Element el, Op op)
- {
- super(fName) ;
- this.op = op ;
- this.element = el ;
+ protected ExprFunctionOp(String fName, Element el, Op op) {
+ super(fName);
+ this.op = op;
+ this.element = el;
}
@Override
- public Expr getArg(int i)
- {
- return null ;
+ public Expr getArg(int i) {
+ return null;
}
@Override
- public boolean isGraphPattern() { return true ; }
+ public boolean isGraphPattern() { return true; }
@Override
- public Op getGraphPattern() { return op ; }
+ public Op getGraphPattern() { return op; }
- public Element getElement() { return element ; }
+ public Element getElement() { return element; }
@Override
- public int numArgs() { return 0 ; }
+ public int numArgs() { return 0; }
// ---- Evaluation
@Override
- public final NodeValue eval(Binding binding, FunctionEnv env)
- {
- // Substitute?
- // Apply optimize transforms after substitution?
-// if ( opRun == null )
-// {
-// opRun = op ;
-// if ( env.getContext().isTrueOrUndef(ARQ.propertyFunctions) )
-// opRun = Optimize.apply("Property Functions", new
TransformPropertyFunction(env.getContext()), opRun) ;
-// }
-
+ public final NodeValue eval(Binding binding, FunctionEnv env) {
ExecutionContext execCxt = new ExecutionContext(env.getContext(),
env.getActiveGraph(),
env.getDataset(),
QC.getFactory(env.getContext())
- ) ;
- QueryIterator qIter1 = QueryIterSingleton.create(binding, execCxt) ;
- QueryIterator qIter = QC.execute(op, qIter1, execCxt) ;
+ );
+ QueryIterator qIter1 = QueryIterSingleton.create(binding, execCxt);
+ QueryIterator qIter = QC.execute(op, qIter1, execCxt);
// Wrap with something to check for closed iterators.
- qIter = QueryIteratorCheck.check(qIter, execCxt) ;
+ qIter = QueryIteratorCheck.check(qIter, execCxt);
// Call the per-operation functionality.
try {
- return eval(binding, qIter, env) ;
- } finally { qIter.close() ; }
+ return eval(binding, qIter, env);
+ } finally { qIter.close(); }
}
protected abstract NodeValue eval(Binding binding, QueryIterator iter,
FunctionEnv env);
- public abstract ExprFunctionOp copy(ExprList args, Op x) ;
- public abstract ExprFunctionOp copy(ExprList args, Element elPattern) ;
+ public abstract ExprFunctionOp copy(ExprList args, Op x);
+ public abstract ExprFunctionOp copy(ExprList args, Element elPattern);
@Override
- public void visit(ExprVisitor visitor) { visitor.visit(this) ; }
- public Expr apply(ExprTransform transform, ExprList args, Op x) { return
transform.transform(this, args, x) ; }
+ public void visit(ExprVisitor visitor) { visitor.visit(this); }
+ public Expr apply(ExprTransform transform, ExprList args, Op x) { return
transform.transform(this, args, x); }
}
diff --git
a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ApplyElementTransformVisitor.java
b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ApplyElementTransformVisitor.java
index 43a9300634..413229e682 100644
---
a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ApplyElementTransformVisitor.java
+++
b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ApplyElementTransformVisitor.java
@@ -33,199 +33,199 @@ import org.apache.jena.sparql.expr.ExprTransformer;
import org.apache.jena.sparql.syntax.*;
class ApplyElementTransformVisitor implements ElementVisitor {
- protected final ElementTransform transform ;
- private final ExprTransform exprTransform ;
+ protected final ElementTransform transform;
+ private final ExprTransform exprTransform;
- private final Deque<Element> stack = new ArrayDeque<>() ;
+ private final Deque<Element> stack = new ArrayDeque<>();
protected final Element pop() {
- return stack.pop() ;
+ return stack.pop();
}
protected final void push(Element elt) {
- stack.push(elt) ;
+ stack.push(elt);
}
public ApplyElementTransformVisitor(ElementTransform transform,
ExprTransform exprTransform) {
if ( transform == null )
- transform = ElementTransformIdentity.get() ;
- this.transform = transform ;
- this.exprTransform = exprTransform ;
+ transform = ElementTransformIdentity.get();
+ this.transform = transform;
+ this.exprTransform = exprTransform;
}
final Element result() {
if ( stack.size() != 1 )
- Log.warn(this, "Stack is not aligned") ;
- return pop() ;
+ Log.warn(this, "Stack is not aligned");
+ return pop();
}
@Override
public void visit(ElementTriplesBlock el) {
- Element el2 = transform.transform(el) ;
- push(el2) ;
+ Element el2 = transform.transform(el);
+ push(el2);
}
@Override
public void visit(ElementPathBlock el) {
- Element el2 = transform.transform(el) ;
- push(el2) ;
+ Element el2 = transform.transform(el);
+ push(el2);
}
@Override
public void visit(ElementFilter el) {
- Expr expr = el.getExpr() ;
- Expr expr2 = transformExpr(expr, exprTransform) ;
- Element el2 = transform.transform(el, expr2) ;
- push(el2) ;
+ Expr expr = el.getExpr();
+ Expr expr2 = transformExpr(expr, exprTransform);
+ Element el2 = transform.transform(el, expr2);
+ push(el2);
}
@Override
public void visit(ElementAssign el) {
- Var v = el.getVar() ;
- Var v1 = TransformElementLib.applyVar(v, exprTransform) ;
- Expr expr = el.getExpr() ;
- Expr expr1 = ExprTransformer.transform(exprTransform, expr) ;
- Element el2 = transform.transform(el, v1, expr1 ) ;
- push(el2) ;
+ Var v = el.getVar();
+ Var v1 = TransformElementLib.applyVar(v, exprTransform);
+ Expr expr = el.getExpr();
+ Expr expr1 = ExprTransformer.transform(exprTransform, expr);
+ Element el2 = transform.transform(el, v1, expr1 );
+ push(el2);
}
@Override
public void visit(ElementBind el) {
- Var v = el.getVar() ;
- Var v1 = TransformElementLib.applyVar(v, exprTransform) ;
- Expr expr = el.getExpr() ;
- Expr expr1 = ExprTransformer.transform(exprTransform, expr) ;
- Element el2 = transform.transform(el, v1, expr1) ;
- push(el2) ;
+ Var v = el.getVar();
+ Var v1 = TransformElementLib.applyVar(v, exprTransform);
+ Expr expr = el.getExpr();
+ Expr expr1 = ExprTransformer.transform(exprTransform, expr);
+ Element el2 = transform.transform(el, v1, expr1);
+ push(el2);
}
@Override
public void visit(ElementData el) {
- Element el2 = transform.transform(el) ;
- push(el2) ;
+ Element el2 = transform.transform(el);
+ push(el2);
}
@Override
public void visit(ElementOptional el) {
- Element elSub = pop() ;
- Element el2 = transform.transform(el, elSub) ;
- push(el2) ;
+ Element elSub = pop();
+ Element el2 = transform.transform(el, elSub);
+ push(el2);
}
@Override
public void visit(ElementLateral el) {
- Element elSub = pop() ;
- Element el2 = transform.transform(el, elSub) ;
- push(el2) ;
+ Element elSub = pop();
+ Element el2 = transform.transform(el, elSub);
+ push(el2);
}
@Override
public void visit(ElementGroup el) {
- ElementGroup newElt = new ElementGroup() ;
- transformFromTo(el.getElements(), newElt.getElements()) ;
- Element el2 = transform.transform(el, newElt.getElements()) ;
- push(el2) ;
+ ElementGroup newElt = new ElementGroup();
+ transformFromTo(el.getElements(), newElt.getElements());
+ Element el2 = transform.transform(el, newElt.getElements());
+ push(el2);
}
@Override
public void visit(ElementUnion el) {
- ElementUnion newElt = new ElementUnion() ;
- transformFromTo(el.getElements(), newElt.getElements()) ;
- Element el2 = transform.transform(el, newElt.getElements()) ;
- push(el2) ;
+ ElementUnion newElt = new ElementUnion();
+ transformFromTo(el.getElements(), newElt.getElements());
+ Element el2 = transform.transform(el, newElt.getElements());
+ push(el2);
}
private boolean transformFromTo(List<Element> elts, List<Element> elts2) {
- boolean changed = false ;
+ boolean changed = false;
for (Element elt : elts) {
- Element elt2 = pop() ;
- changed = (changed || (elt != elt2)) ;
+ Element elt2 = pop();
+ changed = (changed || (elt != elt2));
// Add reversed.
- elts2.add(0, elt2) ;
+ elts2.add(0, elt2);
}
- return changed ;
+ return changed;
}
@Override
public void visit(ElementDataset el) {
- Element sub = pop() ;
- Element el2 = transform.transform(el, sub) ;
- push(el2) ;
+ Element sub = pop();
+ Element el2 = transform.transform(el, sub);
+ push(el2);
}
@Override
public void visit(ElementNamedGraph el) {
- Node n = el.getGraphNameNode() ;
- Node n1 = transformNode(n) ;
- Element elt1 = pop() ;
- Element el2 = transform.transform(el, n1, elt1) ;
- push(el2) ;
+ Node n = el.getGraphNameNode();
+ Node n1 = transformNode(n);
+ Element elt1 = pop();
+ Element el2 = transform.transform(el, n1, elt1);
+ push(el2);
}
@Override
public void visit(ElementExists el) {
- Element elt = el.getElement() ;
- Element elt1 = subElement(elt) ;
- Element el2 = transform.transform(el, elt1) ;
- push(el2) ;
+ Element elt = el.getElement();
+ Element elt1 = subElement(elt);
+ Element el2 = transform.transform(el, elt1);
+ push(el2);
}
@Override
public void visit(ElementNotExists el) {
- Element elt = el.getElement() ;
- Element elt1 = subElement(elt) ;
- Element el2 = transform.transform(el, elt1) ;
- push(el2) ;
+ Element elt = el.getElement();
+ Element elt1 = subElement(elt);
+ Element el2 = transform.transform(el, elt1);
+ push(el2);
}
// When you need to force the walking of the tree ...
// EXISTS / NOT EXISTS
private Element subElement(Element elt) {
- ElementWalker.walk(elt, this) ;
- Element elt1 = pop() ;
- return elt1 ;
+ ElementWalker.walk(elt, this);
+ Element elt1 = pop();
+ return elt1;
}
@Override
public void visit(ElementMinus el) {
- Element elt = el.getMinusElement() ;
- Element elt1 = pop() ;
+ Element elt = el.getMinusElement();
+ Element elt1 = pop();
if ( elt == elt1 )
- push(el) ;
+ push(el);
else
- push(new ElementMinus(elt1)) ;
+ push(new ElementMinus(elt1));
}
@Override
public void visit(ElementService el) {
- Node n = el.getServiceNode() ;
- Node n1 = transformNode(n) ;
- Element elt1 = pop() ;
- Element el2 = transform.transform(el, n1, elt1) ;
- push(el2) ;
+ Node n = el.getServiceNode();
+ Node n1 = transformNode(n);
+ Element elt1 = pop();
+ Element el2 = transform.transform(el, n1, elt1);
+ push(el2);
}
@Override
public void visit(ElementSubQuery el) {
- Query newQuery = QueryTransformOps.transform(el.getQuery(), transform,
exprTransform) ;
- push(new ElementSubQuery(newQuery)) ;
+ Query newQuery = QueryTransformOps.transform(el.getQuery(), transform,
exprTransform);
+ push(new ElementSubQuery(newQuery));
}
private Node transformNode(Node n) {
if ( exprTransform == null )
- return n ;
- return TransformElementLib.apply(n, exprTransform) ;
+ return n;
+ return TransformElementLib.apply(n, exprTransform);
}
private ExprList transformExpr(ExprList exprList, ExprTransform
exprTransform) {
if ( exprList == null || exprTransform == null )
- return exprList ;
- return ExprTransformer.transform(exprTransform, exprList) ;
+ return exprList;
+ return ExprTransformer.transform(exprTransform, exprList);
}
private Expr transformExpr(Expr expr, ExprTransform exprTransform) {
if ( expr == null || exprTransform == null )
- return expr ;
- return ExprTransformer.transform(exprTransform, expr) ;
+ return expr;
+ return ExprTransformer.transform(exprTransform, expr);
}
}
diff --git
a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformCleanGroupsOfOne.java
b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformCleanGroupsOfOne.java
index d6818301c6..15b4475fb3 100644
---
a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformCleanGroupsOfOne.java
+++
b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformCleanGroupsOfOne.java
@@ -18,9 +18,9 @@
package org.apache.jena.sparql.syntax.syntaxtransform;
-import java.util.List ;
+import java.util.List;
-import org.apache.jena.sparql.syntax.* ;
+import org.apache.jena.sparql.syntax.*;
/**
* Clean a SPARQL and ARQ syntax. This applies after using OpAsQuery.
@@ -40,8 +40,8 @@ public class ElementTransformCleanGroupsOfOne extends
ElementTransformCopyBase {
@Override
public Element transform(ElementGroup eltGroup, List<Element> elts) {
if ( elts.size() != 1 )
- return super.transform(eltGroup, elts) ;
- Element elt = elts.get(0) ;
+ return super.transform(eltGroup, elts);
+ Element elt = elts.get(0);
if ( ( elt instanceof ElementTriplesBlock ) ||
( elt instanceof ElementPathBlock ) ||
( elt instanceof ElementFilter ) ||
@@ -50,8 +50,8 @@ public class ElementTransformCleanGroupsOfOne extends
ElementTransformCopyBase {
( elt instanceof ElementMinus ) ||
( elt instanceof ElementOptional )
)
- return super.transform(eltGroup, elts) ; // No transformation.
- return elt ;
+ return super.transform(eltGroup, elts); // No transformation.
+ return elt;
}
// The ElementGroup transformation can be too strong.
@@ -60,17 +60,17 @@ public class ElementTransformCleanGroupsOfOne extends
ElementTransformCopyBase {
// a different query syntax tree).
@Override
public Element transform(ElementUnion eltUnion, List<Element> elts) {
- ElementUnion el2 = new ElementUnion() ;
- for ( int i = 0 ; i < elts.size() ; i++ ) {
- Element el = elts.get(i) ;
+ ElementUnion el2 = new ElementUnion();
+ for ( int i = 0; i < elts.size(); i++ ) {
+ Element el = elts.get(i);
if ( ! ( el instanceof ElementGroup ) ) {
- ElementGroup elg = new ElementGroup() ;
+ ElementGroup elg = new ElementGroup();
elg.addElement(el);
- el = elg ;
+ el = elg;
}
el2.addElement(el);
}
- return el2 ;
+ return el2;
}
// Special case: If Optional, and the original had a {{}} protected
filter, keep {{}}
@@ -80,55 +80,55 @@ public class ElementTransformCleanGroupsOfOne extends
ElementTransformCopyBase {
// RHS of optional is always an ElementGroup in a normal syntax tree.
if ( ! ( transformedElt instanceof ElementGroup ) ) {
// DRY
- ElementGroup protectedElt = new ElementGroup() ;
+ ElementGroup protectedElt = new ElementGroup();
protectedElt.addElement(transformedElt);
- transformedElt = protectedElt ;
+ transformedElt = protectedElt;
}
// Step 1 : does the original eltOptional has a {{}} RHS?
- Element x = eltOptional.getOptionalElement() ;
+ Element x = eltOptional.getOptionalElement();
if ( ! ( x instanceof ElementGroup ) )
// No. But it is not possible in written query syntax to have a
nongroup as the RHS.
- return super.transform(eltOptional, transformedElt) ;
+ return super.transform(eltOptional, transformedElt);
// So far - {}-RHS.
- ElementGroup eGroup = (ElementGroup)x ;
+ ElementGroup eGroup = (ElementGroup)x;
// Is it {{}}?
- //ElementGroup inner = getGroupInGroup(x) ;
+ //ElementGroup inner = getGroupInGroup(x);
if ( eGroup.size() != 1 )
- return super.transform(eltOptional, transformedElt) ;
- Element inner = eGroup.get(0) ;
+ return super.transform(eltOptional, transformedElt);
+ Element inner = eGroup.get(0);
if ( ! ( inner instanceof ElementGroup ) )
- return super.transform(eltOptional, transformedElt) ;
+ return super.transform(eltOptional, transformedElt);
// Yes - {{}}
- ElementGroup innerGroup = (ElementGroup)inner ;
+ ElementGroup innerGroup = (ElementGroup)inner;
// Unbundle multiple levels.
- innerGroup = unwrap(innerGroup) ;
- boolean mustProtect = containsFilter(innerGroup) ;
+ innerGroup = unwrap(innerGroup);
+ boolean mustProtect = containsFilter(innerGroup);
if ( mustProtect ) {
// No need to check for {{}} in elt1 as the
transform(ElementGroup) will have processed it.
- ElementGroup protectedElt = new ElementGroup() ;
+ ElementGroup protectedElt = new ElementGroup();
protectedElt.addElement(transformedElt);
- return new ElementOptional(protectedElt) ;
+ return new ElementOptional(protectedElt);
}
// No need to protect - process as usual.
- return super.transform(eltOptional, transformedElt) ;
+ return super.transform(eltOptional, transformedElt);
}
private boolean containsFilter(ElementGroup eltGroup) {
- return eltGroup.getElements().stream().anyMatch(el2 ->( el2 instanceof
ElementFilter ) ) ;
+ return eltGroup.getElements().stream().anyMatch(el2 ->( el2 instanceof
ElementFilter ) );
}
// Removed layers of groups of one. Return inner most group.
private ElementGroup unwrap(ElementGroup eltGroup) {
if ( eltGroup.size() != 1 )
- return eltGroup ;
- Element el = eltGroup.get(0) ;
+ return eltGroup;
+ Element el = eltGroup.get(0);
if ( ! ( el instanceof ElementGroup ) )
- return eltGroup ;
- ElementGroup eltGroup2 = (ElementGroup)el ;
- return unwrap(eltGroup2) ;
+ return eltGroup;
+ ElementGroup eltGroup2 = (ElementGroup)el;
+ return unwrap(eltGroup2);
}
}
diff --git
a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformCopyBase.java
b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformCopyBase.java
index 360011eed3..f3831b0d98 100644
---
a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformCopyBase.java
+++
b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformCopyBase.java
@@ -16,19 +16,19 @@
* limitations under the License.
*/
-package org.apache.jena.sparql.syntax.syntaxtransform ;
+package org.apache.jena.sparql.syntax.syntaxtransform;
-import java.util.List ;
+import java.util.List;
-import org.apache.jena.graph.Node ;
+import org.apache.jena.graph.Node;
import org.apache.jena.graph.Triple;
-import org.apache.jena.query.Query ;
-import org.apache.jena.sparql.core.BasicPattern ;
-import org.apache.jena.sparql.core.PathBlock ;
+import org.apache.jena.query.Query;
+import org.apache.jena.sparql.core.BasicPattern;
+import org.apache.jena.sparql.core.PathBlock;
import org.apache.jena.sparql.core.Quad;
-import org.apache.jena.sparql.core.Var ;
-import org.apache.jena.sparql.expr.Expr ;
-import org.apache.jena.sparql.syntax.* ;
+import org.apache.jena.sparql.core.Var;
+import org.apache.jena.sparql.expr.Expr;
+import org.apache.jena.sparql.syntax.*;
/** Create a copy if the Element(s) below has changed.
* This is a common base class for writing recursive {@link ElementTransform}
@@ -37,7 +37,7 @@ import org.apache.jena.sparql.syntax.* ;
public class ElementTransformCopyBase implements ElementTransform {
// Note the use of == as object pointer equality.
- protected boolean alwaysCopy = false ;
+ protected boolean alwaysCopy = false;
public ElementTransformCopyBase() {
this(false);
@@ -56,7 +56,7 @@ public class ElementTransformCopyBase implements
ElementTransform {
before.getList().forEach(copy::add);
el = new ElementTriplesBlock(copy);
}
- return el ;
+ return el;
}
@Override
@@ -67,7 +67,7 @@ public class ElementTransformCopyBase implements
ElementTransform {
before.getList().forEach(copy::add);
el = new ElementPathBlock(copy);
}
- return el ;
+ return el;
}
@Override
@@ -83,22 +83,22 @@ public class ElementTransformCopyBase implements
ElementTransform {
@Override
public Element transform(ElementFilter el, Expr expr2) {
if ( !alwaysCopy && el.getExpr() == expr2 )
- return el ;
- return new ElementFilter(expr2) ;
+ return el;
+ return new ElementFilter(expr2);
}
@Override
public Element transform(ElementAssign el, Var v, Expr expr2) {
if ( !alwaysCopy && el.getVar() == v && el.getExpr() == expr2 )
- return el ;
- return new ElementAssign(v, expr2) ;
+ return el;
+ return new ElementAssign(v, expr2);
}
@Override
public Element transform(ElementBind el, Var v, Expr expr2) {
if ( !alwaysCopy && el.getVar() == v && el.getExpr() == expr2 )
- return el ;
- return new ElementBind(v, expr2) ;
+ return el;
+ return new ElementBind(v, expr2);
}
@Override
@@ -109,87 +109,87 @@ public class ElementTransformCopyBase implements
ElementTransform {
el.getTable().rows().forEachRemaining(copy::add);
el = copy;
}
- return el ;
+ return el;
}
@Override
public Element transform(ElementUnion el, List<Element> elts) {
if ( !alwaysCopy && el.getElements() == elts )
- return el ;
- ElementUnion el2 = new ElementUnion() ;
- el2.getElements().addAll(elts) ;
- return el2 ;
+ return el;
+ ElementUnion el2 = new ElementUnion();
+ el2.getElements().addAll(elts);
+ return el2;
}
@Override
public Element transform(ElementOptional el, Element elt1) {
if ( !alwaysCopy && el.getOptionalElement() == elt1 )
- return el ;
- return new ElementOptional(elt1) ;
+ return el;
+ return new ElementOptional(elt1);
}
@Override
public Element transform(ElementLateral el, Element elt1) {
if ( !alwaysCopy && el.getLateralElement() == elt1 )
- return el ;
+ return el;
return new ElementLateral(elt1);
}
@Override
public Element transform(ElementGroup el, List<Element> elts) {
if ( !alwaysCopy && el.getElements() == elts )
- return el ;
- ElementGroup el2 = new ElementGroup() ;
- el2.getElements().addAll(elts) ;
- return el2 ;
+ return el;
+ ElementGroup el2 = new ElementGroup();
+ el2.getElements().addAll(elts);
+ return el2;
}
@Override
public Element transform(ElementDataset el, Element elt1) {
if ( !alwaysCopy && el.getElement() == elt1 )
- return el ;
- return new ElementDataset(el.getDataset(), elt1) ;
+ return el;
+ return new ElementDataset(el.getDataset(), elt1);
}
@Override
public Element transform(ElementNamedGraph el, Node gn, Element elt1) {
if ( !alwaysCopy && el.getGraphNameNode() == gn && el.getElement() ==
elt1 )
- return el ;
- return new ElementNamedGraph(gn, elt1) ;
+ return el;
+ return new ElementNamedGraph(gn, elt1);
}
@Override
public Element transform(ElementExists el, Element elt1) {
if ( !alwaysCopy && el.getElement() == elt1 )
- return el ;
- return new ElementExists(elt1) ;
+ return el;
+ return new ElementExists(elt1);
}
@Override
public Element transform(ElementNotExists el, Element elt1) {
if ( !alwaysCopy && el.getElement() == elt1 )
- return el ;
- return new ElementNotExists(elt1) ;
+ return el;
+ return new ElementNotExists(elt1);
}
@Override
public Element transform(ElementMinus el, Element elt1) {
if ( !alwaysCopy && el.getMinusElement() == elt1 )
- return el ;
- return new ElementMinus(elt1) ;
+ return el;
+ return new ElementMinus(elt1);
}
@Override
public Element transform(ElementService el, Node service, Element elt1) {
if ( !alwaysCopy && el.getServiceNode() == service && el.getElement()
== elt1 )
- return el ;
- return new ElementService(service, elt1, el.getSilent()) ;
+ return el;
+ return new ElementService(service, elt1, el.getSilent());
}
@Override
public Element transform(ElementSubQuery el, Query query) {
if ( !alwaysCopy && el.getQuery() == query )
- return el ;
- return new ElementSubQuery(query) ;
+ return el;
+ return new ElementSubQuery(query);
}
}
diff --git
a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformIdentity.java
b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformIdentity.java
index 7809f1bef5..0e63d1ca15 100644
---
a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformIdentity.java
+++
b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformIdentity.java
@@ -18,15 +18,15 @@
package org.apache.jena.sparql.syntax.syntaxtransform;
-import java.util.List ;
+import java.util.List;
-import org.apache.jena.graph.Node ;
+import org.apache.jena.graph.Node;
import org.apache.jena.graph.Triple;
-import org.apache.jena.query.Query ;
+import org.apache.jena.query.Query;
import org.apache.jena.sparql.core.Quad;
-import org.apache.jena.sparql.core.Var ;
-import org.apache.jena.sparql.expr.Expr ;
-import org.apache.jena.sparql.syntax.* ;
+import org.apache.jena.sparql.core.Var;
+import org.apache.jena.sparql.expr.Expr;
+import org.apache.jena.sparql.syntax.*;
/** Transformation function on an Element that does nothing.
* Do not extend - it assumes that no change below happens.
@@ -37,46 +37,46 @@ import org.apache.jena.sparql.syntax.* ;
public final class ElementTransformIdentity implements ElementTransform
{
private ElementTransformIdentity() {}
- private static ElementTransformIdentity singleton = new
ElementTransformIdentity() ;
- static ElementTransform get() { return singleton ; }
+ private static ElementTransformIdentity singleton = new
ElementTransformIdentity();
+ static ElementTransform get() { return singleton; }
@Override
- public Element transform(ElementTriplesBlock el) { return el ; }
+ public Element transform(ElementTriplesBlock el) { return el; }
@Override
- public Element transform(ElementPathBlock el) { return el ; }
+ public Element transform(ElementPathBlock el) { return el; }
@Override
- public Element transform(ElementFilter el, Expr expr2) { return el ; }
+ public Element transform(ElementFilter el, Expr expr2) { return el; }
@Override
- public Element transform(ElementAssign el, Var v, Expr expr2) { return el
; }
+ public Element transform(ElementAssign el, Var v, Expr expr2) { return el;
}
@Override
- public Element transform(ElementBind el, Var v, Expr expr2) { return el ; }
+ public Element transform(ElementBind el, Var v, Expr expr2) { return el; }
@Override
public Triple transform(Triple triple) { return triple; }
@Override
public Quad transform(Quad quad) { return quad; }
@Override
- public Element transform(ElementData el) { return el ; }
+ public Element transform(ElementData el) { return el; }
@Override
- public Element transform(ElementUnion el, List<Element> elements) { return
el ; }
+ public Element transform(ElementUnion el, List<Element> elements) { return
el; }
@Override
- public Element transform(ElementOptional el, Element subElt) { return el ;
}
+ public Element transform(ElementOptional el, Element subElt) { return el; }
@Override
- public Element transform(ElementLateral el, Element subElt) { return el ; }
+ public Element transform(ElementLateral el, Element subElt) { return el; }
@Override
- public Element transform(ElementGroup el, List<Element> members) { return
el ; }
+ public Element transform(ElementGroup el, List<Element> members) { return
el; }
@Override
- public Element transform(ElementDataset el, Element subElt) { return el ; }
+ public Element transform(ElementDataset el, Element subElt) { return el; }
@Override
- public Element transform(ElementNamedGraph el, Node gn, Element subElt) {
return el ; }
+ public Element transform(ElementNamedGraph el, Node gn, Element subElt) {
return el; }
@Override
- public Element transform(ElementExists el, Element subElt) { return el ; }
+ public Element transform(ElementExists el, Element subElt) { return el; }
@Override
- public Element transform(ElementNotExists el, Element subElt) { return el
; }
+ public Element transform(ElementNotExists el, Element subElt) { return el;
}
@Override
- public Element transform(ElementMinus el, Element eltRHS) { return el ; }
+ public Element transform(ElementMinus el, Element eltRHS) { return el; }
@Override
- public Element transform(ElementService el, Node service, Element subElt)
{ return el ; }
+ public Element transform(ElementService el, Node service, Element subElt)
{ return el; }
@Override
- public Element transform(ElementSubQuery el, Query query) { return el ; }
+ public Element transform(ElementSubQuery el, Query query) { return el; }
}
diff --git
a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformSubst.java
b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformSubst.java
index 5391803db2..22d40bf58f 100644
---
a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformSubst.java
+++
b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformSubst.java
@@ -16,20 +16,20 @@
* limitations under the License.
*/
-package org.apache.jena.sparql.syntax.syntaxtransform ;
+package org.apache.jena.sparql.syntax.syntaxtransform;
-import java.util.Map ;
+import java.util.Map;
-import org.apache.jena.graph.Node ;
-import org.apache.jena.graph.Node_Variable ;
-import org.apache.jena.graph.Triple ;
+import org.apache.jena.graph.Node;
+import org.apache.jena.graph.Node_Variable;
+import org.apache.jena.graph.Triple;
import org.apache.jena.sparql.core.Quad;
-import org.apache.jena.sparql.core.TriplePath ;
-import org.apache.jena.sparql.core.Var ;
-import org.apache.jena.sparql.graph.NodeTransform ;
-import org.apache.jena.sparql.syntax.Element ;
-import org.apache.jena.sparql.syntax.ElementPathBlock ;
-import org.apache.jena.sparql.syntax.ElementTriplesBlock ;
+import org.apache.jena.sparql.core.TriplePath;
+import org.apache.jena.sparql.core.Var;
+import org.apache.jena.sparql.graph.NodeTransform;
+import org.apache.jena.sparql.syntax.Element;
+import org.apache.jena.sparql.syntax.ElementPathBlock;
+import org.apache.jena.sparql.syntax.ElementTriplesBlock;
/** An {@link ElementTransform} which replaces occurrences of a variable with
a Node value.
* Because a {@link Var} is a subclass of {@link Node_Variable} which is a
{@link Node},
@@ -39,89 +39,89 @@ import org.apache.jena.sparql.syntax.ElementTriplesBlock ;
* inside sub-select's and not project (which means it is effectively a
different variable).
*/
public class ElementTransformSubst extends ElementTransformCopyBase {
- private final NodeTransform nodeTransform ;
+ private final NodeTransform nodeTransform;
public ElementTransformSubst(Map<Var, ? extends Node> mapping) {
- this.nodeTransform = new NodeTransformSubst(mapping) ;
+ this.nodeTransform = new NodeTransformSubst(mapping);
}
@Override
public Element transform(ElementTriplesBlock el) {
- ElementTriplesBlock etb = new ElementTriplesBlock() ;
- boolean changed = false ;
+ ElementTriplesBlock etb = new ElementTriplesBlock();
+ boolean changed = false;
for (Triple t : el.getPattern()) {
- Triple t2 = transform(t) ;
- changed = changed || t != t2 ;
- etb.addTriple(t2) ;
+ Triple t2 = transform(t);
+ changed = changed || t != t2;
+ etb.addTriple(t2);
}
if ( changed )
- return etb ;
- return el ;
+ return etb;
+ return el;
}
@Override
public Element transform(ElementPathBlock el) {
- ElementPathBlock epb = new ElementPathBlock() ;
- boolean changed = false ;
+ ElementPathBlock epb = new ElementPathBlock();
+ boolean changed = false;
for (TriplePath p : el.getPattern()) {
- TriplePath p2 = transform(p) ;
- changed = changed || p != p2 ;
- epb.addTriplePath(p2) ;
+ TriplePath p2 = transform(p);
+ changed = changed || p != p2;
+ epb.addTriplePath(p2);
}
if ( changed )
- return epb ;
- return el ;
+ return epb;
+ return el;
}
private TriplePath transform(TriplePath path) {
- Node s = path.getSubject() ;
- Node s1 = transform(s) ;
- Node o = path.getObject() ;
- Node o1 = transform(o) ;
+ Node s = path.getSubject();
+ Node s1 = transform(s);
+ Node o = path.getObject();
+ Node o1 = transform(o);
if ( path.isTriple() ) {
- Node p = path.getPredicate() ;
- Node p1 = transform(p) ;
+ Node p = path.getPredicate();
+ Node p1 = transform(p);
if ( s == s1 && p == p1 && o == o1 )
- return path ;
- return new TriplePath(Triple.create(s1, p1, o1)) ;
+ return path;
+ return new TriplePath(Triple.create(s1, p1, o1));
}
if ( s == s1 && o == o1 )
- return path ;
- return new TriplePath(s1, path.getPath(), o1) ;
+ return path;
+ return new TriplePath(s1, path.getPath(), o1);
}
@Override
public Triple transform(Triple triple) {
- Node s = triple.getSubject() ;
- Node s1 = transform(s) ;
- Node p = triple.getPredicate() ;
- Node p1 = transform(p) ;
- Node o = triple.getObject() ;
- Node o1 = transform(o) ;
+ Node s = triple.getSubject();
+ Node s1 = transform(s);
+ Node p = triple.getPredicate();
+ Node p1 = transform(p);
+ Node o = triple.getObject();
+ Node o1 = transform(o);
if ( s == s1 && p == p1 && o == o1 )
- return triple ;
- return Triple.create(s1, p1, o1) ;
+ return triple;
+ return Triple.create(s1, p1, o1);
}
@Override
public Quad transform(Quad quad) {
- Node g = quad.getGraph() ;
- Node g1 = transform(g) ;
- Node s = quad.getSubject() ;
- Node s1 = transform(s) ;
- Node p = quad.getPredicate() ;
- Node p1 = transform(p) ;
- Node o = quad.getObject() ;
- Node o1 = transform(o) ;
+ Node g = quad.getGraph();
+ Node g1 = transform(g);
+ Node s = quad.getSubject();
+ Node s1 = transform(s);
+ Node p = quad.getPredicate();
+ Node p1 = transform(p);
+ Node o = quad.getObject();
+ Node o1 = transform(o);
if ( g == g1 && s == s1 && p == p1 && o == o1 )
- return quad ;
- return Quad.create(g1, s1, p1, o1) ;
+ return quad;
+ return Quad.create(g1, s1, p1, o1);
}
private Node transform(Node n) {
- return nodeTransform.apply(n) ;
+ return nodeTransform.apply(n);
}
}
diff --git
a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformer.java
b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformer.java
index 7c1d8c7fe0..16864bbb19 100644
---
a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformer.java
+++
b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformer.java
@@ -16,12 +16,12 @@
* limitations under the License.
*/
-package org.apache.jena.sparql.syntax.syntaxtransform ;
+package org.apache.jena.sparql.syntax.syntaxtransform;
-import org.apache.jena.atlas.logging.Log ;
-import org.apache.jena.query.Query ;
-import org.apache.jena.sparql.expr.ExprTransform ;
-import org.apache.jena.sparql.syntax.* ;
+import org.apache.jena.atlas.logging.Log;
+import org.apache.jena.query.Query;
+import org.apache.jena.sparql.expr.ExprTransform;
+import org.apache.jena.sparql.syntax.*;
/** A bottom-up application of a transformation of SPARQL syntax Elements.
* {@linkplain QueryTransformOps#transform} provides the mechanism
@@ -30,56 +30,56 @@ import org.apache.jena.sparql.syntax.* ;
* @see UpdateTransformOps#transform
*/
public class ElementTransformer {
- private static ElementTransformer singleton = new ElementTransformer() ;
+ private static ElementTransformer singleton = new ElementTransformer();
/** Get the current transformer */
public static ElementTransformer get() {
- return singleton ;
+ return singleton;
}
/** Set the current transformer - use with care */
public static void set(ElementTransformer value) {
- ElementTransformer.singleton = value ;
+ ElementTransformer.singleton = value;
}
/** Transform an algebra expression */
public static Element transform(Element element, ElementTransform
transform) {
- return transform(element, transform, null, null, null) ;
+ return transform(element, transform, null, null, null);
}
/** Transformation with specific ElementTransform and ExprTransform */
public static Element transform(Element element, ElementTransform
transform, ExprTransform exprTransform) {
- return get().transformation(element, transform, exprTransform, null,
null) ;
+ return get().transformation(element, transform, exprTransform, null,
null);
}
public static Element transform(Element element, ElementTransform
transform, ExprTransform exprTransform,
ElementVisitor beforeVisitor,
ElementVisitor afterVisitor) {
- return get().transformation(element, transform, exprTransform,
beforeVisitor, afterVisitor) ;
+ return get().transformation(element, transform, exprTransform,
beforeVisitor, afterVisitor);
}
// To allow subclassing this class, we use a singleton pattern
// and these protected methods.
protected Element transformation(Element element, ElementTransform
transform, ExprTransform exprTransform,
ElementVisitor beforeVisitor,
ElementVisitor afterVisitor) {
- ApplyElementTransformVisitor v = new
ApplyElementTransformVisitor(transform, exprTransform) ;
- return transformation(v, element, beforeVisitor, afterVisitor) ;
+ ApplyElementTransformVisitor v = new
ApplyElementTransformVisitor(transform, exprTransform);
+ return transformation(v, element, beforeVisitor, afterVisitor);
}
protected Element transformation(ApplyElementTransformVisitor
transformApply, Element element,
ElementVisitor beforeVisitor,
ElementVisitor afterVisitor) {
if ( element == null ) {
- Log.warn(this, "Attempt to transform a null element - ignored") ;
- return element ;
+ Log.warn(this, "Attempt to transform a null element - ignored");
+ return element;
}
- return applyTransformation(transformApply, element, beforeVisitor,
afterVisitor) ;
+ return applyTransformation(transformApply, element, beforeVisitor,
afterVisitor);
}
/** The primitive operation to apply a transformation to an Op */
protected Element applyTransformation(ApplyElementTransformVisitor
transformApply, Element element,
ElementVisitor beforeVisitor,
ElementVisitor afterVisitor) {
- ElementWalker.walk(element, transformApply, beforeVisitor,
afterVisitor) ;
- Element r = transformApply.result() ;
- return r ;
+ ElementWalker.walk(element, transformApply, beforeVisitor,
afterVisitor);
+ Element r = transformApply.result();
+ return r;
}
protected ElementTransformer() {}
diff --git
a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ExprTransformApplyElementTransform.java
b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ExprTransformApplyElementTransform.java
index 06f651da2c..9e4e3f5806 100644
---
a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ExprTransformApplyElementTransform.java
+++
b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ExprTransformApplyElementTransform.java
@@ -18,10 +18,10 @@
package org.apache.jena.sparql.syntax.syntaxtransform;
-import org.apache.jena.sparql.ARQInternalErrorException ;
-import org.apache.jena.sparql.algebra.Op ;
-import org.apache.jena.sparql.expr.* ;
-import org.apache.jena.sparql.syntax.Element ;
+import org.apache.jena.sparql.ARQInternalErrorException;
+import org.apache.jena.sparql.algebra.Op;
+import org.apache.jena.sparql.expr.*;
+import org.apache.jena.sparql.syntax.Element;
/**
* A copying transform that applies an ElementTransform syntax pattern of
@@ -29,7 +29,7 @@ import org.apache.jena.sparql.syntax.Element ;
* */
public class ExprTransformApplyElementTransform extends ExprTransformCopy
{
- private final ElementTransform transform ;
+ private final ElementTransform transform;
public ExprTransformApplyElementTransform(ElementTransform transform) {
this(transform, false);
@@ -37,21 +37,21 @@ public class ExprTransformApplyElementTransform extends
ExprTransformCopy
public ExprTransformApplyElementTransform(ElementTransform transform,
boolean alwaysDuplicate) {
super(alwaysDuplicate);
- this.transform = transform ;
+ this.transform = transform;
}
@Override
public Expr transform(ExprFunctionOp funcOp, ExprList args, Op opArg)
{
- Element el2 = ElementTransformer.transform(funcOp.getElement(),
transform) ;
+ Element el2 = ElementTransformer.transform(funcOp.getElement(),
transform);
if ( el2 == funcOp.getElement() )
- return super.transform(funcOp, args, opArg) ;
+ return super.transform(funcOp, args, opArg);
if ( funcOp instanceof E_Exists )
- return new E_Exists(el2) ;
+ return new E_Exists(el2);
if ( funcOp instanceof E_NotExists )
- return new E_NotExists(el2) ;
- throw new ARQInternalErrorException("Unrecognized ExprFunctionOp:
\n"+funcOp) ;
+ return new E_NotExists(el2);
+ throw new ARQInternalErrorException("Unrecognized ExprFunctionOp:
\n"+funcOp);
}
}
diff --git
a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ExprTransformNodeElement.java
b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ExprTransformNodeElement.java
index 2429bbe74e..7da7057fd0 100644
---
a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ExprTransformNodeElement.java
+++
b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ExprTransformNodeElement.java
@@ -40,8 +40,8 @@ public class ExprTransformNodeElement extends
ExprTransformCopy {
public ExprTransformNodeElement(NodeTransform nodeTransform,
ElementTransform eltrans) {
this(nodeTransform, eltrans, null, null) ;
}
-
- public ExprTransformNodeElement(NodeTransform nodeTransform,
ElementTransform eltrans,
+
+ public ExprTransformNodeElement(NodeTransform nodeTransform,
ElementTransform eltrans,
ElementVisitor beforeVisitor,
ElementVisitor afterVisitor) {
this.nodeTransform = nodeTransform ;
this.elementTransform = eltrans ;
diff --git
a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/NodeTransformSubst.java
b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/NodeTransformSubst.java
index 2aedae7783..1f7e221875 100644
---
a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/NodeTransformSubst.java
+++
b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/NodeTransformSubst.java
@@ -16,27 +16,27 @@
* limitations under the License.
*/
-package org.apache.jena.sparql.syntax.syntaxtransform ;
+package org.apache.jena.sparql.syntax.syntaxtransform;
-import java.util.Map ;
+import java.util.Map;
-import org.apache.jena.graph.Node ;
-import org.apache.jena.sparql.core.Var ;
-import org.apache.jena.sparql.graph.NodeTransform ;
+import org.apache.jena.graph.Node;
+import org.apache.jena.sparql.core.Var;
+import org.apache.jena.sparql.graph.NodeTransform;
/** A {@link NodeTransform} substituting variables for {@link Node}s. */
public class NodeTransformSubst implements NodeTransform {
- private final Map<Var, ? extends Node> map ;
+ private final Map<Var, ? extends Node> map;
public NodeTransformSubst(Map<Var, ? extends Node> map) {
- this.map = map ;
+ this.map = map;
}
@Override
public Node apply(Node node) {
- Node n = map.get(node) ;
+ Node n = map.get(node);
if ( n == null )
- return node ;
- return n ;
+ return node;
+ return n;
}
}
diff --git
a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/QueryTransformOps.java
b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/QueryTransformOps.java
index 8d873f0714..b461a0a7e0 100644
---
a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/QueryTransformOps.java
+++
b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/QueryTransformOps.java
@@ -28,9 +28,9 @@ import org.apache.jena.graph.Triple;
import org.apache.jena.query.Query;
import org.apache.jena.query.QueryVisitor;
import org.apache.jena.query.SortCondition;
-import org.apache.jena.rdf.model.Literal ;
-import org.apache.jena.rdf.model.RDFNode ;
-import org.apache.jena.rdf.model.Resource ;
+import org.apache.jena.rdf.model.Literal;
+import org.apache.jena.rdf.model.RDFNode;
+import org.apache.jena.rdf.model.Resource;
import org.apache.jena.shared.JenaException;
import org.apache.jena.shared.PrefixMapping;
import org.apache.jena.shared.impl.PrefixMappingImpl;
@@ -274,7 +274,7 @@ public class QueryTransformOps {
if (e2 == null || e2 == ev )
return node;
if ( ! e2.isConstant() )
- return node ;
+ return node;
return e2.getConstant().getNode();
}
@@ -307,7 +307,7 @@ public class QueryTransformOps {
@Override
public void visitPrologue(Prologue prologue) {
- // newQuery.setBaseURI(prologue.getResolver()) ;
+ // newQuery.setBaseURI(prologue.getResolver());
PrefixMapping pmap = new
PrefixMappingImpl().setNsPrefixes(prologue.getPrefixMapping());
newQuery.setPrefixMapping(pmap);
}
diff --git
a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/TransformElementLib.java
b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/TransformElementLib.java
index ed2fb7ba38..d3b4d568be 100644
---
a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/TransformElementLib.java
+++
b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/TransformElementLib.java
@@ -16,50 +16,50 @@
* limitations under the License.
*/
-package org.apache.jena.sparql.syntax.syntaxtransform ;
+package org.apache.jena.sparql.syntax.syntaxtransform;
-import java.util.Map ;
-import java.util.stream.Collectors ;
+import java.util.Map;
+import java.util.stream.Collectors;
-import org.apache.jena.atlas.lib.InternalErrorException ;
+import org.apache.jena.atlas.lib.InternalErrorException;
-import org.apache.jena.graph.Node ;
-import org.apache.jena.rdf.model.RDFNode ;
-import org.apache.jena.sparql.core.Var ;
-import org.apache.jena.sparql.expr.Expr ;
-import org.apache.jena.sparql.expr.ExprTransform ;
-import org.apache.jena.sparql.expr.ExprVar ;
-import org.apache.jena.sparql.expr.NodeValue ;
+import org.apache.jena.graph.Node;
+import org.apache.jena.rdf.model.RDFNode;
+import org.apache.jena.sparql.core.Var;
+import org.apache.jena.sparql.expr.Expr;
+import org.apache.jena.sparql.expr.ExprTransform;
+import org.apache.jena.sparql.expr.ExprVar;
+import org.apache.jena.sparql.expr.NodeValue;
public class TransformElementLib {
public static Var applyVar(Var v, ExprTransform exprTransform) {
if ( exprTransform == null )
- return v ;
- ExprVar expr = new ExprVar(v) ;
- Expr e = exprTransform.transform(expr) ;
+ return v;
+ ExprVar expr = new ExprVar(v);
+ Expr e = exprTransform.transform(expr);
if ( e instanceof ExprVar )
- return ((ExprVar)e).asVar() ;
- throw new InternalErrorException("Managed to turn a variable " + v + "
into " + e) ;
+ return ((ExprVar)e).asVar();
+ throw new InternalErrorException("Managed to turn a variable " + v + "
into " + e);
}
public static Node apply(Node n, ExprTransform exprTransform) {
if ( exprTransform == null )
- return n ;
- Expr e = null ;
+ return n;
+ Expr e = null;
if ( Var.isVar(n) ) {
- Var v = Var.alloc(n) ;
- ExprVar expr = new ExprVar(v) ;
- e = exprTransform.transform(expr) ;
+ Var v = Var.alloc(n);
+ ExprVar expr = new ExprVar(v);
+ e = exprTransform.transform(expr);
} else {
- NodeValue nv = NodeValue.makeNode(n) ;
- e = exprTransform.transform(nv) ;
+ NodeValue nv = NodeValue.makeNode(n);
+ e = exprTransform.transform(nv);
}
if ( e instanceof ExprVar )
- return ((ExprVar)e).asVar() ;
+ return ((ExprVar)e).asVar();
if ( e instanceof NodeValue )
- return ((NodeValue)e).asNode() ;
- throw new InternalErrorException("Managed to turn a node " + n + "
into " + e) ;
+ return ((NodeValue)e).asNode();
+ throw new InternalErrorException("Managed to turn a node " + n + "
into " + e);
}
public static Map<Var, Node> convert(Map<String, ? extends RDFNode>
substitutions) {
diff --git
a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/UpdateTransformOps.java
b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/UpdateTransformOps.java
index b83b2609a5..5bf3932f0e 100644
---
a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/UpdateTransformOps.java
+++
b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/UpdateTransformOps.java
@@ -16,42 +16,42 @@
* limitations under the License.
*/
-package org.apache.jena.sparql.syntax.syntaxtransform ;
-
-import java.util.ArrayList ;
-import java.util.List ;
-import java.util.Map ;
-
-import org.apache.jena.graph.Node ;
-import org.apache.jena.rdf.model.Literal ;
-import org.apache.jena.rdf.model.RDFNode ;
-import org.apache.jena.rdf.model.Resource ;
-import org.apache.jena.sparql.core.Quad ;
-import org.apache.jena.sparql.core.Var ;
-import org.apache.jena.sparql.expr.ExprTransform ;
-import org.apache.jena.sparql.graph.NodeTransform ;
-import org.apache.jena.sparql.modify.request.* ;
-import org.apache.jena.sparql.syntax.Element ;
-import org.apache.jena.update.Update ;
-import org.apache.jena.update.UpdateRequest ;
+package org.apache.jena.sparql.syntax.syntaxtransform;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.jena.graph.Node;
+import org.apache.jena.rdf.model.Literal;
+import org.apache.jena.rdf.model.RDFNode;
+import org.apache.jena.rdf.model.Resource;
+import org.apache.jena.sparql.core.Quad;
+import org.apache.jena.sparql.core.Var;
+import org.apache.jena.sparql.expr.ExprTransform;
+import org.apache.jena.sparql.graph.NodeTransform;
+import org.apache.jena.sparql.modify.request.*;
+import org.apache.jena.sparql.syntax.Element;
+import org.apache.jena.update.Update;
+import org.apache.jena.update.UpdateRequest;
/** Support for transformation of update abstract syntax. */
public class UpdateTransformOps {
/** Transform an {@link Update} based on a mapping from {@link Var}
variable to replacement {@link Node}. */
public static Update transform(Update update, Map<Var, Node>
substitutions) {
- ElementTransform eltrans = new ElementTransformSubst(substitutions) ;
- NodeTransform nodeTransform = new NodeTransformSubst(substitutions) ;
- ExprTransform exprTrans = new ExprTransformNodeElement(nodeTransform,
eltrans) ;
- return transform(update, eltrans, exprTrans) ;
+ ElementTransform eltrans = new ElementTransformSubst(substitutions);
+ NodeTransform nodeTransform = new NodeTransformSubst(substitutions);
+ ExprTransform exprTrans = new ExprTransformNodeElement(nodeTransform,
eltrans);
+ return transform(update, eltrans, exprTrans);
}
/** Transform an {@link UpdateRequest} based on a mapping from {@link Var}
variable to replacement {@link Node}. */
public static UpdateRequest transform(UpdateRequest update, Map<Var, Node>
substitutions) {
- ElementTransform eltrans = new ElementTransformSubst(substitutions) ;
- NodeTransform nodeTransform = new NodeTransformSubst(substitutions) ;
- ExprTransform exprTrans = new ExprTransformNodeElement(nodeTransform,
eltrans) ;
- return transform(update, eltrans, exprTrans) ;
+ ElementTransform eltrans = new ElementTransformSubst(substitutions);
+ NodeTransform nodeTransform = new NodeTransformSubst(substitutions);
+ ExprTransform exprTrans = new ExprTransformNodeElement(nodeTransform,
eltrans);
+ return transform(update, eltrans, exprTrans);
}
/**
@@ -73,147 +73,147 @@ public class UpdateTransformOps {
}
public static Update transform(Update update, ElementTransform transform,
ExprTransform exprTransform) {
- UpdateTransform upParam = new UpdateTransform(transform,
exprTransform) ;
- update.visit(upParam) ;
- Update update1 = upParam.result ;
- return update1 ;
+ UpdateTransform upParam = new UpdateTransform(transform,
exprTransform);
+ update.visit(upParam);
+ Update update1 = upParam.result;
+ return update1;
}
public static UpdateRequest transform(UpdateRequest update,
ElementTransform transform, ExprTransform exprTransform) {
- UpdateRequest req = new UpdateRequest() ;
- req.getPrefixMapping().setNsPrefixes(update.getPrefixMapping()) ;
+ UpdateRequest req = new UpdateRequest();
+ req.getPrefixMapping().setNsPrefixes(update.getPrefixMapping());
for (Update up : update.getOperations()) {
- up = transform(up, transform, exprTransform) ;
- req.add(up) ;
+ up = transform(up, transform, exprTransform);
+ req.add(up);
}
- return req ;
+ return req;
}
static class UpdateTransform implements UpdateVisitor {
- ElementTransform elTransform ;
- ExprTransform exprTransform ;
- Update result = null ;
+ ElementTransform elTransform;
+ ExprTransform exprTransform;
+ Update result = null;
public UpdateTransform(ElementTransform transform, ExprTransform
exprTransform) {
- this.elTransform = transform ;
- this.exprTransform = exprTransform ;
+ this.elTransform = transform;
+ this.exprTransform = exprTransform;
}
@Override
public void visit(UpdateDrop update) {
- result = update ;
+ result = update;
}
@Override
public void visit(UpdateClear update) {
- result = update ;
+ result = update;
}
@Override
public void visit(UpdateCreate update) {
- result = update ;
+ result = update;
}
@Override
public void visit(UpdateLoad update) {
- result = update ;
+ result = update;
}
@Override
public void visit(UpdateAdd update) {
- result = update ;
+ result = update;
}
@Override
public void visit(UpdateCopy update) {
- result = update ;
+ result = update;
}
@Override
public void visit(UpdateMove update) {
- result = update ;
+ result = update;
}
@Override
public void visit(UpdateDataInsert update) {
- result = update ;
+ result = update;
}
@Override
public void visit(UpdateDataDelete update) {
- result = update ;
+ result = update;
}
@Override
public void visit(UpdateDeleteWhere update) {
- List<Quad> quads = update.getQuads() ;
- List<Quad> quads2 = transform(quads) ;
+ List<Quad> quads = update.getQuads();
+ List<Quad> quads2 = transform(quads);
if ( quads == quads2 )
- result = update ;
+ result = update;
else {
- QuadAcc acc = new QuadAcc() ;
- addAll(acc, quads2) ;
- result = new UpdateDeleteWhere(acc) ;
+ QuadAcc acc = new QuadAcc();
+ addAll(acc, quads2);
+ result = new UpdateDeleteWhere(acc);
}
}
@Override
public void visit(UpdateModify update) {
- Element el = update.getWherePattern() ;
- Element el2 = ElementTransformer.transform(el, elTransform,
exprTransform) ;
+ Element el = update.getWherePattern();
+ Element el2 = ElementTransformer.transform(el, elTransform,
exprTransform);
- List<Quad> del = update.getDeleteQuads() ;
- List<Quad> del1 = transform(del) ;
- List<Quad> ins = update.getInsertQuads() ;
- List<Quad> ins1 = transform(ins) ;
+ List<Quad> del = update.getDeleteQuads();
+ List<Quad> del1 = transform(del);
+ List<Quad> ins = update.getInsertQuads();
+ List<Quad> ins1 = transform(ins);
- UpdateModify mod = new UpdateModify() ;
+ UpdateModify mod = new UpdateModify();
- addAll(mod.getDeleteAcc(), del1) ;
- addAll(mod.getInsertAcc(), ins1) ;
+ addAll(mod.getDeleteAcc(), del1);
+ addAll(mod.getInsertAcc(), ins1);
mod.setElement(el2);
- result = mod ;
+ result = mod;
}
private void addAll(QuadAcc acc, List<Quad> quads) {
for (Quad q : quads)
- acc.addQuad(q) ;
+ acc.addQuad(q);
}
public List<Quad> transform(List<Quad> quads) {
- List<Quad> x = new ArrayList<>() ;
- boolean changed = false ;
+ List<Quad> x = new ArrayList<>();
+ boolean changed = false;
for (Quad q : quads) {
- Quad q1 = transform(q) ;
- changed = changed || q1 != q ;
- x.add(q1) ;
+ Quad q1 = transform(q);
+ changed = changed || q1 != q;
+ x.add(q1);
}
if ( changed )
- return x ;
- return quads ;
+ return x;
+ return quads;
}
private Quad transform(Quad q) {
- Node g = q.getGraph() ;
- Node g1 = transform(g) ;
- Node s = q.getSubject() ;
- Node s1 = transform(s) ;
- Node p = q.getPredicate() ;
- Node p1 = transform(p) ;
- Node o = q.getObject() ;
- Node o1 = transform(o) ;
+ Node g = q.getGraph();
+ Node g1 = transform(g);
+ Node s = q.getSubject();
+ Node s1 = transform(s);
+ Node p = q.getPredicate();
+ Node p1 = transform(p);
+ Node o = q.getObject();
+ Node o1 = transform(o);
if ( g == g1 && s == s1 && p == p1 && o == o1 )
- return q ;
- return Quad.create(g1, s1, p1, o1) ;
+ return q;
+ return Quad.create(g1, s1, p1, o1);
}
private Node transform(Node n) {
if ( Var.isVar(n) )
- return TransformElementLib.apply(Var.alloc(n), exprTransform) ;
+ return TransformElementLib.apply(Var.alloc(n), exprTransform);
else
- return TransformElementLib.apply(n, exprTransform) ;
+ return TransformElementLib.apply(n, exprTransform);
}
}
