Package org.jrdf.graph

This package defines a set of APIs required to implement an RDF Graph and it's associated objects.

See:
Description

Interface Summary

Alternative	An Alt is a list of unordered statements which prevents duplicates.
Bag	A Bag is a group of statements that are an unorderd list which allow duplicates.
BlankNode	RDF blank node.
Collection	A Collection holds all the statements of a particular group.
Container	A Container is a grouping of statements.
EquivComparable<T>	Indicates a slightly difference comparison operation - one that takes into account the semantics of the data type.
Graph	An RDF Graph.
GraphElementFactory	A Graph Element Factory is a class which creates the various components of a graph including: resources, literals and blank nodes.
GraphFactory	Allows the construction of a graph.
Literal	RDF literal node.
Node	RDF node.
NodeComparator	Provides a comparison of the three different node types: BNode, URI and Literal.
ObjectNode	Indicates if a Java object can be the object part of an RDF Triple.
PredicateNode	Indicates if a Java object can be the predicate part of an RDF Triple.
Resource	A resource stands for either a Blank Node or a URI Reference.
Sequence	A Sequence is a group of statements that are kept in an orderd list.
SubjectNode	Indicates if a Java object can be the subject part of an RDF Triple.
Triple	RDF Triple.
TripleComparator	Provides a comparison between triples - this will usually be implemented using the order Subject, Predicate, Object of the nodes and a NodeComparator to compare each of the nodes.
TripleFactory	A Triple Factory is a class which defines the creation of triples and certain sets of triples.
TypedNodeVisitable	Indicates that a BlankNode, URIReference or Literal are able to be visited.
TypedNodeVisitor	An object which can visit a BlankNode, URIReference and Literal.
URIReference	RDF URI reference - resource node.
Value	Represents a wrapper of Literal values.

Class Summary

AbstractBlankNode	A base implementation of an RDF BlankNode.
AbstractLiteral	A base implementation of an RDF Literal.
AbstractTriple	A base implementation of an RDF Triple.
AbstractTripleFactory	The base implementation of the Triple Factory which adds to a given graph reified statements, containers and collections.
AbstractURIReference	A base implementation of an RDF URIReference.
AnyNode	A node which represents any node (subject, predicate or object) - unconstrained.
AnyObjectNode	A node which represents any object - unconstrained.
AnyPredicateNode	A node which represents any predicate - unconstrained.
AnySubjectNode	A node which represents any subject - unconstrained.
NullURI	Represents no URI.
ResourceComparator
TripleImpl
TypedNodeVisitorAdapter	An adapter from TypedNodeVisitor.

Exception Summary

AlreadyReifiedException	Exception from a TripleFactory operation involving the reificiation of a statement - if the statement already has a reified triple.
GraphElementFactoryException	Exception from a GraphElementFactory operation.
GraphException	Exception from an Graph operation.
TripleFactoryException	Exception from a TripleFactory operation.

Package org.jrdf.graph Description

This package defines a set of APIs required to implement an RDF Graph and it's associated objects. The basis for this package structure comes from various sources including: the W3C RDF specifications and existing Java mappings including: Jena, Sesame and Sergey Melnik's RDF API.

An RDF Graph is made from RDF triples. Triples consist of a subject, predicate and object. Triples are made of nodes. Nodes can either be resources or literals. Resources can either be labelled with a URI, called URI references, or be blank.

To construct nodes you use a GraphElementFactory which allows you to create any of the nodes individually. You can then create Triples using the TripleFactory. Triples can then be added to the graph using the add method.

Indexation is an essential part of an efficient implementation and part of this package includes interfaces for implementing such implementations. Node and graph maintenance is also available. This design allows a separation between the implementation of the Graphs and of Node storage and handling.

Graph operations are also available to provide basic set based operations.