com.hp.hpl.jena.reasoner

Class TriplePattern

java.lang.Object

com.hp.hpl.jena.reasoner.TriplePattern

All Implemented Interfaces:

ClauseEntry

public class TriplePattern
extends Object
implements ClauseEntry

Datastructure which defines a triple pattern as used in simple rules and in find interfaces.

Wildcards are recorded by using Node_RuleVariable entries rather than nulls because they can be named. If a null is specified that is converted to a variable of name "". Note that whilst some engines might simply require Node_Variables the forward engine requires variables represented using the more specialized subclass - Node_RuleVariable.

It would make more sense to have TriplePattern subclass Triple but that is final for some strange reason.

Constructor Summary

Constructors

Constructor and Description
TriplePattern(Node subject, Node predicate, Node object) Constructor - builds a pattern from three nodes, use Node_RuleVariables as variables, use a variable with an empty name as a wildcard, can also use null as a wildcard.
TriplePattern(Triple match) Constructor - builds a dgenerate pattern from a simple triple.
TriplePattern(TripleMatch match) Constructor - builds a pattern from a standard triple match.

Method Summary

Methods

Modifier and Type	Method and Description
Triple	asTriple() Return the triple pattern as a triple
TripleMatch	asTripleMatch() Return the triple pattern as a triple match
boolean	compatibleWith(TriplePattern pattern) Compare two patterns for compatibility - i.e.
boolean	equals(Object o) Equality override - used so that TriplePattern variants (same to within variable renaming) test as equals
Node	getObject() Returns the object.
Node	getPredicate() Returns the predicate.
Node	getSubject() Returns the subject.
int	hashCode() hash function override
boolean	isGround() Test if the pattern is ground, contains no variables.
boolean	isLegal() Check a pattern to see if it is legal, used to exclude backchaining goals that could never be satisfied.
boolean	sameAs(Object o) Compare triple patterns, taking into account variable indices.
static String	simplePrintString(Node n) Simplified printable name for a node
static String	simplePrintString(Triple t) Simplified printable name for a triple
boolean	subsumes(TriplePattern arg) Compare two patterns and return true if arg is a more specific (more grounded) version of this one.
String	toString() Printable string
boolean	variantOf(TriplePattern pattern) Test if a pattern is just a variant of this pattern.

Methods inherited from class java.lang.Object

getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

TriplePattern

public TriplePattern(Node subject,
             Node predicate,
             Node object)

Constructor - builds a pattern from three nodes, use Node_RuleVariables as variables, use a variable with an empty name as a wildcard, can also use null as a wildcard.

TriplePattern

public TriplePattern(TripleMatch match)

Constructor - builds a pattern from a standard triple match. Node that any filter part of the triple match will not be represented within the pattern and will need to be checked for separately.

TriplePattern

public TriplePattern(Triple match)

Constructor - builds a dgenerate pattern from a simple triple. This would be much easier if we merged Triples and TriplePatterns!

Method Detail

getObject

public Node getObject()

Returns the object.

Returns:

Node

getPredicate

public Node getPredicate()

Returns the predicate.

Returns:

Node

getSubject

public Node getSubject()

Returns the subject.

Returns:

Node

asTripleMatch

public TripleMatch asTripleMatch()

Return the triple pattern as a triple match

asTriple

public Triple asTriple()

Return the triple pattern as a triple

compatibleWith

public boolean compatibleWith(TriplePattern pattern)

Compare two patterns for compatibility - i.e. potentially unifiable. Two patterns are "compatible" in the sense we mean here if all their ground terms match. A variable in either pattern can match a ground term or a variable in the other. We are not, currently, checking for multiple occurances of the same variable. Functor-valued object literals are treated as a special case which are only checked for name/arity matching.

variantOf

public boolean variantOf(TriplePattern pattern)

Test if a pattern is just a variant of this pattern. I.e. it is the same up to variable renaming. This takes into account multiple occurances of the same variable.

isLegal

public boolean isLegal()

Check a pattern to see if it is legal, used to exclude backchaining goals that could never be satisfied. A legal pattern cannot have literals in the subject or predicate positions and is not allowed nested functors in the object.

subsumes

public boolean subsumes(TriplePattern arg)

Compare two patterns and return true if arg is a more specific (more grounded) version of this one. Does not handle functors.

isGround

public boolean isGround()

Test if the pattern is ground, contains no variables.

toString

public String toString()

Printable string

Overrides:

toString in class Object

simplePrintString

public static String simplePrintString(Triple t)

Simplified printable name for a triple

simplePrintString

public static String simplePrintString(Node n)

Simplified printable name for a node

equals

public boolean equals(Object o)

Equality override - used so that TriplePattern variants (same to within variable renaming) test as equals

Overrides:

equals in class Object

hashCode

public int hashCode()

hash function override

Overrides:

hashCode in class Object

sameAs

public boolean sameAs(Object o)

Compare triple patterns, taking into account variable indices. The equality function ignores differences between variables.

Specified by:

sameAs in interface ClauseEntry