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 update-tracking.
|
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.arp |
A parser for RDF/XML.
|
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.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 transitive-reflexive 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 Jena-specific 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 memory-based Graph with the Standard reification style.
|
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) |
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.
|
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 sub-graph 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/rdf-concepts#section-Graph-syntax
|
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 sub-graphs.
|
class |
Delta
Deprecated.
|
class |
Difference
Deprecated.
|
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
Deprecated.
|
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.
|
Modifier and Type | Method and Description |
---|---|
Graph |
Delta.getAdditions()
Deprecated.
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()
Deprecated.
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 |
MultiUnion.addGraph(Graph graph)
Add the given graph to this union.
|
void |
Polyadic.addGraph(Graph graph)
Add the given graph to this composition.
|
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 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)
Deprecated.
|
Difference(Graph L,
Graph R)
Deprecated.
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)
Deprecated.
|
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 sub-graphs of this model.
|
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 | 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 | 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 |
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 |
LPBackwardRuleInfGraph.getSchemaGraph()
Return the schema graph, if any, bound into this inference graph.
|
Graph |
BasicForwardRuleInfGraph.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 |
OWLMiniReasoner.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 |
BasicForwardRuleReasoner.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 |
GenericRuleReasoner.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 |
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 |
OWLFBRuleReasoner.bindSchema(Graph tbox)
Precompute the implications of a schema graph.
|
Reasoner |
BasicForwardRuleReasoner.bindSchema(Graph tbox)
Precompute the implications of a schema graph.
|
Reasoner |
FBRuleReasoner.bindSchema(Graph tbox)
Precompute the implications of a schema graph.
|
Reasoner |
GenericRuleReasoner.bindSchema(Graph tbox)
Precompute the implications of a schema graph.
|
Reasoner |
LPBackwardRuleReasoner.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 |
LPBackwardRuleInfGraph.rebind(Graph data)
Replace the underlying data graph for this inference graph and start any
inferences over again.
|
void |
BasicForwardRuleInfGraph.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