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.