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

org.apache.jena.graph.impl 
This package provides basic implementations of Graph interfaces
such as EventManager and Capabilities.

org.apache.jena.mem 
Various memorybased implementations of interfaces,
specifically GraphMem for memorybased 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 transitivereflexive 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 Jenaspecific exceptions hang, and the interface PrefixMapping
for translation to and from QNames.

org.apache.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 

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?

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)

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 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 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 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 remove() function that converts the remove to
a number of
delete(Triple) operations. 
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 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) 
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  Interface and Description 

interface 
GraphWithPerform
GraphWithPerform is an implementation interface that extends Graph
with the performAdd and performDelete methods used by GraphBase
to invoke nonnotifying versions of add and delete.

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

class 
WrappedGraph
A wrapper class which simply defers all operations to its base.

Modifier and Type  Method and Description 

Graph 
SimpleGraphMaker.create() 
Graph 
BaseGraphMaker.createGraph()
Make a fresh anonymous graph.

Graph 
BaseGraphMaker.createGraph(String name)
A nonstrict 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 nonstrict 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 termequality.

static Graph 
GraphPlain.plain(Graph base)
Return a graph that only has termequality
and storage in the
base 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 termequality
and storage in the
base graph. 
static String 
GraphBase.toString(String prefix,
Graph that)
Answer a humanconsumable representation of
that . 
Constructor and Description 

SimpleEventManager(Graph graph)
Deprecated.
Use the no argument constructor.

WrappedGraph(Graph base) 
Modifier and Type  Class and Description 

class 
GraphMem 
class 
GraphMemBase
GraphMemBase  a common base class for GraphMem and SmallGraphMem.

Constructor and Description 

GraphTripleStore(Graph parent) 
GraphTripleStoreMem(Graph parent) 
StoreTripleIterator(Graph toNotify,
Iterator<Triple> it,
NodeToTriplesMapBase X,
NodeToTriplesMapBase A,
NodeToTriplesMapBase B) 
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 
OntModelImpl.getBaseGraph()
Answer the basegraph of this model.

Modifier and Type  Method and Description 

List<Graph> 
OntModelImpl.getSubGraphs()
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 

Graph 
ModelCom.getGraph() 
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.

Constructor and Description 

ModelCom(Graph base)
make a model based on the specified graph

ModelCom(Graph base,
Personality<RDFNode> personality) 
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 
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.

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.

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

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.

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.

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.

Modifier and Type  Method and Description 

Graph 
SafeGraph.getRawGraph()
Return the unfiltered version of the 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.

Constructor and Description 

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

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