org.aksw.sparqlify.expr.util

Class ExprUtils

java.lang.Object

org.aksw.sparqlify.expr.util.ExprUtils

public class ExprUtils
extends Object

Constructor Summary

Constructors

Constructor and Description
ExprUtils()

Method Summary

Methods

Modifier and Type	Method and Description
static com.hp.hpl.jena.sparql.expr.Expr	andifyBalanced(com.hp.hpl.jena.sparql.expr.Expr... exprs)
static com.hp.hpl.jena.sparql.expr.Expr	andifyBalanced(Iterable<com.hp.hpl.jena.sparql.expr.Expr> exprs)
static boolean	containsFalse(Iterable<com.hp.hpl.jena.sparql.expr.Expr> exprs)
static org.aksw.commons.util.Pair<com.hp.hpl.jena.sparql.core.Var,com.hp.hpl.jena.sparql.expr.NodeValue>	extractConstantConstraint(com.hp.hpl.jena.sparql.expr.Expr expr)
static org.aksw.commons.util.Pair<com.hp.hpl.jena.sparql.core.Var,com.hp.hpl.jena.sparql.expr.NodeValue>	extractConstantConstraint(com.hp.hpl.jena.sparql.expr.Expr a, com.hp.hpl.jena.sparql.expr.Expr b)
static org.aksw.commons.util.Pair<com.hp.hpl.jena.sparql.core.Var,com.hp.hpl.jena.sparql.expr.NodeValue>	extractConstantConstraintDirected(com.hp.hpl.jena.sparql.expr.Expr a, com.hp.hpl.jena.sparql.expr.Expr b) If a is a variable and b is a constant, then a mapping of the variable to the constant is put into the map, and true is returned.
static List<String>	extractNames(Collection<com.hp.hpl.jena.sparql.core.Var> vars)
static String	getFunctionId(com.hp.hpl.jena.sparql.expr.ExprFunction fn)
static Object	getJavaObject(com.hp.hpl.jena.sparql.expr.NodeValue expr)
static Collection<? extends com.hp.hpl.jena.sparql.expr.Expr>	getSubExpressions(com.hp.hpl.jena.sparql.expr.Expr expr, boolean reflexive)
static void	getSubExpressions(com.hp.hpl.jena.sparql.expr.Expr expr, Set<com.hp.hpl.jena.sparql.expr.Expr> result)
static boolean	isConstantArgsOnly(com.hp.hpl.jena.sparql.expr.ExprFunction fn) Checks wtherer all arguments of the given function are constants (non-recursive).
static boolean	isConstantsOnly(Iterable<com.hp.hpl.jena.sparql.expr.Expr> exprs)
static <T> T	opifyBalanced(Iterable<T> exprs, Factory2<T> exprFactory) Concatenates the sub exressions using Logical_And and(and(0, 1), and(2, 3))
static com.hp.hpl.jena.sparql.expr.Expr	orifyBalanced(com.hp.hpl.jena.sparql.expr.Expr... exprs)
static com.hp.hpl.jena.sparql.expr.Expr	orifyBalanced(Iterable<com.hp.hpl.jena.sparql.expr.Expr> exprs)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ExprUtils

public ExprUtils()

Method Detail

isConstantsOnly

public static boolean isConstantsOnly(Iterable<com.hp.hpl.jena.sparql.expr.Expr> exprs)

isConstantArgsOnly

public static boolean isConstantArgsOnly(com.hp.hpl.jena.sparql.expr.ExprFunction fn)

Checks wtherer all arguments of the given function are constants (non-recursive).

Parameters:

fn - The function to test

Returns:

True if all arguments are constants, false otherwise.

andifyBalanced

public static com.hp.hpl.jena.sparql.expr.Expr andifyBalanced(com.hp.hpl.jena.sparql.expr.Expr... exprs)

orifyBalanced

public static com.hp.hpl.jena.sparql.expr.Expr orifyBalanced(com.hp.hpl.jena.sparql.expr.Expr... exprs)

extractNames

public static List<String> extractNames(Collection<com.hp.hpl.jena.sparql.core.Var> vars)

andifyBalanced

public static com.hp.hpl.jena.sparql.expr.Expr andifyBalanced(Iterable<com.hp.hpl.jena.sparql.expr.Expr> exprs)

opifyBalanced

public static <T> T opifyBalanced(Iterable<T> exprs,
                  Factory2<T> exprFactory)

Concatenates the sub exressions using Logical_And and(and(0, 1), and(2, 3))

Parameters:

exprs -

Returns:

orifyBalanced

public static com.hp.hpl.jena.sparql.expr.Expr orifyBalanced(Iterable<com.hp.hpl.jena.sparql.expr.Expr> exprs)

extractConstantConstraint

public static org.aksw.commons.util.Pair<com.hp.hpl.jena.sparql.core.Var,com.hp.hpl.jena.sparql.expr.NodeValue> extractConstantConstraint(com.hp.hpl.jena.sparql.expr.Expr expr)

extractConstantConstraint

public static org.aksw.commons.util.Pair<com.hp.hpl.jena.sparql.core.Var,com.hp.hpl.jena.sparql.expr.NodeValue> extractConstantConstraint(com.hp.hpl.jena.sparql.expr.Expr a,
                                                                                                                          com.hp.hpl.jena.sparql.expr.Expr b)

extractConstantConstraintDirected

public static org.aksw.commons.util.Pair<com.hp.hpl.jena.sparql.core.Var,com.hp.hpl.jena.sparql.expr.NodeValue> extractConstantConstraintDirected(com.hp.hpl.jena.sparql.expr.Expr a,
                                                                                                                                  com.hp.hpl.jena.sparql.expr.Expr b)

If a is a variable and b is a constant, then a mapping of the variable to the constant is put into the map, and true is returned. Otherwise, nothing is changed, and false is returned. A mapping of a variable is set to null, if it is mapped to multiple constants

Parameters:

a -

b -

map -

Returns:

getSubExpressions

public static Collection<? extends com.hp.hpl.jena.sparql.expr.Expr> getSubExpressions(com.hp.hpl.jena.sparql.expr.Expr expr,
                                                                       boolean reflexive)

getSubExpressions

public static void getSubExpressions(com.hp.hpl.jena.sparql.expr.Expr expr,
                     Set<com.hp.hpl.jena.sparql.expr.Expr> result)

getFunctionId

public static String getFunctionId(com.hp.hpl.jena.sparql.expr.ExprFunction fn)

getJavaObject

public static Object getJavaObject(com.hp.hpl.jena.sparql.expr.NodeValue expr)

containsFalse

public static boolean containsFalse(Iterable<com.hp.hpl.jena.sparql.expr.Expr> exprs)