com.hp.hpl.jena.graph
Class Triple

java.lang.Object
  com.hp.hpl.jena.graph.Triple

All Implemented Interfaces:

TripleMatch

public class Triple
extends Object
implements TripleMatch

Triples are the basis for RDF statements; they have a subject, predicate, and object field (all nodes) and express the notion that the relationship named by the predicate holds between the subject and the object.

Author:

Jeremy Carroll, kers

Nested Class Summary

static class

Triple.Field A Field is a selector from Triples; it allows selectors to be passed around as if they were functions, hooray.

Field Summary

static Triple	ANY A Triple that is wildcarded in all fields.
static com.hp.hpl.jena.util.iterator.Map1<Triple,Node>	getObject
static com.hp.hpl.jena.util.iterator.Map1<Triple,Node>	getPredicate
static com.hp.hpl.jena.util.iterator.Map1<Triple,Node>	getSubject
static com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple>	None A triple-iterator with no elements.

Constructor Summary

Triple(Node s, Node p, Node o)

Method Summary

Triple	asTriple() Answer a Triple capturing this match.
static Triple	create(Node s, Node p, Node o) Factory method for creating triples, allows caching opportunities.
static Triple	createMatch(Node s, Node p, Node o)
boolean	equals(Object o) Answer true if o is a Triple with the same subject, predicate, and object as this triple.
Node	getMatchObject() If it is known that all triples selected by this match will have a common object, return that node, otherwise return null
Node	getMatchPredicate() If it is known that all triples selected by this match will have a common predicate, return that node, otherwise return null
Node	getMatchSubject() If it is known that all triples selected by this filter will have a common subject, return that node, otherwise return null
Node	getObject()
Node	getPredicate()
Node	getSubject()
int	hashCode() The hash-code of a triple is the hash-codes of its components munged together: see hashCode(S, P, O).
static int	hashCode(Node s, Node p, Node o) Return the munged hashCodes of the specified nodes, an exclusive-or of the slightly-shifted component hashcodes; this means (almost) all of the bits count, and the order matters, so (S @P O) has a different hash from (O @P S), etc.
boolean	isConcrete()
boolean	matches(Node s, Node p, Node o)
boolean	matches(Triple other)
boolean	objectMatches(Node o)
boolean	predicateMatches(Node p)
boolean	sameAs(Node s, Node p, Node o) Answer true iff this triple has subject s, predicate p, and object o.
boolean	subjectMatches(Node s)
String	toString() return a human-readable string "subject @predicate object" describing the triple
String	toString(PrefixMapping pm)

Methods inherited from class java.lang.Object

getClass, notify, notifyAll, wait, wait, wait

Field Detail

None

public static final com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> None

A triple-iterator with no elements.

getSubject

public static final com.hp.hpl.jena.util.iterator.Map1<Triple,Node> getSubject

getPredicate

public static final com.hp.hpl.jena.util.iterator.Map1<Triple,Node> getPredicate

getObject

public static final com.hp.hpl.jena.util.iterator.Map1<Triple,Node> getObject

ANY

public static final Triple ANY

A Triple that is wildcarded in all fields.

Constructor Detail

Triple

public Triple(Node s,
              Node p,
              Node o)

Method Detail

toString

public String toString()

return a human-readable string "subject @predicate object" describing the triple

Overrides:

toString in class Object

toString

public String toString(PrefixMapping pm)

getSubject

public final Node getSubject()

Returns:

the subject of the triple

getPredicate

public final Node getPredicate()

Returns:

the predicate of the triple

getObject

public final Node getObject()

Returns:

the object of the triple

getMatchSubject

public Node getMatchSubject()

Description copied from interface: TripleMatch

If it is known that all triples selected by this filter will have a common subject, return that node, otherwise return null

Specified by:

getMatchSubject in interface TripleMatch

getMatchPredicate

public Node getMatchPredicate()

Description copied from interface: TripleMatch

If it is known that all triples selected by this match will have a common predicate, return that node, otherwise return null

Specified by:

getMatchPredicate in interface TripleMatch

getMatchObject

public Node getMatchObject()

Description copied from interface: TripleMatch

If it is known that all triples selected by this match will have a common object, return that node, otherwise return null

Specified by:

getMatchObject in interface TripleMatch

asTriple

public Triple asTriple()

Description copied from interface: TripleMatch

Answer a Triple capturing this match.

Specified by:

asTriple in interface TripleMatch

isConcrete

public boolean isConcrete()

equals

public boolean equals(Object o)

Answer true if o is a Triple with the same subject, predicate, and object as this triple.

Overrides:

equals in class Object

sameAs

public boolean sameAs(Node s,
                      Node p,
                      Node o)

Answer true iff this triple has subject s, predicate p, and object o.

matches

public boolean matches(Triple other)

matches

public boolean matches(Node s,
                       Node p,
                       Node o)

subjectMatches

public boolean subjectMatches(Node s)

predicateMatches

public boolean predicateMatches(Node p)

objectMatches

public boolean objectMatches(Node o)

hashCode

public int hashCode()

The hash-code of a triple is the hash-codes of its components munged together: see hashCode(S, P, O).

Overrides:

hashCode in class Object

hashCode

public static int hashCode(Node s,
                           Node p,
                           Node o)

Return the munged hashCodes of the specified nodes, an exclusive-or of the slightly-shifted component hashcodes; this means (almost) all of the bits count, and the order matters, so (S @P O) has a different hash from (O @P S), etc.

create

public static Triple create(Node s,
                            Node p,
                            Node o)

Factory method for creating triples, allows caching opportunities. Attempts to use triples from the cache, if any suitable ones exist.

Returns:

a triple with subject=s, predicate=p, object=o

createMatch

public static Triple createMatch(Node s,
                                 Node p,
                                 Node o)