Package  Description 

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 updatetracking.

com.hp.hpl.jena.graph.impl 
This package provides basic implementations of Graph interfaces
such as Reifier, QueryHandler, BulkUpdateHandler, and EventManager.

com.hp.hpl.jena.ontology 
Provides a set of abstractions and convenience classes for accessing and manipluating ontologies
represented in RDF.

com.hp.hpl.jena.rdf.model 
A package for creating and manipulating RDF graphs.

com.hp.hpl.jena.rdfxml.xmlinput 
A parser for RDF/XML.

com.hp.hpl.jena.reasoner 
The Jena2 reasoner subsystem is designed to allow a range of inference
engines to be plugged into Jena.

com.hp.hpl.jena.reasoner.rulesys 
Provides a selection of simple rule engines for Jena inference models.

com.hp.hpl.jena.reasoner.transitiveReasoner 
This package contains a reasoner which supports transitivereflexive closure
of subPropertyOf and subClassOf relations.

com.hp.hpl.jena.shared 
This package defines some classes common to the Jena API
and SPI levels, in particular the JenaException class from which
all Jenaspecific exceptions hang, and the interface PrefixMapping
for translation to and from QNames.

com.hp.hpl.jena.util 
Miscellaneous collection of utility classes.

Modifier and Type  Method and Description 

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

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.

Modifier and Type  Field and Description 

static Graph 
Graph.emptyGraph
An immutable empty graph.

Modifier and Type  Method and Description 

static Graph 
Factory.createDefaultGraph()
Answer a memorybased 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 subgraph 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.

Modifier and Type  Method and Description 

void 
BulkUpdateHandler.add(Graph g)
Deprecated.
See GraphUtil for helper functions for migration.

void 
BulkUpdateHandler.add(Graph g,
boolean withReifications)
Deprecated.
See GraphUtil for helper functions for migration.

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, predciate or object?

void 
BulkUpdateHandler.delete(Graph g)
Deprecated.
See GraphUtil for helper functions for migration.

void 
BulkUpdateHandler.delete(Graph g,
boolean withReifications)
Deprecated.
See GraphUtil for helper functions for migration.

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 the destination (arg 1) as given in the source (arg 2)

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 subgraph of
extractFrom reachable from root bounded
by this instance's TripleBoundary. 
static com.hp.hpl.jena.util.iterator.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/rdfconcepts#sectionGraphsyntax

static com.hp.hpl.jena.util.iterator.ExtendedIterator<Node> 
GraphUtil.listObjects(Graph g,
Node s,
Node p)
Return an iterator over the unique objects with a given subject and object.

static com.hp.hpl.jena.util.iterator.ExtendedIterator<Node> 
GraphUtil.listPredicates(Graph g,
Node s,
Node o)
Return an iterator over the unique predicate between s and o.

static com.hp.hpl.jena.util.iterator.ExtendedIterator<Node> 
GraphUtil.listSubjects(Graph g,
Node p,
Node o)
Return an iterator over the unique subjects with predciate 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 remve() function.

Modifier and Type  Class and Description 

class 
CompositionBase
Base class for graphs that are composed of multiple subgraphs.

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 duplicateremoval. 
class 
Dyadic
Base class for the twooperand 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
subgraphs (thus providing a basis for polyadic composition operators).

class 
Union
A class representing the dynamic union of two graphs.

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 
Polyadic.getRequiredBaseGraph()
Answer the distinguished graph for the composition, which will be the graph
that receives triple adds and deletes.

Modifier and Type  Method and Description 

List<Graph> 
Polyadic.getSubGraphs()
Answer a list of the graphs other than the updateable (base) 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 subcomponent.

boolean 
Dyadic.dependsOn(Graph other)
Generic dependsOn, true iff it depends on either of the subgraphs.

static com.hp.hpl.jena.util.iterator.Filter<Triple> 
CompositionBase.ifIn(Graph g)
Answer a
Filter that will accept any triple that is an edge of
graph g. 
static com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> 
CompositionBase.rejecting(com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> i,
Graph seen)
Answer an iterator over the elements of
i that are not in
the graph seen . 
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) 
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 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.

Modifier and Type  Class and Description 

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

class 
com.hp.hpl.jena.graph.impl.WrappedGraph
A wrapper class which simply defers all operations to its base.

Modifier and Type  Method and Description 

List<Graph> 
OntModel.getSubGraphs()
i.next()
Answer the subgraphs of this model.

Modifier and Type  Method and Description 

Graph 
ModelGraphInterface.getGraph()
Answer the Graph which this Model is presenting.

Modifier and Type  Method and Description 

static Model 
ModelFactory.createModelForGraph(Graph g)
Answer a model that encapsulates the given 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.

Modifier and Type  Interface and Description 

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

Modifier and Type  Class and Description 

class 
BaseInfGraph
A base level implementation of the InfGraph interface.

Modifier and Type  Method and Description 

Graph 
BaseInfGraph.getDeductionsGraph()
Returns a derivations graph.

Graph 
InfGraph.getDeductionsGraph()
Returns a derivations graph.

Graph 
FGraph.getGraph()
Returns the graph.

Graph 
BaseInfGraph.getRawGraph()
Return the raw RDF data Graph being processed (i.e.

Graph 
InfGraph.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.

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.

com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> 
BaseInfGraph.find(Node subject,
Node property,
Node object,
Graph param)
An extension of the Graph.find interface which allows the caller to
encode complex expressions in RDF and then refer to those expressions
within the query triple.

com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> 
InfGraph.find(Node subject,
Node property,
Node object,
Graph param)
An extension of the Graph.find interface which allows the caller to
encode complex expressions in RDF and then refer to those expressions
within the query triple.

void 
BaseInfGraph.rebind(Graph data)
Replace the underlying data graph for this inference graph and start any
inferences over again.

void 
InfGraph.rebind(Graph data)
Replace the underlying data graph for this inference graph and start any
inferences over again.

Constructor and Description 

BaseInfGraph(Graph data,
Reasoner reasoner)
Constructor

FGraph(Graph graph)
Constructor

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.

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 infernce 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 
ForwardRuleInfGraphI.getCurrentDeductionsGraph()
Return the Graph containing all the static deductions available so far.

Graph 
BasicForwardRuleInfGraph.getCurrentDeductionsGraph()
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.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.

Modifier and Type  Method and Description 

InfGraph 
RDFSRuleReasoner.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 
LPBackwardRuleReasoner.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 
GenericRuleReasoner.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 
OWLFBRuleReasoner.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 
BasicForwardRuleReasoner.bindSchema(Graph tbox)
Precompute the implications of a schema graph.

Reasoner 
LPBackwardRuleReasoner.bindSchema(Graph tbox)
Precompute the implications of a schema graph.

Reasoner 
GenericRuleReasoner.bindSchema(Graph tbox)
Precompute the implications of a schema graph.

Reasoner 
FBRuleReasoner.bindSchema(Graph tbox)
Precompute the implications of a schema graph.

Reasoner 
OWLFBRuleReasoner.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.

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,
com.hp.hpl.jena.reasoner.rulesys.impl.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.

Modifier and Type  Class and Description 

class 
TransitiveInfGraph
Implementation of InfGraph used by the TransitiveReasoner.

Modifier and Type  Method and Description 

Graph 
TransitiveInfGraph.getSchemaGraph()
Return the schema graph, if any, bound into this inference 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.

Constructor and Description 

TransitiveInfGraph(Graph data,
TransitiveReasoner reasoner)
Constructor.

Modifier and Type  Class and Description 

class 
RandomOrderGraph
Wraps a graph and randomizes the order of find results.

Modifier and Type  Method and Description 

static Graph 
RandomOrderGraph.createDefaultGraph() 
Graph 
ClosedException.getGraph()
Answer the graph that this exception was constructed with.

Constructor and Description 

ClosedException(String message,
Graph graph) 
RandomOrderGraph(Graph base) 
RandomOrderGraph(int bufsz,
Graph base) 
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.

Constructor and Description 

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

Licenced under the Apache License, Version 2.0