All Classes and Interfaces
Class
Description
Defines common API for axiom descriptors.
Defines base descriptor, which is used to specify context information for entities and their fields.
Instances of this type represent entity types which are abstract - represented entity type cannot be instantiated.
Parent of all other types of expressions.
Instances of the type AbstractIdentifiableType represent entity or mapped superclass types which can be queried for
attributes, subtypes and so on.
A common class to all attributes defined by a query
Defines common session-related methods.
Indicates that an attempt has been made to instantiate a class that is abstract in terms of JOPA.
Exception thrown when multiple contexts defined in a
AbstractDescriptor are used
for saving an assertion.Thrown when a polymorphic entity cannot be loaded because its types are ambiguous, i.e.
Class used for extracting field name from getter or setter.
Specifies that the annotated field contains only explicit (asserted) values.
Base assertion axiom class.
Represents an attribute of a Java type.
A class that implements this interface can be used to convert entity attribute state into axiom/triple value
representation and back again.
Indicates that a modification to an attribute could not be performed.
Validates modification operations on attributes.
Represents either an OWL axiom or a RDF triple.
Adapts OWLAPI axioms to JOPA (OntoDriver) axioms and vice versa.
This descriptor specifies subject and properties of axioms to search for in the ontology.
Default file-based storage connector.
Instances of the type BasicType represent basic types (including temporal and
enumerated types).
Instances of the type Bindable represent object or attribute types that can
be bound into a Path.
Interface used to interact with the second-level cache.
Creates second level cache based on the specified properties.
This interface defines basic methods for accessing the shared live object cache.
Factory that caches created descriptors.
This exception is thrown when cardinality restriction constraint is violated.
Defines the set of cascadable operations that are propagated to the associated entity.
Represents a change to an object made during a transaction.
Calculates changes made on objects by comparing a clone with its registered original.
Record of a single change to an attribute.
Wraps a collection so that calls to modifying operations are intercepted and reported to the persistence context (if
necessary).
Wraps a
MultilingualString so that calls to modifying operations are intercepted and reported to the
persistence context (if necessary).Specifies how changes to managed objects are tracked in transactions.
This connector tracks transactional changes and writes them on commit to the
SharedStorageConnector.Converts between
Character and a xsd:string representation.Scans application classpath, allowing to find classes of significance (e.g., entity classes).
Helper class wrapping an
OptionSet and adding some custom functions.Builds clones used in transactions for tracking changes.
Interface for closeable resources.
Instances of the type CollectionAttribute represent persistent
javax.util.Collection-valued attributes.
Instances of the type ConcreteEntityType represent entity
types which are can be directly instantiated while loading from storage.
Contains configuration for the persistence provider and utility access methods for it.
Marker interface for classes providing access to the current configuration.
Marker interface for configuration parameter enumerations.
Configuration for the
ConnectionFactoryImpl.Storage connector interface.
Declares some constants and default values used in JOPA.
Constants and default values for the Jena driver.
Used in conjunction with the
SparqlResultSetMapping annotation to map the SELECT clause of a SPARQL query to
a constructor.Descriptor for reading an RDF container.
Handles RDF container access operations.
Interface for managing RDF containers.
Descriptor for saving values in an RDF container.
Declares repository context in which data are stored.
Specifies the conversion of a Basic field or property.
Specifies that the annotated class is a converter and defines its scope.
Determines potential converters which may be used on a field.
Manages attribute converters.
Internal wrapper of a
AttributeConverter providing addition methods.Used to construct criteria queries, compound selections, expressions, predicates, orderings.
Interface used to control the execution of typed queries.
Instances of this class are used to wrap user-defined
AttributeConverter implementation.Represents an ontology data source.
Indicates that a data source cannot be created.
Maps RDF literals to Java objects.
Indicates that the mapping has failed.
Utility containing transformation rules for selected basic types.
Contains utility functions for transformations between OWL2 datatypes (usually based on XSD types) and Java types.
Converts between a xsd:dateTime representation and
Date instances.Utility class for transformation between various date/time representations.
A subset of the Dublin Core Metadata Initiative vocabulary.
Vocabulary in the /elements/1.1/ namespace of Dublin Core.
Vocabulary in the /terms namespace of Dublin Core.
Processes classes available to the current classloader.
Implements loading of inferred statements from the default repository context.
Default converter implementing identity function - it just returns the provided argument.
Default implementation of the
EntityDescriptorFactory interface.Default implementation of the
PersistenceProviderResolver, threadsafe.Default values of
Options.Represents object deletion.
Used to specify additional metadata for entities and their attributes.
Descriptors of an entity.
Configuration parameters common to all OntoDrivers.
Holds configuration of the OntoDriver.
Duration query parameter value representation.
Instances of the type EmbeddableType represent embeddable types.
Indicates and error during the process of mapping an entity to axioms.
Describes an entity.
Creates entity descriptors based on metamodel information.
Manages entity lifecycle callbacks declared either in the entity (entity lifecycle callbacks) or in its entity
listener (entity listener callbacks) and provides means for their invocation.
Specifies the callback listener classes to be used for an entity or mapped superclass.
Thrown by the persistence provider when an entity reference obtained by
EntityManager.getReference(Class, Object) is accessed but the entity does not exist.Utility class for entity properties.
Provides access to persistence context-related attributes needed by entity reference proxies.
Used in conjunction with the
SparqlResultSetMapping annotation to map the SELECT clause of a SPARQL query to
an entity result.Represents the state of an entity with respect to a persistence context.
Interface used to control transactions on resource-local entity managers.
Wraps an
EntityTransaction and mediates communication with the current persistence context and the EntityManager.Instances of the type EntityType represent entity types.
Specifies that a persistent property or field should be persisted as an enumerated type.
Defines mapping for enumerated types.
Builds factories for the driver.
Defines strategies for fetching data from the database.
Describes a singular data property or a plural data, object or annotation property field.
Used in conjunction with the
EntityResult annotation to map columns specified in the SELECT list of a SPARQL
query to the properties or fields of an entity class.Specifies a field of a managed type.
Marker annotation for dynamically generated classes.
Marker interface for generated entity reference proxy classes.
Marker interface for generated lazy loading proxy classes.
Statement loader for GraphDB repositories.
Builds statement loaders for GraphDB repository access.
Specifies the identifier of an entity.
Instances of this type represent entity classes that can be saved to and read from storage.
Instances of the type IdentifiableType represent entity or a mapped superclass types.
Identifier attribute.
Thrown when an entity is missing an identifier and it cannot be generated.
Utility for working with resource identifiers.
Indicates that an unexpected datatype has been provided for a value.
Wraps a target object in an indirect proxy which is able to intercept method calls and perform additional processing
(usually persistence context notification).
Represents an OWL individual (or an RDF resource) identified by the specified IRI.
Indicates whether to consider inferred data and under which conditions.
Specifies that the field values are inferred.
Verifies whether a change to an inferred attribute is valid.
This exception is raised when the user modifies an inferred attribute, which is forbidden.
Specifies the inheritance strategy to be used for an entity class hierarchy.
Defines polymorphic loading strategy options for the
Inheritance annotation.Converts between Java 8
Instant and a supported xsd:dateTime representation.Thrown when an instance of class cannot be created.
This exception is thrown when assertion identifier is not a valid URI.
Indicates that an issue has occurred with user-defined attribute converters.
Indicates that an enum mapping is not valid.
Signals that an entity field mapping is not valid.
Thrown when IRI of ontology does not match the expected one.
Represents an annotation on a program element.
Generates Java names based on IRI identifiers.
Transformations between OntoDriver API-based values and Jena-based ones.
Generic exception for the Jena driver.
Utility methods for working with Jena API.
Utilities related to lazy loading.
Represents the SOQL
SoqlConstants.Functions.LANG function.Represents a string value with a (optional) language tag.
Implemented by generated lazy loading entity proxy classes.
Indicates an issue with lazy loading.
Map proxy that triggers lazy loading when its contents is accessed.Marker interface for lazy loading proxy implementations.
Creates lazy-loading proxies for entity attributes.
Provides access to persistence context-related attributes needed by lazy loading proxies.
Entity lifecycle events.
Instances of the type ListAttribute represent persistent
List-valued attributes.Describes storage of a list.
Thrown when an error occurs during processing of an OWL list.
This interface is used to work with ontology sequences.
Descriptor of list values.
Represents an RDF literal consisting of a lexical form and datatype IRI.
Describes load state of an instance in a persistence context.
Builds
LoadStateDescriptors on various occasions.Manages
LoadStateDescriptors for a persistence context.Converts between Java 8
LocalDateTime and a supported xsd:dateTime representation.Converts between Java 8
LocalTime and a supported xsd:time representation.This is a fixed-size second level cache implementation with LRU eviction policy.
Interface dynamically assigned to entity classes so that their instances may be attached to a persistence context.
Generates persistence context-aware classes that implement the
Manageable interface.Utility methods for processing managed types for metamodel construction.
Builds instances of entity types.
Instances of the type ManagedType represent entity, mapped superclass, and embeddable types.
Instances of the type MapAttribute represent persistent java.util.Map-valued
attributes.
Designates a class whose mapping information is applied to the entities that inherit from it.
Instances of the type MappedSuperclassType represent mapped superclass types.
JOPA mapping annotations.
Marks issues with parsing of IRI mapping files.
Provides access to the metamodel of persistent entities in the persistence
unit.
Indicates an error when building application persistence metamodel.
Metamodel-related utility functions.
General exception for the metamodel generator.
Annotation processor that finds JOPA entities and mapped superclasses and generates a static metamodel based on
them.
Represents a string with translations to (possibly) multiple languages.
Add axiom wrapper which allows us to set ontology to which it is applied.
Interface which enables to set owner ontology of axiom changes.
Remove axiom wrapper which allows us to set ontology to which it is applied.
Specifies multiple native SPARQL named queries.
Specifies a named native SPARQL query.
Manages named queries in the persistence unit.
Represents named resources, i.e., resources identified by a URI.
Namespace declaration allows the use of shorter notation for long URIs.
Holds mapping of prefixes to namespaces and allows resolution of prefixed IRIs.
Wrapper for declaration of multiple namespaces on an element.
Represents addition of a new object.
Indicates that the annotated type should not be considered a JOPA entity.
Denotes class/member that is not present in JPA (Jakarta Persistence)
A naive implementation of a no-op reasoner that just returns axioms asserted in the underlying ontology.
Thrown by the persistence provider when
Query.getSingleResult() or TypedQuery.getSingleResult() is
executed on a query and there is no result to return.Thrown by the persistence provider when
Query.getSingleResult() or TypedQuery.getSingleResult() is
executed on a query and there is more than one result from the query.Allows to convert values between arbitrary types.
Allows providing descriptor for elements of an object property collection.
Describes a general purpose exception that can be thrown by the OntoDriver.
Represents exception raised during the driver initialization.
Parent exception for OntoDriver-specific unchecked exceptions.
Thrown when the driver is unable to apply an ontology change.
Thrown when an error occurs during storage of an ontology.
Holds properties of an ontology storage.
Builder class for the
OntologyStorageProperties.Command line options for configuring the transformation/vocabulary generation.
Built-in converter for mapping to/from enum-valued attributes.
Class for generating output files
A subset of the OWL vocabulary.
Generic exception for a failed transformation/vocabulary generation.
Marks an attribute mapped to an OWL annotation property.
Adapter between OntoDriver API and OWLAPI.
Configuration parameters for the OWL API driver.
Default implementation of the
Connection interface for OWLAPI driver.Main entry point to this OWLAPI-based OntoDriver.
General exception for the OWLAPI driver.
Public access point the simple and referenced list handling in the OWLAPI driver.
Utility methods for the OWLAPI driver.
Specifies that the class is an entity class and maps to an ontological class (RDFS or OWL).
Marks an attribute mapped to an OWL datatype property.
Thrown when an attempt to put an entity with duplicate identifier into the persistence context is made.
Marks an attribute mapped to an OWL object property.
Generic exception indicating that something went wrong during execution of a persistence provider operation.
Represents an ordered pair of values.
Type for query parameter objects.
Query parameter value holder.
Option parser capable of accepting our params
ParticipationConstraint<P extends org.semanticweb.owlapi.model.OWLProperty,O extends org.semanticweb.owlapi.model.OWLObject>
Allows to specify participation constraints of an attribute.
Bootstrap class that is used to obtain an
EntityManagerFactory.Generates classes corresponding to entity classes, but able to be connected to a persistence context.
Interface implemented by the persistence provider.
Determine the list of persistence providers available in the runtime
environment.
Holds the global
PersistenceProviderResolver instance.Scans classpath to discover classes relevant to persistence unit building.
Utility interface between the application and the persistence provider managing the persistence unit.
Utility interface between the application and the persistence provider(s).
PersistentPropertyGetterMatcher<T extends net.bytebuddy.description.method.MethodDescription>
Matches only persistent field getters.
PersistentPropertyMatcher<T extends net.bytebuddy.description.method.MethodDescription>
Matches only persistent attribute getters/setters.
PersistentPropertySetterMatcher<T extends net.bytebuddy.description.method.MethodDescription>
Matches only persistent attribute setters.
Instances of the type PluralAttribute represent persistent collection-valued attributes.
Instances of the type PluralAttribute represent persistent collection-valued
attributes defined by a query.
Plural query attributes can contain multiple values or references, i.e., they must be a collection.
Specifies a callback method for the corresponding lifecycle event.
Invokes post load entity listeners for the passed object.
Specifies a callback method for the corresponding lifecycle event.
Specifies a callback method for the corresponding lifecycle event.
Specifies a callback method for the corresponding lifecycle event.
Interface used to build in predicates.
Resolves ontology prefixes using the prefix.cc service reverse lookup.
Keeps a map of prefixes resolved from provided ontologies.
This interface extends the
Statement and adds the possibility to parametrize queriesSpecifies a callback method for the corresponding lifecycle event.
Specifies a callback method for the corresponding lifecycle event.
Specifies a callback method for the corresponding lifecycle event.
Simple procedure which does accepts no parameter and returns nothing.
Defines a procedure interface, which takes no arguments and returns nothing.
Procedure functional interface.
Denotes an attribute containing values of unmapped properties relevant for an entity.
This interface provides access to properties not mapped by the object model.
Instances of the type PropertiesSpecification represent persistent properties of other types than declared in the
entity type.
Marks annotations that represent property mapping.
A simple wrapper that enables using annotations from methods while processing fields during metamodel creation.
Utility interface implemented by the persistence provider.
Represents an attribute of a Java type that is defined by a query.
Defines query hints supported by JOPA.
Processes query hints.
Allows disabling inference for query execution.
Represents a caretaker of a query, enabling parameter setting and final assembly of the query.
Used to parse queries into builders which enable the query to be further manipulated, e.g.
Exception thrown when an error occurs when parsing a query.
Represents a query and configuration relevant to the query execution.
A subset of the RDF vocabulary.
RDF4J driver configuration parameters.
Provides
RepositoryConnections and other RDF4J-specific objects.DataSource implementation representing the RDF4J OntoDriver.This is a generic, checked exception thrown by the RDF4J driver.
Builds factories for the driver.
Utility methods for the RDF4J driver.
Specifies mapping of an RDF collection.
Specifies mapping of an RDF container.
Instances of the type
RDFContainerAttribute represent attributes mapped to RDF containers.Types of RDF containers, as defined by Section
5.1 of the RDF Schema vocabulary.
A subset of the RDFS vocabulary.
Creates connectors implementing the
JenaOntoDriverProperties.READ_COMMITTED
transactional strategy.Thrown when Jena reasoner cannot be initialized.
Indicates that the driver requested services of a reasoner, but it was not available.
Describes storage of a referenced list.
Represents singly-linked referenced list.
Descriptor of values of a referenced list.
Utility functions using Java Reflection API.
Allows to reload data from the underlying storage.
Attempts to resolve ontology prefix by invoking a remote service.
Wrapper for RDF4J
HTTPRepository allowing to set custom HttpClient for it to use.A RDF4J repository connection wrapper.
Represents a single row in a
ResultSet.Represents a single
SparqlResultSetMapping instance.Represents a set of results of a SPARQL query.
Indicates that an error occurred during iteration over a query result set.
Iterator over a
ResultSet.Manages
SparqlResultSetMapping instances discovered during classpath
processing.Manages result set mappers, which are used to transform query result sets to output based on
SparqlResultSetMapping.Builds mappers for
SparqlResultSetMapping instances discovered on classpath.Implementation of query using result set mapping configuration.
Spliterator implementation for a ResultSet.Thrown by the persistence provider when
EntityTransaction.commit() fails.Represents configuration which influences the driver during its active usage, not its initialization.
Specifies mapping of a sequence of items.
Defines types of sequence modeling in OWL.
The ServerSession is the primary interface for accessing the ontology.
Instances of the type SetAttribute represent persistent java.util.Set-valued
attributes.
Main storage connector using the
JenaOntoDriverProperties.READ_COMMITTED
connector strategy.Represents a simple LIPS-style sequence, which is basically a singly-linked list.
Describes a simple sequence.
Represents values of a simple sequence.
Instances of the type SingularAttribute represents persistent single-valued properties or fields.
Instances of the type SingularQueryAttribute represents persistent single-valued
properties or fields defined by a query.
Singular query attributes contain a single value or reference, ie.
Constants representing the Simple Knowledge Organization Scheme (SKOS) classes and properties.
Creates connectors implementing the
JenaOntoDriverProperties.SNAPSHOT
transactional strategy.This connector implements the
JenaOntoDriverProperties.SNAPSHOT-based
transactional strategy.This class provides an empty implementation of
SoqlListener,
which can be extended to create a listener which only needs to handle a subset
of the available methods.Constants of the Semantic Object Query Language (SOQL).
Supported SOQL functions.
Indicates an error during parsing and translation of SOQL to SPARQL.
This interface defines a complete listener for a parse tree produced by
SoqlParser.SOQL parsing and processing utilities.
This annotation can be used for creating SPARQL queries directly on repository fields.
Constants of SPARQL.
Factory for creating SPARQL queries.
A simplified SPARQL query parser.
Maps SPARQL result set value (a subset of the current row) to output based on a
SparqlResultSetMapping configuration.Represents a problem with a
SparqlResultSetMapping declaration or its runtime usage to map query result to target value(s).Specifies the mapping of the result of a native SPARQL query.
Used to define one or more
SparqlResultSetMapping annotations.This interface represents a SPARQL statement.
Specifies which ontology is used for statement evaluation.
Used for parsing and managing SPARQL statements.
Specifies that the annotated class is a metamodel class that represents the entity or mapped superclass designated by the value element.
Indicates that the static metamodel could not be initialized.
Initializes static metamodel based on the provided runtime metamodel.
This exception is thrown when an exception occurs while accessing the OntoDriver.
Built-in converter for mapping to/from enum-valued attributes.
Represents the subject, predicate and context(s) of a statement.
A combination of statement subject, predicate and context(s).
SubjectPropertyRemove<T extends org.semanticweb.owlapi.model.OWLProperty>
Query parameter value representation for date/time.
Represents an operation that accepts a single input argument and returns no result.
A
Function that may throw a checked exception.Converts language tagged and language-less values to
LangString attributes.Converts literal lexical form to Java
String.Supports mapping selected value types to multilingual strings.
Converter for working with RDF literals with explicit datatype mapping (
Literal).Converter to
URI.Converter to
URL.Represents a change in data made during a transaction.
Thrown by the persistence provider when a transaction is required but is not active.
Basic transactional states.
Specifies that the property or field is not persistent.
Value object representing the same string in multiple languages.
Manages the second level cache shared by all persistence contexts.
The TupleElement interface defines an element that is returned in a query
result tuple.
Instances of the type
Type represent persistent object or attribute types.Interface used to control the execution of typed queries.
Represents a map of references between types.
Represents the set of ontological types to which an entity belongs.
This interface is used for working with individuals' types.
Instances of the type SetAttribute represent persistent java.util.Set-valued
attributes.
Represents a persistence context.
A set of changes made in a
UnitOfWork.Thrown when an unpersisted change is found on commit.
Thrown when it is not possible to execute a type transformation.
Thrown when it is not possible to execute a type transformation.
Denotes class/member which is a part of the JPA 2.0 specification but is not used by JOPA.
Represents assertion value.
Converts values between the OntoDriver model and RDF4J model.
Thrown when an attempt is made to extract value of a variable which is not bound by the
ResultSet.Used in conjunction with the
SparqlResultSetMapping annotation or ConstructorResult annotation to map
a column of the SELECT list of a SPARQL query.DataSource implementation representing the Virtuoso OntoDriver.Marks classes which allow to unwrap provider-specific implementations.
Interface for retrieving concrete implementations of the OntoDriver API and/or classes the implementations use (e.g.
A subset of the XML Schema built-in data types vocabulary.
Maps XML Schema types to Java.
Maps values of
XSD.DATETIME to Java OffsetDateTime.Maps
XSD.DURATION values to Java Duration.Maps temporal values to their corresponding XSD datatype values.
Maps values of
XSD.TIME to Java OffsetTime.Converts between Java 8
ZonedDateTime and a supported xsd:dateTime representation.