Uses of Class
org.apache.jena.graph.Triple

Packages that use Triple

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.mem2
org.apache.jena.mem2.pattern
org.apache.jena.mem2.store
org.apache.jena.mem2.store.fast
org.apache.jena.mem2.store.legacy
org.apache.jena.mem2.store.roaring
org.apache.jena.mem2.store.roaring.strategies
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.

Uses of Triple in org.apache.jena.graph

Fields in org.apache.jena.graph declared as Triple

Modifier and Type	Field	Description
static final Triple	Triple.ANY	A Triple that has Node.ANY in all fields.

Methods in org.apache.jena.graph that return Triple

Modifier and Type	Method	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	Node_Triple.getTriple()
Triple	Node.getTriple()	Get the triple for a triple term (embedded triple), otherwise die horribly
Triple	TripleIterator.nextTriple()	Answer the next() element cast to Triple.

Methods in org.apache.jena.graph that return types with arguments of type Triple

Modifier and Type	Method	Description
abstract Predicate<Triple>	Triple.Field.filterOn(Node n)
final Predicate<Triple>	Triple.Field.filterOn(Triple t)
abstract Predicate<Triple>	Triple.Field.filterOnConcrete(Node n)
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.
default Stream<Triple>	Graph.stream()	Returns a Stream of all triples in the graph.
default Stream<Triple>	Graph.stream(Node s, Node p, Node o)	Returns a Stream of Triples matching a pattern.

Methods in org.apache.jena.graph with parameters of type Triple

Modifier and Type	Method	Description
void	Graph.add(Triple t)	Add the triple t (if possible) to the set belonging to this graph
static void	GraphUtil.add(Graph graph, Triple[] triples)
boolean	Graph.contains(Triple t)	Answer true iff the graph contains a triple that t matches; t may be fluid.
static Node	NodeFactory.createTripleNode(Triple triple)	Deprecated. Use NodeFactory.createTripleTerm(Triple)
static Node	NodeFactory.createTripleTerm(Triple triple)	Create a triple term (RDF-star)
void	Graph.delete(Triple t)	Delete the triple t (if possible) from the set belonging to this graph
static void	GraphUtil.delete(Graph graph, Triple[] triples)
final 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	GraphListenerBase.notifyAddArray(Graph g, Triple[] triples)
void	GraphListener.notifyAddTriple(Graph g, Triple t)	Method called when a single triple has been added to the graph.
void	GraphListenerBase.notifyAddTriple(Graph g, Triple t)
void	GraphListener.notifyDeleteArray(Graph g, Triple[] triples)	Method called when an array of triples has been deleted from the graph.
void	GraphListenerBase.notifyDeleteArray(Graph g, Triple[] triples)
void	GraphListener.notifyDeleteTriple(Graph g, Triple t)	Method called when a single triple has been deleted from the graph.
void	GraphListenerBase.notifyDeleteTriple(Graph g, Triple t)
Object	NodeVisitor.visitTriple(Node_Triple it, Triple triple)

Method parameters in org.apache.jena.graph with type arguments of type Triple

Modifier and Type	Method	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	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.notifyAddIterator(Graph g, Iterator<Triple> it)	Method called when an iterator [of triples] has been added to the graph
void	GraphListenerBase.notifyAddIterator(Graph g, Iterator<Triple> it)
void	GraphListener.notifyAddList(Graph g, List<Triple> triples)	Method called when a list [of triples] has been added to the graph.
void	GraphListenerBase.notifyAddList(Graph g, List<Triple> triples)
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.notifyDeleteIterator(Graph g, Iterator<Triple> it)	Method called when an iterator [of triples] has been deleted from the graph.
void	GraphListenerBase.notifyDeleteIterator(Graph g, Iterator<Triple> it)
void	GraphListener.notifyDeleteList(Graph g, List<Triple> L)	Method called when a list [of triples] has been deleted from the graph.
void	GraphListenerBase.notifyDeleteList(Graph g, List<Triple> triples)

Uses of Triple in org.apache.jena.graph.compose

Methods in org.apache.jena.graph.compose that return types with arguments of type Triple

Modifier and Type	Method	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, 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, Graph seen)	Answer an iterator over the elements of i that are not in the graph seen.

Methods in org.apache.jena.graph.compose with parameters of type Triple

Modifier and Type	Method	Description
ExtendedIterator<Triple>	Difference._graphBaseFind(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.
boolean	Union.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	Delta.performAdd(Triple t)	Add the triple to the graph, ie add it to the additions, remove it from the removals.
void	Difference.performAdd(Triple t)	Add a triple to the difference: add it to the left operand, and remove it from the right operand.
void	DisjointUnion.performAdd(Triple t)
void	Intersection.performAdd(Triple t)
void	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	Delta.performDelete(Triple t)	Remove the triple, ie, remove it from the adds, add it to the removals.
void	Difference.performDelete(Triple t)	Remove a triple from the difference: remove it from the left operand.
void	DisjointUnion.performDelete(Triple t)
void	Intersection.performDelete(Triple t)
void	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.

Method parameters in org.apache.jena.graph.compose with type arguments of type Triple

Modifier and Type	Method	Description
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.
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.

Uses of Triple in org.apache.jena.graph.impl

Methods in org.apache.jena.graph.impl that return types with arguments of type Triple

Modifier and Type	Method	Description
final ExtendedIterator<Triple>	GraphBase.find(Node s, Node p, Node o)
final ExtendedIterator<Triple>	GraphBase.find(Triple m)
ExtendedIterator<Triple>	GraphPlain.find(Node subj, Node pred, Node obj)
ExtendedIterator<Triple>	GraphPlain.find(Triple m)
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>	WrappedGraph.find(Node s, Node p, Node o)
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.
Stream<Triple>	TripleStore.stream(Node sm, Node pm, Node om)	Answer an ExtendedIterator returning all the triples from this store that match the pattern m = (S, P, O).

Methods in org.apache.jena.graph.impl with parameters of type Triple

Modifier and Type	Method	Description
void	GraphBase.add(Triple t)	Add a triple, and notify the event manager.
void	TripleStore.add(Triple t)	Add a triple to this triple store.
void	WrappedGraph.add(Triple t)
final boolean	GraphBase.contains(Triple t)	Answer true iff t is in the graph as revealed by find(t) being non-empty.
boolean	GraphPlain.contains(Triple t)
boolean	TripleStore.contains(Triple t)	Answer true iff this triple store contains the (concrete) triple t.
boolean	WrappedGraph.contains(Triple t)
boolean	TripleStore.containsMatch(Triple t)	Answer true iff this triple store contains the triple match t.
final void	GraphBase.delete(Triple t)	Delete a triple, and notify the event manager.
void	TripleStore.delete(Triple t)	Remove a triple from this triple store.
void	WrappedGraph.delete(Triple t)
final ExtendedIterator<Triple>	GraphBase.find(Triple m)
ExtendedIterator<Triple>	GraphPlain.find(Triple m)
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>	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	CollectionGraph.performAdd(Triple t)	Deprecated, for removal: This API element is subject to removal in a future version.
void	GraphBase.performAdd(Triple t)	Add a triple to the triple store.
void	GraphWithPerform.performAdd(Triple t)	add t to this graph, but do not generate any event
void	WrappedGraph.performAdd(Triple t)
void	CollectionGraph.performDelete(Triple t)	Deprecated, for removal: This API element is subject to removal in a future version.
void	GraphBase.performDelete(Triple t)	Remove a triple from the triple store.
void	GraphWithPerform.performDelete(Triple t)	remove t from this graph, but do not generate any event
void	WrappedGraph.performDelete(Triple t)

Method parameters in org.apache.jena.graph.impl with type arguments of type Triple

Modifier and Type	Method	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 parameters in org.apache.jena.graph.impl with type arguments of type Triple

Modifier	Constructor	Description
	CollectionGraph(Collection<Triple> triples)	Deprecated, for removal: This API element is subject to removal in a future version. Construct a graph from a collection.

Uses of Triple in org.apache.jena.mem

Methods in org.apache.jena.mem that return Triple

Modifier and Type	Method	Description
Triple	TrackingTripleIterator.next()	Answer the next object, remembering it in current.

Methods in org.apache.jena.mem that return types with arguments of type Triple

Modifier and Type	Method	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).
Predicate<Triple>	FieldFilter.getFilter()
ExtendedIterator<Triple>	GraphMem.graphBaseFind(Triple m)	Deprecated. 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>	NodeToTriplesMapMem.iterateAll(Triple pattern)
ExtendedIterator<Triple>	ArrayBunch.iterator()
ExtendedIterator<Triple>	ArrayBunch.iterator(HashCommon.NotifyEmpty container)
ExtendedIterator<Triple>	HashedTripleBunch.iterator()
ExtendedIterator<Triple>	HashedTripleBunch.iterator(HashCommon.NotifyEmpty container)
abstract ExtendedIterator<Triple>	NodeToTriplesMapBase.iterator(Object o, HashCommon.NotifyEmpty container)
abstract ExtendedIterator<Triple>	NodeToTriplesMapBase.iterator(Node index, Node n2, Node n3)
ExtendedIterator<Triple>	NodeToTriplesMapMem.iterator(Object o, HashCommon.NotifyEmpty container)	Answer an iterator over all the triples in this NTM which have index node o.
ExtendedIterator<Triple>	NodeToTriplesMapMem.iterator(Node index, Node n2, Node n3)	Answer an iterator over all the triples in this NTM which match pattern.
ExtendedIterator<Triple>	TripleBunch.iterator()	Answer an iterator over all the triples in this bunch.
ExtendedIterator<Triple>	TripleBunch.iterator(HashCommon.NotifyEmpty container)	Answer an iterator over all the triples in this bunch.
abstract ExtendedIterator<Triple>	NodeToTriplesMapBase.iteratorForIndexed(Object y)	Answer an iterator over all the triples that are indexed by the item y.
ExtendedIterator<Triple>	NodeToTriplesMapMem.iteratorForIndexed(Object y)	Answer an iterator over all the triples that are indexed by the item y.
Spliterator<Triple>	ArrayBunch.spliterator()
Spliterator<Triple>	HashedTripleBunch.spliterator()
Spliterator<Triple>	TripleBunch.spliterator()	Answer a spliterator over all the triples in this bunch.
Stream<Triple>	GraphMem.stream(Node s, Node p, Node o)	Deprecated.
Stream<Triple>	GraphTripleStoreBase.stream(Node sm, Node pm, Node om)	Answer a Stream returning all the triples from this store that match the pattern m = (S, P, O).
Stream<Triple>	NodeToTriplesMapBase.stream(Node index, Node n2, Node n3)
Stream<Triple>	NodeToTriplesMapBase.streamAll()

Methods in org.apache.jena.mem with parameters of type Triple

Modifier and Type	Method	Description
void	ArrayBunch.add(Triple t)
void	GraphTripleStoreBase.add(Triple t)	Add a triple to this triple store.
void	HashedTripleBunch.add(Triple t)
abstract boolean	NodeToTriplesMapBase.add(Triple t)	Add t to this NTM; the node o must be the index node of the triple.
boolean	NodeToTriplesMapMem.add(Triple t)	Add t to this NTM; the node o must be the index node of the triple.
void	TripleBunch.add(Triple t)	Add t to the triples in this bunch.
boolean	ArrayBunch.contains(Triple t)
boolean	GraphTripleStoreBase.contains(Triple t)	Answer true iff this triple store contains the (concrete) triple t.
boolean	HashedTripleBunch.contains(Triple t)
abstract boolean	NodeToTriplesMapBase.contains(Triple t)	Answer true iff this NTM contains the concrete triple t.
boolean	NodeToTriplesMapMem.contains(Triple t)	Answer true iff this NTM contains the concrete triple t.
boolean	TripleBunch.contains(Triple t)	Answer true iff this TripleBunch contains a triple .equals to t.
boolean	ArrayBunch.containsBySameValueAs(Triple t)
boolean	HashedTripleBunch.containsBySameValueAs(Triple t)
abstract boolean	NodeToTriplesMapBase.containsBySameValueAs(Triple t)
boolean	NodeToTriplesMapMem.containsBySameValueAs(Triple t)
boolean	TripleBunch.containsBySameValueAs(Triple t)	Answer true iff this TripleBunch contains a triple with .sameValueAs subject, predicate, and object.
boolean	GraphTripleStoreBase.containsMatch(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)	Deprecated. Answer true iff this graph contains t.
ExtendedIterator<Triple>	GraphMem.graphBaseFind(Triple m)	Deprecated. Answer an ExtendedIterator over all the triples in this graph that match the triple-pattern m.
ExtendedIterator<Triple>	NodeToTriplesMapMem.iterateAll(Triple pattern)
void	GraphMem.performAdd(Triple t)	Deprecated.
void	GraphMem.performDelete(Triple t)	Deprecated.
void	ArrayBunch.remove(Triple t)
void	HashedTripleBunch.remove(Triple t)
abstract boolean	NodeToTriplesMapBase.remove(Triple t)	Remove t from this NTM.
boolean	NodeToTriplesMapMem.remove(Triple t)	Remove t from this NTM.
void	TripleBunch.remove(Triple t)	Remove t from the triples in this bunch.

Method parameters in org.apache.jena.mem with type arguments of type Triple

Modifier and Type	Method	Description
void	TrackingTripleIterator.forEachRemaining(Consumer<? super Triple> action)

Constructor parameters in org.apache.jena.mem with type arguments of type Triple

Modifier	Constructor	Description
	StoreTripleIterator(Graph toNotify, Iterator<Triple> it, NodeToTriplesMapBase X, NodeToTriplesMapBase A, NodeToTriplesMapBase B)
	TrackingTripleIterator(Iterator<Triple> it)

Uses of Triple in org.apache.jena.mem2

Methods in org.apache.jena.mem2 that return types with arguments of type Triple

Modifier and Type	Method	Description
ExtendedIterator<Triple>	GraphMem2.graphBaseFind(Triple tripleMatch)	Returns an ExtendedIterator of all triples in the graph matching the given triple match.
Stream<Triple>	GraphMem2.stream()	Returns a Stream of all triples in the graph.
Stream<Triple>	GraphMem2.stream(Node sm, Node pm, Node om)	Returns a Stream of Triples matching a pattern.

Methods in org.apache.jena.mem2 with parameters of type Triple

Modifier and Type	Method	Description
boolean	GraphMem2.graphBaseContains(Triple tripleMatch)	Answer true if the graph contains any triple matching t.
ExtendedIterator<Triple>	GraphMem2.graphBaseFind(Triple tripleMatch)	Returns an ExtendedIterator of all triples in the graph matching the given triple match.
void	GraphMem2.performAdd(Triple t)	Add a triple to the graph without notifying.
void	GraphMem2.performDelete(Triple t)	Remove a triple from the triple store.

Uses of Triple in org.apache.jena.mem2.pattern

Methods in org.apache.jena.mem2.pattern with parameters of type Triple

Modifier and Type	Method	Description
static MatchPattern	PatternClassifier.classify(Triple tripleMatch)

Uses of Triple in org.apache.jena.mem2.store

Methods in org.apache.jena.mem2.store that return types with arguments of type Triple

Modifier and Type	Method	Description
ExtendedIterator<Triple>	TripleStore.find(Triple tripleMatch)	Returns an ExtendedIterator of all triples in the graph matching the given triple match.
Stream<Triple>	TripleStore.stream()	Returns a Stream of all triples in the graph.
Stream<Triple>	TripleStore.stream(Triple tripleMatch)	Returns a Stream of Triples matching the given pattern.

Methods in org.apache.jena.mem2.store with parameters of type Triple

Modifier and Type	Method	Description
void	TripleStore.add(Triple triple)	Add a triple to the map.
boolean	TripleStore.contains(Triple tripleMatch)	Answer true if the graph contains any triple matching t.
ExtendedIterator<Triple>	TripleStore.find(Triple tripleMatch)	Returns an ExtendedIterator of all triples in the graph matching the given triple match.
void	TripleStore.remove(Triple triple)	Remove a triple from the map.
Stream<Triple>	TripleStore.stream(Triple tripleMatch)	Returns a Stream of Triples matching the given pattern.

Uses of Triple in org.apache.jena.mem2.store.fast

Methods in org.apache.jena.mem2.store.fast that return types with arguments of type Triple

Modifier and Type	Method	Description
ExtendedIterator<Triple>	FastTripleStore.find(Triple tripleMatch)
ExtendedIterator<Triple>	FastArrayBunch.keyIterator()
Spliterator<Triple>	FastArrayBunch.keySpliterator()
Stream<Triple>	FastTripleStore.stream()
Stream<Triple>	FastTripleStore.stream(Triple tripleMatch)

Methods in org.apache.jena.mem2.store.fast with parameters of type Triple

Modifier and Type	Method	Description
void	FastTripleStore.add(Triple triple)
void	FastArrayBunch.addUnchecked(Triple t)
void	FastArrayBunch.addUnchecked(Triple key, int hashCode)
abstract boolean	FastArrayBunch.areEqual(Triple a, Triple b)
boolean	FastTripleStore.contains(Triple tripleMatch)
boolean	FastArrayBunch.containsKey(Triple t)
ExtendedIterator<Triple>	FastTripleStore.find(Triple tripleMatch)
void	FastTripleStore.remove(Triple triple)
void	FastArrayBunch.removeUnchecked(Triple t)
void	FastArrayBunch.removeUnchecked(Triple key, int hashCode)
Stream<Triple>	FastTripleStore.stream(Triple tripleMatch)
boolean	FastArrayBunch.tryAdd(Triple t)
boolean	FastArrayBunch.tryAdd(Triple key, int hashCode)
boolean	FastArrayBunch.tryRemove(Triple t)
boolean	FastArrayBunch.tryRemove(Triple key, int hashCode)

Method parameters in org.apache.jena.mem2.store.fast with type arguments of type Triple

Modifier and Type	Method	Description
boolean	FastArrayBunch.anyMatch(Predicate<Triple> predicate)
boolean	FastArrayBunch.anyMatchRandomOrder(Predicate<Triple> predicate)
boolean	FastTripleBunch.anyMatchRandomOrder(Predicate<Triple> predicate)	This method is used to optimize _PO match operations.

Constructor parameters in org.apache.jena.mem2.store.fast with type arguments of type Triple

Modifier	Constructor	Description
	FastHashedTripleBunch(JenaSet<Triple> set)	Create a new triple bunch from the given set of triples.

Uses of Triple in org.apache.jena.mem2.store.legacy

Methods in org.apache.jena.mem2.store.legacy that return types with arguments of type Triple

Modifier and Type	Method	Description
ExtendedIterator<Triple>	LegacyTripleStore.find(Triple tripleMatch)
Predicate<Triple>	FieldFilter.getFilter()
ExtendedIterator<Triple>	NodeToTriplesMap.iteratorForMatches(Node index, Node n2, Node n3)	Answer an iterator over all the triples in this map that match the pattern.
ExtendedIterator<Triple>	NodeToTriplesMapMem.iteratorForMatches(Node index, Node n2, Node n3)
ExtendedIterator<Triple>	ArrayBunch.keyIterator()
ExtendedIterator<Triple>	NodeToTriplesMapMem.keyIterator()
Spliterator<Triple>	ArrayBunch.keySpliterator()
Spliterator<Triple>	NodeToTriplesMapMem.keySpliterator()
Stream<Triple>	NodeToTriplesMapMem.keyStream()
Stream<Triple>	LegacyTripleStore.stream()
Stream<Triple>	LegacyTripleStore.stream(Triple tripleMatch)
Stream<Triple>	NodeToTriplesMap.streamForMatches(Node index, Node n2, Node n3)	Answer a stream over all the triples in this map that match the pattern.
Stream<Triple>	NodeToTriplesMapMem.streamForMatches(Node index, Node n2, Node n3)

Methods in org.apache.jena.mem2.store.legacy with parameters of type Triple

Modifier and Type	Method	Description
void	LegacyTripleStore.add(Triple triple)
void	ArrayBunch.addUnchecked(Triple t)
void	NodeToTriplesMapMem.addUnchecked(Triple t)
boolean	LegacyTripleStore.contains(Triple tripleMatch)
boolean	ArrayBunch.containsKey(Triple t)
boolean	NodeToTriplesMapMem.containsKey(Triple triple)
ExtendedIterator<Triple>	LegacyTripleStore.find(Triple tripleMatch)
void	LegacyTripleStore.remove(Triple triple)
void	ArrayBunch.removeUnchecked(Triple t)
void	NodeToTriplesMapMem.removeUnchecked(Triple t)
Stream<Triple>	LegacyTripleStore.stream(Triple tripleMatch)
boolean	ArrayBunch.tryAdd(Triple t)
boolean	NodeToTriplesMapMem.tryAdd(Triple t)
boolean	ArrayBunch.tryRemove(Triple t)
boolean	NodeToTriplesMapMem.tryRemove(Triple t)

Method parameters in org.apache.jena.mem2.store.legacy with type arguments of type Triple

Modifier and Type	Method	Description
boolean	ArrayBunch.anyMatch(Predicate<Triple> predicate)
boolean	NodeToTriplesMapMem.anyMatch(Predicate<Triple> predicate)

Uses of Triple in org.apache.jena.mem2.store.roaring

Methods in org.apache.jena.mem2.store.roaring that return Triple

Modifier and Type	Method	Description
Triple	RoaringBitmapTripleIterator.next()

Methods in org.apache.jena.mem2.store.roaring that return types with arguments of type Triple

Modifier and Type	Method	Description
ExtendedIterator<Triple>	RoaringTripleStore.find(Triple tripleMatch)
Stream<Triple>	RoaringTripleStore.stream()
Stream<Triple>	RoaringTripleStore.stream(Triple tripleMatch)

Methods in org.apache.jena.mem2.store.roaring with parameters of type Triple

Modifier and Type	Method	Description
void	RoaringTripleStore.add(Triple triple)
boolean	RoaringTripleStore.contains(Triple tripleMatch)
ExtendedIterator<Triple>	RoaringTripleStore.find(Triple tripleMatch)
void	RoaringTripleStore.remove(Triple triple)
Stream<Triple>	RoaringTripleStore.stream(Triple tripleMatch)

Method parameters in org.apache.jena.mem2.store.roaring with type arguments of type Triple

Modifier and Type	Method	Description
void	RoaringBitmapTripleIterator.forEachRemaining(Consumer<? super Triple> action)

Constructor parameters in org.apache.jena.mem2.store.roaring with type arguments of type Triple

Modifier	Constructor	Description
	RoaringBitmapTripleIterator(org.roaringbitmap.ImmutableBitmapDataProvider bitmap, FastHashSet<Triple> triples)

Uses of Triple in org.apache.jena.mem2.store.roaring.strategies

Methods in org.apache.jena.mem2.store.roaring.strategies that return types with arguments of type Triple

Modifier and Type	Method	Description
ExtendedIterator<Triple>	EagerStoreStrategy.findMatch(Triple tripleMatch, MatchPattern pattern)
ExtendedIterator<Triple>	LazyStoreStrategy.findMatch(Triple tripleMatch, MatchPattern pattern)
ExtendedIterator<Triple>	ManualStoreStrategy.findMatch(Triple tripleMatch, MatchPattern pattern)
ExtendedIterator<Triple>	MinimalStoreStrategy.findMatch(Triple tripleMatch, MatchPattern pattern)
ExtendedIterator<Triple>	StoreStrategy.findMatch(Triple tripleMatch, MatchPattern pattern)	Find the triples that match the given triple and pattern.
Stream<Triple>	EagerStoreStrategy.streamMatch(Triple tripleMatch, MatchPattern pattern)
Stream<Triple>	LazyStoreStrategy.streamMatch(Triple tripleMatch, MatchPattern pattern)
Stream<Triple>	ManualStoreStrategy.streamMatch(Triple tripleMatch, MatchPattern pattern)
Stream<Triple>	MinimalStoreStrategy.streamMatch(Triple tripleMatch, MatchPattern pattern)
Stream<Triple>	StoreStrategy.streamMatch(Triple tripleMatch, MatchPattern pattern)	Stream the triples that match the given triple and pattern.

Methods in org.apache.jena.mem2.store.roaring.strategies with parameters of type Triple

Modifier and Type	Method	Description
void	EagerStoreStrategy.addToIndex(Triple triple, int index)
void	LazyStoreStrategy.addToIndex(Triple triple, int index)
void	ManualStoreStrategy.addToIndex(Triple triple, int index)
void	MinimalStoreStrategy.addToIndex(Triple triple, int index)
void	StoreStrategy.addToIndex(Triple triple, int index)	Add a triple to the index if the cuurent strategy supports indexing.
boolean	EagerStoreStrategy.containsMatch(Triple tripleMatch, MatchPattern pattern)
boolean	LazyStoreStrategy.containsMatch(Triple tripleMatch, MatchPattern pattern)
boolean	ManualStoreStrategy.containsMatch(Triple tripleMatch, MatchPattern pattern)
boolean	MinimalStoreStrategy.containsMatch(Triple tripleMatch, MatchPattern pattern)
boolean	StoreStrategy.containsMatch(Triple tripleMatch, MatchPattern pattern)	Check if the index contains a match for the given triple and pattern.
ExtendedIterator<Triple>	EagerStoreStrategy.findMatch(Triple tripleMatch, MatchPattern pattern)
ExtendedIterator<Triple>	LazyStoreStrategy.findMatch(Triple tripleMatch, MatchPattern pattern)
ExtendedIterator<Triple>	ManualStoreStrategy.findMatch(Triple tripleMatch, MatchPattern pattern)
ExtendedIterator<Triple>	MinimalStoreStrategy.findMatch(Triple tripleMatch, MatchPattern pattern)
ExtendedIterator<Triple>	StoreStrategy.findMatch(Triple tripleMatch, MatchPattern pattern)	Find the triples that match the given triple and pattern.
void	EagerStoreStrategy.removeFromIndex(Triple triple, int index)
void	LazyStoreStrategy.removeFromIndex(Triple triple, int index)
void	ManualStoreStrategy.removeFromIndex(Triple triple, int index)
void	MinimalStoreStrategy.removeFromIndex(Triple triple, int index)
void	StoreStrategy.removeFromIndex(Triple triple, int index)	Remove a triple from the index if the current strategy supports indexing.
Stream<Triple>	EagerStoreStrategy.streamMatch(Triple tripleMatch, MatchPattern pattern)
Stream<Triple>	LazyStoreStrategy.streamMatch(Triple tripleMatch, MatchPattern pattern)
Stream<Triple>	ManualStoreStrategy.streamMatch(Triple tripleMatch, MatchPattern pattern)
Stream<Triple>	MinimalStoreStrategy.streamMatch(Triple tripleMatch, MatchPattern pattern)
Stream<Triple>	StoreStrategy.streamMatch(Triple tripleMatch, MatchPattern pattern)	Stream the triples that match the given triple and pattern.

Uses of Triple in org.apache.jena.rdf.model

Methods in org.apache.jena.rdf.model with parameters of type Triple

Modifier and Type	Method	Description
Statement	ModelGraphInterface.asStatement(Triple t)	Answer a Statement in this Model who's SPO is that of the triple t.

Uses of Triple in org.apache.jena.rdf.model.impl

Methods in org.apache.jena.rdf.model.impl that return Triple

Modifier and Type	Method	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.

Methods in org.apache.jena.rdf.model.impl that return types with arguments of type Triple

Modifier and Type	Method	Description
static ExtendedIterator<Triple>	ReifierStd.findEither(Graph graph, Triple match, boolean showHidden)	Answer an iterator over the reification triples of the graph, or an empty iterator.
static ExtendedIterator<Triple>	ReifierStd.findExposed(Graph graph, Triple match)	Answer an iterator over all the reification triples that match.

Methods in org.apache.jena.rdf.model.impl with parameters of type Triple

Modifier and Type	Method	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 which 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 the graph, or an empty iterator.
static ExtendedIterator<Triple>	ReifierStd.findExposed(Graph graph, Triple match)	Answer an iterator over all the reification triples that match.
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 refications 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_.

Method parameters in org.apache.jena.rdf.model.impl with type arguments of type Triple

Modifier and Type	Method	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)

Uses of Triple in org.apache.jena.reasoner

Methods in org.apache.jena.reasoner that return Triple

Modifier and Type	Method	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)

Methods in org.apache.jena.reasoner that return types with arguments of type Triple

Modifier and Type	Method	Description
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>	BaseInfGraph.find(TriplePattern pattern)	Basic pattern lookup interface.
ExtendedIterator<Triple>	FGraph.find(TriplePattern pattern)	Basic pattern lookup interface.
ExtendedIterator<Triple>	Finder.find(TriplePattern pattern)	Basic pattern lookup interface.
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.
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>	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.
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.

Methods in org.apache.jena.reasoner with parameters of type Triple

Modifier and Type	Method	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

Constructors in org.apache.jena.reasoner with parameters of type Triple

Modifier	Constructor	Description
	TriplePattern(Triple match)	Constructor - builds a degenerate pattern from a simple triple.

Uses of Triple in org.apache.jena.reasoner.rulesys

Fields in org.apache.jena.reasoner.rulesys with type parameters of type Triple

Modifier and Type	Field	Description
static final Predicate<Triple>	Functor.acceptFilter	A static Predicate instance that detects triples with Functor objects

Methods in org.apache.jena.reasoner.rulesys that return Triple

Modifier and Type	Method	Description
Triple	RuleDerivation.getConclusion()
Triple	BindingEnvironment.instantiate(TriplePattern pattern)	Instantiate a triple pattern against the current environment.

Methods in org.apache.jena.reasoner.rulesys that return types with arguments of type Triple

Modifier and Type	Method	Description
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.
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>	BackwardRuleInfGraphI.findDataMatches(TriplePattern pattern)	Match a pattern just against the stored data (raw data, schema, axioms) but no backchaining derivation.
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>	FBRuleInfGraph.findDataMatches(TriplePattern pattern)	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>	LPBackwardRuleInfGraph.findDataMatches(TriplePattern pattern)	Match a pattern just against the stored data (raw data, schema, axioms) but no 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.

Methods in org.apache.jena.reasoner.rulesys with parameters of type Triple

Modifier and Type	Method	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	BackwardRuleInfGraphI.logDerivation(Triple t, Derivation derivation)	Logger a derivation 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 derivation record against the given triple.
void	LPBackwardRuleInfGraph.logDerivation(Triple t, Derivation derivation)	Log 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	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	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.

Constructors in org.apache.jena.reasoner.rulesys with parameters of type Triple

Modifier	Constructor	Description
	RuleDerivation(Rule rule, Triple conclusion, List<Triple> matches, InfGraph infGraph)	Constructor

Constructor parameters in org.apache.jena.reasoner.rulesys with type arguments of type Triple

Modifier	Constructor	Description
	RuleDerivation(Rule rule, Triple conclusion, List<Triple> matches, InfGraph infGraph)	Constructor

Uses of Triple in org.apache.jena.reasoner.rulesys.impl

Methods in org.apache.jena.reasoner.rulesys.impl that return Triple

Modifier and Type	Method	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	BindingVector.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	LPTopGoalIterator.next()
Triple	SafeTripleIterator.next()

Methods in org.apache.jena.reasoner.rulesys.impl that return types with arguments of type Triple

Modifier and Type	Method	Description
ClosableIterator<Triple>	BBRuleContext.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>	LPBRuleEngine.find(TriplePattern goal)	Start a new interpreter running to answer a query.
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)
ExtendedIterator<Triple>	SafeGraph.find(Triple triple)
List<Triple>	EnvironmentFrameWithDerivation.getMatchList()	Return a safe copy of the list of matched subgoals in this subderivation.

Methods in org.apache.jena.reasoner.rulesys.impl with parameters of type Triple

Modifier and Type	Method	Description
void	BBRuleContext.add(Triple t)	Assert a new triple in the deduction graph, triggering any consequent processing as appropriate.
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	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	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	RETERuleContext.add(Triple t)	Assert a new triple in the deduction graph, triggering any consequent processing as appropriate.
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	BFRuleContext.contains(Triple t)	Return true if the triple is already in either the graph or the stack.
boolean	RETERuleContext.contains(Triple t)	Return true if the triple is already in either the graph or the stack.
boolean	FRuleEngine.delete(Triple t)	Remove one triple to the data graph.
boolean	FRuleEngineI.delete(Triple t)	Remove one triple to the data graph.
boolean	RETEEngine.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	OWLExptRuleTranslationHook.needsRerun(FBRuleInfGraph infGraph, Triple t)	Validate a triple add to see if it should reinvoke the hook.
boolean	OWLRuleTranslationHook.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	BFRuleContext.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	BBRuleContext.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	RETERuleContext.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.

Uses of Triple in org.apache.jena.reasoner.transitiveReasoner

Methods in org.apache.jena.reasoner.transitiveReasoner that return types with arguments of type Triple

Modifier and Type	Method	Description
ExtendedIterator<Triple>	TransitiveGraphCache.find(TriplePattern pattern)	Basic pattern lookup interface.
ExtendedIterator<Triple>	TransitiveInfGraph.find(TriplePattern pattern)	Basic pattern lookup interface.
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.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.

Methods in org.apache.jena.reasoner.transitiveReasoner with parameters of type Triple

Modifier and Type	Method	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.

Uses of Triple in org.apache.jena.shared

Methods in org.apache.jena.shared that return Triple

Modifier and Type	Method	Description
Triple	AccessDeniedException.getTriple()

Constructors in org.apache.jena.shared with parameters of type Triple

Modifier	Constructor	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)

Uses of Triple in org.apache.jena.sys

Methods in org.apache.jena.sys that return types with arguments of type Triple

Modifier and Type	Method	Description
static Function<Triple,Object>	Serializer.getTripleSerializer()	Return the current triple serializer replacement function.

Method parameters in org.apache.jena.sys with type arguments of type Triple

Modifier and Type	Method	Description
static void	Serializer.setTripleSerializer(Function<Triple,Object> writeReplaceFunction)	Set the triple serializer replacement function.

Uses of Triple in org.apache.jena.util

Methods in org.apache.jena.util with parameters of type Triple

Modifier and Type	Method	Description
static String	PrintUtil.print(Triple triple)	Return a simplified print string for a Triple

Method parameters in org.apache.jena.util with type arguments of type Triple

Modifier and Type	Method	Description
void	MonitorGraph.snapshot(List<Triple> additions, List<Triple> deletions)	Deprecated, for removal: This API element is subject to removal in a future version. Compute the differences between the current monitored graph and the last snapshot.