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.ontology.tidy Implements an OWL Syntax Checker.  
com.hp.hpl.jena.rdf.arp Reading 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.  
 

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 Reifier.getHiddenTriples()
          return a read-only Graph of the triples used for reification.
 Graph Reifier.getReificationTriples()
          Answer a read-only graph of all the reification quadlets in this reifier.
 Graph Reifier.getParentGraph()
          get the Graph which uses this reifier.
 Graph GraphMaker.getGraph()
          Answer the default graph of this ModelMaker.
 Graph GraphMaker.createGraph()
          Answer a graph who's name isn't interesting.
 Graph GraphMaker.createGraph(java.lang.String name, boolean strict)
          Create a new graph associated with the given name.
 Graph GraphMaker.createGraph(java.lang.String name)
          Create a graph that does not already exist - equivalent to
createGraph( name, false ).
 Graph GraphMaker.openGraph(java.lang.String name, boolean strict)
          Find an existing graph that this factory knows about under the given name.
 Graph GraphMaker.openGraph(java.lang.String name)
          Equivalent to openGraph( name, false )
 Graph GraphMaker.getDescription()
          Answer a Graph describing this GraphMaker using the vocabulary of JMS.
 Graph GraphMaker.getDescription(Node root)
           
 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.
 

Methods in com.hp.hpl.jena.graph with parameters of type Graph
static ExtendedIterator GraphUtil.findAll(Graph g)
          Answer an iterator covering all the triples in the specified graph.
 Graph GraphMaker.addDescription(Graph desc, Node self)
          Add the description of this GraphMaker to the description graph desc, under the name self.
 void GraphListener.notifyAddGraph(Graph g)
          Method called when another graph g has been used to specify the triples added to our attached graph.
 void GraphListener.notifyDeleteGraph(Graph g)
          Method to call when another graph has been used to specify the triples deleted from our attached graph.
 boolean Graph.dependsOn(Graph other)
          true if this graph's content depends on the other 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 BulkUpdateHandler.add(Graph g, boolean withReifications)
          Add all the triples of the given graph into the graph this is handler for.
 void BulkUpdateHandler.add(Graph g)
          Add all the triples of the given graph into the graph this is handler for.
 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.
 

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 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 Polyadic.getBaseGraph()
           Answer the distinguished graph for the composition, which will be the graph that receives triple adds and deletes.
 Graph Delta.getAdditions()
          Answer the graph of all triples added
 Graph Delta.getDeletions()
          Answer the graph of all triples removed
 

Methods in com.hp.hpl.jena.graph.compose with parameters of type Graph
 boolean Polyadic.dependsOn(Graph graph)
           Answer true if this graph contains the given graph as a sub-component.
 void Polyadic.addGraph(Graph graph)
           Add the given graph to this composition.
 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.
 void MultiUnion.addGraph(Graph graph)
           Add the given graph to this union.
 boolean Dyadic.dependsOn(Graph other)
          Generic dependsOn, true iff it depends on either of the subgraphs.
 Union Dyadic.union(Graph X)
           
static Filter CompositionBase.ifIn(Graph g)
           Answer a Filter that will accept any triple that is an edge of graph g.
 

Constructors in com.hp.hpl.jena.graph.compose with parameters of type Graph
Union(Graph L, Graph R)
           
Polyadic(Graph[] graphs)
           Construct a composition of all of the given graphs
MultiUnion(Graph[] graphs)
           Construct a union of all of the given graphs
Intersection(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.
Difference(Graph L, Graph R)
          Initialise a graph representing the difference L - R.
Delta(Graph base)
           
 

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
static java.util.HashSet SimpleTreeQueryPlan.getRoots(Graph pattern)
           
 TreeQueryPlan SimpleQueryHandler.prepareTree(Graph pattern)
           
 TreeQueryPlan QueryHandler.prepareTree(Graph pattern)
          deliver a plan for executing the tree-match query defined by _pattern_.
 ExtendedIterator Query.executeBindings(Graph g, Node[] results)
           
 ExtendedIterator Query.executeBindings(Graph g, java.util.List stages, Node[] results)
           
 NamedGraphMap NamedGraphMap.put(java.lang.String name, Graph g)
          Add a named graph to the map and return this map.
 

Constructors in com.hp.hpl.jena.graph.query with parameters of type Graph
SimpleTreeQueryPlan(Graph target, Graph pattern)
           
SimpleQueryPlan(Graph graph, Query query, Node[] variables)
           
SimpleQueryHandler(Graph graph)
          make an instance, remember the graph
Query(Graph pattern)
          Initialiser for Query; makes a Query with its matches taken from pattern.
PatternStage(Graph graph, Mapping map, ExpressionSet constraints, Triple[] triples)
           
 

Uses of Graph in com.hp.hpl.jena.ontology.tidy
 

Methods in com.hp.hpl.jena.ontology.tidy that return Graph
 Graph SyntaxProblem.problemSubGraph()
          A (hopefully small) subgraph exhibiting the problem.
 

Methods in com.hp.hpl.jena.ontology.tidy with parameters of type Graph
 void Checker.addRaw(Graph g)
          Adds the graph, and definitely not its imports, to the syntax check.
 void Checker.add(Graph g)
          Adds the graph to the syntax check.
 void Checker.addGraphAndImports(Graph g)
          Adds the graph, and definitely its imports, to the syntax check.
 

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.Reader reader, java.lang.String xmlBase)
          Reads from reader, using base URI xmlbase, adding triples to 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.
 

Uses of Graph in com.hp.hpl.jena.rdf.model
 

Methods in com.hp.hpl.jena.rdf.model that return Graph
 Graph Model.getGraph()
          Every model is based on some Graph
 

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.getRawGraph()
          Return the raw RDF data Graph being processed (i.e. the argument to the Reasonder.bind call that created this InfGraph).
 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. the argument to the Reasonder.bind call that created this InfGraph).
 Graph BaseInfGraph.getDeductionsGraph()
          Returns a derivations graph.
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
 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 Reasoner.bind(Graph data)
          Attach the reasoner to a set of RDF data to process.
 void InfGraph.rebind(Graph data)
          Replace the underlying data graph for this inference graph and start any inferences over again.
 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.
 void BaseInfGraph.rebind(Graph data)
          Replace the underlying data graph for this inference graph and start any inferences over again.
 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.
 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.
 

Constructors in com.hp.hpl.jena.reasoner with parameters of type Graph
FGraph(Graph graph)
          Constructor
BaseInfGraph(Graph data, Reasoner reasoner)
          Constructor
 

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 LPBackwardRuleInfGraph.getSchemaGraph()
          Return the schema graph, if any, bound into this inference graph.
 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 BasicForwardRuleInfGraph.getDeductionsGraph()
          Return the Graph containing all the static deductions available so far.
 

Methods in com.hp.hpl.jena.reasoner.rulesys with parameters of type 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 RulePreprocessHook.run(FBRuleInfGraph infGraph, Finder dataFind, Graph inserts)
          Invoke the preprocessing hook.
 InfGraph RDFSRuleReasoner.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.
 InfGraph OWLFBRuleReasoner.bind(Graph data)
          Attach the reasoner to a set of RDF data to process.
 Reasoner LPBackwardRuleReasoner.bindSchema(Graph tbox)
          Precompute the implications of a schema graph.
 InfGraph LPBackwardRuleReasoner.bind(Graph data)
          Attach the reasoner to a set of RDF data to process.
 void LPBackwardRuleInfGraph.rebind(Graph data)
          Replace the underlying data graph for this inference graph and start any inferences over again.
 Reasoner GenericRuleReasoner.bindSchema(Graph tbox)
          Precompute the implications of a schema graph.
 InfGraph GenericRuleReasoner.bind(Graph data)
          Attach the reasoner to a set of RDF data to process.
 Reasoner FBRuleReasoner.bindSchema(Graph tbox)
          Precompute the implications of a schema graph.
 InfGraph FBRuleReasoner.bind(Graph data)
          Attach the reasoner to a set of RDF data to process.
 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.
 Reasoner BasicForwardRuleReasoner.bindSchema(Graph tbox)
          Precompute the implications of a schema graph.
 InfGraph BasicForwardRuleReasoner.bind(Graph data)
          Attach the reasoner to a set of RDF data to process.
 void BasicForwardRuleInfGraph.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.rulesys with parameters of type Graph
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.
RDFSRuleInfGraph(Reasoner reasoner, java.util.List rules, Graph schema)
          Constructor.
RDFSRuleInfGraph(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.
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.
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.
 

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
 Reasoner TransitiveReasoner.bindSchema(Graph tbox)
          Extracts all of the subClass and subProperty declarations from the given schema/tbox and caches the resultant graphs.
 InfGraph TransitiveReasoner.bind(Graph data)
          Attach the reasoner to a set of RDF ddata to process.
 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
RandomOrderGraph(int bufsz, Graph base)
           
RandomOrderGraph(Graph base)
           
ClosedException(java.lang.String message, Graph graph)
           
BadDescriptionException(java.lang.String message, Graph badGraph)
           
 

Uses of Graph in com.hp.hpl.jena.util
 

Methods in com.hp.hpl.jena.util that return Graph
 Graph QueryMapper.getGraph()
           
 Graph QueryMapper.toQueryGraph(Model m)
           
 



Copyright © 2000-2003 Hewlett-Packard. All Rights Reserved.