| Home >> All >> com >> hp >> hpl >> jena >> rdf |
Package Samples:
• com.hp.hpl.jena.rdf.arp.test: A parser for RDF/XML .
• com.hp.hpl.jena.rdf.model.test: A package for creating and manipulating RDF graphs.
• com.hp.hpl.jena.rdf.arp.lang
• com.hp.hpl.jena.rdf.arp
• com.hp.hpl.jena.rdf.listeners
• com.hp.hpl.jena.rdf.model.impl
• com.hp.hpl.jena.rdf.model
Classes:
• 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 ...
• 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 ...
• 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() ...
• 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 ...
• 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.
• InfModel: An extension to the normal Model interface that supports access to any underlying inference capability. In Jena the primary use of inference is to generate additional entailments from a set of RDF data. These entailments just appear as additional RDF data in the inferred model and are accessed through the normal API. For example, if an inference engine can determine the class of a resource "foo" is "fooClass" then all Model API calls such as listStatements and getProperty should act as if the triple: foo rdf:type fooClass . were in the data. A few reasoner services cannot be made directly available ...
• RDFReaderF: An RDFReader factory inferface. This factory interface is slightly unusual, in that, as well as creating and returning RDFReader's, it also provides methods for creating a reader, invoking a read method on it and then shuting it down. The factory will create an appropriate reader for the particular serialization language being read. Predefined languages include: RDF/XML - default RDF/XML-ABBREV N-TRIPLE N3 System wide defaults for classes to use as readers for these languages are defined. These defaults may be overwridden by setting a system property with a name of the form com.hp.hpl.jena.readers. ...
• Statement: An RDF Statement. A Statement is not a Resource, but can produce a ReifiedStatement that represents it and from which the Statement can be recovered. A statement instance tracks which model it is associated with. 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, ...
• JenaConfig: A Class for configuring Jena's behaviour. It is sometimes necessary to configure Jena's behaviour. For example when external functionality has changed, it may, for a time be desirable to be able to configure Jena to continue the old behaviour so that existing code which relied on the old behaviour does not break. Configuration options can sometimes be set using system properties. The following system properties are defined: com.hp.hpl.jena.oldLiteralCompare : This can be set to "true" before running Jena to turn on old literal compare behaviour. See setOldLiteralCompare below.
• ModelMaker: A ModelMaker contains a collection of named models, methods for creating new models [both named and anonymous] and opening previously-named models, removing models, and accessing a single "default" Model for this Maker. Additional constraints are placed on a ModelMaker as compared to its ancestor ModelSource . ModelMakers do not arbitrarily forget their contents - once they contain a named model, that model stays inside the ModelMaker until that ModelMaker goes away, and maybe for longer (eg if the ModelMaker fronted a database or directory). And new models can be added to a ModelMaker.
• ModelChangedListener: The interface for classes that listen for model-changed events. In all cases, the argument is [a copy of] the item that has been presented to the model, or its underlying graph, for addition or removal. For an add, the item [or parts of that item] may have already been present in the model; for remove, the item [or parts of it] need not have been absent from the item. NOTE that the listener is supplied with more-or-less faithful copies of the original items that were added to, or removed from, the model. In particular, graph-level updates to the model appear as statements, not triples.
• Bag: An RDF Bag container. This interface defines methods for accessing RDF Bag resources. These methods operate on the RDF statements contained in a model. The Bag implementation may cache state from the underlying model, so objects should not be added to or removed a the Bag by directly manipulating its properties, whilst the Bag is being accessed through this interface. When a member is deleted from a Bag using this interface, or an iterator returned through this interface, all the other members with higher ordinals are renumbered using an implementation dependendent algorithm.
• ResourceFactory: A Factory class for creating resources. This class creates resources and properties and things of that ilk. It is designed as a singleton. There are static convenience methods on this class itself, so the easy way to create resource is for example to do something like: Resource r = ResourceFactory.createResource(); If a factory object is needed, then this can be obtained using the getInstance method on the class. The factory object used may be changed using the setInstance method.
• ModelSpecFactory: ModelSpecFactory is the [new] class for delivering new ModelSpec objects described by their RDF specifications. The ModelSpec objects are created by ModelSpecCreator objects found in a ModelSpecCreatorRegistry, where they are identified by their RDF types as found in the RDF description. ModelSpecFactory finds [if necessary] the root of the description, finds the most specific type of that root which is a subclass of JenaModelSpec.ModelSpec, and invokes the corresponding creator object. ModelSpecFactory has no instance methods.
• ModelSource: The revised and soon-to-be-core interface for sources of models, typically generated from RDF descriptions. ModelSources can supply models in a variety of ways. some fresh model of the kind this ModelSource supplies the particular model this ModelSource supplies a named model from the collection this ModelSource supplies A ModelSource is free to "forget" named models if it so wishes; for example, it may be a discard-if-getting-full cache.
| Home | Contact Us | Privacy Policy | Terms of Service |