Package | Description |
---|---|
org.apache.jena.graph |
This package defines the Graph and Node family of classes, which
form the underlying datatypes of the Jena system.
|
org.apache.jena.graph.compose |
This package defines simple composite graphs - union, intersection,
difference, and update-tracking.
|
org.apache.jena.graph.impl |
This package provides basic implementations of Graph interfaces
such as EventManager and Capabilities.
|
org.apache.jena.mem |
Various memory-based implementations of interfaces,
specifically GraphMem for memory-based Graphs.
|
org.apache.jena.rdf.model |
A package for creating and manipulating RDF graphs.
|
org.apache.jena.rdf.model.impl |
This package contains implementations of the interfaces defined
in the .model package, eg ModelCom for Model, ResourceImpl
for Resource, and so on.
|
org.apache.jena.reasoner |
The Jena2 reasoner subsystem is designed to allow a range of inference
engines to be plugged into Jena.
|
org.apache.jena.reasoner.rulesys |
Provides a selection of simple rule engines for Jena inference models.
|
org.apache.jena.reasoner.rulesys.impl |
Internal implementation objects used by the rule system interpreters
and compilers.
|
org.apache.jena.reasoner.transitiveReasoner |
This package contains a reasoner which supports transitive-reflexive closure
of subPropertyOf and subClassOf relations.
|
org.apache.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.
|
org.apache.jena.sys | |
org.apache.jena.util |
Miscellaneous collection of utility classes.
|
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 ExtendedIterator<Triple> |
Triple.None
Deprecated.
|
Modifier and Type | Method and Description |
---|---|
Triple |
FrontsTriple.asTriple() |
static Triple |
Triple.create(Node s,
Node p,
Node o) |
static Triple |
Triple.createMatch(Node s,
Node p,
Node o) |
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.
|
Modifier and Type | Method and Description |
---|---|
abstract Predicate<Triple> |
Triple.Field.filterOn(Node n) |
Predicate<Triple> |
Triple.Field.filterOn(Triple t) |
default ExtendedIterator<Triple> |
Graph.find()
Returns an iterator over all Triples in the graph.
|
ExtendedIterator<Triple> |
Graph.find(Node s,
Node p,
Node o)
Returns an iterator over Triples matching a pattern.
|
ExtendedIterator<Triple> |
Graph.find(Triple m)
Returns an iterator over all the Triples that match the triple pattern.
|
static ExtendedIterator<Triple> |
GraphUtil.findAll(Graph g)
Answer an iterator covering all the triples in the specified graph.
|
Modifier and Type | Method and Description |
---|---|
static void |
GraphUtil.add(Graph graph,
Triple[] triples) |
void |
Graph.add(Triple t)
Add the triple t (if possible) to the set belonging to this graph
|
boolean |
Graph.contains(Triple t)
Answer true iff the graph contains a triple that t matches; t may be
fluid.
|
static void |
GraphUtil.delete(Graph graph,
Triple[] triples) |
void |
Graph.delete(Triple t)
Delete the triple t (if possible) from the set belonging to this graph
|
Predicate<Triple> |
Triple.Field.filterOn(Triple t) |
ExtendedIterator<Triple> |
Graph.find(Triple m)
Returns an iterator over all the Triples that match the triple pattern.
|
abstract Node |
Triple.Field.getField(Triple t) |
boolean |
Triple.matches(Triple other)
Does this triple, used as a pattern match, the other triple (usually a ground triple)
|
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.
|
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 |
---|---|
static void |
GraphUtil.add(Graph graph,
Iterator<Triple> it) |
static void |
GraphUtil.add(Graph graph,
List<Triple> triples) |
static void |
GraphUtil.delete(Graph graph,
Iterator<Triple> it) |
static void |
GraphUtil.delete(Graph graph,
List<Triple> triples) |
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 |
---|
Node_Triple(Triple triple) |
Modifier and Type | Method and Description |
---|---|
ExtendedIterator<Triple> |
Difference._graphBaseFind(Triple t) |
ExtendedIterator<Triple> |
MultiUnion.graphBaseFind(Triple t)
Answer an iterator over the triples in the union of the graphs in this composition.
|
static Predicate<Triple> |
CompositionBase.ifIn(Graph g)
Answer a
Predicate that will accept any triple that is an edge of
graph g. |
static ExtendedIterator<Triple> |
CompositionBase.rejecting(ExtendedIterator<Triple> i,
Graph seen)
Answer an iterator over the elements of
i that are not in
the graph seen . |
static ExtendedIterator<Triple> |
CompositionBase.rejecting(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 |
---|---|
ExtendedIterator<Triple> |
Difference._graphBaseFind(Triple t) |
boolean |
MultiUnion.graphBaseContains(Triple t)
Answer true if at least one of the graphs in this union contain the given triple.
|
boolean |
Union.graphBaseContains(Triple t) |
boolean |
DisjointUnion.graphBaseContains(Triple t) |
ExtendedIterator<Triple> |
MultiUnion.graphBaseFind(Triple t)
Answer an iterator over the triples in the union of the graphs in this composition.
|
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 |
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 |
Union.performAdd(Triple t)
To add a triple to the union, add it to the left operand; this is asymmetric.
|
void |
Intersection.performAdd(Triple t) |
void |
DisjointUnion.performAdd(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.
|
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 |
Union.performDelete(Triple t)
To remove a triple, remove it from both operands.
|
void |
Intersection.performDelete(Triple t) |
void |
DisjointUnion.performDelete(Triple t) |
Modifier and Type | Method and Description |
---|---|
static ExtendedIterator<Triple> |
CompositionBase.rejecting(ExtendedIterator<Triple> i,
Graph seen)
Answer an iterator over the elements of
i that are not in
the graph seen . |
static ExtendedIterator<Triple> |
CompositionBase.rejecting(ExtendedIterator<Triple> i,
Set<Triple> seen)
Answer an iterator over the elements of iterator i that are not in the set
seen . |
static ExtendedIterator<Triple> |
CompositionBase.rejecting(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 |
---|---|
ExtendedIterator<Triple> |
GraphPlain.find(Node subj,
Node pred,
Node obj) |
ExtendedIterator<Triple> |
GraphBase.find(Node s,
Node p,
Node o) |
ExtendedIterator<Triple> |
WrappedGraph.find(Node s,
Node p,
Node o) |
ExtendedIterator<Triple> |
TripleStore.find(Triple t)
Answer an ExtendedIterator returning all the triples from this store that
match the pattern
m = (S, P, O) . |
ExtendedIterator<Triple> |
GraphPlain.find(Triple m) |
ExtendedIterator<Triple> |
GraphBase.find(Triple m) |
ExtendedIterator<Triple> |
WrappedGraph.find(Triple m) |
ExtendedIterator<Triple> |
GraphBase.forTestingOnly_graphBaseFind(Triple t) |
static ExtendedIterator<Triple> |
SimpleEventManager.notifyingRemove(Graph g,
Iterator<Triple> i)
Answer an iterator which wraps
i to ensure that if a
.remove() is executed on it, the graph g will be notified. |
Modifier and Type | Method and Description |
---|---|
void |
TripleStore.add(Triple t)
Add a triple to this triple store.
|
void |
GraphBase.add(Triple t)
Add a triple, and notify the event manager.
|
void |
WrappedGraph.add(Triple t) |
boolean |
TripleStore.contains(Triple t)
Answer true iff this triple store contains the (concrete) triple
t . |
boolean |
GraphPlain.contains(Triple t) |
boolean |
GraphBase.contains(Triple t)
Answer
true iff t is in the graph as revealed by
find(t) being non-empty. |
boolean |
WrappedGraph.contains(Triple t) |
void |
TripleStore.delete(Triple t)
Remove a triple from this triple store.
|
void |
GraphBase.delete(Triple t)
Delete a triple, and notify the event manager.
|
void |
WrappedGraph.delete(Triple t) |
ExtendedIterator<Triple> |
TripleStore.find(Triple t)
Answer an ExtendedIterator returning all the triples from this store that
match the pattern
m = (S, P, O) . |
ExtendedIterator<Triple> |
GraphPlain.find(Triple m) |
ExtendedIterator<Triple> |
GraphBase.find(Triple m) |
ExtendedIterator<Triple> |
WrappedGraph.find(Triple m) |
ExtendedIterator<Triple> |
GraphBase.forTestingOnly_graphBaseFind(Triple t) |
void |
GraphBase.notifyAdd(Triple t)
Tell the event manager that the triple
t has been added to the graph. |
void |
SimpleEventManager.notifyAddArray(Graph g,
Triple[] ts) |
void |
SimpleEventManager.notifyAddTriple(Graph g,
Triple t) |
void |
GraphBase.notifyDelete(Triple t)
Tell the event manager that the triple
t has been deleted from the
graph. |
void |
SimpleEventManager.notifyDeleteArray(Graph g,
Triple[] ts) |
void |
SimpleEventManager.notifyDeleteTriple(Graph g,
Triple t) |
void |
GraphBase.performAdd(Triple t)
Add a triple to the triple store.
|
void |
CollectionGraph.performAdd(Triple t) |
void |
WrappedGraph.performAdd(Triple t) |
void |
GraphWithPerform.performAdd(Triple t)
add
t to this graph, but do not generate any event |
void |
GraphBase.performDelete(Triple t)
Remove a triple from the triple store.
|
void |
CollectionGraph.performDelete(Triple t) |
void |
WrappedGraph.performDelete(Triple t) |
void |
GraphWithPerform.performDelete(Triple t)
remove
t from this graph, but do not generate any event |
Modifier and Type | Method and Description |
---|---|
void |
SimpleEventManager.notifyAddIterator(Graph g,
Iterator<Triple> it) |
void |
SimpleEventManager.notifyAddIterator(Graph g,
List<Triple> it) |
void |
SimpleEventManager.notifyAddList(Graph g,
List<Triple> L) |
void |
SimpleEventManager.notifyDeleteIterator(Graph g,
Iterator<Triple> it) |
void |
SimpleEventManager.notifyDeleteIterator(Graph g,
List<Triple> L) |
void |
SimpleEventManager.notifyDeleteList(Graph g,
List<Triple> L) |
static ExtendedIterator<Triple> |
SimpleEventManager.notifyingRemove(Graph g,
Iterator<Triple> i)
Answer an iterator which wraps
i to ensure that if a
.remove() is executed on it, the graph g will be notified. |
Constructor and Description |
---|
CollectionGraph(Collection<Triple> triples)
Construct a graph from a collection.
|
CollectionGraph(Collection<Triple> triples,
boolean iteratorDeleteAllowed)
Construct a graph from a collection.
|
Modifier and Type | Method and Description |
---|---|
Triple |
TrackingTripleIterator.next()
Answer the next object, remembering it in
current . |
Modifier and Type | Method and Description |
---|---|
ExtendedIterator<Triple> |
GraphTripleStoreBase.find(Triple t)
Answer an ExtendedIterator returning all the triples from this store that
match the pattern
m = (S, P, O) . |
ExtendedIterator<Triple> |
GraphMem.graphBaseFind(Triple m)
Answer an ExtendedIterator over all the triples in this graph that match the
triple-pattern
m . |
ExtendedIterator<Triple> |
NodeToTriplesMapBase.iterateAll()
Answer an iterator over all the triples in this NTM.
|
ExtendedIterator<Triple> |
NodeToTriplesMap.iterateAll(Triple pattern) |
ExtendedIterator<Triple> |
HashedTripleBunch.iterator() |
ExtendedIterator<Triple> |
TripleBunch.iterator()
Answer an iterator over all the triples in this bunch.
|
ExtendedIterator<Triple> |
SetBunch.iterator() |
ExtendedIterator<Triple> |
ArrayBunch.iterator() |
ExtendedIterator<Triple> |
HashedTripleBunch.iterator(HashCommon.NotifyEmpty container) |
ExtendedIterator<Triple> |
TripleBunch.iterator(HashCommon.NotifyEmpty container)
Answer an iterator over all the triples in this bunch.
|
ExtendedIterator<Triple> |
SetBunch.iterator(HashCommon.NotifyEmpty container) |
ExtendedIterator<Triple> |
ArrayBunch.iterator(HashCommon.NotifyEmpty container) |
abstract ExtendedIterator<Triple> |
NodeToTriplesMapBase.iterator(Node index,
Node n2,
Node n3) |
ExtendedIterator<Triple> |
NodeToTriplesMap.iterator(Node index,
Node n2,
Node n3) |
ExtendedIterator<Triple> |
NodeToTriplesMapMem.iterator(Node index,
Node n2,
Node n3)
Answer an iterator over all the triples in this NTM which match
pattern . |
abstract Iterator<Triple> |
NodeToTriplesMapBase.iterator(Object o,
HashCommon.NotifyEmpty container) |
ExtendedIterator<Triple> |
NodeToTriplesMap.iterator(Object o,
HashCommon.NotifyEmpty container) |
Iterator<Triple> |
NodeToTriplesMapMem.iterator(Object o,
HashCommon.NotifyEmpty container)
Answer an iterator over all the triples in this NTM which have index node
o . |
abstract Iterator<Triple> |
NodeToTriplesMapBase.iteratorForIndexed(Object y)
Answer an iterator over all the triples that are indexed by the item
y . |
Iterator<Triple> |
NodeToTriplesMap.iteratorForIndexed(Object y)
Answer an iterator over all the triples that are indexed by the item
y . |
Iterator<Triple> |
NodeToTriplesMapMem.iteratorForIndexed(Object y)
Answer an iterator over all the triples that are indexed by the item
y . |
Modifier and Type | Method and Description |
---|---|
void |
HashedTripleBunch.add(Triple t) |
void |
GraphTripleStoreBase.add(Triple t)
Add a triple to this triple store.
|
void |
TripleBunch.add(Triple t)
Add
t to the triples in this bunch. |
abstract boolean |
NodeToTriplesMapBase.add(Triple t)
Add
t to this NTM; the node o must
be the index node of the triple. |
boolean |
NodeToTriplesMap.add(Triple t) |
void |
SetBunch.add(Triple t) |
boolean |
NodeToTriplesMapMem.add(Triple t)
Add
t to this NTM; the node o must
be the index node of the triple. |
void |
ArrayBunch.add(Triple t) |
boolean |
HashedTripleBunch.contains(Triple t) |
boolean |
GraphTripleStoreBase.contains(Triple t)
Answer true iff this triple store contains the (concrete) triple
t . |
boolean |
TripleBunch.contains(Triple t)
Answer true iff this TripleBunch contains a triple .equals to
t . |
abstract boolean |
NodeToTriplesMapBase.contains(Triple t)
Answer true iff this NTM contains the concrete triple
t . |
boolean |
NodeToTriplesMap.contains(Triple t) |
boolean |
SetBunch.contains(Triple t) |
boolean |
NodeToTriplesMapMem.contains(Triple t)
Answer true iff this NTM contains the concrete triple
t . |
boolean |
ArrayBunch.contains(Triple t) |
boolean |
GraphTripleStoreBase.containsByEquality(Triple t) |
boolean |
HashedTripleBunch.containsBySameValueAs(Triple t) |
boolean |
TripleBunch.containsBySameValueAs(Triple t)
Answer true iff this TripleBunch contains a triple with .sameValueAs
subject, predicate, and object.
|
abstract boolean |
NodeToTriplesMapBase.containsBySameValueAs(Triple t) |
boolean |
NodeToTriplesMap.containsBySameValueAs(Triple t) |
boolean |
SetBunch.containsBySameValueAs(Triple t) |
boolean |
NodeToTriplesMapMem.containsBySameValueAs(Triple t) |
boolean |
ArrayBunch.containsBySameValueAs(Triple t) |
void |
GraphTripleStoreBase.delete(Triple t)
Remove a triple from this triple store.
|
ExtendedIterator<Triple> |
GraphTripleStoreBase.find(Triple t)
Answer an ExtendedIterator returning all the triples from this store that
match the pattern
m = (S, P, O) . |
boolean |
GraphMem.graphBaseContains(Triple t)
Answer true iff this graph contains
t . |
ExtendedIterator<Triple> |
GraphMem.graphBaseFind(Triple m)
Answer an ExtendedIterator over all the triples in this graph that match the
triple-pattern
m . |
ExtendedIterator<Triple> |
NodeToTriplesMap.iterateAll(Triple pattern) |
void |
GraphMem.performAdd(Triple t) |
void |
GraphMem.performDelete(Triple t) |
void |
HashedTripleBunch.remove(Triple t) |
void |
TripleBunch.remove(Triple t)
Remove
t from the triples in this bunch. |
abstract boolean |
NodeToTriplesMapBase.remove(Triple t)
Remove
t from this NTM. |
boolean |
NodeToTriplesMap.remove(Triple t) |
void |
SetBunch.remove(Triple t) |
boolean |
NodeToTriplesMapMem.remove(Triple t)
Remove
t from this NTM. |
void |
ArrayBunch.remove(Triple t) |
Constructor and Description |
---|
StoreTripleIterator(Graph toNotify,
Iterator<Triple> it,
NodeToTriplesMapBase X,
NodeToTriplesMapBase A,
NodeToTriplesMapBase B) |
TrackingTripleIterator(Iterator<Triple> it) |
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 |
StatementImpl.asTriple() |
static Triple[] |
StatementImpl.asTriples(Statement[] statements)
returns an array of triples corresponding to the array of statements; ie
the i'th element of the result is the i'th element of the input as a triple.
|
static Triple |
ReifierStd.getTriple(Graph graph,
Node n)
Answer the triple associated with the node
n . |
Modifier and Type | Method and Description |
---|---|
static ExtendedIterator<Triple> |
ReifierStd.findEither(Graph graph,
Triple match,
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.
|
static ExtendedIterator<Triple> |
ReifierStd.findExposed(Graph graph,
Triple match)
Answer an iterator over all the reification triples that this Reifier exposes
(ie all if Standard, none otherwise) that match m.
|
ExtendedIterator<Triple> |
ModelCom.findTriplesFrom(Selector s)
Answer an [extended] iterator which returns the triples in this graph which
are selected by the (S, P, O) triple in the selector, ignoring any special
tests it may do.
|
Modifier and Type | Method and Description |
---|---|
static ExtendedIterator<Node> |
ReifierStd.allNodes(Graph graph,
Triple t)
return an iterator over all the nodes that are reifiying t in the graph
|
Statement |
ModelCom.asStatement(Triple t)
Answer a Statement in this Model whcih encodes the given Triple.
|
Statement[] |
ModelCom.asStatements(Triple[] triples) |
static ExtendedIterator<Triple> |
ReifierStd.findEither(Graph graph,
Triple match,
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.
|
static ExtendedIterator<Triple> |
ReifierStd.findExposed(Graph graph,
Triple match)
Answer an iterator over all the reification triples that this Reifier exposes
(ie all if Standard, none otherwise) that match m.
|
static boolean |
ReifierStd.hasTriple(Graph graph,
Triple t) |
void |
ModelListenerAdapter.notifyAddArray(Graph graph,
Triple[] triples) |
void |
ModelListenerAdapter.notifyAddTriple(Graph g,
Triple t) |
void |
ModelListenerAdapter.notifyDeleteArray(Graph g,
Triple[] triples) |
void |
ModelListenerAdapter.notifyDeleteTriple(Graph g,
Triple t) |
static Node |
ReifierStd.reifyAs(Graph graph,
Node node,
Triple triple)
note the triple _t_ as reified using _n_ as its representing node.
|
static void |
ReifierStd.remove(Graph graph,
Node node,
Triple triple)
remove any existing binding for _n_; hasNode(n) will return false and
getTriple(n) will return null.
|
static void |
ReifierStd.remove(Graph graph,
Triple triple)
remove all bindings which map to this triple.
|
static Statement |
StatementImpl.toStatement(Triple t,
ModelCom eg)
create a Statement from the triple _t_ in the enhanced graph _eg_.
|
Modifier and Type | Method and Description |
---|---|
StmtIterator |
ModelCom.asStatements(Iterator<Triple> it) |
List<Statement> |
ModelCom.asStatements(List<Triple> triples) |
static StmtIterator |
IteratorFactory.asStmtIterator(Iterator<Triple> i,
ModelCom m) |
void |
ModelListenerAdapter.notifyAddIterator(Graph g,
Iterator<Triple> it) |
void |
ModelListenerAdapter.notifyAddIterator(Graph g,
List<Triple> triples) |
void |
ModelListenerAdapter.notifyAddList(Graph g,
List<Triple> triples) |
void |
ModelListenerAdapter.notifyDeleteIterator(Graph g,
Iterator<Triple> it) |
void |
ModelListenerAdapter.notifyDeleteList(Graph g,
List<Triple> triples) |
Modifier and Type | Method and Description |
---|---|
Triple |
TriplePattern.asTriple()
Return the triple pattern as a triple
|
Triple |
TriplePattern.asTripleMatch()
Return the triple pattern as a triple match (concrete terms + Node.ANY)
|
Modifier and Type | Method and Description |
---|---|
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.
|
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.
|
ExtendedIterator<Triple> |
FGraph.find(TriplePattern pattern)
Basic pattern lookup interface.
|
ExtendedIterator<Triple> |
BaseInfGraph.find(TriplePattern pattern)
Basic pattern lookup interface.
|
ExtendedIterator<Triple> |
Finder.find(TriplePattern pattern)
Basic pattern lookup interface.
|
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.
|
abstract 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.
|
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.
|
Modifier and Type | Method and Description |
---|---|
Iterator<Derivation> |
InfGraph.getDerivation(Triple triple)
Return the derivation of the given triple (which is the result of
some previous find operation).
|
Iterator<Derivation> |
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
|
Constructor and Description |
---|
TriplePattern(Triple match)
Constructor - builds a degenerate pattern from a simple triple.
|
Modifier and Type | Field and Description |
---|---|
static Predicate<Triple> |
Functor.acceptFilter
A static Predicate instance that detects triples with Functor objects
|
Modifier and Type | Method and Description |
---|---|
Triple |
RuleDerivation.getConclusion() |
Triple |
BindingEnvironment.instantiate(TriplePattern pattern)
Instantiate a triple pattern against the current environment.
|
Modifier and Type | Method and Description |
---|---|
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.
|
ExtendedIterator<Triple> |
BasicForwardRuleInfGraph.find(TriplePattern pattern)
Basic pattern lookup interface.
|
ExtendedIterator<Triple> |
FBRuleInfGraph.find(TriplePattern pattern)
Basic pattern lookup interface.
|
ExtendedIterator<Triple> |
LPBackwardRuleInfGraph.find(TriplePattern pattern)
Basic pattern lookup interface.
|
ExtendedIterator<Triple> |
BasicForwardRuleInfGraph.findDataMatches(Node subject,
Node predicate,
Node object)
Search the combination of data and deductions graphs for the given triple pattern.
|
ExtendedIterator<Triple> |
FBRuleInfGraph.findDataMatches(Node subject,
Node predicate,
Node object)
Search the combination of data and deductions graphs for the given triple pattern.
|
ExtendedIterator<Triple> |
ForwardRuleInfGraphI.findDataMatches(Node subject,
Node predicate,
Node object)
Search the combination of data and deductions graphs for the given triple pattern.
|
ExtendedIterator<Triple> |
FBRuleInfGraph.findDataMatches(TriplePattern pattern)
Search the combination of data and deductions graphs for the given triple pattern.
|
ExtendedIterator<Triple> |
LPBackwardRuleInfGraph.findDataMatches(TriplePattern pattern)
Match a pattern just against the stored data (raw data, schema,
axioms) but no derivation.
|
ExtendedIterator<Triple> |
BackwardRuleInfGraphI.findDataMatches(TriplePattern pattern)
Match a pattern just against the stored data (raw data, schema,
axioms) but no backchaining derivation.
|
ExtendedIterator<Triple> |
FBRuleInfGraph.findFull(TriplePattern pattern)
Internal variant of find which omits the filters which block illegal RDF data.
|
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.
|
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.
|
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.
|
List<Triple> |
RuleDerivation.getMatches() |
ExtendedIterator<Triple> |
FBRuleInfGraph.graphBaseFind(Node subject,
Node property,
Node object)
Returns an iterator over Triples.
|
ExtendedIterator<Triple> |
LPBackwardRuleInfGraph.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 |
FBRuleInfGraph.addDeduction(Triple t)
Add a new deduction to the deductions graph.
|
void |
ForwardRuleInfGraphI.addDeduction(Triple t)
Add a new deduction to the deductions graph.
|
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.
|
void |
BasicForwardRuleInfGraph.logDerivation(Triple t,
Derivation derivation)
Log a dervivation record against the given triple.
|
void |
ForwardRuleInfGraphI.logDerivation(Triple t,
Derivation derivation)
Logger a derivation record against the given triple.
|
void |
LPBackwardRuleInfGraph.logDerivation(Triple t,
Derivation derivation)
Log a derivation record against the given triple.
|
void |
BackwardRuleInfGraphI.logDerivation(Triple t,
Derivation derivation)
Logger a derivation 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 |
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 |
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 |
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 |
BasicForwardRuleInfGraph.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 |
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 |
RuleContext.remove(Triple t)
Remove a triple from the deduction graph (and the original graph if relevant).
|
void |
RuleContext.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.
|
void |
SilentAddI.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 |
---|---|
static Triple |
LPInterpreter.deref(TriplePattern t)
Return a dereferenced copy of a triple.
|
Triple |
BFRuleContext.getNextTriple()
Return the next triple to be added to the graph, removing it from
the stack.
|
Triple |
EnvironmentFrameWithDerivation.getResult()
Return the final instantiated goal given the current binding state.
|
Triple |
BindingStack.instantiate(TriplePattern pattern)
Instantiate a triple pattern against the current environment.
|
Triple |
LPBindingEnvironment.instantiate(TriplePattern pattern)
Instantiate a triple pattern against the current environment.
|
Triple |
BindingVector.instantiate(TriplePattern pattern)
Instantiate a triple pattern against the current environment.
|
Triple |
LPTopGoalIterator.next() |
Modifier and Type | Method and Description |
---|---|
ClosableIterator<Triple> |
BBRuleContext.find(Node s,
Node p,
Node o) |
ClosableIterator<Triple> |
RETERuleContext.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.
|
ExtendedIterator<Triple> |
SafeGraph.find(Node s,
Node p,
Node o) |
ClosableIterator<Triple> |
BFRuleContext.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.
|
ExtendedIterator<Triple> |
SafeGraph.find(Triple triple) |
ExtendedIterator<Triple> |
LPBRuleEngine.find(TriplePattern goal)
Start a new interpreter running to answer a query.
|
List<Triple> |
EnvironmentFrameWithDerivation.getMatchList()
Return a safe copy of the list of matched subgoals in this subderivation.
|
Modifier and Type | Method and Description |
---|---|
void |
BBRuleContext.add(Triple t)
Assert a new triple in the deduction graph, triggering any consequent processing as appropriate.
|
void |
FRuleEngineI.add(Triple t)
Add one triple to the data graph, run any rules triggered by
the new data item, recursively adding any generated triples.
|
void |
RETERuleContext.add(Triple t)
Assert a new triple in the deduction graph, triggering any consequent processing as appropriate.
|
void |
RETEEngine.add(Triple t)
Add one triple to the data graph, run any rules triggered by
the new data item, recursively adding any generated triples.
|
void |
BFRuleContext.add(Triple t)
Add a triple to a temporary "pending" store, ready to be added to added to the
deductions graph and the processing stack later.
|
void |
FRuleEngine.add(Triple t)
Add one triple to the data graph, run any rules triggered by
the new data item, recursively adding any generated triples.
|
void |
BFRuleContext.addTriple(Triple t)
Add a triple to the stack of triples to waiting to be processed by the rule engine.
|
void |
RETEEngine.addTriple(Triple triple,
boolean deduction)
Add a new triple to the network.
|
boolean |
GenericTripleMatchFrame.bindResult(Triple triple,
LPInterpreter interpreter)
Bind the goal variables to the given result triple.
|
boolean |
BBRuleContext.contains(Triple t) |
boolean |
RETERuleContext.contains(Triple t)
Return true if the triple is already in either the graph or the stack.
|
boolean |
BFRuleContext.contains(Triple t)
Return true if the triple is already in either the graph or the stack.
|
boolean |
FRuleEngineI.delete(Triple t)
Remove one triple to the data graph.
|
boolean |
RETEEngine.delete(Triple t)
Remove one triple to the data graph.
|
boolean |
FRuleEngine.delete(Triple t)
Remove one triple to the data graph.
|
void |
RETEEngine.deleteTriple(Triple triple,
boolean deduction)
Remove a new triple from the network.
|
ExtendedIterator<Triple> |
SafeGraph.find(Triple triple) |
void |
RETEClauseFilter.fire(Triple triple,
boolean isAdd)
Insert or remove a triple into the network.
|
boolean |
GenericTripleMatchFrame.functorMatch(Triple t,
LPInterpreter interpreter)
Check that the object of a triple match corresponds to the given functor pattern.
|
static boolean |
FRuleEngine.match(TriplePattern pattern,
Triple triple,
BindingStack env)
Test if a TriplePattern matches a Triple in the given binding
environment.
|
boolean |
OWLRuleTranslationHook.needsRerun(FBRuleInfGraph infGraph,
Triple t)
Validate a triple add to see if it should reinvoke the hook.
|
boolean |
OWLExptRuleTranslationHook.needsRerun(FBRuleInfGraph infGraph,
Triple t)
Validate a triple add to see if it should reinvoke the hook.
|
boolean |
RDFSCMPPreprocessHook.needsRerun(FBRuleInfGraph infGraph,
Triple t)
Validate a triple add to see if it should reinvoke the hook.
|
void |
BBRuleContext.remove(Triple t)
Remove a triple from the deduction graph (and the original graph if relevant).
|
void |
RETERuleContext.remove(Triple t)
Remove a triple from the deduction graph (and the original graph if relevant).
|
void |
BFRuleContext.remove(Triple t)
Remove a triple from the deduction graph (and the original graph if relevant).
|
void |
BBRuleContext.silentAdd(Triple t)
Assert a new triple in the deduction graph, bypassing any processing machinery.
|
void |
RETERuleContext.silentAdd(Triple t)
Assert a new triple in the deduction graph, bypassing any processing machinery.
|
void |
BFRuleContext.silentAdd(Triple t)
Assert a new triple in the deduction graph, bypassing any processing machinery.
|
void |
RETEEngine.testTripleInsert(Triple t)
This fires a triple into the current RETE network.
|
Modifier and Type | Method and Description |
---|---|
ExtendedIterator<Triple> |
TransitiveInfGraph.find(TriplePattern pattern)
Basic pattern lookup interface.
|
ExtendedIterator<Triple> |
TransitiveGraphCache.find(TriplePattern pattern)
Basic pattern lookup interface.
|
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.
|
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.
|
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 |
AccessDeniedException.getTriple() |
Modifier and Type | Method and Description |
---|---|
ExtendedIterator<Triple> |
RandomOrderGraph.find(Node s,
Node p,
Node o) |
ExtendedIterator<Triple> |
RandomOrderGraph.find(Triple triple) |
Modifier and Type | Method and Description |
---|---|
ExtendedIterator<Triple> |
RandomOrderGraph.find(Triple triple) |
Constructor and Description |
---|
AccessDeniedException(String message,
Throwable cause,
Triple triple) |
AccessDeniedException(String message,
Triple triple) |
AccessDeniedException(Throwable cause,
Triple triple) |
AddDeniedException(String message,
Throwable throwable,
Triple triple) |
AddDeniedException(String message,
Triple triple) |
AddDeniedException(Throwable throwable,
Triple triple) |
DeleteDeniedException(String message,
Throwable cause,
Triple triple) |
DeleteDeniedException(String message,
Triple triple) |
DeleteDeniedException(Throwable cause,
Triple triple) |
ReadDeniedException(String message,
Throwable cause,
Triple triple) |
ReadDeniedException(String message,
Triple triple) |
ReadDeniedException(Throwable cause,
Triple triple) |
UpdateDeniedException(String message,
Throwable cause,
Triple triple) |
UpdateDeniedException(String message,
Triple triple) |
UpdateDeniedException(Throwable cause,
Triple triple) |
Modifier and Type | Method and Description |
---|---|
static Function<Triple,Object> |
Serializer.getTripleSerializer()
Return the current triple serializer replacement function.
|
Modifier and Type | Method and Description |
---|---|
static void |
Serializer.setTripleSerializer(Function<Triple,Object> writeReplaceFunction)
Set the triple serializer replacement function.
|
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.
|
Licenced under the Apache License, Version 2.0