Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

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

Packages that use Graph
com.hp.hpl.jena.db | A general database backend for persistent storage of Jena models.
com.hp.hpl.jena.enhanced | This package defines the enhanced node and graph classes; an enhanced node is one embedded in a particular enhanced graph.
com.hp.hpl.jena.graph | This package defines the Graph and Node family of classes, which form the underlying datatypes of the Jena system.
com.hp.hpl.jena.graph.compose | This package defines simple composite graphs - union, intersection, difference, and update-tracking.
com.hp.hpl.jena.graph.impl | 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)`
`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.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
`BaseInfGraph(Graph data, Reasoner reasoner, ReificationStyle style)`
`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` | `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` | `BasicFBReifier.getParentGraph()`
`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.
`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.
`BasicForwardRuleInfGraph(Reasoner reasoner, java.util.List rules, Graph schema, ReificationStyle style)`
`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.
`FBRuleInfGraph(Reasoner reasoner, java.util.List rules, Graph schema, ReificationStyle style)`
`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

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

Copyright © 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Hewlett-Packard Development Company, LP