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

Methods in com.hp.hpl.jena.graph that return Triple
 Triple FrontsTriple.asTriple()
           
 Triple TripleMatch.asTriple()
          Answer a Triple capturing this match.
 Triple Triple.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, String fact)
          Utility factory as for create(String), but allowing the PrefixMapping to be specified explicitly.
static Triple Triple.create(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.
 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, 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 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)
           
 boolean Union.graphBaseContains(Triple t)
           
 void Delta.performAdd(Triple t)
          Add the triple to the graph, ie add it to the additions, remove it from the removals.
 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 Difference.performAdd(Triple t)
          Add a triple to the difference: add it to the left operand, and remove it from the right operand.
 void DisjointUnion.performAdd(Triple t)
           
 void Intersection.performAdd(Triple t)
           
 void Union.performAdd(Triple t)
          To add a triple to the union, add it to the left operand; this is asymmetric.
 void Delta.performDelete(Triple t)
          Remove the triple, ie, remove it from the adds, add it to the removals.
 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 Difference.performDelete(Triple t)
          Remove a triple from the difference: remove it from the left operand.
 void DisjointUnion.performDelete(Triple t)
           
 void Intersection.performDelete(Triple t)
           
 void Union.performDelete(Triple t)
          To remove a triple, remove it from both operands.
 

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

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

Methods in com.hp.hpl.jena.graph.query with parameters of type Triple
 void NamedTripleBunches.add(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 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 com.hp.hpl.jena.graph.query.SimpleQueryEngine.Cons SimpleQueryEngine.cons(Triple pattern, 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.
 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.
 Stage SimpleQueryHandler.patternStage(Mapping map, ExpressionSet constraints, Triple[] t)
           
 Triple[] SimpleTripleSorter.sort(Triple[] ts)
          Sort the triple array so that more-bound triples come before less-bound triples.
 Triple[] TripleSorter.sort(Triple[] triples)
          Sort the array triples and return the reorganised array.
static 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
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 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.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
 Iterator InfGraph.getDerivation(Triple triple)
          Return the derivation of the given triple (which is the result of some previous find operation).
 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 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 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 BasicForwardRuleInfGraph.addDeduction(Triple t)
          Add a new deduction to the deductions graph.
 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.
 boolean RuleContext.contains(Triple t)
          Return true if the triple is already in either the graph or the stack.
 Iterator BasicForwardRuleInfGraph.getDerivation(Triple t)
          Return the derivation of at triple.
 Iterator LPBackwardRuleInfGraph.getDerivation(Triple t)
          Return the derivation of at triple.
 void BasicForwardRuleInfGraph.logDerivation(Triple t, Object derivation)
          Log a dervivation record against the given triple.
 void LPBackwardRuleInfGraph.logDerivation(Triple t, Object derivation)
          Log a dervivation record against the given triple.
 void BackwardRuleInfGraphI.logDerivation(Triple t, Object derivation)
          Log a dervivation record against the given triple.
 void ForwardRuleInfGraphI.logDerivation(Triple t, Object derivation)
          Log a dervivation record against the given triple.
 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 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 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 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.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 RETERuleInfGraph.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 RuleContext.remove(Triple t)
          Remove a triple from the deduction graph (and the original graph if relevant).
 void BasicForwardRuleInfGraph.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 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.
 

Constructors in com.hp.hpl.jena.reasoner.rulesys with parameters of type Triple
RuleDerivation(Rule rule, Triple conclusion, 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(String message, Triple triple)
           
DeleteDeniedException(String message, Triple triple)
           
UpdateDeniedException(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 String PrintUtil.print(Triple triple)
          Return a simplified print string for a Triple
 



Copyright © 2000, 2001, 2002, 2003, 2004 Hewlett-Packard Development Company, LP