All Classes and Interfaces
Class
Description
Base class for representation of XSD duration, time, date/time
and related datatype instances.
This is the base class of all date/time datatype validators.
Abstract base class to provide shared implementation for ontology language profiles.
Superclass of exceptions thrown when permissions do not allow an operation
on a graph.
Exception to throw for a denied add operation
Bind the second argument to 1+ the first argument.
A string literal property value from an RDF/XML file.
A string literal property value from an RDF/XML file.
Interface defining an individual in which all members of a collection are
declared pair-wise disjoint.
Implementation of the abstraction of axioms that denote the single name assumption.
A property restriction that requires the named property to have have any range
instances to be members of a given class.
Implementation of the allValuesFrom restriction abstraction.
Exception to throw when an attempt is made to create a named
object (eg persistent model) when an object of that name already
exists.
Exception to throw when adding a view to a Polymorphic discovers that
the view to add is already on a ring.
The exception raised by reifyAs if a node is already bound to
a single reified triple.
An RDF Alternative container.
Exception thrown if an Alt has no default statement.
An implementation of Alt.
Exception to throw when an AssemblerGroup has a choice of types
from which to try and find an implementation.
Interface that represents the category of annotation properties in an ontology
language.
Implementation for ontology abstraction of annotation property
System id for an anonymous node.
Represent the schema type "anySimpleType"
@xerces.internal
Represent the schema type "anyURI"
@xerces.internal
A URI or blank node reported to a
StatementHandler.A URI or blank node reported to a
StatementHandler.A resource from the input file.
A resource from the input file.
Deprecated.
Direct access to the RDF/XML parser is planned for removal.
Deprecated.
Direct access to the RDF/XML parser is planned for removal.
Error numbers used by ARP.
Error numbers used by ARP.
Convenience generalization of all ARP handler interfaces.
Convenience generalization of all ARP handler interfaces.
The interface to set the various handlers on ARP.
The interface to set the various handlers on ARP.
The interface to set the various options on ARP.
The interface to set the various options on ARP.
This class is not part of the API.
This class is not part of the API.
An ArrayBunch implements TripleBunch with a linear search of a short-ish
array of Triples.
An ArrayBunch implements TripleBunch with a linear search of a short-ish
array of Triples.
A spliterator for arrays.
A spliterator for arrays.
The standard Activity Stream vocabulary.
An Assembler creates objects from their RDF descriptions.
Assembler Exception class: contains code shared by all the Assembler
exceptions.
AssemblerHelp provides utility methods used by, and useful for working with,
the Assembler code, including the methods that expand a model to include the
required inferences and to find the most specific type of a root in an
assembler specification.
Assert the n^2 differtFrom pairs from a distinctMembers list
Exception to throw when an assertion fails.
Represents a PSVI item for one attribute information item.
Exception to indicate that authentication is required for the operation to proceed.
This interface collects together those operations that the backchaining
engine needs to invoke in the parent InfGraph.
Exception to throw when a string cannot be converted to a Boolean
value.
Exception to throw when a literal required to be a single character isn't.
Exception to throw if a model (or graph) is a bad description
Exception to throw if a Description contains multiple roots of
a specified type.
Exception to throw if a Description has no root of a specified type
Exception used to report that the object of a statement is not a Resource.
An RDF Bag container.
An implementation of Bag
This class provides encode/decode for RFC 2045 Base64 as
defined by RFC 2045, N.
Represent the schema type "base64Binary"
@xerces.internal
Dummy implementation of the Builtin interface that specific
implementations can inherit from.
Support the old style "subclass" way to choose capabilities.
Base level implementation of datatype from which real implementations
can inherit.
Pair object used to encode both lexical form
and datatype for a typed literal with unknown
datatype.
the factory to create/return built-in schema DVs and create user-defined DVs
@xerces.internal
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.
A base level implementation of the InfGraph interface.
the base factory to create/return built-in schema DVs and create user-defined DVs
@xerces.internal
This is not part of the public API.
An inference graph interface that runs a set of forward chaining
rules to conclusion on each added triple and stores the entire
result set.
Reasoner implementation which augments or transforms an RDF graph
according to a set of rules.
Implementation of RuleContext for use in the backward chaining
interpreter.
An implementation of the generic RuleContext interface used by
the basic forward (BF) rule engine.
Interface through which the current bound values of variables
can be found.
Provides a trail of possible variable bindings for a forward rule.
An implementation of a binding environment that maintains
a single array of bound values for the variables in a rule.
A multi set of BindingVector's divided in buckets matching an unique
combination of values at given indices managed by RETEQueue
Functions related to blank nodes, and the implementation.
Boyer-Moore searcher.
Encapsulates a class description formed from a boolean combination of other
class descriptions (ie union, intersection or complement).
Shared implementation for implementations of Boolean clas expressions.
Represent the schema type "boolean"
@xerces.internal
Predicate used to check if a variable has been bound.
An exception to throw if an internal error is detected.
Rules employ builtins to do all tests and actions other than simple triple
matches and triple creation.
Exceptions thrown by runtime errors in executing rule system
builtin operations.
The personalities that are provided for the existing Jena classes.
A pruned (and slightly stewed) version of Map, containing just those operations
required by NodeToTriplesMaps.
The
ByteList is an immutable ordered collection of
byte.Implementation of
org.apache.xerces.xs.datatypes.ByteList.Exception used to report a failure of a group assembler to construct an
object because there is no component assembler associated with the
object's most specific type.
Exception to throw when a character cannot be encoded into some context
for some reason.
Exception used to report a failure to load a class.
The exception thrown by reifyAs if a node is bound to bits and
pieces of (an)other triple(s).
Interface for expressing capabilities.
Interface representing the ontology abstraction for a qualified cardinality
restriction.
Implementation of the exact qualified cardinality restriction
A property restriction that requires the named property to have have exactly
the given number of values for a given instance to be a member of the class defined
by the restriction.
Implementation of the cardinality restriction abstraction.
Class that merely notes that a change has occurred.
Some support for the Character Model Recommendation
from the W3C (currently in second last call working
draft).
Some support for the Character Model Recommendation
from the W3C (currently in second last call working
draft).
This class provides a number of static methods which interact with
java.nio.charset.Charset to analyze and transform the strings identifying
character encodings.
Characters and character classes
Represents a single frame in the LP interpreter's choice point stack,
represents the OR part of the search tree.
Common interface for all objects that can go into rules.
An iterator which should be closed after use.
Exception that may be thrown if an operation is attempted on a closed graph.
CollectionFactory - a central place for allocating sets and maps, mostly so that
it's easy to plug in new implementations (eg trove).
A simple graph implementation that wraps a collection of triples.
Class description that is formed from the complement of another class description
Implementation of a node representing a complement class description.
Base class for graphs that are composed of multiple sub-graphs.
An Exception indicating that Jena is not working
because it is not correctly configured.
An extension of ValidationState which can be configured to turn
off checking for ID/IDREF errors and unparsed entity errors.
Commonly used constants.
Frame in the LPInterpreter's control stack used to represent matching
to the results of a tabled predicate.
An RDF Container.
An internal class not normally of interest to application developers.
A Content object records content to be used to fill models.
An internal class not normally of interest to application developers.
Exception that is thrown when an ontology resource is converted to another
facet, using
as(), and the requested conversion is not
possible.CountLiteralValues(X, P, C) sets C to be the number of semantically
distinct values for P on resource X.
Represents an ontology DataRange: a class-like construct that contains only concrete
data literals.
Default implementation of the interface that defines a closed enumeration
of concrete values for the range of a property.
Base class for datatype exceptions.
Exception thrown when a lexical form does not match the stated
datatype.
Used to format JAXP 1.3 Datatype API error messages using a specified locale.
Interface that encapsulates the class of properties whose range values are
datatype values (as distinct from
ObjectProperty whose values are
individuals).
Implementation of the datatype property abstraction
The interface that a DTD datatype must implement.
Validator for <date> datatype (W3C Schema datatypes)
@xerces.internal
Validator for <dateTime> datatype (W3C Schema Datatypes)
@xerces.internal
Validator for <dateTimeStamp> datatype (W3C Schema Datatypes)
Validator for <gDay> datatype (W3C Schema datatypes)
@xerces.internal
Dublin Core version 1.0 vocabulary.
Vocabulary definitions from file:vocabularies/dublin-core_11.xml
Constants for the W3C Data Catalog Vocabulary.
Vocabulary definitions from vocabularies/dublin-core_terms.xml
Vocabulary definitions from vocabularies/dublin-core_types.xml
Represent the schema type "decimal"
@xerces.internal
Exception to throw if a delete is denied.
Graph operation for wrapping a base graph and leaving it unchanged while
recording all the attempted updates for later access.
Derivation records are used to determine how an inferred triple
was derived from a set of source triples and a reasoner.
Class representing the dynamic set difference L - R of two graphs.
Bind the third argument to the arithmetic difference between the
first and second arguments.
DisjointUnion - a version of Union that assumes the graphs are disjoint, and
hence that
find need not do duplicate-removal.Exception thrown when an attempt is made find an entity by name, but it
cannot be located.
This exception may be raised when an attempt to convert an RDFNode
to a ReifiedStatement fails because the RDFNode does not correspond
to a reification.
Transform DOM nodes of RDF.XML into Jena Models.
Transform DOM nodes of RDF.XML into Jena Models.
Represent the schema type "double"
@xerces.internal
A variant of the "remove" builtin that will delete matched triples
from the graph but will not trigger further rule processing for
the removed triples.
Validator for <duration> datatype (W3C Schema Datatypes)
@xerces.internal
Base class for the two-operand composition operations; has two graphs L and R
Represents a PSVI item for one element information item.
A exception that is thrown when an operation is attempted on an empty (nil)
list that actually requires a list of length one or more.
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.EnhGraph wraps a plain graph
and contains enhanced nodes that wrap the
plain nodes of the plain graph.
A specialisation of Polymorphic that models an extended node in a an extended graph.
Represent the schema type "entity"
@xerces.internal
The entity state interface defines methods that must be implemented
by components that store information about entity declarations, as well as by
entity validator that will need to validate attributes of type entity.
Encapsulates a class description representing a closed enumeration of individuals.
Implementation of a node representing an enumerated class description.
Represents a single frame in the LP interpreter's environment stack.
Extension of the normal AND-stack environment frame to support
incremental derivation logging.
Check that the two args are semantically equal.
Extended callbacks from a reader to an RDF application.
Extended callbacks from a reader to an RDF application.
An ExtendedIterator is a
NOTE that the result of these operations consumes the base iterator(s); they do not make independent copies.
ClosableIterator on which other operations
are defined for convenience in iterator composition: composition, filtering
in, filtering out, and element mapping.NOTE that the result of these operations consumes the base iterator(s); they do not make independent copies.
A special factory to create/return built-in schema DVs and create user-defined DVs
that includes anyAtomicType, yearMonthDuration, dayTimeDuration and dateTimeStamp
@xerces.internal
An ArrayBunch implements TripleBunch with a linear search of a short-ish
array of Triples.
This is the base class for
FastHashSet and FastHashSet.Map from nodes to triple bunches.
A set of triples - backed by
FastHashSet.Map which grows, if needed but never shrinks.
Set which grows, if needed but never shrinks.
A bunch of triples - a stripped-down set with specialized methods.
A triple store that uses hash tables to map from nodes to triple bunches.
An inference graph that uses a mixture of forward and backward
chaining rules.
Structure used to wrap up pre-processed/compiled rule sets.
Rule-based reasoner interface.
Wrapper round a Graph to implement the slightly modified Finder
interface.
A class that encapsulates a filter on fields on a triple.
A class that encapsulates a filter on fields on a triple.
FileManager
A FileManager provides access to named file-like resources by opening
InputStreams to things in the filing system, by URL (http: and file:) and
found by the classloader.
Creates a sub-Iterator by filtering.
Minimal interface for preforming simple pattern find operations.
Some simple helper methods used when working with Finders,
particularly to compose them into cascade sequences.
Represent the schema type "float"
@xerces.internal
This interface collects together the operations on the InfGraph which
are needed to support the forward rule engine.
Base class for stack frame objects.
HasNode - interface for objects that front a Node in some context.
FrontsTriple (see also FrontsNode) is an interface for things that can be seen as
wrappers round triples.
The processing engine for forward production rules.
Structure used to wrap up processed rule indexes.
Rule engines implement the internals of forward rule inference
graphs and the forward part of hybrid graphs.
Factory class for creating
FRuleEngineI.the factory to create/return built-in schema DVs and create user-defined DVs
@xerces.internal
Interface encapsulating the class of properties that are functional: that is,
properties in which a given given domain value has a unique value in the
range.
Implementation of the functional property abstraction
A functor comprises a functor name and a list of
arguments.
Datatype definition for functor-valued literals.
Tests if the first argument is greater than or equal to the second.
A generator represents a set of memoized results for a single
tabled subgoal.
Core properties of choice frames used use to represent the OR state of
the backtracking search.
A reasoner interface that is able to invoke any of the useful
rule engine combinations.
Class used as an enum for describing rule modes.
Factory object for creating general rule reasoner instances.
Frame on the choice point stack used to represent the state of some form of triple
match - this is either a direct graph query or a query to a cached set of results.
The interface to be satisfied by implementations maintaining collections
of RDF triples.
GraphBase is an implementation of Graph that provides some convenient
base functionality for Graph implementations.
The component of a graph responsible for managing events and listeners.
GraphEvents is the base class for Jena general graph events.
Interface for listening to graph-level update events.
A
GraphListener that converts "add" and "delete" operations to
GraphListenerBase.addEvent(org.apache.jena.graph.Triple) and GraphListenerBase.deleteEvent(org.apache.jena.graph.Triple) together with optional
GraphListenerBase.startRead() and GraphListenerBase.finishRead().A factory for providing instances of named graphs with appropriate storage models.
An implementation of graph isomorphism for Graph equality.
Deprecated.
This implementation of GraphMem will be replaced by a new
implementation.
A graph that stores triples in memory.
A graph that stores triples in memory.
A graph that stores triples in memory.
A graph that stores triples in memory.
GraphMemBase - a common base class for GraphMem and SmallGraphMem.
A factory class for creating memory Graphs.
Personalities for Graphs.
A version of Graph that enforces term equality even if the base graph uses value-indexing.
An ad-hoc collection of useful code for graphs
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.
Tests if the first argument is greater than the second.
Shared stuff for our hashing implementations: does the base work for
hashing and growth sizes.
A hashed structure may become empty as a side-effect of a .remove on one
of its iterators: a container can request notification of this by passing
a
NotifyEmpty object in when the iterator is constructed,
and its emptied method is called when the bunch
becomes empty.Common code for hash tables and sets.
Implementation of
JenaMap based on HashCommonBase.Implementation of
JenaSet based on HashCommonBase.An implementation of BunchMap that does open-addressed hashing.
A map from nodes to bunches of triples.
A bunch of triples, implemented as a set of triples.
Exception to throw when a Statement or Resource (which don't have
a useful common supertype, alas) don't have an associated model.
A property restriction that requires the named property to have a given individual as
its value.
Implementation of the hasValue restriction abstraction.
format validation
This class encodes/decodes hexadecimal data
@xerces.internal
Represent the schema type "hexBinary"
@xerces.internal
Register a node as to be hidden from query
result iterators.
Represent the schema type "ID"
@xerces.internal
Represent the schema type "IDREF"
@xerces.internal
Exception thrown when attempting to access a field of an XSDDateTime
object that is not legal for the current date/time type.
Exception used to signal that a configuration parameter was used
(typically in a setParameter call) that was not understood - either
because it was not a recognized parameter URI or its value range was incorrect.
Interface defining a generic factory interface for generating enhanced nodes
from normal graph nodes.
Interface that encapsulates an individual in an ontology, sometimes
referred to as a fact or assertion, or a member of the a-box.
Implementation for the ontology abstraction representing ontology class descriptions.
Extends the Graph interface to give additional means to query an inferred
graph.
An extension to the normal Model interface that supports access to any
underlying inference capability.
Default implementation of the InfModel interface which simply wraps up
an InfGraph.
Represent the schema type "integer"
@xerces.internal
The dynamic intersection of two graphs L and R.
Encapsulates a class description that is the intersection of a list of
class expressions.
Implementation of a node representing an intersection class description.
A simple integer based stack.
Datatype exception for invalid facet.
Datatype exception for invalid values.
A exception that is thrown when an operation is attempted on a list that is
not well-formed, and is being processed in strict mode.
Exception to throw when it is discovered that a property has been given
an illegal URI.
Interface encapsulating the class of properties that are inverse functional:
that is, properties in which a given given range value has a unique value in
the domain (effectively, a key).
Implementation of the functional property abstraction
Exception thrown due to IRI problems.
Provider: an implementation of a factory for IRIs.
Non-resolving provider that accepts anything string for <...>.
IRIProvider implemented using java.net.URI.Provider for
IRIx using the jena-iri module.IRIx implementation for the jena-iri provider.Operations in support of
IRIx.Support for RFC3986 IRIs.
A resolver is a base IRI and a policy for resolution.
Tests the single argument to make sure it is blank node.
Tests whether the first argument is an instance of the datatype defined
by the resource in the second argument.
Tests the single argument to make sure it is not a Functor.
Tests the single argument to make sure it is a literal.
Represents an abstract PSVI item for an element or an attribute
information item.
Builds Jena Iterators and other things (RDFNode and Statement)
needed in a Model.
Iterator that iterates over the entries of sets which are contained in the given iterator of sets.
Provides various meta-data constants about the Jena package.
This should be a superclass of exceptions arising from Jena code.
A map from keys of type
K to values of type V.This class holds global, static, configuration parameters that
affect the behaviour of the Jena API.
Methods and constants that define features of the current the environment.
Set interface specialized for the use cases in triple store implementations.
Extension of
JenaSet that allows to add and remove elements
with a given hash code.Lifecycle interface for Jena system and subsystems.
Jena "system" - simple controls for ensuring components are loaded and initialized.
Create XML input methods.
An exception that denotes some inconsistency between the arguments to a method
in the ontology API, and the language definition for a given ontology profile.
An ExtendedIterator that is created lazily.
Tests if the first argument is less than or equal to the second.
Successor of
GraphTripleStoreMem that uses term-equality
instead of literal value equality.Tests if the first argument is less than the second.
Returns true if the first argument is a list which contains the second argument.
Represent the schema list types
@xerces.internal
listEntry(?list, ?index, ?val) will bind ?val to the ?index'th entry
in the RDF list ?list.
Test if the two argument lists contain the same semantic elements.
A exception that is thrown when an operation attempts to access an indexed
list element beyond the length of the list.
Bind the second arg to the length of the first arg treated as a list.
For each element in the RDF list (third argument) it asserts
triples with that as the object and subject and predicate given by arguments
one and two.
For each element in the RDF list (first argument) it asserts
triples with that as the subject and predicate and object given by arguments
two and three.
Returns false if the first argument is a list which contains the second argument.
Test if the two argument lists differ.
An RDF Literal.
An implementation of Literal.
Represents the "contents" of a Node_Literal.
This class is not in the public API.
Exception to throw when an RDFNode required to be a Literal isn't, or when a
literal Node is required but a non-literal Node supplied.
Alternative locations for URIs.
Vocabulary definitions from Vocabularies/location-mapping-rdfs.n3
Interface to things that open streams by some string reference
Deprecated.
Use
StreamManager and LocatorClassLoader from org.apache.jena.riot.system.stream.Deprecated.
Use
StreamManager and LocatorFile from org.apache.jena.riot.system.stream.Deprecated.
Use
StreamManager and LocatorHTTP from org.apache.jena.riot.system.stream.Deprecated.
Use
StreamManager and LocatorZip from org.apache.jena.riot.system.stream.A multiple-reader plus single-writer lock.
Lock implementation using a Multiple Reader, Single Writer policy.
The signature of classes that can go on the LPEngines processing
agenda.
Inference graph for accessing the LP version of the backward chaining
rule engine.
Reasoner implementation which augments or transforms an RDF graph
according to a set of rules.
Implementation of the binding environment interface for use in LP
backward rules.
LP version of the core backward chaining engine.
Bytecode interpreter engine for the LP version of the backward
chaining rule system.
The context in which an LPInterpreter instance is running.
Marker interface for classes than can be used to initialize the
state of an LP interpreter - either an initial context (which
in turn is either a top level iterator or an generator being
run for the first time), or a previous saved context (i.e.
Holds the set of backward rules used by an LPEngine.
Exception used to indicate syntactic errors the LP version of the
backward chaining rule engine.
Wraps up the results an LP rule engine instance into a conventional
iterator.
The
LSInputList interface provides the abstraction of an
ordered collection of LSInputs, without defining or
constraining how this collection is implemented.Create or lookup an anonymous instance of a property value.
Bind a blank node to the first argument.
Create a new anonymous node and bind it to the each argument
An iterator that consumes an underlying iterator and maps its results before
delivering them; supports remove if the underlying iterator does.
A registry for mapping functor names on java objects (instances
of subclasses of Builtin) which implement their behaviour.
Combines the actions of
Map and Filter, mapping
unacceptable objects to null and acceptable ones to their mapped
value.A MapFilterIterator takes a MapFilter and an [Extended]Iterator and returns a new
ExtendedIterator which delivers the sequence of all non-null elements MapFilter(X)
for X from the base iterator.
An instance of this class has ranges captured in matching.
A pattern for matching triples.
Bind the third arg to the max of the first two args.
Interface representing the ontology abstraction for a qualified maximum cardinality
restriction.
Implementation of the max qualified cardinality restriction
A property restriction that requires the named property to have have at most
the given number of values for a given instance to be a member of the class defined
by the restriction.
Implementation of the max cardinality restriction abstraction.
Bind the third arg to the min of the first two args.
Interface representing the ontology abstraction for a qualified minimum cardinality
restriction.
Implementation of the min qualified cardinality restriction
A property restriction that requires the named property to have have at least
the given number of values for a given instance to be a member of the class defined
by the restriction.
Implementation of the min cardinality restriction abstraction.
A Mode object controls whether persistent objects can be created or reused
by an assembler.
An RDF Model.
The interface for classes that listen for model-changed events.
Common methods for model implementations.
Convenience methods which extend the
Model interface.The ModelExpansion code expands a model
M against a
schema S, returning a new model which contains
the statements of M
any statements (A rdfs:subClassOf B) from S where neither A nor B
is a bnode.ModelFactory provides methods for creating standard kinds of Model.
Helper functions for ModelFactory - in here to keep from obtruding on the
end-users.
A ModelGetter object can retrieve a Model given a URL for it.
ModelGraphInterface - this interface mediates between the API Model level
and the SPI Graph level.
Adapter class that converts a ModelChangedListener into a GraphListener.
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.
A ModelMakerImpl implements a ModelMaker over a GraphMaker.
A component interface used by ModelGetter for reading models.
The revised and soon-to-be-core interface for sources of models,
typically generated from RDF descriptions.
Graph wrapper which provides normal access to an underlying graph but
also maintains a snapshot of the triples it was last known to contain.
Model wrapper which provides normal access to an underlying model but
also maintains a snapshot of the triples it was last known to contain.
Validator for <gMonthDay> datatype (W3C Schema Datatypes)
@xerces.internal
Validator for <gMonth> datatype (W3C Schema Datatypes)
@xerces.internal
A graph implementation that presents the union of zero or more subgraphs,
one of which is distinguished as the updateable graph.
Variant of the normal TriplePattern object which can be updated in place
to avoid store turn over.
Represents an interface to query namespace information.
This exception is thrown when a putative namespace (for a PrefixMapping)
ends with a name character, which we disallow because it is an invitation
to errors.
The interface for being notified about namespace use in an RDF/XML
document.
The interface for being notified about namespace use in an RDF/XML
document.
NiceIterator is the standard base class implementing ExtendedIterator.
A Node_ANY (there should be only one) is a meta-node that is used to stand
for any other node in a query.
RDF blank nodes.
Extension to the RDF Data model.
RDF Graphs as RDF terms.
An RDF node holding a literal value.
Marker special nodes for datastructures.
A variation on the normal Node_Variable which support for value bindings.
RDF triples as RDF terms for RDF-star quoted triples.
RDF nodes with a global identity given by a URI.
"variable" nodes; these are outside the RDF specification
Exception thrown if a literal-access operation is attempted on a non-literal
node.
An iterator which returns RDF nodes.
A NodeIterator implementation.
Personalities for nodes.
A map from a node to the triples that have that node as subject, predicate or object.
A base class for in-memory graphs
The NodeVisitor interface is used by Node::visitWith so that an application
can have type-dispatch on the class of a Node.
Exception to throw when there is no reader with the specified language
NoReasonerSuppliedException - the exception to throw if a reasoner (spec)
was required, but none was given (eg in ModelSpecs).
NoSuchReasonerException - the exception to throw when looking up a
reasoner fails (in ModelSpec construction).
Tests the single argument to make sure it is not a blank node.
Tests whether the first argument is not an instance of the datatype defined
by the resource in the second argument.
Check that the two args are different.
Exception to throw when some (dynamically loaded) class isn't of the
required type.
Exception thrown when an attempt is made find something and it is not found.
Tests the single argument to make sure it is not a Functor.
Tests the single argument to make sure it is a literal.
Can be used in two arg form (X, P) or three arg form (X, P, V).
Bind the first arg to the current date time in the current locale and timezone.
Exception to throw if there is no writer for the specified language.
An iterator which returns namespace URI's.
An NsIterator implementation
Deprecated.
A command line interface into ARP.
N-Triple Reader
Writes out an XML serialization of a model.
An empty iterator.
A listener that ignores everything you tell it; intended as a base class
or an identity element.
The standard Open Annotation vocabulary.
Helper class for listObjects.
The
ObjectList is an immutable ordered collection of
Object.Listener that funnels all the changes into add/removed(Object) x, ie, leaves
discrimination to be done on the type of object added or removed.
Contains a list of Objects.
Interface encapsulating properties whose range values are restricted to
individuals (as distinct from datatype valued
properties).
Implementation of the object property abstraction
An extension to a standard map that supports one-to-many mappings: that is, there
may be zero, one or many values corresponding to a given key.
Helper class to implement the Map.Entry interface to enumerate entries in the map
Interface that represents an ontology node characterising a class description.
Implementation of the ontology abstraction representing ontology classes.
Vocabulary definitions from file:vocabularies/ont-manager.rdf
Provides services for managing ontology documents, including loading imported
documents, and locally caching documents from resolvable URL's to improve
load performance.
The default implementation of
OntDocumentManager.ReadHook makes no changes.Interface defining a handler call-back in the case that the
OntDocumentManager
fails in an attempt to read the contents of a URL into a model.Interface denoting a handler class that can intervene in the process of
reading a source document into a model.
Vocabulary definitions from file:vocabularies/ont-event.rdf
An enhanced view of a Jena model that is known to contain ontology
data, under a given ontology
vocabulary (such as OWL).
Implementation of a model that can process general ontologies in OWL
and similar languages.
Encapsulates a description of the components of an ontology model, including the
storage scheme, reasoner and language profile.
An OntModelSpecAssembler constructs OntModelSpec's from their
RDF description.
Interface encapsulating the distinguished instance in a given ontology
document that presents meta-data and other processing data about the document
(including which other documents are imported by a document).
Exception for generic errors that arise while processing ontologies
Implementation of the Ontology interface, encapsulating nodes that hold the
meta-data about whole ontologies.
Interface encapsulating a property in an ontology.
Implementation of the abstraction representing a general ontology property.
Provides a common super-type for all of the abstractions in this ontology
representation package.
Abstract base class to provide shared implementation for implementations of ontology
resources.
Some general utilities and algorithms to support developers working with the
general classes in the Jena ontology API.
A simple representation of disjoint sets
Simple data structure mapping RDF nodes to disjoint sets, and
pairs of resources to their LCA.
A filter which accepts statements whose predicate matches one of a collection
of predicates held by the filter object.
Superclass of exceptions of all refusals of operation on a graph.
Constants for the W3C Organization Ontology.
Vocabulary definitions from file:vocabularies/owl.owl
OWL constants are used during Jena initialization.
OWL2 vocabulary.
Ontology language profile implementation for the DL variant of the OWL 2002/07 language.
Experimental change to OWL translation hook that doesn't handle translation
of restrictions to functors.
A hybrid forward/backward implementation of the OWL closure rules.
Factory class for creating blank instances of the OWL Reasoner.
Ontology language profile implementation for the Lite variant of the OWL 2002/07 language.
Reasoner configuration for the OWL micro reasoner.
Reasoner factory for the OWL micro configuration.
Reasoner configuration for the OWL mini reasoner.
Reasoner factory for the OWL mini configuration.
Ontology language profile implementation for the Full variant of the OWL 2002/07 language.
The vocabulary used by WebOnt to encode results of test runs.
A rule preprocessor that scans the data looking for intersection
definitions and augments the rule base by translations of the
intersection statement.
The vocabulary used by the WebOnt working group to define test manifests.
@xerces.internal
An exception during the RDF processing of ARP.
An exception during the RDF processing of ARP.
Classify a triple match into one of the 8 match patterns.
Defines a set of permitted mappings from [interface] Class objects to
Implementation factories that can generate instances of the facet represented
by the Class.Exception denoting that a personality is misconfigured in some way.
A base class for composition graphs that are composed from zero or more
sub-graphs (thus providing a basis for polyadic composition operators).
Abstract base class for all polymorphic RDF objects, especially enhanced node and enhanced graph.
Methods for recording namespace prefix mappings and applying and
unapplying them to URIs.
Factory class to create an unspecified kind of PrefixMapping.
Exception to throw when the prefix argument to setNsPrefix is
illegal for some reason.
Exception to throw when trying to update a locked PrefixMapping.
An implementation of PrefixMapping.
Print its argument list as a side effect
A collection of small utilities for pretty printing nodes, triples
and associated things.
Bind the third arg to the product of the first two args.
Interface that encapsulates the elements of a general vocabulary
corresponding to a particular ontology language.
Exception that is raised when an ontology operation is attempted that is
not present in the language profile for the current ontology model.
Provides a means to map between the URI's that represent ontology languages
and their language profiles.
An RDF Property.
An implementation of Property.
Exception to throw if something does not have the specified property.
Exception used to report that a required property is missing.
This interface provides access to the post schema validation infoset for an
API that provides a streaming document infoset, such as SAX, XNI, and
others.
A structure that holds the components of an XML Namespaces qualified
name.
Represent the schema type "QName" and "NOTATION"
@xerces.internal
Represents a qualified restriction, in which all values of the restricted property
are required to be members of a given class.
Implementation of qualied restrictions.
Bind the third arg to the ratio of the first two args.
Wraps a graph and randomizes the order of find results.
RandomOrderIterator - Reorders the elements returned by an Iterator.
The standard RDF vocabulary.
RDF constants are used during Jena initialization.
The same items of vocabulary, but at the Node level, parked inside a
nested class so that there's a simple way to refer to them.
Interface on a datatype representation.
The default error handler for RDF/XML I/O.
rdf:dirLangString (literal with language and initial text direction)
This covers the unusual case of "foo"^^rdf:langString or "foo"^^rdf:dirLangString.
A generic error handler.
rdf:html.
rdf:json.
rdf:langString.
Provides a convenience encapsulation for lists formed from chains of RDF
statements arranged to form a head/tail cons-cell structure.
Interface that encapsulates a function to apply to every element in a
list.
Interface that encapsulates a function to apply to each element of a list
in turn, and passing the result to an accumulator.
Standard implementation the list abstraction from rdf.model.
Interface covering RDF resources and literals.
An RDFReader factory interface.
An
RDFReader reads a serialized representation of RDF,
e.g.RDFS vocabulary items
RDFS constants are used during Jena initialization.
The RDFS vocabulary, expressed for the SPI layer in terms of .graph Nodes.
A rule preprocessor that scans all supplied data looking for instances
of container membership properties and adds those to the deductions set.
A backward chaining implementation of the RDFS closure rules
based upon the basic backward rule interpreter.
Factory class for creating blank instances of the hybrid rule RDFS reasoner.
A pure forward chaining implementation of the RDFS closure rules
based upon the basic forward rule interpreter.
Ontology language profile for working with RDFS ontologies.
Customization of the generic rule inference graph for RDFS inference.
A full implementation of RDFS reasoning using a hybrid rule system, together
with optimized subclass/subproperty closure using the transitive graph caches.
Factory class for creating blank instances of the hybrid rule RDFS reasoner
with TGC support.
This class includes fragment IDs from the
RDF Syntax WD, to identify grammar rules etc.
The vocabulary used by the RDFCore working group to define test manifests.
The interface for visiting (ie type-dispatching) an RDF Node.
An RDFWriter factory interface.
RDFWriterI is an interface to RDF serializers.
Writes out RDF in the abbreviated syntax, for human consumption
not only machine readable.
Writes out an XML serialization of a model.
The main RDFXML parser, other variants of XMLHandler are for more specialized purposes.
The main RDFXML parser, other variants of XMLHandler are for more specialized purposes.
Interface between Jena and ARP.
Interface between Jena and ARP.
This interface only adds documentation to
RDFWriterI.The minimal interface to which all reasoners (or reasoner adaptors) conform.
Exception to throw when a reasoner [or factory] has multiple clashing
descriptions.
Exception signalling some generic problem with the reasoning subsystem.
The interface through which a reasoner (inference engine) can be
instantiated.
The ReasonerFactoryAssembler constructs a ReasonerFactory from the
description.
A global registry of known reasoner modules.
A collection of RDF terms used in driving or configuring some of the
builtin reasoners.
A regular expression matching engine using Non-deterministic Finite Automaton (NFA).
Library support for reification.
Exception thrown due to relative IRIs when not permitted.
Remove the body clause given by index arguments from the database.
An iterator which returns RDF Resources.
An implementation of ResIterator.
An RDF Resource.
A Factory class for creating resources.
The interface to resource factory objects.
An implementation of Resource.
Exception to throw when an RDFNode required to be a Resource isn't, or when a Node
supposed to be a resource isn't.
General utility methods that operate on RDF resources, but which are not specific
to a given model.
Interface that encapsulates a class description formed by restricting one or
more properties to have constrained values and/or cardinalities.
Implementation of the ontology abstraction representing restrictions.
Checks a triple against the grounded matches and intra-triple matches
for a single rule clause.
Manages a set of ready-to-fire rules.
A RETE version of the forward rule system engine.
Structure used to wrap up processed rule indexes.
Interface for all nodes in the network.
Represents one input left of a join node.
An implementation of the generic RuleContext for use in the RETE implementation.
RETE implementation of the forward rule inference graph.
Interface for all inner nodes in the RETE network.
Interface for all non-terminal nodes in the network.
The final node in a RETE graph.
@xerces.internal
A triple iterator that iterates over triple indices in a RoaringBitmap
BatchIterator.A triple store that is ideal for handling extremely large graphs.
Constants for the W3C Registered Organization Vocabulary.
The standard RSS vocabulary.
Representation of a generic inference rule.
Inner class which provides minimalist parsing support based on
tokenisation with depth 1 lookahead.
Inner class.
Object used to hold the compiled bytecode stream for a single rule clause.
Interface used to convey context information from a rule engine
to the stack of procedural builtins.
Derivation records are used to determine how an inferred triple
was derived from a set of source triples and a reasoner.
Implementors of this interface can be used as preprocessing passes
during intialization of (hybrid) rule systems.
RuleReasoner - an interface to capture the idea of a Reasoner that relies on
Rules; motivated primarily by the testing for ModelSpecs which specify
Rules for Reasoners.
RuleReasonerFactory - a ReasonerFactory interface which allows rules
to be set up to be installed into each reasoner this factory produces.
A RuleSet wraps a list of rules.
RulesetNotFoundException - exception to throw when a Ruleset is not found
(eg when handing reasoner specifications)
Indexes a collection of rule.
A SafeGraph wraps a graph which might contain generalized RDF
triples and hides them from API queries so that consumers
of it are safe (but can use getRawGraph() to get back the unsafe graph.
Wrapper around triple searches using in the back chainer to attempt a restart
in the case of a failure such as cross-transaction query.
Use arbitrary SAX input to Jena.
Use arbitrary SAX input to Jena.
Allows connecting an arbitrary source of SAX events with ARP.
Allows connecting an arbitrary source of SAX events with ARP.
This class is public merely to reduce the amount of irrelevant documentation
generated by Javadoc for
SAX2RDF.This class is public merely to reduce the amount of irrelevant documentation
generated by Javadoc for
SAX2RDF.@xerces.internal
Defines a factory API that enables applications to
the factory to create/return built-in schema 1.0 DVs and create user-defined DVs
@xerces.internal
Collection of symbols used to parse a Schema Grammar.
RDF Sequence container.
An implementation of Seq
Exception to throw when the index of a sequence is not in range.
An internal class not normally of interest to developers.
The injection points for the Node and Triple
Serializable process.Setup of jena-iri package IRI Factory for parsing and for checking.
The
ShortList is an immutable ordered collection of
unsigned short.Contains a list of shorts.
Interface supported by each of the rule system interpreters that
allow triples to added directly to the deductions cache, by-passing
any processing machinery.
Simple implementation of GraphEventManager for GraphBase to use.
A SimpleGraphFactory produces memory-based graphs and records them
in a local map.
A ClosableIterator that contains only one element
Vocabulary definition for the
W3C SKOS Recommendation.
Vocabulary definition for the
W3C SKOS-XL Recommendation.
A property restriction that requires the named property to have at least one
range instance belonging to the given class.
Implementation of the someValuesFrom restriction abstraction.
An iterator over a sparse array, that skips null entries.
A spliterator for sparse arrays.
A spliterator for sparse arrays.
A spliterator for sparse arrays.
A spliterator for sparse arrays.
Code to split an URI or IRI into prefix and local part.
Default implementation of ValidityReport which simply stores a list
of precomputed Report records.
A set of constants used to record state information in the
backchaining rule interpreter.
An RDF Statement.
Abstract base class for StaementImpl - pulls up the stuff that doesn't depend
on how statements are represented (as S/P/O or as Triples).
The callback from a reader to an RDF application.
The callback from a reader to an RDF application.
An implementation of Statement.
A listener that filters all its listening down to the single-statement level.
A collection of convenient functions to parse an XML stream using ARP.
A collection of convenient functions to parse an XML stream using ARP.
Bridge StAX and SAX parsing.
Bridge StAX and SAX parsing.
An iterator which returns RDF Statements.
An implementation of StmtIterator.
An iterator wrapper for NodeToTriplesMap iterators which ensures that
a .remove on the base iterator is copied to the other two maps of this
GraphMem.
Builtin which concatenates a set of strings.
Represent the schema type "string"
@xerces.internal
The
StringList is an immutable ordered collection of
GenericString.Contains a list of Strings.
Bind the third arg to the sum of the first two args.
This class is an unsynchronized hash table primary used for String
to Object mapping.
This class is a symbol table implementation that guarantees that
strings used as identifiers are unique references.
Interface that encapsulates a property that is symmetric, i.e. one
in which if
p(x, y) holds, thenp(y, x)
must also hold.
Implementation of the symmetric property abstraction
Exception to throw when a syntax error is detected in some input.
System setup and configuration.
Note: this has been copied here from ARQ.
Arrange that the given predicate is tabled by the backchaining engine.
Arrange that all backchaining goals should be tabled (aka memoized)
by the LP engine.
Minimal implementation of
TaintMinimal implementation of
TaintIn some rules we need to be able to create temporary property values
which are inferred from ontology constraints but not present in the ground
data.
Inner class used to hold and hash a node pair.
Validator for <time> datatype (W3C Schema Datatypes)
@xerces.internal
A tokenizer, similar to java's StringTokenizer but allows for quoted
character strings which can include other separators.
A WrappedIterator which remembers the last object next'ed in a
protected instance variable, so that subclasses have access to it
during .remove.
Preliminary interface for graphs supporting transactions.
A base for transaction handlers; provide implementations of execute* operations
using the fundamental begin-commit-abort.
Uses two transitive graph caches to store a subclass and a subproperty
lattice and use them within a larger inference graph.
Datastructure used to represent a closed transitive reflexive relation.
Implementation of InfGraph used by the TransitiveReasoner.
Interface that denotes a property that is transitive i.e. one
in which if
x p y holds,
and y p z
holds, then x p z must also hold.
Implementation of the transitive property abstraction
A simple "reasoner" used to help with API development.
Factory class for creating blank instances of the transitive reasoner.
Triples are the basis for RDF statements; they have a subject, predicate, and
object field (all nodes) and express the notion that the relationship named
by the predicate holds between the subject and the object.
A Field is a selector from Triples; it allows selectors to be passed
around as if they were functions.
A bunch of triples - a stripped-down set with specialized methods.
A bunch of triples - a stripped-down set with specialized methods.
An extended iterator that can return its next element as a Triple.
Frame on the choice point stack used to represent the state of a direct
graph triple match.
Datastructure which defines a triple pattern as used in simple
rules and in find interfaces.
TripleStore - interface for bulk storage of triples used in composed graphs.
A triple store is a collection of triples that supports access to
triples matching a triple pattern.
The TypeMapper provides a global registry of known datatypes.
All primitive types plus ID/IDREF/ENTITY/INTEGER are derived from this abstract
class.
Predicate used to check if a variable has not been bound.
A class representing the dynamic union of two graphs.
Class description that is formed from the union of a list of a class descriptions.
Implementation of a node representing a union class description.
Represent the schema union types
@xerces.internal
A Filter that filters out duplicate values.
Exception used to report an unknown language encoding.
Exception to throw when Jena is presented with an unknown property
of some kind.
Exception used to report an unknown reasoner factory name.
Exception to throw if an enhanced graph does not support polymorphism
to a specific class.
A class to represent a Uniform Resource Identifier (URI).
MalformedURIExceptions are thrown in the process of building a URI
or setting fields on a URI when an operation would result in an
invalid URI specification.
Builtin which concatenates a set of strings to generate a new URI.
This class provides methods to encode and decode URI References
in accordance with http://www.w3.org/TR/charmod/#sec-URIs .
Some utility functions.
A small random collection of utility functions used by the rule systems.
Class to get the information back after content is validated.
ValidationContext has all the information required for the
validation of: id, idref, entity, notation, qname
@xerces.internal
ValidationManager is a coordinator property for validators in the
pipeline.
Implementation of the ValidationContext interface.
Data structure used to report the results of validation
or consistency checking operations.
VCARD vocabulary class for namespace http://www.w3.org/2001/vcard-rdf/3.0#
Constants for the https://www.w3.org/TR/2014/NOTE-vcard-rdf-20140522/.
This class defines the version number of the parser.
Constants for the W3C Vocabulary of Interlinked Datasets.
Basic Access Control ontology.
Jena exceptions that explicitly wrap other (usually checked) exceptions.
A wrapper class which simply defers all operations to its base.
A wrapped IO exception.
a WrappedIterator is an ExtendedIterator wrapping around a plain (or
presented as plain) Iterator.
WrappedReasonerFactory - a wrapper round ReasonerFactories that
accepts a Resource configuring initial rules, schemas, etc.
This class defines the basic properties of characters in XML 1.1.
This class defines the basic XML character properties.
This class defines the basic properties of characters in XML 1.1.
This class defines the basic XML character properties.
Both the baseURI and the lang may be tainted with errors.
Both the baseURI and the lang may be tainted with errors.
This class converts SAX events into a stream of encapsulated events suitable
for the RDF parser.
This class converts SAX events into a stream of encapsulated events suitable
for the RDF parser.
Builtin data type to represent XMLLiteral (i.e.
Builtin data type to represent XMLLiteral (i.e.
This interface represents the Annotation schema component.
The interface represents the Attribute Declaration schema component.
This interface represents the Attribute Group Definition schema component.
This interface represents the Attribute Use schema component.
This interface represents the Complex Type Definition schema component.
This interface defines constants used by this specification.
Defines Jena resources corresponding to the URIs for
the XSD primitive datatypes which are known to Jena.
Base class for all date/time/duration type representations.
Interface to expose the values for all date-time related types.
Implement base64binary type.
Base implementation for all numeric datatypes derived from
xsd:decimal.
Base implementation for all string datatypes derived from
xsd:string.
Root class for XSD datatypes with binary values, xsd:hexBinary and xsd:base64Binary.
Datatype template used to define XSD int types
Representation of an XSD datatype based on the Xerces-2
XSD implementation.
Generic XML Schema datatype (outside the xsd: namespace)
Represent an XSD date/time value.
Type processor for dateTime, most of the machinery is in the
base XSDAbstractDateTimeType class.
Type processor for date, most of the machinery is in the
base XSDAbstractDateTimeType class.
Type processor for gDay, most of the machinery is in the
base XSDAbstractDateTimeType class.
Datatype representation for xsd:float.
Represent an XSD duration value.
The XSD duration type, the only job of this extra layer is to
wrap the return value in a more convenient accessor type.
Interface to expose the value of 'decimal' and related datatypes.
This class is pool that enables caching of XML Schema declaration objects.
Datatype representation for xsd:float.
Implement hexbinary type.
Type processor for gMonthDay, most of the machinery is in the
base XSDAbstractDateTimeType class.
Type processor for gMonth, most of the machinery is in the
base XSDAbstractDateTimeType class.
Interface to expose the value of the 'double' datatype.
A datatype that does not use the Xerces machinery for isEqual, yet is still an XSDDatatype.
Type processor for time, most of the machinery is in the
base XSDAbstractDateTimeType class.
Type processor for gYearMonth, most of the machinery is in the
base XSDAbstractDateTimeType class.
Type processor for year, most of the machinery is in the
base XSDAbstractDateTimeType class.
The interface represents the Element Declaration schema component.
The XML Schema API operations only raise exceptions in "exceptional"
circumstances, i.e., when an operation is impossible to perform (either
for logical reasons, because data is lost, or because the implementation
has become unstable).
Describes a constraining facet.
The class used to pass all facets to
XSSimpleType.applyFacets(org.apache.jena.ext.xerces.impl.dv.XSFacets, short, short, org.apache.jena.ext.xerces.impl.dv.ValidationContext).Interface to expose value of the float datatype.
This interface represents the Identity-constraint Definition schema
component.
This interface allows one to retrieve an instance of
XSLoader.An interface that provides a method to load XML Schema documents.
This interface represents an XML Schema.
This interface represents the Model Group schema component.
This interface represents the Model Group Definition schema component.
Describes a multi-value constraining facets: pattern and enumeration.
Objects implementing the
XSNamedMap interface are used to
represent immutable collections of XML Schema components that can be
accessed by name.The interface represents the namespace schema information information item.
The
XSNamesaceItemList interface provides the abstraction of
an immutable ordered collection of XSNamespaceItems, without
defining or constraining how this collection is implemented.This interface represents the Notation Declaration schema component.
The
XSObject is a base object for the XML Schema component
model.The
XSObjectList interface provides the abstraction of an
immutable ordered collection of XSObjects, without defining
or constraining how this collection is implemented.Contains a list of XSObjects.
This interface represents the Particle schema component.
Interface to expose QName actual values
This interface
XSSimpleType represents the simple type
definition of schema component and defines methods to query the information
contained.@xerces.internal
This interface represents the Simple Type Definition schema component.
Base class for XSSimpleType wrapper implementations.
Describes a term that can be one of a model group, a wildcard, or an
element declaration.
This interface represents a complex or simple type definition.
Represents an actual value of a simple type.
This interface represents the Wildcard schema component.
Validator for <gYear> datatype (W3C Schema Datatypes)
@xerces.internal
Validator for <gYearMonth> datatype (W3C Schema Datatypes)
@xerces.internal