Docjar: A Java Source and Docuemnt Enginecom.*    java.*    javax.*    org.*    all    new    plug-in

Quick Search    Search Deep

com.hp.hpl.jena.graph.compose.* (20)com.hp.hpl.jena.graph.compose.test.* (10)
com.hp.hpl.jena.graph.impl.* (27)com.hp.hpl.jena.graph.query.* (72)
com.hp.hpl.jena.graph.query.regexptrees.* (22)com.hp.hpl.jena.graph.query.regexptrees.test.* (2)
com.hp.hpl.jena.graph.query.test.* (9)com.hp.hpl.jena.graph.test.* (28)

com.hp.hpl.jena.graph: Javadoc index of package com.hp.hpl.jena.graph.

Package Samples:

com.hp.hpl.jena.graph.test: 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.test: This package defines simple composite graphs - union, intersection, difference, and update-tracking.  
com.hp.hpl.jena.graph.query.test: Defines the graph-level Query classes, allowing multi-pattern query over arbitrary graphs.  


Expression: Expression - the interface for expressions that is expected by Query for constraints. An Expression can be evaluated (given a name->value mapping); it can be prepared into a Valuator (given a name->index mapping); and it can be analysed into its components. An Expression can be a variable, an application, or a literal value. If an access method (eg getName) is applied to an Expression for which it is not appropriate (eg an application), the result is unspecified ; an implementation is free to throw an exception, deliver a null result, deliver a misleading value, whatever is convenient. The nested ...
SimpleTripleSorter: A TripleSorter for "optimising" queries. The triples of the query are permuted by moving the "lightest" triples to earlier positions. Within each region of the same lightness, triples the bind the most variables to their right are preferred. Otherwise the order is preserved. The notion of "lightness" makes more concrete triples lighter than less concrete ones, and variables lighter than ANY. Variables that have been bound by the time their containing triple is processed weigh just a little. The notion of "bind the most" is just the sum of occurances of the variables in the triple in the other triples. ...
GraphBase: GraphBase is an implementation of Graph that provides some convenient base functionality for Graph implementations. Subtypes of GraphBase must provide performAdd(Triple), performDelete(Triple), graphBaseFind(TripleMatch,TripleAction), and graphBaseSize(). GraphBase provides default implementations of the other methods, including the other finds (on top of that one), a simple-minded prepare, and contains. GraphBase also handles the event-listening and registration interfaces. When a GraphBase is closed, future operations on it may throw an exception.
SimpleEventManager: Simple implementation of GraphEventManager for GraphBase to use. The listeners are held as an [Array]List. The code duplication is a right pain. The most natural removal tactic, a meta-method that took the notification method as an argument, is not available in Java, and I can't off-hand think of a clean alternative. This class also holds the utility method notifyingRemove, which wraps iterators so that their .remove() operation notifies the specified graph of the removal.
GraphMatcher: An implemantation of graph isomorphism for Graph equality. The underlying algorithm is exponential but will only enter a non-deterministic polynomial part when there are a lot of difficult to distinguish anonymous nodes connected to each other by statements with the same property(s). Non-pathological examples, where most nodes have some properties that help distinguish them from other nodes, will experience nearly linear performance.
AbstractTestGraphMaker: Abstract base class for testing graph factories. Subclasses define the method getGraphFactory() which supplies a new graph factory to be tested: ATGF invokes that during setUp and closes it in tearDown . This bunch of tests is not remotely exhaustive, but it was sufficent to drive the development of the first full graph factory. (Although at the time it wasn't abstract.)
FileGraphTransactionHandler: A TransactionHandler for FileGraphs. When a FileGraph begin()s a transaction, its current contents are checkpointed into a sibling file (whose name starts "checkPoint-"). On an abort(), the current contents are discarded, and the checkpointed contents restored; on a commit(), the current contents are written back to the backing file, and the checkpoint file is deleted. Nested transactions are Not Allowed.
BulkUpdateHandler: Defines how bulk update may be done on Graphs. Bulk updates are not necessarily transactions; that is, a bulk update may fail part-way through, leaving some but not all triples added or deleted. However, if a bulk update does not fail (ie throw an exception) then the addition or removal of triples must have been successfully completed in accordance with the operation of the owning graph.
NodeCache: A NodeCache caches nodes according to their labels, to reduce store turnover at the expense of some additional computation. The cache is represented as an array indexed by the reduced hashcode of the labels of the nodes it contains. Only the most recent node with any given reduced hash is kept. This tactic means that we don't need to have any explicit cache-clearing code in normal oepration.
Polyadic: A base class for composition graphs that are composed from zero or more sub-graphs (thus providing a basis for polyadic composition operators). A distinguished graph is the designated graph for additions to the union. By default, this is the first sub-graph of the composition, however any of the graphs in the composition can be nominated to be the distinguished graph.
Graph: The interface to be satisfied by implementations maintaining collections of RDF triples. The core interface is small (add, delete, find, contains) and is augmented by additional classes to handle more complicated matters such as reification, query handling, bulk update, event management, and transaction handling. For add(Triple) see GraphAdd.
TripleCache: TripleCache caches triples according to their SPO members, to reduce store turnover at the expense of some added computation. The cache is implemented as an array indexed by the (reduced) hashCode of the triples it stores. Each slot is treated independantly and only the most recent stored triple is remembered - there is no weighting, LRU, or anything like that.
GetTriple: this interface describes types that can have a triple extracted using a getTriple method. It was constructed so that Node's can have possibly embedded triples but defer to a GetTriple object if they have no triple of their own; the particular GetTriple used initially is in Reifier, but that seemed excessively special.
SimpleBulkUpdateHandler: A simple-minded implementation of the bulk update interface. This only operates on (subclasses of) GraphBase, since it needs access to the performAdd/performDelete operations. It handles update events, with a special eye to not copying iterators unless there is at least one listener registered with the graph's event manager.
GraphMaker: A factory for providing instances of named graphs with appropriate storage models. It represents a directory, or a database, or a mapping: names map to graphs for the lifetime of the GraphMaker. Names can be "arbitrary" character sequences. A GraphMaker has a reification style which is shared by all the graphs it creates.
Text: Text - represents literal text for the match, to be taken as it stands. May include material that was meta-quoted in the original patterm. There are two sub-classes, one for strings and one for single characters; the factory methods ensure that there are no single-character TextString instances.
ConstraintStage: A ConstraintStage implements the constraint evaluation part of a query. Any constraints not handled by previous PatternStages are prepared against the mapping and valuated against each binding that comes down the pipe; only bindings that evaluate to true are passed onward.
CompositionBase: Base class for graphs that are composed of multiple sub-graphs. This is to provide a home for shared functionality that was previously in Dyadic before refactoring.
DisjointUnion: DisjointUnion - a version of Union that assumes the graphs are disjoint, and hence that find need not do duplicate-removal. Adding things to the graph adds them to the left component, and does not add triples that are already in the right component.
GraphEventManager: The component of a graph responsible for managing events and listeners. The interface extends GraphListener because most of the notificiations are the same; the special case to note is that an event manager expects to be handed iterator events as lists, not as iterators.
Pipe: A Pipe is anything that can be used to get and put Domain objects; it can be closed, and it can be tested for whether more elements are available. A pipe may be closed with an exception, in which case hasNext/get will fail with that exception when they are called.

Home | Contact Us | Privacy Policy | Terms of Service