|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
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 | This package provides basic implementations of Graph interfaces such as Reifier, QueryHandler, BulkUpdateHandler, and EventManager. |
com.hp.hpl.jena.graph.query | Defines the graph-level Query classes, allowing multi-pattern query over arbitrary graphs. |
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.dig | |
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. |
Uses of Graph in com.hp.hpl.jena.db |
---|
Classes in com.hp.hpl.jena.db that implement Graph | |
---|---|
class |
GraphRDB
A persistent Graph implementation using a relational database for storage. |
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 alternate constructor and 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 |
---|
Fields in com.hp.hpl.jena.graph declared as Graph | |
---|---|
static Graph |
Graph.emptyGraph
An immutable empty graph. |
Methods in com.hp.hpl.jena.graph that return Graph | |
---|---|
Graph |
GraphMaker.addDescription(Graph desc,
Node self)
Add the description of this GraphMaker to the description graph desc, under the name self. |
static Graph |
Factory.createDefaultGraph()
Answer a memory-based Graph with the Standard reification style. |
static Graph |
Factory.createDefaultGraph(ReificationStyle style)
Answer a memory-based Graph with the given reification style. |
Graph |
GraphMaker.createGraph()
Answer a graph who's name isn't interesting. |
Graph |
GraphMaker.createGraph(java.lang.String name)
Create a graph that does not already exist - equivalent to createGraph( name, false ) . |
Graph |
GraphMaker.createGraph(java.lang.String name,
boolean strict)
Create a new graph associated with the given name. |
static Graph |
Factory.createGraphMem()
|
static Graph |
Factory.createGraphMem(ReificationStyle style)
|
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.getDescription()
Answer a Graph describing this GraphMaker using the vocabulary of JenaModelSpec. |
Graph |
GraphMaker.getDescription(Node root)
|
Graph |
GraphMaker.getGraph()
Answer the default graph of this GraphMaker. |
Graph |
Reifier.getParentGraph()
get the Graph which uses this reifier. |
Graph |
GraphMaker.openGraph()
Answer the default graph of this GraphMaker, if it has one. |
Graph |
GraphMaker.openGraph(java.lang.String name)
Equivalent to openGraph( name, false ) |
Graph |
GraphMaker.openGraph(java.lang.String name,
boolean strict)
Find an existing graph that this factory knows about under the given name. |
Methods in com.hp.hpl.jena.graph with parameters of type Graph | |
---|---|
void |
BulkUpdateHandler.add(Graph g)
Add all the triples of the given graph into the graph this is handler for. |
void |
BulkUpdateHandler.add(Graph g,
boolean withReifications)
Add all the triples of the given graph into the graph this is handler for. |
Graph |
GraphMaker.addDescription(Graph desc,
Node self)
Add the description of this GraphMaker to the description graph desc, under the name self. |
void |
BulkUpdateHandler.delete(Graph g)
Remove all the triples of the given graph from the graph this is handler for. |
void |
BulkUpdateHandler.delete(Graph g,
boolean withReifications)
Remove all the triples of the given graph from the graph this is handler for. |
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 |
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 |
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,
java.util.Iterator it)
Method called when an iterator [of triples] has been added to the graph |
void |
GraphEventManager.notifyAddIterator(Graph g,
java.util.List 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,
java.util.List 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,
java.util.Iterator it)
Method called when an iterator [of triples] has been deleted from the graph. |
void |
GraphEventManager.notifyDeleteIterator(Graph g,
java.util.List 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,
java.util.List 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,
java.lang.Object value)
method to call for a general event |
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
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
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
A class representing the dynamic union of two graphs. |
Methods in com.hp.hpl.jena.graph.compose that return Graph | |
---|---|
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. |
Methods in com.hp.hpl.jena.graph.compose with parameters of type Graph | |
---|---|
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 Filter |
CompositionBase.ifIn(Graph g)
Answer a Filter that will accept any triple that is an edge of
graph g. |
static ExtendedIterator |
CompositionBase.rejecting(ExtendedIterator 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 com.hp.hpl.jena.graph.compose with parameters of type Graph | |
---|---|
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)
|
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. |
class |
com.hp.hpl.jena.graph.impl.WrappedGraph
A wrapper class which simply defers all operations to its base. |
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 |
NamedGraphMap.get(java.lang.String name)
Answer the GRaph with the given name, or null if there isn't one. |
Methods in com.hp.hpl.jena.graph.query with parameters of type Graph | |
---|---|
Applyer |
QueryTriple.createApplyer(Graph g)
|
ExtendedIterator |
Query.executeBindings(Graph g,
java.util.List stages,
Node[] results)
|
ExtendedIterator |
Query.executeBindings(Graph g,
Node[] results)
|
static java.util.Set |
SimpleTreeQueryPlan.getRoots(Graph pattern)
|
static ExtendedIterator |
SimpleQueryHandler.objectsFor(Graph g,
Node s,
Node p)
|
static ExtendedIterator |
SimpleQueryHandler.predicatesFor(Graph g,
Node s,
Node o)
|
TreeQueryPlan |
SimpleQueryHandler.prepareTree(Graph pattern)
|
TreeQueryPlan |
QueryHandler.prepareTree(Graph pattern)
deliver a plan for executing the tree-match query defined by _pattern_. |
NamedGraphMap |
NamedGraphMap.put(java.lang.String name,
Graph g)
Add a named graph to the map and return this map. |
static ExtendedIterator |
SimpleQueryHandler.subjectsFor(Graph g,
Node p,
Node o)
|
Constructors in com.hp.hpl.jena.graph.query with parameters of type Graph | |
---|---|
PatternStage(Graph graph,
Mapping map,
ExpressionSet constraints,
Triple[] triples)
|
|
PatternStageBase(QueryNodeFactory factory,
Graph graph,
Mapping map,
ExpressionSet constraints,
Triple[] triples)
|
|
Query(Graph pattern)
Initialiser for Query; makes a Query with its matches taken from pattern . |
|
SimpleQueryHandler(Graph graph)
make an instance, remember the graph |
|
SimpleQueryPlan(Graph graph,
Query query,
Node[] variables)
|
|
SimpleTreeQueryPlan(Graph target,
Graph pattern)
|
Uses of Graph in com.hp.hpl.jena.rdf.arp |
---|
Methods in com.hp.hpl.jena.rdf.arp with parameters of type Graph | |
---|---|
void |
JenaReader.read(Graph g,
java.io.InputStream in,
java.lang.String xmlBase)
Reads from inputStream, using base URI xmlbase, adding triples to graph. |
void |
JenaReader.read(Graph g,
java.io.Reader reader,
java.lang.String xmlBase)
Reads from reader, using base URI xmlbase, adding triples to graph. |
Uses of Graph in com.hp.hpl.jena.rdf.model |
---|
Methods in com.hp.hpl.jena.rdf.model that return Graph | |
---|---|
Graph |
ModelGraphInterface.getGraph()
Answer the Graph which this Model is presenting. |
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.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. the argument to the Reasonder.bind call that created this InfGraph). |
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 | |
---|---|
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 |
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 |
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 com.hp.hpl.jena.reasoner with parameters of type Graph | |
---|---|
BaseInfGraph(Graph data,
Reasoner reasoner)
Constructor |
|
FGraph(Graph graph)
Constructor |
Uses of Graph in com.hp.hpl.jena.reasoner.dig |
---|
Classes in com.hp.hpl.jena.reasoner.dig that implement Graph | |
---|---|
class |
DIGInfGraph
An InfGraph that performs reasoning via a DIG interface to an external reasoner. |
Methods in com.hp.hpl.jena.reasoner.dig that return Graph | |
---|---|
Graph |
DIGAdapter.getGraph()
Answer the graph of local (source) data. |
Graph |
DIGReasoner.getSchema()
Answer the schema (tbox) graph for this reasoner, or null if no schema is defined. |
Graph |
DIGInfGraph.getSchemaGraph()
Return the schema graph, if any, bound into this inference graph. |
Methods in com.hp.hpl.jena.reasoner.dig with parameters of type Graph | |
---|---|
InfGraph |
DIGReasoner.bind(Graph data)
Bind the given data graph to any existing t-box schema that we have, and answer the resulting inference graph. |
Reasoner |
DIGReasoner.bindSchema(Graph tbox)
Bind a schema, or tbox, to this DIG reasoner. |
ExtendedIterator |
DIGInfGraph.find(Node subject,
Node property,
Node object,
Graph param)
An extension of the find(com.hp.hpl.jena.graph.TripleMatch) interface which allows the caller to
encode complex expressions in RDF and then refer to those expressions
within the query triple. |
void |
DIGInfGraph.rebind(Graph data)
Replace the underlying data graph for this inference graph and start any inferences over again. |
Constructors in com.hp.hpl.jena.reasoner.dig with parameters of type Graph | |
---|---|
DIGAdapter(OntModelSpec spec,
Graph source)
Construct a DIG adapter for the given source data graph, which is encoding an ontology in a language represented by the given model spec. |
|
DIGAdapter(OntModelSpec spec,
Graph source,
DIGConnection connection,
Model axioms)
Construct a DIG adapter for the given source data graph, which is encoding an ontology in a language represented by the given model spec. |
|
DIGInfGraph(Graph data,
DIGReasoner reasoner)
Constructor |
|
DIGReasoner(Graph tbox,
ReasonerFactory factory,
Resource configuration)
Construct a DIG reasoner, that can generate inference graphs binding an external DIG inference engine (e.g. |
Uses of Graph in com.hp.hpl.jena.reasoner.rulesys |
---|
Subinterfaces of Graph in com.hp.hpl.jena.reasoner.rulesys | |
---|---|
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 com.hp.hpl.jena.reasoner.rulesys that implement Graph | |
---|---|
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. |
Methods in com.hp.hpl.jena.reasoner.rulesys that return Graph | |
---|---|
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 |
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. |
Methods in com.hp.hpl.jena.reasoner.rulesys with parameters of type Graph | |
---|---|
InfGraph |
RDFSRuleReasoner.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 |
LPBackwardRuleReasoner.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 |
BasicForwardRuleReasoner.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 |
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 |
BasicForwardRuleReasoner.bindSchema(Graph tbox)
Precompute the implications of a schema graph. |
InfGraph |
FBRuleInfGraph.cloneWithPremises(Graph premises)
Return a new inference graph which is a clone of the current graph together with an additional set of data premises. |
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. |
Constructors in com.hp.hpl.jena.reasoner.rulesys with parameters of type Graph | |
---|---|
BasicForwardRuleInfGraph(Reasoner reasoner,
Graph schema)
Constructor. |
|
BasicForwardRuleInfGraph(Reasoner reasoner,
java.util.List rules,
Graph schema)
Constructor. |
|
BasicForwardRuleInfGraph(Reasoner reasoner,
java.util.List rules,
Graph schema,
Graph data)
Constructor. |
|
FBRuleInfGraph(Reasoner reasoner,
Graph schema)
Constructor. |
|
FBRuleInfGraph(Reasoner reasoner,
java.util.List rules,
Graph schema)
Constructor. |
|
FBRuleInfGraph(Reasoner reasoner,
java.util.List 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,
java.util.List rules,
Graph schema)
Constructor. |
|
RDFSRuleInfGraph(Reasoner reasoner,
java.util.List rules,
Graph schema,
Graph data)
Constructor. |
|
RETERuleInfGraph(Reasoner reasoner,
Graph schema)
Constructor. |
|
RETERuleInfGraph(Reasoner reasoner,
java.util.List rules,
Graph schema)
Constructor. |
|
RETERuleInfGraph(Reasoner reasoner,
java.util.List rules,
Graph schema,
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 | |
---|---|
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. |
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. |
Uses of Graph in com.hp.hpl.jena.shared |
---|
Classes in com.hp.hpl.jena.shared that implement Graph | |
---|---|
class |
RandomOrderGraph
Wraps a graph and randomizes the order of find results. |
Methods in com.hp.hpl.jena.shared that return Graph | |
---|---|
static Graph |
RandomOrderGraph.createDefaultGraph()
|
Graph |
ClosedException.getGraph()
Answer the graph that this exception was constructed with. |
Constructors in com.hp.hpl.jena.shared with parameters of type Graph | |
---|---|
ClosedException(java.lang.String message,
Graph graph)
|
|
RandomOrderGraph(Graph base)
|
|
RandomOrderGraph(int bufsz,
Graph base)
|
Uses of Graph in com.hp.hpl.jena.util |
---|
Classes in com.hp.hpl.jena.util that implement Graph | |
---|---|
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 com.hp.hpl.jena.util that return Graph | |
---|---|
Graph |
QueryMapper.getGraph()
|
Graph |
QueryMapper.toQueryGraph(Model m)
|
Constructors in com.hp.hpl.jena.util with parameters of type Graph | |
---|---|
MonitorGraph(Graph g)
Constructor, wrap the given graph with a state monitor |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |