com.hp.hpl.jena.reasoner
Class TriplePattern

java.lang.Object
  com.hp.hpl.jena.reasoner.TriplePattern

All Implemented Interfaces:

com.hp.hpl.jena.reasoner.rulesys.ClauseEntry

public class TriplePattern

extends java.lang.Object

implements com.hp.hpl.jena.reasoner.rulesys.ClauseEntry

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

Wildcards are recorded by using Node_Variable entries rather than nulls because they can be named. If a null is specified that is converted to a variable of name "".

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

Version:

$Revision: 1.14 $ on $Date: 2003/06/22 16:10:50 $

Author:

Dave Reynolds

Constructor Summary

TriplePattern(Node subject, Node predicate, Node object)
Constructor - builds a pattern from three nodes, use Node_Variables 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

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. potentially unifiable.
boolean	equals(java.lang.Object o) Equality override
Node	getObject() Returns the object.
Node	getPredicate() Returns the predicate.
Node	getSubject() Returns the subject.
int	hashCode() hash function override
boolean	isLegal() Check a pattern to see if it is legal, used to exclude backchaining goals that could never be satisfied.
boolean	sameAs(java.lang.Object o) Compare triple patterns, taking into account variable indices.
static java.lang.String	simplePrintString(Node n) Simplified printable name for a node
static java.lang.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.
java.lang.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_Variables 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.

toString

public java.lang.String toString()

Printable string

simplePrintString

public static java.lang.String simplePrintString(Triple t)

Simplified printable name for a triple

simplePrintString

public static java.lang.String simplePrintString(Node n)

Simplified printable name for a node

equals

public boolean equals(java.lang.Object o)

Equality override

hashCode

public int hashCode()

hash function override

sameAs

public boolean sameAs(java.lang.Object o)

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

Specified by:

sameAs in interface com.hp.hpl.jena.reasoner.rulesys.ClauseEntry