|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
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
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.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 | |
---|---|
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 |
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. |
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. |
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. |
void |
RuleContext.remove(Triple t)
Remove a triple from the deduction graph (and the original graph if relevant). |
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 |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |