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

Quick Search    Search Deep

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

Package Samples:



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.
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.
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.
ReifierFragmentHandler: ReifierFragmentHandler: instances of this class handle fragments of reifications, ie the triples (tag rdf:subject/predicate/object X) and (tag rdf:type Statement). They are delivered from FragmentHandler instances and remain bound to their originating instance.
FileGraphMaker: A FileGraph factory, making FileGraphs based round some supplied directory. We have to keep track of created files ourselves, because a FileGraph that has been created but not closed is not visible in the filing system. (This might count as a bug at some point.)
WrappedBulkUpdateHandler: WrappedBulkUpdateHandler - a base class for wrapped bulk update handlers (needed so WrappedGraph works properly with events). Each operation is passed on to the base handler, and then this graph's event manager is notified.
FileGraph: A FileGraph is a memory-based graph that is optionally read in from a file when it is created, and is written back when it is closed. It supports (weak) transactions by using checkpoint files.
GraphWithPerform: GraphWithPerform is an implementation interface that extends Graph with the performAdd and performDelete methods used by GraphBase to invoke non-notifying versions of add and delete.
BaseGraphMaker: This base class provides convenience functions for the three "usual" graph makers and a place to hold the reification style for the graphs it constructs.
LiteralLabel: Represents the "contents" of a Node_Literal. These contents comprise a lexical form, an optional language tag, and optional datatype structure and a value.
GraphAddList: A List that implements the GraphAdd interface, so that it can be passed to things that want to add triples to Graphs. The triples are filtered.
ReifierFragmentsMap: ReifierFragmentsMap: how a SimpleReifier manages its incomplete reifications. Most of the active operations are deferred to FragmentHandler.
AllCapabilities: A default implementation of capabilities, in which everything is allowed, size is accurate, and graphs may be completely empty.
SimpleReifierFragmentsMap: SimpleReifierFragmentsMap - a map from nodes to the incompleteb(or overcomplete) reification quadlets.
ReifierTripleMap: ReifierTripleMap - an interface that describes how SimpleReifier manages complete reified statements.
TripleStore: TripleStore - interface for bulk storage of triples used in composed graphs.
WrappedReifier: WrappedReifier: a class that wraps a reifier [needed by WrappedGraph].
SimpleReifierTripleMap: SimpleReifierTripleMap - a map storing complete node -> triple maps.
WrappedGraph: A wrapper class which simply defers all operations to its base.
FragmentTripleIterator: Iterator which delivers all the triples from a Fragment's map.

Home | Contact Us | Privacy Policy | Terms of Service