|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
| Packages that use Triple | |
|---|---|
| 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.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.graph |
|---|
| Fields in com.hp.hpl.jena.graph declared as Triple | |
|---|---|
static Triple |
Triple.ANY
A Triple that is wildcarded in all fields. |
| Fields in com.hp.hpl.jena.graph with type parameters of type Triple | |
|---|---|
static com.hp.hpl.jena.util.iterator.Map1<Triple,Node> |
Triple.getObject
|
static com.hp.hpl.jena.util.iterator.Map1<Triple,Node> |
Triple.getPredicate
|
static com.hp.hpl.jena.util.iterator.Map1<Triple,Node> |
Triple.getSubject
|
static com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
Triple.None
A triple-iterator with no elements. |
| Methods in com.hp.hpl.jena.graph that return Triple | |
|---|---|
Triple |
Triple.asTriple()
|
Triple |
TripleMatch.asTriple()
Answer a Triple capturing this match. |
Triple |
FrontsTriple.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)
|
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 |
GraphEvents.getTriple()
A fluid triple relevant to the event, or null if not applicable. |
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 that return types with arguments of type Triple | |
|---|---|
abstract com.hp.hpl.jena.util.iterator.Filter<Triple> |
Triple.Field.filterOn(Node n)
|
com.hp.hpl.jena.util.iterator.Filter<Triple> |
Triple.Field.filterOn(Triple t)
|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
Graph.find(Node s,
Node p,
Node o)
Returns an iterator over Triple. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
Graph.find(TripleMatch m)
Returns an iterator over all the Triples that match the triple pattern. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
Reifier.find(TripleMatch m)
Answer an iterator over all the reification triples in this Reifier that match m. |
static com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
GraphUtil.findAll(Graph g)
Answer an iterator covering all the triples in the specified graph. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
Reifier.findEither(TripleMatch m,
boolean showHidden)
Answer an iterator over the reification triples of this Reifier, or an empty iterator - if showHidden is false, only the exposed triples, otherwise only the concealed ones. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
Reifier.findExposed(TripleMatch m)
Answer an iterator over all the reification triples that this Reifier exposes (ie all if Standard, none otherwise) that match m. |
| Methods in com.hp.hpl.jena.graph with parameters of type Triple | |
|---|---|
boolean |
TripleMatchFilter.accept(Triple t)
The object is wanted. |
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. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Node> |
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. |
com.hp.hpl.jena.util.iterator.Filter<Triple> |
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. |
| Method parameters in com.hp.hpl.jena.graph with type arguments of type Triple | |
|---|---|
void |
BulkUpdateHandler.add(Iterator<Triple> it)
Add all the elements from the iterator into the graph this is handler for. |
void |
BulkUpdateHandler.add(List<Triple> triples)
Add all the triples in the list into the graph this is handler for. |
void |
BulkUpdateHandler.delete(Iterator<Triple> it)
Remove all the triples in the iterator from the graph this is handler for. |
void |
BulkUpdateHandler.delete(List<Triple> triples)
Remove all the triples in the list from the graph this is handler for. |
void |
GraphListener.notifyAddIterator(Graph g,
Iterator<Triple> it)
Method called when an iterator [of triples] has been added to the graph |
void |
GraphEventManager.notifyAddIterator(Graph g,
List<Triple> triples)
Notify all attached listeners that an iterator [of triples] has been added to the graph; its content has been captured in the list triples. |
void |
GraphListener.notifyAddList(Graph g,
List<Triple> triples)
Method called when a list [of triples] has been added to the graph. |
void |
GraphListener.notifyDeleteIterator(Graph g,
Iterator<Triple> it)
Method called when an iterator [of triples] has been deleted from the graph. |
void |
GraphEventManager.notifyDeleteIterator(Graph g,
List<Triple> triples)
Notify all attached listeners that an iterator [of triples] has been removed from the graph; its content has been captured in the list triples. |
void |
GraphListener.notifyDeleteList(Graph g,
List<Triple> L)
Method called when a list [of triples] has been deleted from the graph. |
| Constructors in com.hp.hpl.jena.graph with parameters of type Triple | |
|---|---|
TripleMatchFilter(Triple tMatch)
Creates new TripleMatchFilter |
|
TripleMatchIterator(Triple m,
Iterator<Triple> iter)
|
|
| Constructor parameters in com.hp.hpl.jena.graph with type arguments of type Triple | |
|---|---|
TripleMatchIterator(Triple m,
Iterator<Triple> iter)
|
|
| Uses of Triple in com.hp.hpl.jena.graph.compose |
|---|
| Methods in com.hp.hpl.jena.graph.compose that return types with arguments of type Triple | |
|---|---|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
MultiUnion.graphBaseFind(TripleMatch t)
Answer an iterator over the triples in the union of the graphs in this composition. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
DisjointUnion.graphBaseFind(TripleMatch m)
|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
Union.graphBaseFind(TripleMatch t)
To find in the union, find in the components, concatenate the results, and omit duplicates. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
Difference.graphBaseFind(TripleMatch t)
|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
Intersection.graphBaseFind(TripleMatch s)
|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
Delta.graphBaseFind(TripleMatch tm)
Find all the base triples matching tm, exclude the ones that are deleted, add the ones that have been added. |
static com.hp.hpl.jena.util.iterator.Filter<Triple> |
CompositionBase.ifIn(Graph g)
Answer a Filter that will accept any triple that is an edge of
graph g. |
static com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
CompositionBase.rejecting(com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> i,
Graph seen)
Answer an iterator over the elements of i that are not in
the graph seen. |
static com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
CompositionBase.rejecting(com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> i,
Set<Triple> seen)
Answer an iterator over the elements of iterator i that are not in the set seen. |
| 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 |
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 |
DisjointUnion.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 |
Difference.performAdd(Triple t)
Add a triple to the difference: add it to the left operand, and remove it from the right operand. |
void |
Intersection.performAdd(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.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 |
DisjointUnion.performDelete(Triple t)
|
void |
Union.performDelete(Triple t)
To remove a triple, remove it from both operands. |
void |
Difference.performDelete(Triple t)
Remove a triple from the difference: remove it from the left operand. |
void |
Intersection.performDelete(Triple t)
|
void |
Delta.performDelete(Triple t)
Remove the triple, ie, remove it from the adds, add it to the removals. |
| Method parameters in com.hp.hpl.jena.graph.compose with type arguments of type Triple | |
|---|---|
static com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
CompositionBase.rejecting(com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> i,
Graph seen)
Answer an iterator over the elements of i that are not in
the graph seen. |
static com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
CompositionBase.rejecting(com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> i,
Set<Triple> seen)
Answer an iterator over the elements of iterator i that are not in the set seen. |
static com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
CompositionBase.rejecting(com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> i,
Set<Triple> seen)
Answer an iterator over the elements of iterator i that are not in the set seen. |
| 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 that return types with arguments of type Triple | |
|---|---|
Iterator<Triple> |
QueryTriple.SimpleApplyer.find(Domain d)
|
List<Triple> |
Query.getPattern()
Answer a list of the triples that have been added to this query. |
| 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 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,
Object cons)
|
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. |
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 |
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) |
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<String> |
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)
|
|
| Constructor parameters in com.hp.hpl.jena.graph.query with type arguments of type Triple | |
|---|---|
SimpleQueryEngine(List<Triple> pattern,
TripleSorter sorter,
ExpressionSet constraints)
|
|
| 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 that return types with arguments of type Triple | |
|---|---|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
BaseInfGraph.find(Node subject,
Node property,
Node object,
Graph param)
An extension of the Graph.find interface which allows the caller to encode complex expressions in RDF and then refer to those expressions within the query triple. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
InfGraph.find(Node subject,
Node property,
Node object,
Graph param)
An extension of the Graph.find interface which allows the caller to encode complex expressions in RDF and then refer to those expressions within the query triple. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
FGraph.find(TriplePattern pattern)
Basic pattern lookup interface. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
Finder.find(TriplePattern pattern)
Basic pattern lookup interface. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
BaseInfGraph.find(TriplePattern pattern)
Basic pattern lookup interface. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
FGraph.findWithContinuation(TriplePattern pattern,
Finder continuation)
Extended find interface used in situations where the implementator may or may not be able to answer the complete query. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
Finder.findWithContinuation(TriplePattern pattern,
Finder continuation)
Extended find interface used in situations where the implementator may or may not be able to answer the complete query. |
abstract com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
BaseInfGraph.findWithContinuation(TriplePattern pattern,
Finder continuation)
Extended find interface used in situations where the implementator may or may not be able to answer the complete query. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
BaseInfGraph.graphBaseFind(Node subject,
Node property,
Node object)
Returns an iterator over Triples. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
BaseInfGraph.graphBaseFind(TripleMatch m)
Returns an iterator over Triples. |
| Methods in com.hp.hpl.jena.reasoner with parameters of type Triple | |
|---|---|
Iterator<Derivation> |
BaseInfGraph.getDerivation(Triple triple)
Return the derivation of the given triple (which is the result of some previous find operation). |
Iterator<Derivation> |
InfGraph.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.rulesys |
|---|
| Fields in com.hp.hpl.jena.reasoner.rulesys with type parameters of type Triple | |
|---|---|
static com.hp.hpl.jena.util.iterator.Filter<Triple> |
Functor.acceptFilter
A static Filter instance that detects triples with Functor objects |
| 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 that return types with arguments of type Triple | |
|---|---|
com.hp.hpl.jena.util.iterator.ClosableIterator<Triple> |
RuleContext.find(Node s,
Node p,
Node o)
In some formulations the context includes deductions that are not yet visible to the underlying graph but need to be checked for. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
BasicFBReifier.find(TripleMatch m)
|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
LPBackwardRuleInfGraph.find(TriplePattern pattern)
Basic pattern lookup interface. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
FBRuleInfGraph.find(TriplePattern pattern)
Basic pattern lookup interface. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
BasicForwardRuleInfGraph.find(TriplePattern pattern)
Basic pattern lookup interface. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
FBRuleInfGraph.findDataMatches(Node subject,
Node predicate,
Node object)
Search the combination of data and deductions graphs for the given triple pattern. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
BasicForwardRuleInfGraph.findDataMatches(Node subject,
Node predicate,
Node object)
Search the combination of data and deductions graphs for the given triple pattern. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
ForwardRuleInfGraphI.findDataMatches(Node subject,
Node predicate,
Node object)
Search the combination of data and deductions graphs for the given triple pattern. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
BackwardRuleInfGraphI.findDataMatches(TriplePattern pattern)
Match a pattern just against the stored data (raw data, schema, axioms) but no backchaining derivation. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
LPBackwardRuleInfGraph.findDataMatches(TriplePattern pattern)
Match a pattern just against the stored data (raw data, schema, axioms) but no derivation. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
FBRuleInfGraph.findDataMatches(TriplePattern pattern)
Search the combination of data and deductions graphs for the given triple pattern. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
BasicFBReifier.findEither(TripleMatch m,
boolean showHidden)
|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
BasicFBReifier.findExposed(TripleMatch m)
|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
FBRuleInfGraph.findFull(TriplePattern pattern)
Internal variant of find which omits the filters which block illegal RDF data. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
LPBackwardRuleInfGraph.findWithContinuation(TriplePattern pattern,
Finder continuation)
Extended find interface used in situations where the implementator may or may not be able to answer the complete query. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
FBRuleInfGraph.findWithContinuation(TriplePattern pattern,
Finder continuation)
Extended find interface used in situations where the implementator may or may not be able to answer the complete query. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
BasicForwardRuleInfGraph.findWithContinuation(TriplePattern pattern,
Finder continuation)
Extended find interface used in situations where the implementator may or may not be able to answer the complete query. |
List<Triple> |
RuleDerivation.getMatches()
|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
LPBackwardRuleInfGraph.graphBaseFind(Node subject,
Node property,
Node object)
Returns an iterator over Triples. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
FBRuleInfGraph.graphBaseFind(Node subject,
Node property,
Node object)
Returns an iterator over Triples. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
BasicForwardRuleInfGraph.graphBaseFind(Node subject,
Node property,
Node object)
Returns an iterator over Triples. |
| 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 |
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. |
void |
ForwardRuleInfGraphI.addDeduction(Triple t)
Add a new deduction to the deductions graph. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Node> |
BasicFBReifier.allNodes(Triple t)
|
ValidityReport.Report |
FBRuleInfGraph.checkLiteral(Node prop,
Triple triple)
Check a given literal value for a property against the set of known range constraints for it. |
boolean |
RuleContext.contains(Triple t)
Return true if the triple is already in either the graph or the stack. |
Iterator<Derivation> |
LPBackwardRuleInfGraph.getDerivation(Triple t)
Return the derivation of at triple. |
Iterator<Derivation> |
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 |
BackwardRuleInfGraphI.logDerivation(Triple t,
Derivation derivation)
Logger a dervivation record against the given triple. |
void |
LPBackwardRuleInfGraph.logDerivation(Triple t,
Derivation derivation)
Log a dervivation record against the given triple. |
void |
BasicForwardRuleInfGraph.logDerivation(Triple t,
Derivation derivation)
Log a dervivation record against the given triple. |
void |
ForwardRuleInfGraphI.logDerivation(Triple t,
Derivation derivation)
Logger 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 |
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 |
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 |
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.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 |
RETERuleInfGraph.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 |
LPBackwardRuleInfGraph.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 |
SilentAddI.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,
List<Triple> matches,
InfGraph infGraph)
Constructor |
|
| Constructor parameters in com.hp.hpl.jena.reasoner.rulesys with type arguments of type Triple | |
|---|---|
RuleDerivation(Rule rule,
Triple conclusion,
List<Triple> matches,
InfGraph infGraph)
Constructor |
|
| Uses of Triple in com.hp.hpl.jena.reasoner.transitiveReasoner |
|---|
| Methods in com.hp.hpl.jena.reasoner.transitiveReasoner that return types with arguments of type Triple | |
|---|---|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
TransitiveInfGraph.find(TriplePattern pattern)
Basic pattern lookup interface. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
TransitiveGraphCache.find(TriplePattern pattern)
Basic pattern lookup interface. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
TransitiveInfGraph.findWithContinuation(TriplePattern pattern,
Finder continuation)
Extended find interface used in situations where the implementator may or may not be able to answer the complete query. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
TransitiveGraphCache.findWithContinuation(TriplePattern pattern,
Finder continuation)
Extended find interface used in situations where the implementator may or may not be able to answer the complete query. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
TransitiveInfGraph.graphBaseFind(Node subject,
Node property,
Node object)
Returns an iterator over Triples. |
| 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()
|
| Methods in com.hp.hpl.jena.shared that return types with arguments of type Triple | |
|---|---|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
RandomOrderGraph.find(Node s,
Node p,
Node o)
|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
RandomOrderGraph.find(TripleMatch m)
|
| 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 |
| Method parameters in com.hp.hpl.jena.util with type arguments of type Triple | |
|---|---|
void |
MonitorGraph.snapshot(List<Triple> additions,
List<Triple> deletions)
Compute the differences between the current monitored graph and the last snapshot. |
void |
MonitorGraph.snapshot(List<Triple> additions,
List<Triple> deletions)
Compute the differences between the current monitored graph and the last snapshot. |
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||