All Classes and Interfaces

Class
Description
A task being executed by a SessionTaskDispatcher.
The dispatcher applies its session when the task is added.
Exception thrown if the user is already logged in.
Usually for application servers that don't allow a user logged in more than once.
The proven identity of a client, i.e., the outcome of a successful authentication.
Thrown by an AuthenticationProvider that vetoes the credentials it was given.
Drives the chain of AuthenticationProviders.
Verifies Credentials on the server side.
Configuration for a database backend.
The configuration is stored via the standard Preferences and provides the parameters necessary to connect to the database backend.
The config refers to a DriverConfiguration that loads the corresponding driver.
Annotation for the class id of a persistent object.
Runtime exception thrown for database constraint violations.
The credentials presented by a client to prove its identity.
Thrown when the credentials were valid but have expired.
The user interaction a CredentialsProvider may need while obtaining credentials.
Obtains the Credentials on the client side, before the session is opened.
Annotation to express that the annotated class is an implementation of a CredentialsProvider.
The default implementation of an Authentication.
The default authentication manager.
The credentials prompt for applications without a graphical user interface.
The default master serial event handler factory.
The default implementation for a session-info.
Default session info factory.
A thread executing tasks in a serialized manner on an exclusive session.
Configuration for a backend driver.
The configuration is stored via the standard Preferences and provides the parameters necessary to load the driver.
An exclusive session provider.
Thrown if a login is refused, because authentication failed or for any other reason.
Wraps the master serial used by the ModificationTracker.
The tracker of a remote client periodically requests the master serial from the server.
Interface for a master serial event.
Such events can be sent from the server to the client via the ModificationTracker.
Factory for MasterSerialEvent-handlers.
Annotation for the handler of a MasterSerialEvent.
A master serial event containing a list of events.
This event type is used whenever there is more than one event pending for the client.
Modification event.
Holds the event detail.
Details are equal if their names are equal, regardless of the serial.
Listener for modifications.
A modification listener adapter.
Provides the default priority 100, no time frame and no time delay.
Tracks global changes.
A pool of sessions for multiple session infos.
Allows different users to use multiple sessions in parallel.
Runtime exception thrown if objects that should exist are not found in the database.
Runtime exception thrown if an object cannot be removed, for example because it is still referenced.
The traditional username and password credentials.
The built-in username/password credentials provider.
The root of all persistence-related runtime exceptions.
Persistent fields and methods are annotated with this annotation.
The remote session.
Provides access to the remote (server-side) client session.
A savepoint handle.
The session.
Describes a persistence and security context.
Bundle for the session module.
Runtime exception thrown if the session is already closed.
A handler invoked whenever a Session is closed.
Interface for objects depending on sessions.
Factory for Sessions.
Holder for a session.
Session information.
Factory for SessionInfo.
A task dispatcher to keep sessions alive.
The task to keep a session alive.
The task uses the executor service of the daemon to spawn asynchronous pings.
A pool of sessions for a given session-info.
Allows a single user to use multiple sessions in parallel.
The sessions are created via SessionFactory.create(SessionPool, SessionInfo).
Executes runnables on a pool of sessions.
Useful to run background tasks in parallel, each task with its own session.
Factory for session pools.
Provider for local or remote session pools.
Session provider.
A TaskDispatcher using a Session.
The tasks are executed serially by the dispatcher thread, which owns the session exclusively.
Lock for the DefaultSessionTaskDispatcher.
Provides access to the dispatcher's session while the lock is held.
Utility methods for session-related stuff.
Extended validation utilities.
Honors the field- and method-order by using the ordinal of the Persistent-annotation, which is generated according to the model's definition.
As a result, the validators are invoked by priority + position in the source code.
Annotation for the tablename of a PDO.
A session holder returning the thread-local session.
Nice if no domain context is available, e.g., for low-level AbstractDbObjects.
Token-based credentials, such as an OAuth2 access token or an OIDC ID token.
Enum that maps the low-level integer constants of the transaction isolation levels in java.sql.Connection.
Enum for read-write or read-only transactions.
Maps a proven identity onto the application's user entity.
Exception thrown if client's and server's versions don't match.