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

Quick Search    Search Deep

com.hp.hpl.jena.* (1257)

Package Samples:

com.hp.hpl.jena.util.iterator.test: A package for defining useful iterators and iterator operations, including concatenation, mapping, filtering, empty and singleton iterators, iterator wrappers, and the ExtendedIterator class used in many places in Jena.  
com.hp.hpl.jena.shared.wg: 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.ontology.impl.test: Provides default implementations for the abstractions defined in the com.hp.hpl.jena.ontology package.  
com.hp.hpl.jena.vocabulary.test: A package containing constant classes with predefined constant objects for classes and properties defined in well known vocabularies.  
com.hp.hpl.jena.ontology.impl: Provides a set of abstractions and convenience classes for accessing and manipluating ontologies represented in RDF.  
com.hp.hpl.jena.enhanced.test: 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.test: This package defines the Graph and Node family of classes, which form the underlying datatypes of the Jena system.  
com.hp.hpl.jena.reasoner.transitiveReasoner: The Jena2 reasoner subsystem is designed to allow a range of inference engines to be plugged into Jena.  
com.hp.hpl.jena.graph.compose.test: This package defines simple composite graphs - union, intersection, difference, and update-tracking.  
com.hp.hpl.jena.mem.test: Various memory-based implementations of interfaces, specifically GraphMem for memory-based Graphs.  
com.hp.hpl.jena.ontology.daml.impl: A re-implementation of the Jena 1.X DAML+OIL API, to assist Jena 1 users to move to Jena2.  
com.hp.hpl.jena.reasoner.rulesys.impl.oldCode: Internal implementation objects used by the rule system interpreters and compilers.  
com.hp.hpl.jena.graph.query.test: Defines the graph-level Query classes, allowing multi-pattern query over arbitrary graphs.  
com.hp.hpl.jena.ontology.daml.impl.test: Implementations of the interfaces defined in com.hp.hpl.jena.ontology.daml .  
com.hp.hpl.jena.datatypes.xsd.impl: Provides datatype definitions for the XML Schema datatypes support by Jena.  
com.hp.hpl.jena.datatypes.xsd: Provides the core interfaces through which datatypes are described to Jena.  
com.hp.hpl.jena.reasoner.rulesys.test: Provides a selection of simple rule engines for Jena inference models.  
com.hp.hpl.jena.rdf.arp.test: A parser for RDF/XML .  
com.hp.hpl.jena.xmloutput.test: Writing RDF/XML .  
com.hp.hpl.jena.db.test: A general database backend for persistent storage of Jena models.  

Classes:

Rule: Representation of a generic inference rule. This represents the rule specification but most engines will compile this specification into an abstract machine or processing graph. The rule specification comprises a list of antecendents (body) and a list of consequents (head). If there is more than one consequent then a backchainer should regard this as a shorthand for several rules, all with the same body but with a singleton head. Each element in the head or body can be a TriplePattern, a Functor or a Rule. A TriplePattern is just a triple of Nodes but the Nodes can represent variables, wildcards ...
Model: An RDF Model. An RDF model is a set of Statements. Methods are provided for creating resources, properties and literals and the Statements which link them, for adding statements to and removing them from a model, for querying a model and set operations for combining models. Models may create Resources [URI nodes and bnodes]. Creating a Resource does not make the Resource visible to the model; Resources are only "in" Models if Statements about them are added to the Model. Similarly the only way to "remove" a Resource from a Model is to remove all the Statements that mention it. When a Resource or ...
OntModel: An enhanced view of a Jena model that is known to contain ontology data, under a given ontology vocabulary (such as OWL). This class does not by itself compute the deductive extension of the graph under the semantic rules of the language. Instead, we wrap an underlying model with this ontology interface, that presents a convenience syntax for accessing the language elements. Depending on the inference capability of the underlying model, the OntModel will appear to contain more or less triples. For example, if this class is used to wrap a plain memory or database model, only the relationships asserted ...
OntEventManager: An adapter that translates RDF model-level changes into higher level changes that are appropriate to ontology users. The large number of specific events that the ontology model can produce makes the traditional Java style of listener interface impractical. Instead, this event manager allows the user to register handlers , based on command pattern, against specific event types . For example, to register a handler for the declaration of an ontology class: OntModel m = ... OntEventManager em = m.getEventManager(); em.addHandler( OntEvents.CLASS_DECLARATION, new OntEventHandler() { public void action( ...
SimpleSelector: A general selector class for use when querying models. An instance of this class is passed with query calls to models. The model will use the test method of this class to decide whether a statement should be included in the selection. Instances of this class can be provided with subject, predicate and object constraints. If a subject, a predicate or an object are provided, the model implementation may restrict the statements that it tests to statements whose subject, predicate and object match those provided in the constructor. This can provide for considerably more efficient searching. However, ...
Alt: An RDF Alternative container. This interface defines methods for accessing RDF Alternative resources. These methods operate on the RDF statements contained in a model. The Alternative implementation may cache state from the underlying model, so objects should not be added to or removed from the Alternative by directly manipulating its properties, whilst the Alternative is being accessed through this interface. When a member is deleted from an Alternative using this interface, or an iterator returned through this interface, all the other members with higher ordinals are renumbered using an implementation ...
Container: An RDF Container. This interface defines methods for accessing RDF container resources. These methods operate on the RDF statements contained in a model. The container implementation may cache state from the underlying model, so objects should not be added to or removed from the container by directly manipulating its properties, whilst the container is being accessed through this interface. When a member is deleted from a container using this interface, or an iterator returned through this interface, all the other members with higher ordinals are renumbered using an algorithm which may depend on ...
Seq: RDF Sequence container. This interface defines methods for accessing RDF Sequence resources. These methods operate on the RDF statements contained in a model. The Sequence implementation may cache state from the underlying model, so objects should not be added to or removed from the Sequence by directly manipulating its properties, whilst the Sequence is being accessed through this interface. When a member is deleted from a sequence using this interface, or an iterator returned through this interface, all the other members with higher ordinals are renumbered to one below what they previously were. ...
NTriple: A command line interface into ARP. Creates NTriple's or just error messages. java <class-path> com.hp.hpl.jena.arp.NTriple ( [ -[xstfu]][ -b xmlBase -[eiw] NNN[,NNN...] ] [ file ] [ url ] )... <class-path> should contain jena.jar , xerces.jar , and icu4j.jar or equivalents. All options, files and URLs can be intemingled in any order. They are processed from left-to-right. file Converts (embedded) RDF in XML file into N-triples url Converts (embedded) RDF from URL into N-triples -b uri Sets XML Base to the absolute URI. -r Content is RDF (no embedding, rdf:RDF tag may be omitted). -t ...
URI: A class to represent a Uniform Resource Identifier (URI). This class is designed to handle the parsing of URIs and provide access to the various components (scheme, host, port, userinfo, path, query string and fragment) that may constitute a URI. Parsing of a URI specification is done according to the URI syntax described in RFC 2396 . Every URI consists of a scheme, followed by a colon (':'), followed by a scheme-specific part. For URIs that follow the "generic URI" syntax, the scheme- specific part begins with two slashes ("//") and may be followed by an authority segment (comprised of user information, ...
RDFList: Provides a convenience encapsulation for lists formed from chains of RDF statements arranged to form a head/tail cons-cell structure. The properties that form the links between cells, and from cells to values, are specified by a vocabulary interface, so this abstraction is designed to cope equally well with DAML lists, RDF lists, and user-defined lists. A well-formed list has cells that are made up of three statements: one denoting the rdf:type of the list cell, one denoting the link to the value of the list at that point, and one pointing to the list tail. If a list cell is not well-formed, list ...
FileManager: FileManager A FileManager provides access to named file-like resources by opening InputStreams to things in the filing system, by URL (http: and file:) amd found by the classloader. It can also load RDF data from such a system resource into an existing model or create a new (Memory-based) model. There is a global FileManager which provide uniform access to system resources: applications may also create specialised FileManagers. A FileManager contains a list of location functions to try: the global FileManger has one LocatorFile , one LocatorClassLoader and one LocatorURL A FileManager works in ...
ARP: Another RDF Parser. To load an RDF file: Create an ARP. Set its handlers, by calling the getHandlers() 55 method, and then. Setting the statement handler. Optionally setting the other handlers. Call a load method. Xerces is used for parsing the XML. The SAXEvents generated by Xerces are then analysed as RDF by ARP. Errors may occur in either the XML or the RDF part, see ARPHandlers.setErrorHandler(org.xml.sax.ErrorHandler) 55 for details of how to distinguish between them. For very large files, ARP does not use any additional memory except when either the ExtendedHandler.discardNodesWithNodeID() ...
TestPackage: These tests give a small version of a model-like interface TestModel with different views over the nodes in the graph TestSubject , TestProperty TestObject Any node can be any one of these three, but the interface only works if the node is the subject, property or object, respectively, of some triple in the graph. There are two implementations of the three interfaces. We use four different personalities, in the tests, from various combinations of the implementation classes with the interface classes. A more realistic test would be a basic set of interfaces with implementations, and then some more ...
TransitiveGraphCache: Datastructure used to represent a closed transitive reflexive relation. It (mostly) incrementally maintains a transitive reduction and transitive closure of the relationship and so queries should be faster than dynamically computing the closed or reduced relations. The implementation stores the reduced and closed relations as real graph (objects linked together by pointers). For each graph node we store its direct predecessors and successors and its closed successors. A cost penalty is the storage turnover involved in turning the graph representation back into triples to answer queries. We could ...
Literal: An RDF Literal. In RDF2003 literals can be typed. If typed then the literal comprises a datatype, a lexical form and a value (together with an optional xml:lang string). Old style literals have no type and are termed "plain" literals. Implementations of this interface should be able to support both plain and typed literals. In the case of typed literals the primitive accessor methods such as getInt() determine if the literal value can be coerced to an appropriate java wrapper class. If so then the class is unwrapped to extract the primitive value returned. If the coercion fails then a runtime DatatypeFormatException ...
SelectorImpl: A general selector class for use when querying models. OBSOLETE: use SimpleSelector. This implementation is a stub that provides only constructors. An instance of this class is passed with query calls to models. The model will use the test method of this class to decide whether a statement should be included in the selection. Instances of this class can be provided with subject, predicate and object constraints. If a subject, a predicate or an object are provided, the model implementation may restrict the statements that it tests to statements whose subject, predicate and object match those provided ...
ModelCon: Convenience methods which extend the Model interface. The Model interface provides a set of primitive operations on an RDF model. This interface extends those methods with a set of convenience methods. This interface provides methods supporting typed literals. This means that methods are provided which will translate a built in type, or an object to an RDF Literal. This translation is done by invoking the toString() method of the object, or its built in equivalent. The reverse translation is also supported. This is built in for built in types. Factory objects, provided by the application, are used ...
SAX2RDF: Allows connecting an arbitrary source of SAX events with ARP. For use with a DOM tree, see The Java Developer's Almanac for a discussion of how to transform a DOM into a source of SAX events. The use pattern is to create and initialize one of these, then set it as the content, lexical and error handler for some source of SAX events (e.g. from a parser). It must be configured to use namespaces, and namespace prefixes. This initializing can be done for XMLReaders using installHandlers(org.xml.sax.XMLReader, com.hp.hpl.jena.rdf.arp.XMLHandler) 55 . Triples and errors are reported on a different thread. ...
Resource: An RDF Resource. Resource instances when created are associated with a specific model. They support a range of methods, such as getProperty() and addProperty() which will access or modify that model. This enables the programmer to write code in a compact and easy style. This interface provides methods supporting typed literals. This means that methods are provided which will translate a built in type, or an object to an RDF Literal. This translation is done by invoking the toString() method of the object, or its built in equivalent. The reverse translation is also supported. This is built in for ...
DAML_OIL: Defines a vocabulary of RDF constants used by the latest release of DAML+oil for class and property names. The contract maintained by the DAML_OIL class is that it will be periodically updated to reflect the latest release of DAML+OIL. Currently this is the March 2001 release. Older versions of the DAML+OIL vocabulary, for compatability with older ontology documents, are maintained in classes named DAML_OIL_YYYY_MM , for example DAML_OIL_2000_12. Note that rudimentary support for multiple versions of DAML namespaces is included in this release, by the mechanism of providing methods with the same ...
GraphRDB: A persistent Graph implementation using a relational database for storage. This graph stores data persistently in a relational database. It supports the full Graph interface and should operate just like a GraphMem. Internally, each GraphRDB keeps a list of specialized graphs. For each operation, it works through the list of graphs attempting to perform the operation on each one. The intention is that each type of specialized graph is optimized for a different type of triple. For example, one type of specialied graph might be optimized for storing triples in a particular ontology. The last specialized ...
PropertyIterator: Provides a means of traversing the relationships in a DAML model, respecting some of the extended semantics of DAML+OIL over RDF. In particular, the PropertyIterator knows about class, property and instance equivalence, transitive properties, inverse properties, the class hierarchy and the property hierarchy. Given a property P, and a resource x, iterates over all the y such that x P y , respecting the fact that P may be transitive (so x P y and y P z implies x P z ), and symmetric (so x P y implies y P x ). The iterator is lazily evaluated, so changes to the model while iterating could generate ...
EmptyListUpdateException: Exception that is thrown when an attept is made to perform a side-effectful operation on an RDFList that is the empty list, or rdf:nil . This is not permissible, since it would cause the URI of the RDFList to change from rdf:nil to a new bNode, and in Jena the URI of a node is invariant. To avoid this operation, when extending an empty list use operations that return the updated list (such as RDFList.cons(com.hp.hpl.jena.rdf.model.RDFNode) 55 , or RDFList.with(com.hp.hpl.jena.rdf.model.RDFNode) 55 , or check first to see if the list is empty 55 , and replace it with a non-null list.
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 ...

Home | Contact Us | Privacy Policy | Terms of Service