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.rdql RDQL - A query language for Jena.  
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.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
 void GraphRDB.performAdd(Triple t)
           
 void GraphRDB.performDelete(Triple t)
           
 boolean GraphRDB.contains(Triple t)
           
 

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

Methods in com.hp.hpl.jena.graph that return Triple
 Triple TripleMatch.asTriple()
          Answer a Triple capturing this match.
 Triple TripleIterator.nextTriple()
          Answer the next() element cast to Triple.
 Triple Triple.asTriple()
           
static Triple Triple.create(Node s, Node p, Node o)
          Factory method for creating triples, allows caching opportunities.
static Triple Triple.createMatch(Node s, Node p, Node o)
           
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.create(PrefixMapping pm, java.lang.String fact)
          Utility factory as for create(String), but allowing the PrefixMapping to be specified explicitly.
 Triple GetTriple.getTriple(Node n)
          Answer the triple associated with the node n.
 

Methods in com.hp.hpl.jena.graph with parameters of type Triple
 boolean Triple.matches(Triple other)
           
 Node Reifier.reifyAs(Node n, Triple t)
          note the triple _t_ as reified using _n_ as its representing node.
 boolean Reifier.hasTriple(Triple t)
           
 ExtendedIterator Reifier.allNodes(Triple t)
          return an iterator over all the nodes that are reifiying t in this reifier.
 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 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_.
 void GraphListener.notifyAddTriple(Triple t)
          Method called when a single triple has been added to the graph.
 void GraphListener.notifyAddArray(Triple[] triples)
          Method called when an array of triples has been added to the graph.
 void GraphListener.notifyDeleteTriple(Triple t)
          Method called when a single triple has been deleted from the graph.
 void GraphListener.notifyDeleteArray(Triple[] triples)
          Method called when an array of triples has been deleted from the graph.
 void GraphAdd.add(Triple t)
          Add the triple t (if possible) to the set belonging to this graph
 void Graph.delete(Triple t)
          Remove the triple t (if possible) from the set belonging to this graph
 boolean Graph.contains(Triple t)
          Answer true iff the graph contains a triple that t matches; t may be fluid.
 void BulkUpdateHandler.add(Triple[] triples)
          Add all the triples into the graph this is handler for.
 void BulkUpdateHandler.delete(Triple[] triples)
          Remove all the triples from the graph this is handler for.
 

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

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

Methods in com.hp.hpl.jena.graph.compose with parameters of type Triple
 void Union.performAdd(Triple t)
          To add a triple to the union, add it to the left operand; this is asymmetric.
 void Union.performDelete(Triple t)
          To remove a triple, remove it from both operands.
 boolean Union.contains(Triple t)
           
 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 MultiUnion.notifyAdd(Triple t)
          adds are notified by the base graph (and we share its event handler).
 void MultiUnion.notifyDelete(Triple t)
          deletes are notified by the base graph (and we share its event handler).
 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.
 boolean MultiUnion.contains(Triple t)
           Answer true if at least one of the graphs in this union contain the given triple.
 void Intersection.performAdd(Triple t)
           
 void Intersection.performDelete(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 Difference.performDelete(Triple t)
          Remove a triple from the difference: remove it from the left operand.
 void Delta.performAdd(Triple t)
          Add the triple to the graph, ie add it to the additions, remove it from the removals.
 void Delta.performDelete(Triple t)
          Remove the triple, ie, remove it from the adds, add it to the removals.
 boolean CompositionBase.contains(Triple t)
           Answer true if the given triple occurs at least once in this graph.
 

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
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.
 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.
 Stage SimpleQueryHandler.patternStage(Mapping map, ExpressionSet constraints, Triple[] t)
           
static com.hp.hpl.jena.graph.query.SimpleQueryEngine.Cons SimpleQueryEngine.cons(Triple pattern, java.lang.Object cons)
           
 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.
 Query Query.addMatch(Triple t)
          Add a triple to the query's collection of match triples.
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.
 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.
 void NamedTripleBunches.add(java.lang.String name, Triple pattern)
          Associate another triple with the given name.
 

Constructors in com.hp.hpl.jena.graph.query with parameters of type Triple
PatternStage(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 that return Triple
 Triple Statement.asTriple()
          answer the Triple containing the appropriate Nodes corrsponding to the subject, predicate, and object fields.
 

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

Methods in com.hp.hpl.jena.rdql with parameters of type Triple
 void Query.addTriplePattern(Triple t)
          Programmatic API operation
 

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
static java.lang.String TriplePattern.simplePrintString(Triple t)
          Simplified printable name for a triple
 java.util.Iterator InfGraph.getDerivation(Triple triple)
          Return the derivation of the given triple (which is the result of some previous find operation).
 boolean BaseInfGraph.contains(Triple t)
          Test if the graph contains the given triple.
 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.
 

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.rulesys
 

Methods in com.hp.hpl.jena.reasoner.rulesys that return Triple
 Triple RuleDerivation.getConclusion()
           
 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 SilentAddI.silentAdd(Triple t)
          Assert a new triple in the deduction graph, bypassing any processing machinery.
 boolean RuleContext.contains(Triple t)
          Return true if the triple is already in either the graph or the stack.
 void RuleContext.silentAdd(Triple t)
          Assert a new triple in the deduction graph, bypassing any processing machinery.
 void RuleContext.add(Triple t)
          Assert a new triple in the deduction graph, triggering any consequent processing as appropriate.
 void RuleContext.remove(Triple t)
          Remove a triple from the deduction graph (and the original graph if relevant).
 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 RETERuleInfGraph.performDelete(Triple t)
          Removes the triple t (if possible) from the set belonging to this graph.
 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 LPBackwardRuleInfGraph.performDelete(Triple t)
          Removes the triple t (if possible) from the set belonging to this graph.
 java.util.Iterator LPBackwardRuleInfGraph.getDerivation(Triple t)
          Return the derivation of at triple.
 void LPBackwardRuleInfGraph.logDerivation(Triple t, java.lang.Object derivation)
          Log a dervivation record against the given triple.
 void LPBackwardRuleInfGraph.silentAdd(Triple t)
          Assert a new triple in the deduction graph, bypassing any processing machinery.
 void ForwardRuleInfGraphI.addDeduction(Triple t)
          Add a new deduction to the deductions graph.
 void ForwardRuleInfGraphI.logDerivation(Triple t, java.lang.Object derivation)
          Log a dervivation record against the given triple.
 void FBRuleInfGraph.addDeduction(Triple t)
          Add a new deduction to the deductions graph.
 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 FBRuleInfGraph.performDelete(Triple t)
          Removes the triple t (if possible) from the set belonging to this graph.
 void BasicForwardRuleInfGraph.addDeduction(Triple t)
          Add a new deduction to the deductions graph.
 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 BasicForwardRuleInfGraph.performDelete(Triple t)
          Removes the triple t (if possible) from the set belonging to this graph.
 void BasicForwardRuleInfGraph.logDerivation(Triple t, java.lang.Object derivation)
          Log a dervivation record against the given triple.
 void BasicForwardRuleInfGraph.silentAdd(Triple t)
          Assert a new triple in the deduction graph, bypassing any processing machinery.
 java.util.Iterator BasicForwardRuleInfGraph.getDerivation(Triple t)
          Return the derivation of at triple.
 void BackwardRuleInfGraphI.logDerivation(Triple t, java.lang.Object derivation)
          Log a dervivation record against the given triple.
 

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
 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.
 boolean TransitiveEngine.add(Triple t)
          Add one triple to caches if it is relevant.
 boolean TransitiveEngine.delete(Triple t)
          Removes the triple t (if relevant) from the caches.
 

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
UpdateDeniedException(java.lang.String message, Triple triple)
           
DeleteDeniedException(java.lang.String message, Triple triple)
           
AddDeniedException(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
 



Copyright © 2000-2003 Hewlett-Packard. All Rights Reserved.