Uses of Interface
com.hp.hpl.jena.graph.Graph

Packages that use Graph

com.hp.hpl.jena.db	A general database backend for persistent storage of jena models.
com.hp.hpl.jena.enhanced	This package defines the enhanced node and graph classes; an enhanced node is one embedded in a particular enhanced graph.
com.hp.hpl.jena.graph	This package defines the Graph and Node family of classes, which form the underlying datatypes of the Jena system.
com.hp.hpl.jena.graph.compose	This package defines simple composite graphs - union, intersection, difference, and update-tracking.
com.hp.hpl.jena.graph.impl
com.hp.hpl.jena.graph.query	Defines the graph-level Query classes, allowing multi-pattern query over arbitrary graphs.
com.hp.hpl.jena.rdf.model	A package for creating and manipulating RDF graphs.
com.hp.hpl.jena.reasoner	The Jena2 reasoner subsystem is designed to allow a range of inference engines to be plugged into Jena.
com.hp.hpl.jena.reasoner.rdfsReasoner1	This package contains an example RDFS reasoner.
com.hp.hpl.jena.reasoner.transitiveReasoner	This package contains a reasoner which supports transitive-reflexive closure of subPropertyOf and subClassOf relations.

Uses of Graph in com.hp.hpl.jena.db

Classes in com.hp.hpl.jena.db that implement Graph

class

GraphRDB GraphRDB implementation This graph stores data persistently in a relational database.

Constructors in com.hp.hpl.jena.db with parameters of type Graph

GraphRDB(IDBConnection con, java.lang.String graphID, Graph requestedProperties, boolean isNew)
Deprecated. Please use the alernate constructor and explicely choose the desired reification behaviour.

GraphRDB(IDBConnection con, java.lang.String graphID, Graph requestedProperties, int reificationBehaviour, boolean isNew)
Construct a new GraphRDB

Uses of Graph in com.hp.hpl.jena.enhanced

Methods in com.hp.hpl.jena.enhanced that return Graph

Graph

EnhGraph.asGraph() Answer the normal graph that this enhanced graph is wrapping.

Constructors in com.hp.hpl.jena.enhanced with parameters of type Graph

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

Uses of Graph in com.hp.hpl.jena.graph

Methods in com.hp.hpl.jena.graph that return Graph

Graph	Reifier.getHiddenTriples() return a read-only Graph of the triples used for reification.
Graph	Reifier.getParentGraph() get the Graph which uses this reifier.
Graph	GraphMaker.getGraph() Answer an instance of a graph
Graph	GraphMaker.createGraph(java.lang.String name, boolean strict) Create a new graph associated with the given name.
Graph	GraphMaker.createGraph(java.lang.String name) Create a graph that does not already exist - equivalent to createGraph( name, false ).
Graph	GraphMaker.openGraph(java.lang.String name, boolean strict) Find an existing graph that this factory knows about under the given name.
Graph	GraphMaker.openGraph(java.lang.String name) Equivalent to openGraph( name, false )
static Graph	Factory.createDefaultGraph()

Methods in com.hp.hpl.jena.graph with parameters of type Graph

static ExtendedIterator	GraphUtil.findAll(Graph g) Answer an iterator covering all the triples in the specified graph.
void	GraphListener.notifyAddGraph(Graph g) Method called when another graph g has been used to specify the triples added to our attached graph.
void	GraphListener.notifyDeleteGraph(Graph g) Method to call when another graph has been used to specify the triples deleted from our attached graph.
boolean	Graph.dependsOn(Graph other) true if this graph's content depends on the other 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
void	BulkUpdateHandler.add(Graph g) Add all the triples of the given graph into the graph this is handler for.
void	BulkUpdateHandler.delete(Graph g) Remove all the triples of the given graph from the graph this is handler for.

Constructors in com.hp.hpl.jena.graph with parameters of type Graph

GraphEvent(Graph g)
Constructor for GraphEvent.

Uses of Graph in com.hp.hpl.jena.graph.compose

Classes in com.hp.hpl.jena.graph.compose that implement Graph

class	CompositionBase Base class for graphs that are composed of multiple sub-graphs.
class	Delta
class	Difference
class	Dyadic
class	Intersection an implementation of a dynamic intersection of two models.
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

Methods in com.hp.hpl.jena.graph.compose that return Graph

Graph	Polyadic.getBaseGraph() Answer the distinguished graph for the composition, which will be the graph that receives triple adds and deletes.
Graph	Delta.getAdditions()
Graph	Delta.getDeletions()

Methods in com.hp.hpl.jena.graph.compose with parameters of type Graph

boolean	Polyadic.dependsOn(Graph graph) Answer true if this graph contains the given graph as a sub-component.
void	Polyadic.addGraph(Graph graph) Add the given graph to this composition.
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.
boolean	Dyadic.dependsOn(Graph other)
Union	Dyadic.union(Graph X)
static Filter	CompositionBase.ifIn(Graph g) Answer a Filter that will accept any triple that is an edge of graph g.

Constructors in com.hp.hpl.jena.graph.compose with parameters of type Graph

Union(Graph L, Graph R)

Polyadic(Graph[] graphs)
Construct a composition of all of the given graphs

MultiUnion(Graph[] graphs)
Construct a union of all of the given graphs

Intersection(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.

Difference(Graph L, Graph R)

Delta(Graph base)

Uses of Graph in com.hp.hpl.jena.graph.impl

Classes in com.hp.hpl.jena.graph.impl that implement Graph

class

com.hp.hpl.jena.graph.impl.GraphBase GraphBase is an implementation of Graph that provides some convenient base functionality for Graph implementations.

Uses of Graph in com.hp.hpl.jena.graph.query

Methods in com.hp.hpl.jena.graph.query that return Graph

Graph	TreeQueryPlan.executeTree()
Graph	SimpleTreeQueryPlan.executeTree()
Graph	Query.ArgMap.get(java.lang.String name)

Methods in com.hp.hpl.jena.graph.query with parameters of type Graph

static java.util.HashSet	SimpleTreeQueryPlan.getRoots(Graph pattern)
Stage	SimpleQueryHandler.patternStage(Mapping map, Graph constraints, Triple[] t)
TreeQueryPlan	SimpleQueryHandler.prepareTree(Graph pattern)
Stage	QueryHandler.patternStage(Mapping map, Graph constraints, Triple[] p) produce a single Stage which will probe the underlying graph for triples matching p and inject all the resulting bindings into the processing stream (see Stage for details) _map_ is the variable binding map to use and update.
TreeQueryPlan	QueryHandler.prepareTree(Graph pattern) deliver a plan for executing the tree-match query defined by _pattern_.
Query	Query.addConstraint(Graph g)
ExtendedIterator	Query.executeBindings(Graph g, Node[] results)
Query.ArgMap	Query.ArgMap.put(java.lang.String name, Graph g)

Constructors in com.hp.hpl.jena.graph.query with parameters of type Graph

SimpleTreeQueryPlan(Graph target, Graph pattern)

SimpleQueryPlan(Graph graph, Query query, Node[] variables)

SimpleQueryHandler(Graph graph)
make an instance, remember the graph

Query(Graph pattern)

PatternStage(Graph graph, Mapping map, Triple[] triples)

ConstraintStage(Mapping map, Graph g)
constructor: compile the graph _g_ into a Predicate using the supplied _map_ for bindings of variables.

Uses of Graph in com.hp.hpl.jena.rdf.model

Methods in com.hp.hpl.jena.rdf.model that return Graph

Graph

Model.getGraph() Every model is based on some Graph

Methods in com.hp.hpl.jena.rdf.model with parameters of type Graph

static Model

ModelFactory.createModelForGraph(Graph g) Answer a model that encapsulates the given graph.

Uses of Graph in com.hp.hpl.jena.reasoner

Subinterfaces of Graph in com.hp.hpl.jena.reasoner

interface

InfGraph Extends the Graph interface to give additional means to query an inferred graph.

Classes in com.hp.hpl.jena.reasoner that implement Graph

class

BaseInfGraph A base level implementation of the InfGraph interface.

Methods in com.hp.hpl.jena.reasoner that return Graph

Graph	InfGraph.getRawGraph() Return the raw RDF data Graph being processed (i.e. the argument to the Reasonder.bind call that created this InfGraph).
Graph	FGraph.getGraph() Returns the graph.
Graph	BaseInfGraph.getRawGraph() Return the raw RDF data Graph being processed (i.e. the argument to the Reasonder.bind call that created this InfGraph).
abstract Graph	BaseInfGraph.getSchemaGraph() Return the schema graph, if any, bound into this inference graph.

Methods in com.hp.hpl.jena.reasoner with parameters of type Graph

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	Reasoner.bind(Graph data) Attach the reasoner to a set of RDF data to process.
void	InfGraph.rebind(Graph data) Replace the underlying data graph for this inference graph and start any inferences over again.
ExtendedIterator	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.
void	BaseInfGraph.rebind(Graph data) Replace the underlying data graph for this inference graph and start any inferences over again.
ExtendedIterator	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.
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.

Constructors in com.hp.hpl.jena.reasoner with parameters of type Graph

FGraph(Graph graph)
Constructor

BaseInfGraph(Graph data, Reasoner reasoner)
Constructor

Uses of Graph in com.hp.hpl.jena.reasoner.rdfsReasoner1

Classes in com.hp.hpl.jena.reasoner.rdfsReasoner1 that implement Graph

class

RDFSInfGraph An RDFS reasoner that has been bound to both a TBox and an ABox.

Methods in com.hp.hpl.jena.reasoner.rdfsReasoner1 that return Graph

Graph

RDFSInfGraph.getSchemaGraph() Return the schema graph, if any, bound into this inference graph.

Methods in com.hp.hpl.jena.reasoner.rdfsReasoner1 with parameters of type Graph

Reasoner	RDFSReasoner.bindSchema(Graph tbox) Deprecated. Extracts all of the subClass and subProperty declarations from the given schema/tbox and caches the resultant graphs.
InfGraph	RDFSReasoner.bind(Graph data) Deprecated. Attach the reasoner to a set of RDF ddata to process.

Constructors in com.hp.hpl.jena.reasoner.rdfsReasoner1 with parameters of type Graph

RDFSInfGraph(RDFSReasoner reasoner, Graph data)
Constructor

Uses of Graph in com.hp.hpl.jena.reasoner.transitiveReasoner

Classes in com.hp.hpl.jena.reasoner.transitiveReasoner that implement Graph

class

TransitiveInfGraph Implementation of InfGraph used by the TransitiveReasoner.

Methods in com.hp.hpl.jena.reasoner.transitiveReasoner that return Graph

Graph

TransitiveInfGraph.getSchemaGraph() Return the schema graph, if any, bound into this inference graph.

Methods in com.hp.hpl.jena.reasoner.transitiveReasoner with parameters of type Graph

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

Constructors in com.hp.hpl.jena.reasoner.transitiveReasoner with parameters of type Graph

TransitiveInfGraph(Graph data, TransitiveReasoner reasoner)
Constructor.