Package | Description |
---|---|
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.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.
|
Modifier and Type | Method and Description |
---|---|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
GraphRDB.getPropertyTriples()
Returns triples that describe this graph in the system properties graph.
|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
GraphRDB.graphBaseFind(TripleMatch m) |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
GraphRDB.reifierTriples(TripleMatch m) |
Modifier and Type | Method and Description |
---|---|
boolean |
GraphRDB.graphBaseContains(Triple t) |
void |
GraphRDB.performAdd(Triple t) |
void |
GraphRDB.performDelete(Triple t) |
Modifier and Type | Method and Description |
---|---|
void |
GraphRDB.add(List<Triple> triples)
Add a list of triples.
|
void |
GraphRDB.delete(List<Triple> triples)
Delete a list of triples.
|
Modifier and Type | Field and Description |
---|---|
static Triple |
Triple.ANY
A Triple that is wildcarded in all fields.
|
Modifier and Type | Field and Description |
---|---|
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.
|
Modifier and Type | Method and Description |
---|---|
Triple |
FrontsTriple.asTriple() |
Triple |
Triple.asTriple() |
Triple |
TripleMatch.asTriple()
Answer a Triple capturing this match.
|
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. |
Modifier and Type | Method and Description |
---|---|
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.
|
Modifier and Type | Method and Description |
---|---|
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.
|
Modifier and Type | Method and Description |
---|---|
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.
|
Constructor and Description |
---|
TripleMatchFilter(Triple tMatch)
Creates new TripleMatchFilter
|
TripleMatchIterator(Triple m,
Iterator<Triple> iter) |
Constructor and Description |
---|
TripleMatchIterator(Triple m,
Iterator<Triple> iter) |
Modifier and Type | Method and Description |
---|---|
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.
|
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> |
DisjointUnion.graphBaseFind(TripleMatch m) |
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.
|
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 . |
Modifier and Type | Method and Description |
---|---|
boolean |
Union.graphBaseContains(Triple t) |
boolean |
DisjointUnion.graphBaseContains(Triple t) |
boolean |
MultiUnion.graphBaseContains(Triple t)
Answer true if at least one of the graphs in this union contain the given triple.
|
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 |
Union.performAdd(Triple t)
To add a triple to the union, add it to the left operand; this is asymmetric.
|
void |
DisjointUnion.performAdd(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 |
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.
|
void |
Union.performDelete(Triple t)
To remove a triple, remove it from both operands.
|
void |
DisjointUnion.performDelete(Triple t) |
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.
|
Modifier and Type | Method and Description |
---|---|
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 . |
Modifier and Type | Method and Description |
---|---|
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.
|
Modifier and Type | Method and Description |
---|---|
Iterator<Triple> |
QueryTriple.SimpleApplyer.find(Domain d) |
List<Triple> |
Query.getPattern()
Answer a list of the triples that have been added to this query.
|
Modifier and Type | Method and Description |
---|---|
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) |
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)
|
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.
|
Constructor and Description |
---|
GuardArranger(Triple[] triples) |
PatternStage(Graph graph,
Mapping map,
ExpressionSet constraints,
Triple[] triples) |
PatternStageBase(QueryNodeFactory factory,
Graph graph,
Mapping map,
ExpressionSet constraints,
Triple[] triples) |
Constructor and Description |
---|
SimpleQueryEngine(List<Triple> pattern,
TripleSorter sorter,
ExpressionSet constraints) |
Modifier and Type | Method and Description |
---|---|
Statement |
ModelGraphInterface.asStatement(Triple t)
Answer a Statement in this Model who's SPO is that of the triple
t . |
Modifier and Type | Method and Description |
---|---|
Triple |
TriplePattern.asTriple()
Return the triple pattern as a triple
|
Modifier and Type | Method and Description |
---|---|
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> |
BaseInfGraph.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> |
FGraph.find(TriplePattern pattern)
Basic pattern lookup interface.
|
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> |
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.
|
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> |
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.
|
Modifier and Type | Method and Description |
---|---|
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
|
Constructor and Description |
---|
TriplePattern(Triple match)
Constructor - builds a dgenerate pattern from a simple triple.
|
Modifier and Type | Field and Description |
---|---|
static com.hp.hpl.jena.util.iterator.Filter<Triple> |
Functor.acceptFilter
A static Filter instance that detects triples with Functor objects
|
Modifier and Type | Method and Description |
---|---|
Triple |
RuleDerivation.getConclusion() |
Triple |
BasicFBReifier.getTriple(Node n) |
Triple |
BindingEnvironment.instantiate(TriplePattern pattern)
Instantiate a triple pattern against the current environment.
|
Modifier and Type | Method and Description |
---|---|
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> |
BasicForwardRuleInfGraph.find(TriplePattern pattern)
Basic pattern lookup interface.
|
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.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> |
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> |
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> |
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.
|
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.
|
List<Triple> |
RuleDerivation.getMatches() |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
BasicForwardRuleInfGraph.graphBaseFind(Node subject,
Node property,
Node object)
Returns an iterator over Triples.
|
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.
|
Modifier and Type | Method and Description |
---|---|
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.
|
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> |
BasicForwardRuleInfGraph.getDerivation(Triple t)
Return the derivation of at triple.
|
Iterator<Derivation> |
LPBackwardRuleInfGraph.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 |
BasicForwardRuleInfGraph.logDerivation(Triple t,
Derivation derivation)
Log a dervivation record against the given triple.
|
void |
LPBackwardRuleInfGraph.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 |
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.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.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 |
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.
|
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 |
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.
|
void |
LPBackwardRuleInfGraph.silentAdd(Triple t)
Assert a new triple in the deduction graph, bypassing any processing machinery.
|
Constructor and Description |
---|
RuleDerivation(Rule rule,
Triple conclusion,
List<Triple> matches,
InfGraph infGraph)
Constructor
|
Constructor and Description |
---|
RuleDerivation(Rule rule,
Triple conclusion,
List<Triple> matches,
InfGraph infGraph)
Constructor
|
Modifier and Type | Method and Description |
---|---|
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.find(TriplePattern pattern)
Basic pattern lookup interface.
|
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.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.
|
Modifier and Type | Method and Description |
---|---|
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.
|
Modifier and Type | Method and Description |
---|---|
Triple |
UpdateDeniedException.getTriple() |
Modifier and Type | Method and Description |
---|---|
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) |
Constructor and Description |
---|
AddDeniedException(String message,
Triple triple) |
DeleteDeniedException(String message,
Triple triple) |
UpdateDeniedException(String message,
Triple triple) |
Modifier and Type | Method and Description |
---|---|
Triple |
QueryMapper.toQueryTriple(Statement s) |
Modifier and Type | Method and Description |
---|---|
static String |
PrintUtil.print(Triple triple)
Return a simplified print string for a Triple
|
Modifier and Type | Method and Description |
---|---|
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.
|
Copyright ? 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Hewlett-Packard Development Company, LP