com.hp.hpl.jena.graph
Class Triple

java.lang.Object
  extended by 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.


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)
           
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)

createMatch

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


Licenced under the Apache License, Version 2.0