Uses of Interface
org.apache.jena.graph.Graph

Packages that use Graph

Package	Description
org.apache.jena.enhanced	This package defines the enhanced node and graph classes; an enhanced node is one embedded in a particular enhanced graph.
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.ontology	Provides a set of abstractions and convenience classes for accessing and manipluating ontologies represented in RDF.
org.apache.jena.ontology.impl	Provides default implementations for the abstractions defined in the org.apache.jena.ontology package.
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.rdfxml.xmlinput	A parser for RDF/XML.
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.util	Miscellaneous collection of utility classes.

Uses of Graph in org.apache.jena.enhanced

Methods in org.apache.jena.enhanced that return Graph

Modifier and Type	Method and Description
Graph	EnhGraph.asGraph() Answer the normal graph that this enhanced graph is wrapping.

Constructors in org.apache.jena.enhanced with parameters of type Graph

Constructor and Description
EnhGraph(Graph g, Personality<RDFNode> p) Construct an enhanced graph from the given underlying graph, and a factory for generating enhanced nodes.

Uses of Graph in org.apache.jena.graph

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

Modifier and Type	Field and Description
static Graph	Graph.emptyGraph An immutable empty graph.

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

Modifier and Type	Method and Description
static Graph	Factory.createDefaultGraph() Answer a memory-based Graph.
Graph	GraphMaker.createGraph() Answer a graph who's name isn't interesting.
Graph	GraphMaker.createGraph(String name) Create a graph that does not already exist - equivalent to createGraph( name, false ).
Graph	GraphMaker.createGraph(String name, boolean strict) Create a new graph associated with the given name.
static Graph	Factory.createGraphMem()
static Graph	Factory.createGraphMemWithTransactionHandler(TransactionHandler th)
static Graph	Factory.empty() Immutable graph with no triples
Graph	GraphExtract.extract(Node node, Graph graph) Answer a new graph which is the reachable subgraph from node in graph with the terminating condition given by the TripleBoundary passed to the constructor.
Graph	GraphExtract.extractInto(Graph toUpdate, Node root, Graph extractFrom) Answer the graph toUpdate augmented with the sub-graph of extractFrom reachable from root bounded by this instance's TripleBoundary.
Graph	GraphMaker.getGraph() Answer the default graph of this GraphMaker.
Graph	GraphMaker.openGraph() Answer the default graph of this GraphMaker, if it has one.
Graph	GraphMaker.openGraph(String name) Equivalent to openGraph( name, false )
Graph	GraphMaker.openGraph(String name, boolean strict) Find an existing graph that this factory knows about under the given name.

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

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.add(Graph graph, Triple[] triples)
static void	GraphUtil.addInto(Graph dstGraph, Graph srcGraph) Add triples into the destination (arg 1) from the source (arg 2)
static boolean	GraphUtil.containsNode(Graph graph, Node node) Does the graph use the node anywhere as a subject, predicate or object?
static void	GraphUtil.delete(Graph graph, Iterator<Triple> it)
static void	GraphUtil.delete(Graph graph, List<Triple> triples)
static void	GraphUtil.delete(Graph graph, Triple[] triples)
static void	GraphUtil.deleteFrom(Graph dstGraph, Graph srcGraph) Delete triples in the destination (arg 1) as given in the source (arg 2).
static void	GraphUtil.deleteLoopDst(Graph dstGraph, Graph srcGraph) Delete the triple in srcGraph from dstGraph by checking the contents of dsgGraph against the srcGraph.
static void	GraphUtil.deleteLoopSrc(Graph dstGraph, Graph srcGraph) Delete triples in srcGraph from dstGraph by looping on srcGraph.
boolean	Graph.dependsOn(Graph other) true if this graph's content depends on the other graph.
Graph	GraphExtract.extract(Node node, Graph graph) Answer a new graph which is the reachable subgraph from node in graph with the terminating condition given by the TripleBoundary passed to the constructor.
Graph	GraphExtract.extractInto(Graph toUpdate, Node root, Graph extractFrom) Answer the graph toUpdate augmented with the sub-graph of extractFrom reachable from root bounded by this instance's TripleBoundary.
static ExtendedIterator<Triple>	GraphUtil.findAll(Graph g) Answer an iterator covering all the triples in the specified graph.
boolean	Graph.isIsomorphicWith(Graph g) Compare this graph with another using the method described in http://www.w3.org/TR/rdf-concepts#section-Graph-syntax
static ExtendedIterator<Node>	GraphUtil.listObjects(Graph g, Node s, Node p) Return an iterator over the unique objects with a given subject and object.
static ExtendedIterator<Node>	GraphUtil.listPredicates(Graph g, Node s, Node o) Return an iterator over the unique predicate between s and o.
static ExtendedIterator<Node>	GraphUtil.listSubjects(Graph g, Node p, Node o) Return an iterator over the unique subjects with predicate p and object o.
void	GraphListener.notifyAddArray(Graph g, Triple[] triples) Method called when an array of triples has been added to the graph.
void	GraphListener.notifyAddGraph(Graph g, Graph added) Method called when another graph g has been used to specify the triples added to our attached graph.
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.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.notifyDeleteGraph(Graph g, Graph removed) Method to call when another graph has been used to specify the triples deleted from our attached 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.
void	GraphListener.notifyDeleteTriple(Graph g, Triple t) Method called when a single triple has been deleted from the graph.
void	GraphListener.notifyEvent(Graph source, Object value) method to call for a general event.
static void	GraphUtil.remove(Graph g, Node s, Node p, Node o) A safe and cautious remove() function that converts the remove to a number of delete(Triple) operations.

Constructors in org.apache.jena.graph with parameters of type Graph

Constructor and Description
Node_Graph(Graph graph)

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

Classes in org.apache.jena.graph.compose that implement Graph

Modifier and Type	Class and Description
class	CompositionBase Base class for graphs that are composed of multiple sub-graphs.
class	Delta Graph operation for wrapping a base graph and leaving it unchanged while recording all the attempted updates for later access.
class	Difference Class representing the dynamic set difference L - R of two graphs.
class	DisjointUnion DisjointUnion - a version of Union that assumes the graphs are disjoint, and hence that find need not do duplicate-removal.
class	Dyadic Base class for the two-operand composition operations; has two graphs L and R
class	Intersection The dynamic intersection of two graphs L and R.
class	MultiUnion A graph implementation that presents the union of zero or more subgraphs, one of which is distinguished as the updateable graph.
class	Polyadic A base class for composition graphs that are composed from zero or more sub-graphs (thus providing a basis for polyadic composition operators).
class	Union A class representing the dynamic union of two graphs.

Methods in org.apache.jena.graph.compose that return Graph

Modifier and Type	Method and Description
Graph	Delta.getAdditions() Answer the graph of all triples added.
Graph	Polyadic.getBaseGraph() Answer the distinguished graph for the composition, which will be the graph that receives triple adds and deletes.
Graph	Delta.getDeletions() Answer the graph of all triples removed.
Graph	Dyadic.getL() Answer the left (first) operand of this Dyadic.
Graph	Dyadic.getR() Answer the right (second) operand of this Dyadic.
Graph	Polyadic.getRequiredBaseGraph() Answer the distinguished graph for the composition, which will be the graph that receives triple adds and deletes.

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

Modifier and Type	Method and Description
List<Graph>	Polyadic.getSubGraphs() Answer a list of the graphs other than the updateable (base) graph

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

Modifier and Type	Method and Description
void	Polyadic.addGraph(Graph graph) Add the given graph to this composition.
void	MultiUnion.addGraph(Graph graph) Add the given graph to this union.
boolean	Polyadic.dependsOn(Graph graph) Answer true if this graph contains the given graph as a sub-component.
boolean	Dyadic.dependsOn(Graph other) Generic dependsOn, true iff it depends on either of the subgraphs.
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.
void	Polyadic.removeGraph(Graph graph) Remove the given graph from this composition.
void	Polyadic.setBaseGraph(Graph graph) Set the designated updateable graph for this composition.
Union	Dyadic.union(Graph X)

Constructors in org.apache.jena.graph.compose with parameters of type Graph

Constructor and Description
Delta(Graph base)
Difference(Graph L, Graph R) Initialise a graph representing the difference L - R.
DisjointUnion(Graph L, Graph R)
Dyadic(Graph L, Graph R) When the graph is constructed, copy the prefix mappings of both components into this prefix mapping.
Intersection(Graph L, Graph R)
MultiUnion(Graph[] graphs) Construct a union of all of the given graphs
Polyadic(Graph[] graphs) Construct a composition of all of the given graphs
Union(Graph L, Graph R)

Constructor parameters in org.apache.jena.graph.compose with type arguments of type Graph

Constructor and Description
MultiUnion(Iterator<Graph> graphs) Construct a union of all of the given graphs.
Polyadic(Iterator<Graph> graphs) Construct a composition of all of the given graphs.

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

Subinterfaces of Graph in org.apache.jena.graph.impl

Modifier and Type	Interface and Description
interface	GraphWithPerform GraphWithPerform is an implementation interface that extends Graph with the performAdd and performDelete methods used by GraphBase to invoke non-notifying versions of add and delete.

Classes in org.apache.jena.graph.impl that implement Graph

Modifier and Type	Class and Description
class	CollectionGraph A simple graph implementation that wraps a collection of triples.
class	GraphBase GraphBase is an implementation of Graph that provides some convenient base functionality for Graph implementations.
class	GraphPlain A version of Graph that enforces term equality even if the base graph uses value-indexing.
class	WrappedGraph A wrapper class which simply defers all operations to its base.

Methods in org.apache.jena.graph.impl that return Graph

Modifier and Type	Method and Description
Graph	SimpleGraphMaker.create()
Graph	BaseGraphMaker.createGraph() Make a fresh anonymous graph.
Graph	BaseGraphMaker.createGraph(String name) A non-strict create.
Graph	SimpleGraphMaker.createGraph(String name, boolean strict) Create a graph and record it with the given name in the local map.
Graph	BaseGraphMaker.getGraph() Answer the default graph for this maker.
Graph	WrappedGraph.getWrapped()
Graph	BaseGraphMaker.openGraph()
Graph	SimpleGraphMaker.openGraph()
Graph	BaseGraphMaker.openGraph(String name) A non-strict open.
Graph	SimpleGraphMaker.openGraph(String name, boolean strict) Open (aka find) a graph with the given name in the local map.
static Graph	GraphPlain.plain() Return a graph that only has term-equality.
static Graph	GraphPlain.plain(Graph base) Return a graph that only has term-equality and storage in the base graph.

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

Modifier and Type	Method and Description
boolean	GraphBase.dependsOn(Graph other) Default implementation answers true iff this graph is the same graph as the argument graph.
boolean	WrappedGraph.dependsOn(Graph other)
static boolean	GraphMatcher.equals(Graph m1, Graph m2) Are the two models isomorphic? The isomorphism is defined as a bijection between the anonymous variables such that the statements are identical.
static int	GraphMatcher.hashCode(Graph g)
boolean	GraphBase.isIsomorphicWith(Graph g) Answer true iff this graph is isomorphic to g according to the algorithm (indeed, method) in GraphMatcher.
boolean	WrappedGraph.isIsomorphicWith(Graph g)
static Node[][]	GraphMatcher.match(Graph m1, Graph m2) Return an isomorphism between the two models.
void	SimpleEventManager.notifyAddArray(Graph g, Triple[] ts)
void	SimpleEventManager.notifyAddGraph(Graph g, Graph added)
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.notifyAddTriple(Graph g, Triple t)
void	SimpleEventManager.notifyDeleteArray(Graph g, Triple[] ts)
void	SimpleEventManager.notifyDeleteGraph(Graph g, Graph removed)
void	SimpleEventManager.notifyDeleteIterator(Graph g, Iterator<Triple> it)
void	SimpleEventManager.notifyDeleteIterator(Graph g, List<Triple> L)
void	SimpleEventManager.notifyDeleteList(Graph g, List<Triple> L)
void	SimpleEventManager.notifyDeleteTriple(Graph g, Triple t)
void	SimpleEventManager.notifyEvent(Graph source, Object event)
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.
static Graph	GraphPlain.plain(Graph base) Return a graph that only has term-equality and storage in the base graph.
static String	GraphBase.toString(String prefix, Graph that) Answer a human-consumable representation of that.

Constructors in org.apache.jena.graph.impl with parameters of type Graph

Constructor and Description
SimpleEventManager(Graph graph) Deprecated. Use the no argument constructor.
WrappedGraph(Graph base)

Uses of Graph in org.apache.jena.mem

Classes in org.apache.jena.mem that implement Graph

Modifier and Type	Class and Description
class	GraphMem
class	GraphMemBase GraphMemBase - a common base class for GraphMem and SmallGraphMem.

Constructors in org.apache.jena.mem with parameters of type Graph

Constructor and Description
GraphTripleStore(Graph parent)
GraphTripleStoreMem(Graph parent)
StoreTripleIterator(Graph toNotify, Iterator<Triple> it, NodeToTriplesMapBase X, NodeToTriplesMapBase A, NodeToTriplesMapBase B)

Uses of Graph in org.apache.jena.ontology

Methods in org.apache.jena.ontology that return types with arguments of type Graph

Modifier and Type	Method and Description
List<Graph>	OntModel.getSubGraphs() i.next() Answer the sub-graphs of this model.

Uses of Graph in org.apache.jena.ontology.impl

Methods in org.apache.jena.ontology.impl that return Graph

Modifier and Type	Method and Description
Graph	OntModelImpl.getBaseGraph() Answer the base-graph of this model.

Methods in org.apache.jena.ontology.impl that return types with arguments of type Graph

Modifier and Type	Method and Description
List<Graph>	OntModelImpl.getSubGraphs() Answer the sub-graphs of this model.

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

Methods in org.apache.jena.rdf.model that return Graph

Modifier and Type	Method and Description
Graph	ModelGraphInterface.getGraph() Answer the Graph which this Model is presenting.

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

Modifier and Type	Method and Description
static Model	ModelFactory.createModelForGraph(Graph g) Answer a model that encapsulates the given graph.

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

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

Modifier and Type	Method and Description
Graph	ModelCom.getGraph()

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

Modifier and Type	Method and Description
static ExtendedIterator<Node>	ReifierStd.allNodes(Graph graph) return an iterator over all the nodes that are reifiying something in the graph
static ExtendedIterator<Node>	ReifierStd.allNodes(Graph graph, Triple t) return an iterator over all the nodes that are reifiying t in the graph
Model	ModelCom.asModel(Graph g)
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 Triple	ReifierStd.getTriple(Graph graph, Node n) Answer the triple associated with the node n.
static boolean	ReifierStd.hasTriple(Graph graph, Node node) true iff _n_ is associated with some triple.
static boolean	ReifierStd.hasTriple(Graph graph, Triple t)
void	ModelListenerAdapter.notifyAddArray(Graph graph, Triple[] triples)
void	ModelListenerAdapter.notifyAddGraph(Graph g, Graph added)
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.notifyAddTriple(Graph g, Triple t)
void	ModelListenerAdapter.notifyDeleteArray(Graph g, Triple[] triples)
void	ModelListenerAdapter.notifyDeleteGraph(Graph g, Graph removed)
void	ModelListenerAdapter.notifyDeleteIterator(Graph g, Iterator<Triple> it)
void	ModelListenerAdapter.notifyDeleteList(Graph g, List<Triple> triples)
void	ModelListenerAdapter.notifyDeleteTriple(Graph g, Triple t)
void	ModelListenerAdapter.notifyEvent(Graph g, Object event)
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.

Constructors in org.apache.jena.rdf.model.impl with parameters of type Graph

Constructor and Description
ModelCom(Graph base) make a model based on the specified graph
ModelCom(Graph base, Personality<RDFNode> personality)

Uses of Graph in org.apache.jena.rdfxml.xmlinput

Methods in org.apache.jena.rdfxml.xmlinput with parameters of type Graph

Modifier and Type	Method and Description
void	JenaReader.read(Graph g, InputStream in, String xmlBase) Reads from inputStream, using base URI xmlbase, adding triples to graph.
void	JenaReader.read(Graph g, Reader reader, String xmlBase) Reads from reader, using base URI xmlbase, adding triples to graph.

Uses of Graph in org.apache.jena.reasoner

Subinterfaces of Graph in org.apache.jena.reasoner

Modifier and Type	Interface and Description
interface	InfGraph Extends the Graph interface to give additional means to query an inferred graph.

Classes in org.apache.jena.reasoner that implement Graph

Modifier and Type	Class and Description
class	BaseInfGraph A base level implementation of the InfGraph interface.

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

Modifier and Type	Method and Description
Graph	InfGraph.getDeductionsGraph() Returns a derivations graph.
Graph	BaseInfGraph.getDeductionsGraph() Returns a derivations graph.
Graph	FGraph.getGraph() Returns the graph.
Graph	InfGraph.getRawGraph() Return the raw RDF data Graph being processed (i.e.
Graph	BaseInfGraph.getRawGraph() Return the raw RDF data Graph being processed (i.e.
abstract Graph	BaseInfGraph.getSchemaGraph() Return the schema graph, if any, bound into this inference graph.

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

Modifier and Type	Method and Description
InfGraph	Reasoner.bind(Graph data) Attach the reasoner to a set of RDF data to process.
Reasoner	Reasoner.bindSchema(Graph tbox) This is most commonly used to attach an ontology (a set of tbox axioms in description logics jargon) to a reasoner.
InfGraph	BaseInfGraph.cloneWithPremises(Graph premises) Return a new inference graph which is a clone of the current graph together with an additional set of data premises.
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.
void	InfGraph.rebind(Graph data) Replace the underlying data graph for this inference graph and start any inferences over again.
void	BaseInfGraph.rebind(Graph data) Replace the underlying data graph for this inference graph and start any inferences over again.

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

Constructor and Description
BaseInfGraph(Graph data, Reasoner reasoner) Constructor
FGraph(Graph graph) Constructor

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

Subinterfaces of Graph in org.apache.jena.reasoner.rulesys

Modifier and Type	Interface and Description
interface	BackwardRuleInfGraphI This interface collects together those operations that the backchaining engine needs to invoke in the parent InfGraph.
interface	ForwardRuleInfGraphI This interface collects together the operations on the InfGraph which are needed to support the forward rule engine.

Classes in org.apache.jena.reasoner.rulesys that implement Graph

Modifier and Type	Class and Description
class	BasicForwardRuleInfGraph An inference graph interface that runs a set of forward chaining rules to conclusion on each added triple and stores the entire result set.
class	FBRuleInfGraph An inference graph that uses a mixture of forward and backward chaining rules.
class	LPBackwardRuleInfGraph Inference graph for accessing the LP version of the backward chaining rule engine.
class	RDFSRuleInfGraph Customization of the generic rule inference graph for RDFS inference.
class	RETERuleInfGraph RETE implementation of the forward rule inference graph.

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

Modifier and Type	Method and Description
Graph	FBRuleReasoner.getBoundSchema() Answer the schema graph bound into this reasoner, or null if there isn't one.
Graph	BasicForwardRuleInfGraph.getCurrentDeductionsGraph() Return the Graph containing all the static deductions available so far.
Graph	ForwardRuleInfGraphI.getCurrentDeductionsGraph() Return the Graph containing all the static deductions available so far.
Graph	BasicForwardRuleInfGraph.getDeductionsGraph() Return the Graph containing all the static deductions available so far.
Graph	ForwardRuleInfGraphI.getDeductionsGraph() Return the Graph containing all the static deductions available so far.
Graph	BasicForwardRuleInfGraph.getSchemaGraph() Return the schema graph, if any, bound into this inference graph.
Graph	LPBackwardRuleInfGraph.getSchemaGraph() Return the schema graph, if any, bound into this inference graph.

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

Modifier and Type	Method and Description
InfGraph	RDFSRuleReasoner.bind(Graph data) Attach the reasoner to a set of RDF data to process.
InfGraph	GenericRuleReasoner.bind(Graph data) Attach the reasoner to a set of RDF data to process.
InfGraph	OWLFBRuleReasoner.bind(Graph data) Attach the reasoner to a set of RDF data to process.
InfGraph	FBRuleReasoner.bind(Graph data) Attach the reasoner to a set of RDF data to process.
InfGraph	LPBackwardRuleReasoner.bind(Graph data) Attach the reasoner to a set of RDF data to process.
InfGraph	BasicForwardRuleReasoner.bind(Graph data) Attach the reasoner to a set of RDF data to process.
InfGraph	OWLMiniReasoner.bind(Graph data) Attach the reasoner to a set of RDF data to process.
InfGraph	OWLMicroReasoner.bind(Graph data) Attach the reasoner to a set of RDF data to process.
Reasoner	RDFSRuleReasoner.bindSchema(Graph tbox) Precompute the implications of a schema graph.
Reasoner	GenericRuleReasoner.bindSchema(Graph tbox) Precompute the implications of a schema graph.
Reasoner	OWLFBRuleReasoner.bindSchema(Graph tbox) Precompute the implications of a schema graph.
Reasoner	FBRuleReasoner.bindSchema(Graph tbox) Precompute the implications of a schema graph.
Reasoner	LPBackwardRuleReasoner.bindSchema(Graph tbox) Precompute the implications of a schema graph.
Reasoner	BasicForwardRuleReasoner.bindSchema(Graph tbox) Precompute the implications of a schema graph.
static Node	Util.getPropValue(Node root, Node prop, Graph context) Helper - returns the (singleton) value for the given property on the given root node in the data graph.
static Node	Util.makeList(Node[] nodes, Graph graph) Construct an RDF list from the given array of nodes and assert it in the graph returning the head of the list.
void	BasicForwardRuleInfGraph.rebind(Graph data) Replace the underlying data graph for this inference graph and start any inferences over again.
void	LPBackwardRuleInfGraph.rebind(Graph data) Replace the underlying data graph for this inference graph and start any inferences over again.
void	RulePreprocessHook.run(FBRuleInfGraph infGraph, Finder dataFind, Graph inserts) Invoke the preprocessing hook.

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

Constructor and Description
BasicForwardRuleInfGraph(Reasoner reasoner, Graph schema) Constructor.
BasicForwardRuleInfGraph(Reasoner reasoner, List<Rule> rules, Graph schema) Constructor.
BasicForwardRuleInfGraph(Reasoner reasoner, List<Rule> rules, Graph schema, Graph data) Constructor.
FBRuleInfGraph(Reasoner reasoner, Graph schema) Constructor.
FBRuleInfGraph(Reasoner reasoner, List<Rule> rules, Graph schema) Constructor.
FBRuleInfGraph(Reasoner reasoner, List<Rule> rules, Graph schema, Graph data) Constructor.
LPBackwardRuleInfGraph(Reasoner reasoner, LPRuleStore ruleStore, Graph data, Graph schema) Constructor.
RDFSRuleInfGraph(Reasoner reasoner, List<Rule> rules, Graph schema) Constructor.
RDFSRuleInfGraph(Reasoner reasoner, List<Rule> rules, Graph schema, Graph data) Constructor.
RETERuleInfGraph(Reasoner reasoner, Graph schema) Constructor.
RETERuleInfGraph(Reasoner reasoner, List<Rule> rules, Graph schema) Constructor.
RETERuleInfGraph(Reasoner reasoner, List<Rule> rules, Graph schema, Graph data) Constructor.

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

Classes in org.apache.jena.reasoner.rulesys.impl that implement Graph

Modifier and Type	Class and Description
class	SafeGraph A SafeGraph wraps a graph which might contain generalized RDF triples and hides them from API queries so that consumers of it are safe (but can use getRawGraph() to get back the unsafe graph.

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

Modifier and Type	Method and Description
Graph	SafeGraph.getRawGraph() Return the unfiltered version of the graph

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

Modifier and Type	Method and Description
void	OWLRuleTranslationHook.run(FBRuleInfGraph infGraph, Finder dataFind, Graph inserts) Invoke the preprocessing hook.
void	OWLExptRuleTranslationHook.run(FBRuleInfGraph infGraph, Finder dataFind, Graph inserts) Invoke the preprocessing hook.
void	RDFSCMPPreprocessHook.run(FBRuleInfGraph infGraph, Finder dataFind, Graph inserts) Invoke the preprocessing hook.

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

Constructor and Description
SafeGraph(Graph base) Wrap a graph to hide generalized triples

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

Classes in org.apache.jena.reasoner.transitiveReasoner that implement Graph

Modifier and Type	Class and Description
class	TransitiveInfGraph Implementation of InfGraph used by the TransitiveReasoner.

Methods in org.apache.jena.reasoner.transitiveReasoner that return Graph

Modifier and Type	Method and Description
Graph	TransitiveInfGraph.getSchemaGraph() Return the schema graph, if any, bound into this inference graph.

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

Modifier and Type	Method and Description
InfGraph	TransitiveReasoner.bind(Graph data) Attach the reasoner to a set of RDF ddata to process.
Reasoner	TransitiveReasoner.bindSchema(Graph tbox) Extracts all of the subClass and subProperty declarations from the given schema/tbox and caches the resultant graphs.
boolean	TransitiveEngine.checkOccurance(Node prop, Graph graph) Test if there are any usages of prop within the given graph.

Constructors in org.apache.jena.reasoner.transitiveReasoner with parameters of type Graph

Constructor and Description
TransitiveInfGraph(Graph data, TransitiveReasoner reasoner) Constructor.

Uses of Graph in org.apache.jena.shared

Classes in org.apache.jena.shared that implement Graph

Modifier and Type	Class and Description
class	RandomOrderGraph Wraps a graph and randomizes the order of find results.

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

Modifier and Type	Method and Description
static Graph	RandomOrderGraph.createDefaultGraph()
Graph	ClosedException.getGraph() Answer the graph that this exception was constructed with.

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

Constructor and Description
ClosedException(String message, Graph graph)
RandomOrderGraph(Graph base)
RandomOrderGraph(int bufsz, Graph base)

Uses of Graph in org.apache.jena.util

Classes in org.apache.jena.util that implement Graph

Modifier and Type	Class and Description
class	MonitorGraph Graph wrapper which provides normal access to an underlying graph but also maintains a snapshot of the triples it was last known to contain.

Methods in org.apache.jena.util that return Graph

Modifier and Type	Method and Description
static Graph	PrefixMappingUtils.graphInUsePrefixMapping(Graph graph) Return a read-only graph that has the same data (RDF triples) as the one given, but has a prefix mapping that only includes "in use" prefixes as calculated by PrefixMappingUtils.calcInUsePrefixMapping(Graph, PrefixMapping).

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

Modifier and Type	Method and Description
static PrefixMapping	PrefixMappingUtils.calcInUsePrefixMapping(Graph graph) Analyse the graph to see which prefixes of the graph are in use.
static PrefixMapping	PrefixMappingUtils.calcInUsePrefixMapping(Graph graph, PrefixMapping prefixMapping) Analyse the graph to see which prefixes of the given PrefixMapping are in use.
static PrefixMapping	PrefixMappingUtils.calcInUsePrefixMappingTTL(Graph graph) Analyse the graph to see which prefixes of the graph are in use.
static PrefixMapping	PrefixMappingUtils.calcInUsePrefixMappingTTL(Graph graph, PrefixMapping prefixMapping) Analyse the graph to see which prefixes of the given PrefixMapping are used by the graph triples.
static Graph	PrefixMappingUtils.graphInUsePrefixMapping(Graph graph) Return a read-only graph that has the same data (RDF triples) as the one given, but has a prefix mapping that only includes "in use" prefixes as calculated by PrefixMappingUtils.calcInUsePrefixMapping(Graph, PrefixMapping).

Constructors in org.apache.jena.util with parameters of type Graph

Constructor and Description
MonitorGraph(Graph g) Constructor, wrap the given graph with a state monitor