Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

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

Packages that use Triple
com.hp.hpl.jena.db | A general database backend for persistent storage of Jena models.
com.hp.hpl.jena.graph | This package defines the Graph and Node family of classes, which form the underlying datatypes of the Jena system.
com.hp.hpl.jena.graph.compose | This package defines simple composite graphs - union, intersection, difference, and update-tracking.
com.hp.hpl.jena.graph.query | Defines the graph-level Query classes, allowing multi-pattern query over arbitrary graphs.
com.hp.hpl.jena.rdf.model | A package for creating and manipulating RDF graphs.
com.hp.hpl.jena.reasoner | The Jena2 reasoner subsystem is designed to allow a range of inference engines to be plugged into Jena.
com.hp.hpl.jena.reasoner.dig |
com.hp.hpl.jena.reasoner.rulesys | Provides a selection of simple rule engines for Jena inference models.
com.hp.hpl.jena.reasoner.transitiveReasoner | This package contains a reasoner which supports transitive-reflexive closure of subPropertyOf and subClassOf relations.
com.hp.hpl.jena.shared | This package defines some classes common to the Jena API and SPI levels, in particular the JenaException class from which all Jena-specific exceptions hang, and the interface PrefixMapping for translation to and from QNames.
com.hp.hpl.jena.util | Miscellaneous collection of utility classes.

Uses of Triple in com.hp.hpl.jena.db

Methods in com.hp.hpl.jena.db with parameters of type Triple
`boolean` | `GraphRDB.graphBaseContains(Triple t)`
`void` | `GraphRDB.performAdd(Triple t)`
`void` | `GraphRDB.performDelete(Triple t)`

Uses of Triple in com.hp.hpl.jena.graph

Fields in com.hp.hpl.jena.graph declared as Triple
`static Triple` | `Triple.ANY` A Triple that is wildcarded in all fields.

Methods in com.hp.hpl.jena.graph that return Triple
`Triple` | `TripleMatch.asTriple()` Answer a Triple capturing this match.
`Triple` | `Triple.asTriple()`
`Triple` | `FrontsTriple.asTriple()`
`static Triple` | `Triple.create(Node s, Node p, Node o)` Factory method for creating triples, allows caching opportunities.
`static Triple` | `Triple.create(PrefixMapping pm, java.lang.String fact)` Utility factory as for create(String), but allowing the PrefixMapping to be specified explicitly.
`static Triple` | `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` | `Triple.createMatch(Node s, Node p, Node o)`
`Triple` | `TripleCache.get(Node s, Node p, Node o)` Answer any triple in the cache with subject `s`, predicate `p`, and object `o`, or `null` if no such triple exists.
`Triple` | `GetTriple.getTriple(Node n)` Answer the triple associated with the node `n`.
`Triple` | `TripleIterator.nextTriple()` Answer the next() element cast to Triple.
`Triple` | `TripleCache.put(Triple t)` Cache the triple `t` by storing it in the slot with the its reduced hash.

Methods in com.hp.hpl.jena.graph with parameters of type Triple
`void` | `GraphAdd.add(Triple t)` Add the triple t (if possible) to the set belonging to this graph
`void` | `BulkUpdateHandler.add(Triple[] triples)` Add all the triples into the graph this is handler for.
`ExtendedIterator` | `Reifier.allNodes(Triple t)` return an iterator over all the nodes that are reifiying t in this reifier.
`boolean` | `Graph.contains(Triple t)` Answer true iff the graph contains a triple that t matches; t may be fluid.
`void` | `Graph.delete(Triple t)` Remove the triple t (if possible) from the set belonging to this graph
`void` | `BulkUpdateHandler.delete(Triple[] triples)` Remove all the triples from the graph this is handler for.
`Filter` | `Triple.Field.filterOn(Triple t)`
`abstract Node` | `Triple.Field.getField(Triple t)`
`boolean` | `Reifier.handledAdd(Triple t)` true iff the Reifier has handled an add of the triple _t_.
`boolean` | `Reifier.handledRemove(Triple t)` true iff the Reifier has handled a remove of the triple _t_.
`boolean` | `Reifier.hasTriple(Triple t)`
`boolean` | `Triple.matches(Triple other)`
`void` | `GraphListener.notifyAddArray(Graph g, Triple[] triples)` Method called when an array of triples has been added to the graph.
`void` | `GraphListener.notifyAddTriple(Graph g, Triple t)` Method called when a single triple has been added to the graph.
`void` | `GraphListener.notifyDeleteArray(Graph g, Triple[] triples)` Method called when an array of triples has been deleted from the graph.
`void` | `GraphListener.notifyDeleteTriple(Graph g, Triple t)` Method called when a single triple has been deleted from the graph.
`Triple` | `TripleCache.put(Triple t)` Cache the triple `t` by storing it in the slot with the its reduced hash.
`Node` | `Reifier.reifyAs(Node n, Triple t)` note the triple _t_ as reified using _n_ as its representing node.
`void` | `Reifier.remove(Node n, Triple t)` remove any existing binding for _n_; hasNode(n) will return false and getTriple(n) will return null.
`void` | `Reifier.remove(Triple t)` remove all bindings which map to this triple.
`boolean` | `TripleBoundary.stopAt(Triple t)` Answer true if this triple is a stopping triple, and whatever search is using this interface should proceed no further.

Constructors in com.hp.hpl.jena.graph with parameters of type Triple
`TripleMatchFilter(Triple tMatch)` Creates new TripleMatchFilter
`TripleMatchIterator(Triple m, java.util.Iterator iter)`

Uses of Triple in com.hp.hpl.jena.graph.compose

Methods in com.hp.hpl.jena.graph.compose with parameters of type Triple
`boolean` | `Union.graphBaseContains(Triple t)`
`boolean` | `MultiUnion.graphBaseContains(Triple t)` Answer true if at least one of the graphs in this union contain the given triple.
`boolean` | `DisjointUnion.graphBaseContains(Triple t)`
`void` | `Union.performAdd(Triple t)` To add a triple to the union, add it to the left operand; this is asymmetric.
`void` | `MultiUnion.performAdd(Triple t)` Add the given triple to the union model; the actual component model to be updated will be the designated (or default) updateable graph.
`void` | `Intersection.performAdd(Triple t)`
`void` | `DisjointUnion.performAdd(Triple t)`
`void` | `Difference.performAdd(Triple t)` Add a triple to the difference: add it to the left operand, and remove it from the right operand.
`void` | `Delta.performAdd(Triple t)` Add the triple to the graph, ie add it to the additions, remove it from the removals.
`void` | `Union.performDelete(Triple t)` To remove a triple, remove it from both operands.
`void` | `MultiUnion.performDelete(Triple t)` Delete the given triple from the union model; the actual component model to be updated will be the designated (or default) updateable graph.
`void` | `Intersection.performDelete(Triple t)`
`void` | `DisjointUnion.performDelete(Triple t)`
`void` | `Difference.performDelete(Triple t)` Remove a triple from the difference: remove it from the left operand.
`void` | `Delta.performDelete(Triple t)` Remove the triple, ie, remove it from the adds, add it to the removals.

Uses of Triple in com.hp.hpl.jena.graph.query

Methods in com.hp.hpl.jena.graph.query that return Triple
`Triple[]` | `TripleSorter.sort(Triple[] triples)` Sort the array triples and return the reorganised array.
`Triple[]` | `SimpleTripleSorter.sort(Triple[] ts)` Sort the triple array so that more-bound triples come before less-bound triples.

Methods in com.hp.hpl.jena.graph.query with parameters of type Triple
`void` | `NamedTripleBunches.add(java.lang.String name, Triple pattern)` Associate another triple with the given name.
`Query` | `Query.addMatch(Triple t)` Add a triple to the query's collection of match triples.
`static QueryTriple` | `QueryTriple.classify(QueryNodeFactory f, Mapping m, Triple t)`
`static QueryTriple[]` | `QueryTriple.classify(QueryNodeFactory f, Mapping m, Triple[] t)`
`static Pattern[]` | `PatternStageCompiler.compile(PatternCompiler compiler, Mapping map, Triple[] source)` to compile an array of triples, compile each triple and form the corresponding array of Patterns.
`static SimpleQueryEngine.Cons` | `SimpleQueryEngine.cons(Triple pattern, java.lang.Object cons)`
`boolean` | `Pattern.match(Domain d, Triple t)` Answer true iff this pattern, given the values for variables as found in a given Domain, matches the given triple; update the Domain with any variable bindings.
`abstract boolean` | `Matcher.match(Domain d, Triple t)` Answer true iff we match the triple `t` given the bindings in `d`, updating those bindings if appropriate; the bindings may be updated even if the match answers `false`.
`Stage` | `SimpleQueryHandler.patternStage(Mapping map, ExpressionSet constraints, Triple[] t)`
`Stage` | `QueryHandler.patternStage(Mapping map, ExpressionSet constraints, Triple[] p)` produce a single Stage which will probe the underlying graph for triples matching p and inject all the resulting bindings into the processing stream (see Stage for details) _map_ is the variable binding map to use and update.
`Triple[]` | `TripleSorter.sort(Triple[] triples)` Sort the array triples and return the reorganised array.
`Triple[]` | `SimpleTripleSorter.sort(Triple[] ts)` Sort the triple array so that more-bound triples come before less-bound triples.
`static java.util.Set` | `Util.variablesOf(Triple t)` Answer a new set which contains exactly the names of the variable[ node]s in the triple.

Constructors in com.hp.hpl.jena.graph.query with parameters of type Triple
`GuardArranger(Triple[] triples)`
`PatternStage(Graph graph, Mapping map, ExpressionSet constraints, Triple[] triples)`
`PatternStageBase(QueryNodeFactory factory, Graph graph, Mapping map, ExpressionSet constraints, Triple[] triples)`

Uses of Triple in com.hp.hpl.jena.rdf.model

Methods in com.hp.hpl.jena.rdf.model with parameters of type Triple
`Statement` | `ModelGraphInterface.asStatement(Triple t)` Answer a Statement in this Model who's SPO is that of the triple `t`.

Uses of Triple in com.hp.hpl.jena.reasoner

Methods in com.hp.hpl.jena.reasoner that return Triple
`Triple` | `TriplePattern.asTriple()` Return the triple pattern as a triple

Methods in com.hp.hpl.jena.reasoner with parameters of type Triple
`java.util.Iterator` | `InfGraph.getDerivation(Triple triple)` Return the derivation of the given triple (which is the result of some previous find operation).
`java.util.Iterator` | `BaseInfGraph.getDerivation(Triple triple)` Return the derivation of the given triple (which is the result of some previous find operation).
`void` | `BaseInfGraph.performAdd(Triple t)` Add one triple to the data graph, run any rules triggered by the new data item, recursively adding any generated triples.
`void` | `BaseInfGraph.performDelete(Triple t)` Removes the triple t (if possible) from the set belonging to this graph.
`static java.lang.String` | `TriplePattern.simplePrintString(Triple t)` Simplified printable name for a triple

Constructors in com.hp.hpl.jena.reasoner with parameters of type Triple
`TriplePattern(Triple match)` Constructor - builds a dgenerate pattern from a simple triple.

Uses of Triple in com.hp.hpl.jena.reasoner.dig

Methods in com.hp.hpl.jena.reasoner.dig with parameters of type Triple
`void` | `DIGInfGraph.performAdd(Triple t)` Add one triple to the data graph, mark the graph not-prepared, but don't run prepare() just yet.
`void` | `DIGInfGraph.performDelete(Triple t)` Delete one triple from the data graph, mark the graph not-prepared, but don't run prepare() just yet.

Uses of Triple in com.hp.hpl.jena.reasoner.rulesys

Methods in com.hp.hpl.jena.reasoner.rulesys that return Triple
`Triple` | `RuleDerivation.getConclusion()`
`Triple` | `BasicFBReifier.getTriple(Node n)`
`Triple` | `BindingEnvironment.instantiate(TriplePattern pattern)` Instantiate a triple pattern against the current environment.

Methods in com.hp.hpl.jena.reasoner.rulesys with parameters of type Triple
`void` | `RuleContext.add(Triple t)` Assert a new triple in the deduction graph, triggering any consequent processing as appropriate.
`void` | `ForwardRuleInfGraphI.addDeduction(Triple t)` Add a new deduction to the deductions graph.
`void` | `FBRuleInfGraph.addDeduction(Triple t)` Add a new deduction to the deductions graph.
`void` | `BasicForwardRuleInfGraph.addDeduction(Triple t)` Add a new deduction to the deductions graph.
`ExtendedIterator` | `BasicFBReifier.allNodes(Triple t)`
`boolean` | `RuleContext.contains(Triple t)` Return true if the triple is already in either the graph or the stack.
`java.util.Iterator` | `LPBackwardRuleInfGraph.getDerivation(Triple t)` Return the derivation of at triple.
`java.util.Iterator` | `BasicForwardRuleInfGraph.getDerivation(Triple t)` Return the derivation of at triple.
`boolean` | `BasicFBReifier.handledAdd(Triple t)`
`boolean` | `BasicFBReifier.handledRemove(Triple t)`
`boolean` | `BasicFBReifier.hasTriple(Triple t)`
`void` | `LPBackwardRuleInfGraph.logDerivation(Triple t, java.lang.Object derivation)` Log a dervivation record against the given triple.
`void` | `ForwardRuleInfGraphI.logDerivation(Triple t, java.lang.Object derivation)` Log a dervivation record against the given triple.
`void` | `BasicForwardRuleInfGraph.logDerivation(Triple t, java.lang.Object derivation)` Log a dervivation record against the given triple.
`void` | `BackwardRuleInfGraphI.logDerivation(Triple t, java.lang.Object derivation)` Log a dervivation record against the given triple.
`boolean` | `RulePreprocessHook.needsRerun(FBRuleInfGraph infGraph, Triple t)` Validate a triple add to see if it should reinvoke the hook.
`void` | `RETERuleInfGraph.performAdd(Triple t)` Add one triple to the data graph, run any rules triggered by the new data item, recursively adding any generated triples.
`void` | `LPBackwardRuleInfGraph.performAdd(Triple t)` Add one triple to the data graph, run any rules triggered by the new data item, recursively adding any generated triples.
`void` | `FBRuleInfGraph.performAdd(Triple t)` Add one triple to the data graph, run any rules triggered by the new data item, recursively adding any generated triples.
`void` | `BasicForwardRuleInfGraph.performAdd(Triple t)` Add one triple to the data graph, run any rules triggered by the new data item, recursively adding any generated triples.
`void` | `RETERuleInfGraph.performDelete(Triple t)` Removes the triple t (if possible) from the set belonging to this graph.
`void` | `LPBackwardRuleInfGraph.performDelete(Triple t)` Removes the triple t (if possible) from the set belonging to this graph.
`void` | `FBRuleInfGraph.performDelete(Triple t)` Removes the triple t (if possible) from the set belonging to this graph.
`void` | `BasicForwardRuleInfGraph.performDelete(Triple t)` Removes the triple t (if possible) from the set belonging to this graph.
`Node` | `BasicFBReifier.reifyAs(Node n, Triple t)`
`void` | `BasicFBReifier.remove(Node n, Triple t)`
`void` | `RuleContext.remove(Triple t)` Remove a triple from the deduction graph (and the original graph if relevant).
`void` | `BasicFBReifier.remove(Triple t)`
`void` | `SilentAddI.silentAdd(Triple t)` Assert a new triple in the deduction graph, bypassing any processing machinery.
`void` | `RuleContext.silentAdd(Triple t)` Assert a new triple in the deduction graph, bypassing any processing machinery.
`void` | `LPBackwardRuleInfGraph.silentAdd(Triple t)` Assert a new triple in the deduction graph, bypassing any processing machinery.
`void` | `BasicForwardRuleInfGraph.silentAdd(Triple t)` Assert a new triple in the deduction graph, bypassing any processing machinery.

Constructors in com.hp.hpl.jena.reasoner.rulesys with parameters of type Triple
`RuleDerivation(Rule rule, Triple conclusion, java.util.List matches, InfGraph infGraph)` Constructor

Uses of Triple in com.hp.hpl.jena.reasoner.transitiveReasoner

Methods in com.hp.hpl.jena.reasoner.transitiveReasoner with parameters of type Triple
`boolean` | `TransitiveEngine.add(Triple t)` Add one triple to caches if it is relevant.
`void` | `TransitiveGraphCache.addRelation(Triple t)` Register a new relation instance in the cache
`boolean` | `TransitiveEngine.delete(Triple t)` Removes the triple t (if relevant) from the caches.
`void` | `TransitiveInfGraph.performAdd(Triple t)` Add one triple to the data graph, run any rules triggered by the new data item, recursively adding any generated triples.
`void` | `TransitiveInfGraph.performDelete(Triple t)` Removes the triple t (if possible) from the set belonging to this graph.
`void` | `TransitiveGraphCache.removeRelation(Triple t)` Remove an instance of a relation from the cache.

Uses of Triple in com.hp.hpl.jena.shared

Methods in com.hp.hpl.jena.shared that return Triple
`Triple` | `UpdateDeniedException.getTriple()`

Constructors in com.hp.hpl.jena.shared with parameters of type Triple
`AddDeniedException(java.lang.String message, Triple triple)`
`DeleteDeniedException(java.lang.String message, Triple triple)`
`UpdateDeniedException(java.lang.String message, Triple triple)`

Uses of Triple in com.hp.hpl.jena.util

Methods in com.hp.hpl.jena.util that return Triple
`Triple` | `QueryMapper.toQueryTriple(Statement s)`

Methods in com.hp.hpl.jena.util with parameters of type Triple
`static java.lang.String` | `PrintUtil.print(Triple triple)` Return a simplified print string for a Triple

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

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