Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.hp.hpl.jena.graph
Class Triple

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

All Implemented Interfaces:
  TripleMatch

    public class Triple

extends java.lang.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 Map1` | `getObject`
`static Map1` | `getPredicate`
`static Map1` | `getSubject`

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` | `create(PrefixMapping pm, java.lang.String fact)` Utility factory as for create(String), but allowing the PrefixMapping to be specified explicitly.
`static Triple` | `create(java.lang.String fact)` Utility factory method for creating a triple based on the content of an "S P O" string.
`static Triple` | `createMatch(Node s, Node p, Node o)`
`boolean` | `equals(java.lang.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)`
`java.lang.String` | `toString()` return a human-readable string "subject @predicate object" describing the triple
`java.lang.String` | `toString(PrefixMapping pm)`

Methods inherited from class java.lang.Object
`getClass, notify, notifyAll, wait, wait, wait`

Field Detail

### getSubject

    public static final Map1 getSubject

### getPredicate

    public static final Map1 getPredicate

### getObject

    public static final Map1 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 java.lang.String toString()

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

  Overrides:
    `toString` in class `java.lang.Object`

### toString

    public java.lang.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(java.lang.Object o)

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

  Overrides:
    `equals` in class `java.lang.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 `java.lang.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)

### create

    public static Triple create(java.lang.String fact)

  Utility factory method for creating a triple based on the content of an "S P O" string. The S, P, O are processed by Node.create, see which for details of the supported syntax. This method exists to support test code. Nodes are interpreted using the Standard prefix mapping.

### create

    public static Triple create(PrefixMapping pm,
                                java.lang.String fact)

  Utility factory as for create(String), but allowing the PrefixMapping to be specified explicitly.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Hewlett-Packard Development Company, LP