All Classes and Interfaces
Class
Description
Data for the escalation measure to abort item.
In case an
ADEPT2Service cannot be initialised or started due to
a major problem, an AbortServiceException may be raised.An
AbortTransactionException indicates that a transaction in a
service cannot be completed and therefore has to be aborted.This class combines several parameters to one (POST) parameter.
An
AbstractActivity unifies the similarities of activities (used
in the process model), activity templates (intermediate objects for
transferring the necessary information from the activity model to the process
model), activity template definitions (the corresponding objects in the
activity model) and activity instances (the objects that are finally
executed).This class provides the basic means for an activity event handler, that is,
providing the attributes of an
EventHandler as well as declining
all signals sent while the handler is executing an activity.This interface unifies the methods of an
ActivityModelParameter
used with inheritance (in the GUI) as well as for storage.This interface unifies the methods of an
ActivityTemplateDefinition used with inheritance (in the GUI) as
well as for storage.Abstract implementation for the ADEPT2 service interface.
This class manages all sessions and threads currently active in this
service.
An abstract class providing the basic means for authenticating and managing a
SessionFactory as well as some session management (token verification and alike).This class extends an authenticated service by the means for changing a
configuration.
AbstractConfigurableRootResource<S extends ConfigurableService,W extends AbstractRootResourceConfigurableWebService<S>>
This class extends the REST root resource by the means for managing a configuration.
This class provides the configuration of a service and returns it.
This interface unifies the methods of a
ConfigurationSet
used with inheritance (in the GUI) as well as for storage.This class provides the basic means for a SOAP web service endpoint.
An abstract event providing the type handling and ID handling as well as the
creation date.
This class provides the basic means for an event handler, that is, providing
the attributes of an
EventHandler.The event manager creates event handler and event sources.
This abstract class provides the means for managing the handler registered
for an event source.
This interface unifies the methods of an
ExecutableComponentDescription used with inheritance (in the
GUI) as well as for storage.This class provides the basic means for a
RemoteGUIManager which
is the interaction between remotely executed component to GUI context (via
ActivityStateNotification and vice versa
(via AbstractGUIManager.terminateRemoteExecution(SessionToken, EBPInstanceReference, String)).This
GUIContext enables the usage of HTML as graphical user interface.The clean-up task for closing all replies and responses of an
AbstractHTMLContext.Parent class for all incremental worklist data, initial as well as following.
This class provides the basic means for an instance start event handler, that is, providing the
attributes of an
EventHandler as well as retrieving the "latest" template
to instantiate and let subclasses check for its input parameters.This class handles provides the basic means for handling iterators.
Parent class for all remote iterator data based on lists of objects of the same type.
An abstract class providing the basic means for authenticating and managing a
ClientSessionFactory.A one work executor allows for an arbitrary amount of objects having work, but only one piece of
work is allowed for each object at a time.
This class represents runtime data for an one work executor.
An abstract implementation for an
ObjectRunnable including some lifecycle management
like being active and termination.A thread pool executor that accepts work for specific objects.
This is an abstract base class for wrapper implementations.
This interface unifies the methods of an
Operation used with
inheritance (in the GUI) as well as for storage.This interface unifies the methods of a
ParameterTemplate
used with inheritance (in the GUI) as well as for storage.A pipelining executor handles work in pipelines.
Abstract implementation of the process template check.
This class manages interfaces (or super-classes) of component types and
instances of components including singletons.
Default implementation for resolving service name and component types.
InstanceInformation encapsulates the properties from the
configuration relevant for a component instance.The instantiation modes an instance may have.
This class provides the basic means for a window mechanism for lists of elements, that is, the
basic means for a
RemoteIterator.Parent class for all remote iterator data, initial as well as following.
This class provides the means for making REST calls to callback objects.
This class provides the basic means for a REST root resource.
This class extends the
AbstractRootResourceWebService by the means to manage a
configuration.An abstract root resource web service provides web service implementations for
ADEPT2Service.This class provides the basic means for handling of shared events.
An event source that distributes events among several sharing event
sources.
A source for events shared among several sharing event sources.
This class provides the common fields of all simple parameter selections.
An abstract stub provides a specific Java API interface for a web service stub.
This class provides the basic means for making REST callback calls
This class provides the basic means for a REST sub resource.
An abstract sub resource web service resembles
AbstractSubService, that is, an abstract implementation
providing some basic means for a web service for a (sub) resource.An abstract implementation for sub services of an
AbstractADEPT2Service.An abstract implementation of
SystemDataFormatter providing to helper
methods to ensure the presence of a value and the correctness of its type in
the provided map.This class extends the basic
AbstractRemoteIterator by the means for alive time tracking
of a RemoteIterator as well as AbstractTimeTrackingRemoteIterator.isSnapshot() and AbstractTimeTrackingRemoteIterator.isForwardOnly().A basic implementation for a
TransferableGUIContext just
enough to satisfy the interface.Abstract base class for web components implementing a generic request / reply mechanism handling
various user signals from the web frontend, like signalling states, etc.
Abstract base class for web components implementing handling of external and internal resources
which may be used for and from the web frontend.
Abstract implementation for wrapping a template object.
An abstract class providing the basic means for an object-oriented wrapper
for a
UDTValue providing direct access to various data of the
UDT.These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.An abstract class handling all comparisons with
ActivityConstants.AccessType.A comparison for a data attribute being one of several specified
AccessType
values.A comparison for a data attribute being not one of several specified
AccessType values.A deserialiser for instances of
AccessTypeComparison.An
AcquireLockException indicates that a lock of a specific
type on an object can not be acquired since the object is already locked by
another locking object (and possibly with another type of lock).This class represents the data that is provided as response to an activation
request, that is, this indicates a successful activation.
The activity is a pluggable component associated to a node.
This class combines several parameters to one (POST) parameter.
The data used to register a REST or SSE callback for an
ActivityStateNotification or an
ExecutionMessageNotification.
This class just provides the differences between
ActivityConfiguration and
Configuration.In AristaFlow configuration values in the activity model may stem from an
input parameter as well as the configuration of the corresponding process.
Shared constants for activities and activity templates.
The type of data edges, which specifies the direction (read or write
access).
The type of the entity of the activity model.
Constants for known activity types.
All attributes of the activity model that may be overridden locally at
runtime.
Constants for meta data entries of activities, used by
the OpenOfficeIntegration.
The execution mode of the operation or an activity.
ActivityData provides convenience methods for retrieval of
input and output parameter types and values as well as writing the output
parameter values.An
ActivityEventHandler extends an event handler by the means to
combine event handling and activity execution.To allow for event handler to execute activities and to control these
executions, an
ActivityEventManager provides a subset of the
methods of a RuntimeService.An event source that creates events for specific activities.
This class combines several parameters to one (POST) parameter.
This class combines several parameters to one (POST) parameter.
This class combines several parameters to one (POST) parameter.
This class combines several parameters to one (POST) parameter.
This class combines several parameters to one (POST) parameter.
This class combines several parameters to one (POST) parameter.
This class combines several parameters to one (POST) parameter.
This interface provides methods to control the life cycle of activities after
they are started (or resumed).
An activity reference for an activity group identifying the group in the worklist manager (
ActivityGroupReference.getGroupId() as well as logically via name and execution context.The
ActivityInstance is an instance of
ActivityTODO Describe inheritance.
An
ActivityModelParameter resembles a Parameter by
additional information needed in the activity model.A reference to an activity, e.g.
This class combines several parameters to one (POST) parameter.
These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.An abstract class handling all comparisons with
ActivityReferenceType.A comparison for a data attribute being one of several specified
ActivityReferenceType values.A comparison for a data attribute being not one of several specified
ActivityReferenceType values.A comparison for
ActivityReferenceType being nullA comparison for
ActivityReferenceType being not nullA deserialiser for instances of
ActivityReferenceTypeComparison.This class combines several parameters to one (POST) parameter.
This class combines several parameters to one (POST) parameter.
This class combines several parameters to one (POST) parameter.
This class combines several parameters to one (POST) parameter.
The activity repository manages the objects that are used in process steps
("activities").
The data used to register a REST callback for an
ActivityStateNotification or an
ExecutionMessageNotification.
The data used to register a SSE callback for an
ActivityStateNotification or an
ExecutionMessageNotification.
This interface provides the means to control start events of an activity,
that is, selecting, deselecting, starting and resuming an activity.
This class represents the different states of the component of an activity.
An enumeration for the state of the component of an activity.
This is a callback for activity states.
An
ActivityStateListener provides access to an
ActivityStateNotification which is notified when the observed activity terminates
(has been closed, suspended, reset, failed or signalled).This interface is used as a callback for the events when an executed activity
terminates, that is has been closed, suspended, reset, failed or signalled.
A stub implementing
ActivityStateCallback and calling a REST service
conforming to ActivityStateNotificationRest.A stub implementing
ActivityStateCallback and sending server-sent events.This class wraps an
ActivityStateCallback and forwards calls to
ActivityStateNotification appropriately.An
ActivityTemplate represents the object that is finally
assigned (dragged) to a process node; it is a self-contained artificial
vessel to transport all relevant information to the process model.ActivityTemplateDefinitions are located below
Operations, that is, they override the attributes of operations.This interface provides the means for managing
ActivityTemplateDefinitions which includes retrieval, creation,
updating and managing the states of
ActivityTemplateDefinitions.This interface provides the means to control terminating events of an
activity, that is, finishing, suspending and failing an activity.
This class wraps a normal client session factory and adds specific additional
attributes to all created session tokens.
AddDataTransformatorRemoteIteratorWebService<WJ,WI,A,I extends InitialRemoteIteratorData<WI>,N extends RemoteIteratorData<WI>>
This remote iterator web service provides the web service interface for going through a remote
iterator.
Change operation for adding a system parameter to a node.
A
Runnable for adding an event source for a specific worklist item.Change operation for adding a system data flow.
An activity reference to an ADEPT2 activity represented by a node of a
process instance.
This module of the communication service is responsible for the export of
callback objects, i.
Deprecated.
The default implementation of an activity reference.
Interface for tracking changes in properties of
ADEPT2EBPReference.This factory is responsible to create remote object identifiers and callback object identifiers
valid for the communication service this factory is assigned to.
Description of an (ADEPT2) service which can be initialised and started by
the registry.
Super class for all runtime exceptions thrown by the ADEPT2 services.
This submodule of the
CommunicationService is
responsible for publishing services, i.Submodules of the
CommunicationService defined by this interface are
responsible for creating stubs which represent the corresponding remote
services/callback objects on remote side.The default thread factory overwritten to name the threads.
This class provides a lightweight implementation for a user-defined data type (UDT).
Provides a method to convert values of one ADEPT2 data type to another where
possible.
These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.An abstract class handling all comparisons with
ProcessConstants.AdeptDataType.A comparison for a data attribute being one of several specified
AdeptDataType
values.A comparison for a data attribute being not one of several specified
AdeptDataType values.A deserialiser for instances of
AdeptDataTypeComparison.This class resembles an
InternalWorklistItem but it allows a
supervisor to control worklist items (InternalWorklistItem)
directly.These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.Some pre-defined filters for worklists.
This interface is similar to
CallbackHandler but it
allows for remote callback handling by the annotation to prevent transferring
the CallbackHandler but call it remotely.A wrapper for
AFCallbackHandler treated as
CallbackHandler.Class has been renamed to prevent name conflicts with stub generators and other WS/REST backends.
Instances of this class (and subclasses) can be used wherever an
EbpInstanceReference is expected.This thread pool executor enhances a normal thread pool by:
prepending the state of a thread to the thread name,
logging exceptions (and results) of futures where no one has been
interested in and
logging statistics.
Thread names will be prefixed as following:
NEW: Used for newly created threads.
ACT: Used for active threads that are currently executing tasks.
IDL: Used for idle threads, i.e.
This class combines several parameters to one (POST) parameter.
This exception indicates that the an agent is not known to a specific runtime
manager and therefore can not execute activities on this runtime manager.
This class combines several parameters to one (POST) parameter.
Utility functions concerning the activity model.
Exception indicating the failing of an application / activity due to an
erroneous environment, for instance, required parameters are missing or wrong
or the GUI-context can not be used.
This class defines the ADEPT2-error codes for application failures.
Exception indicating the failing of an application / activity for internal
reasons.
A callback to retrieve the application name for which to log on.
This class represents a data container (usually an instance data container) to be archived.
This class combines several parameters to one (POST) parameter.
Utility class to facilitate common checks on method parameters and create
appropriate
IllegalArgumentExceptions, NullArgumentException,
IndexOutOfBoundsExceptions etc..An expression engine for hierarchical configurations of Apache Commons Configuration.
Servlet implementation for the HTTP service of the HTML context.
This class represents the entry point to the AristaFlow platform.
This class defines
Object.equals(Object) and Object.hashCode() on arrays
considering the contents of the arrays (deep equality).Utility class for array-related helper methods.
A wrapper for arrays that provide a useful (i.
A wrapper for byte arrays that provide a useful (i.
This is required since OpenAPI lets Maps always have a String as key.
Change operation for the creation/assignment of an empty embedded subprocess
on a node.
Change operation for the assignment of an executable business process
(activity or sub-process/lightweight-process) to a node.
A worklist update may contain soft update types, that is, it is unclear
whether an item is added or changed or removed or not present at all.
The lightweight representation of an
ActivityTemplateDefinition
for usage in the activity repository.This class serves as common interface for the Java classes separating the filters applied to
atomic attributes from the ones applied to collection attributes.
This class represents the comparison part for atomic attributes with atomic values.
This class represents the comparison part for atomic attributes with a collection of atomic
attributes (possible values are from an
Enum).This class provides the means to create a filter comparing an object with null.
An atomic entity expression consists of a start entity type (plus optionally
a selection) and an optional chain of functions (plus optionally a selection
each).
An
AtomicSelection is a selection like id=5 or
lastName LIKE 'sch%', i.e.An
ATParameter extends a Parameter by additional
information needed when assigning (dragging) an activity (template
definition) to a process node.An
ATParameterTemplate represents a
ParameterTemplate but only provides the information needed when
assigning (dragging) an activity (template definition) to a process node.This interface allows arbitrary objects to have additional attributes.
Annotates a method of a view interface, including the name of the attribute.
Represents an attribute that can be filtered
and the path of methods through the containing objects
that must be called to retrieve it
This class just overrides the schema with a non-recursive
AttributeList.Type specialisation.
An
AttributedInputStream wraps an input stream and allows for attributing it.A factory that can construct new Attribute objects
by hierarchically navigating through the method tree
of a specified class.
/** /** This class just overrides the schema with a non-recursive
AttributeList.AttributeMetaData is a simple immutable container class for
AttributeMetaData.MetaDataElement-objects, supposed to conveniently hold all available
meta information about the attributes of one entity type.Used to hold information about a single attribute.
Setter for the model viewer attribute.
This authentication data specifies an agent further, either via user name and/or org position ID
or via one or more
QualifiedAgents.This class is similar to
AbstractAuthenticatedService.This interface marks service that authenticate at the security manager.
This interface provides methods for authenticating agents based on
appropriate credentials.
Each field will be set in an appropriate
AFCallbackHandler or provided as parameter
to the Java API.These classes override the schema hiding the list of qualified agents contained in the ILM model.
An
AuthenticationException is thrown when authenticating and the
provided Agent user name and/or password are incorrect or the authentication
fails due to an exception thrown by the used authentication framework.This interfaces declares and describes various authentication methods that
may be supported by implementations of
Authentication and
SecurityManager.A comparator based on the authentication priority of
OrgModelExtensions.A listener to automatically save a properties configuration to the corresponding file when
changing the configuration.
This class combines several parameters to one (POST) parameter.
This interface defines a graphical context that could be used by application
components to integrate them into a AWT-GUI on a workflow-client.
Encodes and decodes to and from Base64 notation.
A
Base64.InputStream will read data from another
java.io.InputStream, given in the constructor,
and encode/decode to/from Base64 notation on the fly.A
Base64.OutputStream will write data to another
java.io.OutputStream, given in the constructor,
and encode/decode to/from Base64 notation on the fly.Configuration-related global constants for general use in configuration files.
A wrapping servlet context that loads resources relative to a provided class.
A very basic
SystemDataFormatter using the Object.toString() method
of each value.This class just overrides the schema with a
Schema.oneOf().An abstract class handling all boolean comparisons.
A comparison for a data attribute value being equal to a boolean value.
A comparison for a data attribute value being different from a boolean value.
A deserialiser for instances of
BooleanComparison.This bootstrap registry is the central entity from which other registries and
services can be retrieved.
An implementation for graph elements using BPMN symbols instead of the normal AristaFlow symbols.
Changes of entities takes place in
Branches.Deprecated, for removal: This API element is subject to removal in a future version.
The clean-up task deleting the temporary file if appropriate
A
BuildtimeActivity unifies the similarities of the objects
representing activities at buildtime.A
SerialisableAttachment having plain byte[] content.Cache implementation.
A
ThreadPoolExecutor which comes in two flavours:
Creates new threads to run a new task, if the amount of threads is less than the
corePoolSize.This incremental worklist update implements a cache for the underlying incremental worklist
update, that is, when iterating via
CachingIncWorklistUpdate.getNext(int), all retrieved item updates will be
cached.The clean-up task for closing/dropping the
IncrementalWorklistUpdate.This iterator implements a cache for the underlying iterator, that is, when iterating via
AbstractRemoteIterator.getNext(int), all retrieved elements will be cached.The clean-up task for closing the wrapped
RemoteIterator.CalendarTools provides methods useful for determining
public holidays and calculating dates.Represents a day of an unspecific year, that is just a month and a day.
This annotation marks a parameter as callback having a callback interface and an URL where the
callback is expected.
A wrapper for
CallbackHandler treated as
AFCallbackHandler.Records information about the caller of a method: the current thread, its
stack trace at the moment this trace was created (unless a custom stack trace
is explicitly specified in the constructor) and a timestamp.
This class provides constants for capabilities of security tokens.
Interface for providing methods to check capabilities of session tokens.
This interface unifies a
ChangeableConfiguration and an
ActivityConfiguration and allows to change the attributes of the
ActivityConfiguration, that is whether a configuration value
stems from an input parameter or the corresponding process configuration.This interface extends the
Configuration by the means to change
the configuration values.This interface extends the
ConfigurationDescription by the means
to add or remove configuration entries.This interface extends
IconDescriptor by the means to change
its attributes.An instance which provides all necessary change primitives
for modifications on instance level.
/**
This interface extends
ResourceDescriptor by the means to change
its attributes.Combines two changes depending on how they relate to each other.
Class to track property changes.
A helper class with tools which are used by the change operations.
The ProcessChangePrimitive interface provides all basic functions for
changing a process (template or instance).
A
ChangeReport provides a CheckReport together
with the old and the new ID of the instance and the new changeable instance
object.This map extends a normal
HashMap by the means to track and
combine changes for property values.A type for specifying changes to elements of a collection-based property.
Constants and enums that are used in checks like data flow checks and are used to report the
kinds of messages of checks in a check report.
The check report is used for collection of check results.
Represents an entry in the check report.
Constants that define whether the corresponding report or report
entry contains an error message (FAILURE), a warning message
(WARNING), an info message (INFO) or simply a success message (OK).
Deprecated, for removal: This API element is subject to removal in a future version.
A filter for log records only allowing log records with source classes having one of several
specific prefixes or class names and at least a specific level.
This is a combination of
ClassesNameFilter and ClassNameSubFilter, that is, it
allows for several root classes and will only allow different log record source classes.What classloader to use for the execution of an activity.
A filter for log records only allowing log records with source classes having
a specific prefix and at least a specific level.
A filter for log records only allowing log records with source classes having one of several
specific prefixes or class names and at least a specific level while the root class, that is, the
class requesting the logger, is different.
Cache implementation with cleanup logic applied when removing an entry due to the cache becoming
too big.
Cleanup aims to complement the functionality of Cleaner and provide some
answers to questions that Cleaner left open.A builder for
Cleanup that provides some additional options and generally easier
usage than complex constructors.A cleanup task for cleaning up a collection of objects being converted and afterwards being
closed in case the conversion yields a
AutoCloseable.Deprecated, for removal: This API element is subject to removal in a future version.
Use
Cleanup.CollCloseTask instead.A cleanup callable executes a callable and afterwards a special cleanup
consuming runnable finally after the first callable.
A cleanup runnable executes a runnable (or several ones) and afterwards a special cleanup
runnable finally after the first runnable.
This interface provides the means for clean-up logic as normal or as post-mortem action.
Convenient base class for
CleanupTask with the option to provide a custom descriptor
for the clean-up task and/or a logger.A simple cleanup task for cleaning up an
AtomicReference.An abstract cleanup task for closing a supplied
AutoCloseable and resetting it via
a Runnable.A simple cleanup task for cleaning up a
Mutable.The client administration interface allows controlled access to data in the
organisational model, thus allowing end-user to easily change their own data.
An implementation of
OAuth2AccessTokenProvider that acquires an access token via the
OAuth 2.0 client credentials grant.A lot of frameworks use a session ID to identify users.
This interface provides the basic logic for client components/plugins for an
AristaFlow-server.
Listener for events that the active agent has changed.
Listener for events that the availability of an
ADEPT2Service has changed.Sub-service implementation which implements some default behaviour for all
implementations of
ClientService.A tracker for the availability of a specific
ADEPT2Services.These are the details for a ClientSessionFactory.
This class contains a token as Base64-encoded string.
A client session factory provides the user with a token needed for calling
the ADEPT2-API.
A worklist used at the client-side and therefore supporting
ClientWorklistItems.This is a simplified callback for client worklist update notifications.
The data used to register a REST or SSE callback for a
ClientWorklist.
A worklist item with additional attributes, which are typically required by the worklist client.
These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.Some pre-defined filters for worklists.
Client-side listener interface to get notified when a
ClientWorklist is updated, e.g.The data used to register a REST callback for a
ClientWorklist.
A stub implementing
ClientWorklistRevRespectingCallback and calling a REST service
conforming to ClientWorklistRest.This callback requires communication in both directions.
The data used to register a SSE callback for a
ClientWorklist.
A stub implementing
ClientWorklistCallback and sending server-sent events.This class wraps a
ClientWorklist used for asynchronously notifying worklist
updates.A pair that implements
Closeable and will propagate Closeable.close() to
each element (if it is a Closeable).This stream ensures post-mortem clean-up of resources by
closing the wrapped
input stream.Interface for polling a cluster node via communication.
Requests to the communication heartbeat, that is, what should the
communication heartbeat do.
Interface for polling a cluster node via DB and requesting a restart of the local cluster node if
required.
Requests to the cluster heartbeat, that is, signals to the cluster database.
The operations which can be requested to be performed by the cluster
heartbeat.
Deprecated.
This class is subject of change and must not be used yet except for testing purpose.
This class provides all information concerning a cluster node.
This class encapsulates the state of a cluster node in memory.
A
TwoPhasePlatform used for bootstrapping a cluster node.This class allows for communication between different nodes of a cluster.
An enumeration that defines the comparison operations supported by the log
management facility, aka.
The comparison operators used within the OrgModelManager to select certain
entities based on their attribute values.
This comparator can be used to compare code descriptors.
A filter applied to a collection, getting a simple attribute from the collection and applying a
normal attribute filter.
These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.A comparison for
Collection<DataElement> being null.A comparison for
Collection<DataElement> being not null.These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.A comparison for
Collection<Delegation> being null.A comparison for
Collection<Delegation> being not null.This class serves as common interface for the Java classes separating the filters applied to
atomic attributes from the ones applied to collection
attributes.
This class provides the means to create a filter comparing a collection attribute with null.
These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.A comparison for
Collection<Node> being null.A comparison for
Collection<Node> being not null.These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.A comparison for
Collection<ProcessModelParameter> being null.A comparison for
Collection<ProcessModelParameter> being not
null.These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.A comparison for
Collection<QualifiedAgent> being null.A comparison for
Collection<QualifiedAgent> being not null.These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.A comparison for
Collection<StructuralDataEdge> being null.A comparison for
Collection<StructuralDataEdge> being not null.These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.A comparison for
Collection<SimpleParameter> being null.A comparison for
Collection<SimpleParameter> being not null.Tool methods for collections
An iterator wrapping an
Enumeration in an Iterator.A map considering equalling keys and values based on object identity instead of
Object.equals(Object).An enumeration wrapping one or several iterators (and enumerations), i.
These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.A comparison for
Collection<URI> being null.A comparison for
Collection<URI> being not null.These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.A comparison for
Collection<UUID> being null.A comparison for
Collection<UUID> being not null.Represents a column in the entry schema of a
log in the log
management facility, aka.
Constants which may be used across all data models.
This class offers tool methods for several models.
An interceptor for a communication stack.
Interface to perform transformation before and after performing a communication.
This communication service provides all the technically necessary to do both
remote calls to remote services or remote callback objects and to publish
remote services itself.
Marks the implementing class as layer within a communication stack.
A class extending this class implements a layer within a communication
stack handling requests and responses and it represents the communication
stack consisting of this layer and all following layers.
Provides the base implementation for the last layer, i.
Represents a filter that compares an attribute
to a constant value using a specified comparison operator
(i.e.
Represents the comparison operators that can be used
in a
ComparisonFilterSome comparison operators for strings.
A
ComplexEntityExpression connects two or more
EntityExpressions, i.e.Enumerates the possible types of complex entity expressions.
A
ComplexSelection consists of other (atomic or complex)
selections and combines them either conjunctively (AND) or disjunctively
(OR).Enumerates the possible types of complex selections.
This
ObjectInputStream uses the context classloader of the
current thread instead of the last used classloader like the
ObjectInputStream.A composite check consisting of other checks.
These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.A simple class for handling events concurrently via an
executor service.
This is similar to a normal
CountDownLatch but
it uses a wrapped lock for synchronising as well as a new corresponding
condition for signalling.This interface extends an
ADEPT2Service by the means to retrieve
and change the configuration.A configuration object provides the means to access configuration values
type-safe.
The IDs for configurations, see
Configuration.getConfigurationID(String).Configuration-related global constants for general use in configuration
files.
The names for all supported communication protocols (which are equal to
the instance names of the corresponding communication services).
Classes specified as implementation for a component type may be annotated
with a
ConfigurationDescription.The configuration description defines the entries of a corresponding
configuration, specifies the types and further restrictions for the
configuration values as well as a description for the user.
A configuration entry declares a configuration value and provides
additional information for it, that is a name for the entry, a description,
the data type and restrictions on the type as well as the usage of the
configuration value.
Provides the functionality for the validation of
configuration descriptions and
configurations.A
ConfigurationException will be thrown if an erroneous
configuration is discovered.This configuration manager handles configurations for components and services of the
AristaFlow-System.
This provider extends a normal
PropertyProvider to support configuration directories as
URLs to load configuration files from, a directory to write configurations changed at runtime to,
a directory to write the logs to and boolean flags for whether to load configuration files from
bundles (jar-files containing the AristaFlow-components), whether to use debug logging while
bootstrapping and whether to keep the registered log handlers.A
ConfigurationSet is a collection of configurations,
configuration descriptions as well as a few other attributes.This interface provides the means for managing
ConfigurationSets
which includes retrieval, creation, updating and managing the states of
ConfigurationSets.This class provides methods for converting values used in
Configurations from the
corresponding type to strings and back.A
ConfigurationValidator can be specified in a
ConfigurationDescription and (if specified) is used to validate a
configuration at application startup without having to wait until the
component (for which the configuration was intended) is instantiated.This interface marks an
ADEPT2Service to require a configuration
manager in its constructor.The "POSITION op Value" filter
A
ConstraintViolationException represents the violation of
some defined constraint, for example, deleting an entity that is referenced
by another entity.A runnable consuming an object of type
T or an exception of
type E.A description of the container...
The "CONTAINS ALL" filter.
The super interface for all filters that match on some kind of "contains" relation.
Applies a filter to a collection, all elements have to match.
Applies a filter to a collection, one element has to match.
This exceptions is thrown when the conversion of a value is not possible.
Helper class for the conversion of an activity template to an activity
Change operation to copy a process node.
These tool methods are used for the copy/paste and duplicate functionality of
the activity repository.
This change operation offers the possibility to surround nodes with a block
of the following types:
AND-Split -> AND-Join
XOR-Split -> XOR-Join
LOOP-Start -> LOOP-End
Call isPossible first to check if the insertion of the surrounding block is
valid, than call perform operation to execute the change.
The lightweight representation of a
ConfigurationSet for usage
in the activity repository.This subclass refers to the
CSVFormatter and decouples LoggerManager from
AristaFlow-specific classes in CSVFormatter.A thread pool for executing the tasks by the submitting thread.
A factory for custom filters that can't be constructed using the regular
FilterFactory.This
DatabaseConfiguration checks whether the corresponding table exists before it
executes a query or a statement.The names of the database management systems supported by DBAccess.
A
DataConsistencyException indicates an inconsistency in the data (of a service).This interface encapsulates the data context of an application as provided by
the execution manager for the runtime manager, that is, the values of the
input and output parameters of an application.
This is a data container without relation to any activity.
This interface provides reading access to all input and output parameters of
an application as well as write access to output parameters.
There may be only one data edge connecting a data element and a node per
direction.
The DataElement interface offers access to the data elements of a process.
This comparator can be used to compare DataElements.
These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.This class combines several parameters to one (POST) parameter.
The data manager provides access to different interfaces which handle (the
values of) data elements and user-defined data types (UDTs) at runtime.
Data monitoring provides access to a data set.
A
SerialisableAttachment having a datasource as content.The
DataSourceException is a generic exception that is thrown
whenever there's a problem while accessing a data source (like files or a
database) and this problem prevents the task from finishing properly or at
least within acceptable parameters.A simple wrapper for a
JDBCDataSource which is required by
DatabaseConfiguration.Enumeration that defines the data types supported by the log management
facility, aka.
Enumeration that defines the allowed data types for the attributes of entity types.
The data type manager provides the means to administer user-defined data
types (UDTs) and user-defined functions (UDFs).
Simple tool class featuring simple formatting of relative and absolute
times.
This is a provider interface that must be implemented in a vendor-specific
way in order to support a certain DBMS.
A DB event source that takes its configuration from an activity configuration
provided from a process step.
A source for events based on SQL statements, that is a SQL statement is
executed regularly and the result set (if one exists) is notified as event to
the corresponding event handler.
This logger wraps a normal logger and provides more parameters to a log
record.
Represents an activity which is used for decisions in the process model.
Represents an activity instance which is used for decisions in the process
model.
Holds all information associated with a decision ID
This comparator applies to
DecisionStatements.This servlet simply returns
HttpServletResponse.SC_NOT_FOUND to any request.Default Implementation of the AbsenceInformation Interface
The default event manager supports arbitrary events (e. g.
Default implementation of the process check service.
This class wraps a dynamically added
Servlet and allows to change initialisation
parameters and URL patterns for the servlet.A servlet config for a servlet which is deployed after the main servlet already has been deployed
- and of which the context may have already been initialised.
This servlet context provides the means for adding servlets after the parent servlet context has
already been initialised.
A delayer provides the means to delay a call based on the amount of tries a
provided element has experienced.
These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.A comparison for
Delegation being nullA comparison for
Delegation being not nullThis interface supports user-defined delegation handling procedures.
Delegation allows to assign another user as the currently assigned one.
Data for the escalation measure for delegation.
Use this change operation to delete the split/start loop and join/end loop
nodes.
Change operation for the deletion of a data edge between a node and a data element.
ChangeOperation to delete a data element (including its in- and outgoing data
edges).
Deletes an empty branch between a split and its corresponding join node.
Change operation for the deletion of a single node.
This class combines several parameters to one (POST) parameter.
A meta interface for the TemplateDeltaLayer and the InstanceDeltaLayer.
A
DemuxRequest wraps a HttpServletRequest and adapts its paths.This servlet allows to register sub servlets at runtime, i.
A
Dependency object represents a concrete dependency of a
SystemDataConsumer to a SystemDataProducer (a method of the
process model providing system data) or a Dependency.SystemDataProvider (a
normal data source providing system data).This enumeration provides system data provider that "extend"
SystemDataProducer, that is, both provide system data (for instance
process relevant timestamps, agent IDs,...) but while system data producer
represent methods from the process model, system data provider represent
other data sources, for instance arbitrary data elements.A
DependencyProvider establishes the context for
SystemDataConsumers and provides dependency-related information
about them.This class provides abstract deserialiser classes.
Deserialises either a JSON object or a plain value (including
JsonToken.VALUE_NULL to
an instance of a specific type Comparison.Deserialisers.AbstractNullableDeserialiser<T extends Serializable,F extends AtomicAttributeFilter<T>,N extends AtomicAttributeFilter<T>>
Deserialises either a JSON object,
JsonToken.VALUE_NULL or a plain value to an instance
of a specific type Comparison or a AtomicAttributeFilter.NullComparison in case of
JsonToken.VALUE_NULL.Deserialisers.ComparisonDeserialiser<T extends Serializable,O extends Enum<O>,F extends AtomicAttributeFilter.Comparison<O,T>>
Deserialises either a JSON object or a plain value (including
JsonToken.VALUE_NULL to
an instance of a specific type Comparison.Deserialisers.EnumComparisonDeserialiser<T extends Enum<T>,EC extends AtomicAttributeFilter.EnumComparison<T>>
Deserialises
EnumComparisons of a specific class but does not return a
NullComparison.Deserialisers.EnumValueTypeDeserialiser<T extends Serializable,F extends AtomicAttributeFilter<? extends T>,E extends Enum<E> & AtomicAttributeFilter<? extends T>,D extends Deserialisers.EnumValueTypeDeserialiser<T,F,E,D>>
A
TypeDeserializer handling scalar values by
reading a string and parsing this to a specific enum value converting it to an
AtomicAttributeFilter.Deserialisers.FilterTypeDeserialiser<T extends Serializable,O extends Enum<O>,F extends AtomicAttributeFilter<? extends T>,C extends AtomicAttributeFilter.Comparison<O,T>,M extends MultipleFilter<T,F>,D extends Deserialisers.FilterTypeDeserialiser<T,O,F,C,M,D>>
This type deserialiser adds the means for deserialising plain values (i. e.
Deserialisers.NullableEnumComparisonDeserialiser<T extends Enum<T>,EC extends AtomicAttributeFilter.EnumComparison<T>,NC extends AtomicAttributeFilter<T>>
Deserialises
EnumComparisons or NullComparison of a specific class.Deserialisers.PlainNullCollectionPreDeserialiser<T extends Serializable,F extends CollectionFilter<T>>
This class provides the means for deserialising a collection property that should be compared
with
null but omits the comparison operator.Deserialisers.PlainNullPreDeserialiser<T extends Serializable,NC extends AtomicAttributeFilter.NullComparison<T>>
This class provides the means for deserialising a property that should be compared with
null but omits the comparison operator.Combines different changes, for instance the changes refer to the different
property values.
This deserialiser chooses between two different class hierarchy based on the presence of a
specific field (name).
This interface allows to provide special distribution handling procedures.
These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.A deserialiser for instances of
DoubleComparison.An abstract class handling all double comparisons.
A comparison for a data attribute value being equal to a double value.
A comparison for a data attribute value being greater than or equal to a double value.
A comparison for a data attribute value being greater than a double value.
A comparison for a data attribute value being less than or equal to a double value.
A comparison for a data attribute value being less than a double value.
A comparison for a data attribute value being different from a double value.
The
java.sql.DriverManager uses a native method to retrieve
the classloader from the calling class which keeps the calling class
(including its classloader) from being garbage collected.A dynamic entity expression is basically a
parameter reference in an org policy - i.e.This class provides the means for handling dynamically registered services including registering and unregistering.
This interface provides the means for signalling adding, updating and removing services to
users of the
DynamicServiceRegistration.The mode to register a service.
A servlet for dynamically deployment that will be notified of (un-)deployment.
An extension of
ServletContext that adds methods to remove previously added servlets.A simple wrapper to provide
DynamicServlet for a HttpServlet.This interface provides a reference to an instance of an executable business
process (EBP) or rather to the corresponding container.
These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.A comparison for
EbpInstanceReference being nullA comparison for
EbpInstanceReference being not nullAn enumeration for the type of
ExecutableBusinessProcesses, that
is whether it is an activity or a subprocess.These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.A deserialiser for instances of
EbpTypeComparison.An abstract class handling all comparisons with
EBPType.A comparison for a data attribute being one of several specified
EBPType values.A comparison for a data attribute being not one of several specified
EBPType
values.The lightweight representation of an
ExecutableComponentDescription for usage in the activity
repository.The interface for edges, used to model the controlflow (control-, loop- and
sync-edges).
A simple data structure and builder for an email.
This class represents an email address with the address (
first.last@xyz.com) and an
optional name, e.The possible priorities for e-mails.
Simple object that wraps the result of sending an e-mail.
Simple HTTP service based on a
ServletService (an embedded servlet
container).The
EmbeddedProcess is used to embed another process
template.A servlet service deploying servlets dynamically via Servlet API 3.0.
Validates the configuration of the embedded servlet service, that is, an
instance of
ServletContext needs to be provided and the URL of
the outer servlet.This class implements a remote iterator for empty results.
Signals the end of a change transaction
An enquiry allows an agent to suspend a running activity, annotate it with a
question and delegate it to other agents who can then reply the question or
help the originator in solving the problem.
Plug-in data for enquiries.
This class combines several parameters to one (POST) parameter.
Enquiry mode defining how the set of enquiry recipients is determined.
This class just overrides the schema with a
Schema.oneOf().A comparison for
Enquiry being nullA comparison for
Enquiry being not nullThis class combines several parameters to one (POST) parameter.
This class handles enriching operations, parameters and types of the OpenAPI.
This class represents an entity, i.e.
These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.This enumeration lists the all entity types that are defined in the
Organisational Meta Model.
This enumeration needs to be copied since OpenAPI uses
Object.toString() for generating
the values but Jackson per default uses Enum.name().Combines equal changes, for instance the changes refer to the same property
value.
Tool methods supporting implementation of
Object.equals(Object).These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.An error dialogue that displays stack trace information in its details area.
Error handling process data, ie.
Constants for the parameter names which build the API of the template.
Plug-in data for escalation of process steps.
This interface supports user-defined escalation handling procedures.
EscalationMeasures provides the means to escalate a worklist
item accordingly (and prevents accessing arbitrary functions of the
worklist manager).This interface represents an event source and event handler.
An
EventHandler listens to an event and processes it as soon as
the event occurs.This exception indicates that an event handler had a problem when handling an
event.
An event manager provides the means to create events including arbitrary data
and handling these events.
An event source produces events and forwards them to one or more event
handler for processing the event.
This class provides the means to call a method and replace an occurred exception by a different
one.
This class implements
ExceptionHandler an thus provides the means for handling
exceptions appropriately.A callable catching exceptions and virtual machine errors and optionally rethrowing them.
A runnable catching runtime exceptions and virtual machine errors and optionally rethrowing them.
The
ExecutableBusinessProcess (EBP) defines a common
interface for objects which can be plugged to nodes of a process.The
ExecutableBusinessProcessInstance is an instance of
ExecutableBusinessProcessThis interface describes the methods that are necessary to enable the
RuntimeManager to control the single applications accordingly to the
requirements of the process management system.
Definition of the constants for signals that could be interpreted by
execution environments.
An
ExecutableComponentDescription is the logical counterpart of
the physical entity that is called at runtime, the
"ExecutableComponent".This interface provides the means for managing
ExecutableComponentDescriptions which includes retrieval,
creation, updating and managing the states of
ExecutableComponentDescriptions.This interface provides additional methods necessary to execute a process
instance, that is, setting the user who performs a node and manipulating node
states and iteration counts.
Interface for tracking property changes on
ExecutableInstance
objects.Node properties which are changeable in an executable instance.
Properties which are changeable in an executable instance.
This client service extends a client service for local execution by the means
to execute activities remotely.
This interface provides methods to get all the information necessary for the
execution of an activity by the runtime client.
This is the response to
ActivityStartingWebService.getExecutionContexts(de.aristaflow.ilm.base.sessionmanagement.SessionToken, java.util.Collection, Integer)
combining an activity and the corresponding execution context or an exceptional response together
in one object.This interface allows external clients to control the execution of an
activity.
The execution control properties reflect the abilities of applications
(operations, activity templates, etc.), on reacting to execution
control requests from the outside.
These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.This abstract execution environment is for easy development of new execution
environments.
To offer the possibility that each application can provide its own execution
and termination context objects that fit the application's needs best a
factory has to be provided that loads the corresponding implementations.
This is the defining interface for the execution history and its data
structure.
Contains constants for the names of all columns in the
ExecutionHistory.SCHEMA of
the execution history.Allowed values for the
stateChange column.Constains a single entry of the execution history.
These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.This class combines several parameters to one (POST) parameter.
This interface provides access to node and instance counts based on time and type to be monitored
by JMX.
This interface defines methods for write access to the
execution history.
The execution manager executes process instances, that is, it interprets the
process structure and the node states and steps through the process by
manipulating node states and starting applications assigned to nodes.
This interface provides access to node and instance counts based on type, node state and instance
execution statuses to be monitored by JMX.
This is a simplified callback for execution messages.
An
ExecutionMessageListener provides access to an
ExecutionMessageNotification which is notified when there are
request messages for a specific execution of a proprietarily executing
client.This interface simulates the notification of an
ExecutableComponent when using a
proprietarily executing client.A stub implementing
ExecutionMessageRespondingCallback and calling a REST service
conforming to ExecutionMessageNotificationRest.A stub implementing
ExecutionMessageCallback and sending server-sent events.This callback requires communication in both directions.
Executor-related utility methods.An extension to
Connection in order to provide further functionality
to assist in writing vendor-independent database accessing code.A
RereadableContent based on a file.This class implements the cleanup without referring to the
RereadableContent it
cleans up.An event that is produced to indicate the presence of a file or a sub-directory.
An event handler for file events, that stores data from an occurred file
event as output parameter in the data context of the corresponding activity.
A file event source that takes its configuration from an activity
configuration provided from a process step.
An event for files, that is, an event is produced and sent as soon as a file
(or a directory) is created or stored in a specific folder.
A source for events based on files in a specific folder (configured).
A file filter applying the configured restrictions for the file event source to the searched
directory.
An event handler for marking files from file events.
Creates and manages connections to a FILERO server.
This class provides value conversion from
FILERO data types to
ADEPT data types.
Simple filename filter based on file suffix.
Utility class containing file-related helper methods, mostly concerning file
names and paths.
The compatibility of the file name.
A simple object that wraps a file, that is, file content and meta information.
This class provides the additional meta data for a
FileUDT without the file
content.A
FileUDTValue extends a UDTValue by file
support.Represents a file by its name as well as an optional charset which is used
to decode the bytes read from the file.
A
Filter can be used to restrict the result list returned by
ModelExplorer.getEntities(de.aristaflow.adept2.base.sessionmanagement.SessionToken, de.aristaflow.adept2.model.orgmodel.EntityType, Filter, boolean, String...).Super interface for all filter classes.
This class serves as common interface for the Java classes.
A simple container class for a selection/condition, consisting of an
attribute name, a comparison operator and a value object.
A mail event source that allows for filtering mails and additionally provides
the means to get the configuration from an activity.
A mail event source that filters mails and only creates the corresponding
events if the filters apply.
A mail event source that filters mails before creating the corresponding mail
events.
A factory to create filters
A
FilterNotSupportedException indicates that a provided filter
cannot be transformed to another representation, for instance SQL.This class combines several parameters to one (POST) parameter.
Data for the finish with default values measure.
This class restricts filtering to atomic attribute selections and to 4 specific types and
comparing to
null.These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.This class deserialises to the appropriate comparison used for OM attributes.
These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.A generic but sophisticated implementation of
ObjectPool.This interfaces somewhat extends
AuthMethod but these authentication
methods here are supported by the global security manager.The global configuration manages the system wide configuration of executable components and
applications.
Interface for late resolution of global URIs.
The invocation target for global URIs resolving global URIs to local URIs and
providing the corresponding invocation target.
This file provides direct access to the global properties of AristaFlow.
A
GlobalProvider allows for central management of configurations
and additional resources like icons and third party libraries.Global registry for querying PMS-wide service instances.
A cache for all information from the global registry to prevent expensive
look-ups in the global registry.
An optional service for providing the global registry URI to the
ServiceRegistry.This interface provides access to a
GlobalRegistry service.The global security manager extends the normal security manager by methods
accepting additional communication contexts that allow for
communication-related information that can be used for authentication.
The
GlobalServiceExport allows services that may not be directly
exported, for instance due to firewall restrictions, to export them
indirectly.This interface marks a
CommunicationService to need a global service export.A
GlobalTransactionManager handles transactions globally, this
can be either service-specific, spanning several services, spanning several
databases or even several database management systems.The global user configuration manages global and user-specific configurations that should apply
system-wide, e.
Implement this interface to provide your own symbols for the AristaFlow process graph
Factory for the graphical model.
An activity reference referring to a group of worklist items and therefore also a group of
activity references.
This interface provides attribute values for a grouping worklist item.
This class defines constants regarding the GUI of application components.
This interface provides access to the parent GUI of an application.
A
GUIContextUnavailableException indicates that a requested
GUI-context has not been created due to an internal failure.The GUI manager handles client-specific GUI-issues, for instance, providing a
suitable GUI context for applications.
A disposable class to facilitate the calculation of hash codes, i.e.
This class controls the heartbeats of a cluster node, that is , the heartbeat for the database
and the heartbeat for the communication.
HTMLContext provides the means to create an HTML-document as
user-interface for an executed component.An
Attachment represents either binary data or a (text) file uploaded to the
HTTP-service.This class ignores implements an
Attachment that ignores closing.The
HTTPReply wraps the data sent as GET or POST to the web server.A HTTP-response to be sent to the HTTP-client.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
MediaType and MediaTypes instead.HTML-activities are provided a single HTTP-service which accepts data sent
back to an activity and assigns it to a registered activity.
A
HTTPService provides the means to register and deregister
handlers for replies for an activity sent via HTTP.Tool methods for simplifying life with HTTP.
An icon descriptor is used as a reference to the icon in the repository and
to store additional data, like a revision and support types.
Simple class for a dimension, that is a width and a height in pixel used
for icons.
This interface provides the means for managing icons and
IconDescriptors which includes retrieval, creation, updating and
managing the states of IconDescriptorss.This interface provides icons (images in PNG-format) at runtime to the
appropriate clients for displaying specific icons for process steps.
The identifier is used to uniquely describe the usage of a data type, e.g.
This interface provides the means for managing
Identifiers which includes retrieval,
creation, updating and managing the states of Identifiers.
The ID Execution Environment is used for executing application which though
they implement the
The activity URI is used for retrieving the class to be executed by this environment.
ExecutableComponent interface don't have an
ADEPT2-Registry conform constructor.The activity URI is used for retrieving the class to be executed by this environment.
This class wraps an embedded template, so that
Template.getID()
returns the ID of the embedded process instead of the ID the original
template had.An
IllegalConfigurationDescriptionException is thrown if there's an
inherent error in the ConfigurationDescription of a component.This class provides the means to allow serialisation frameworks to (de-)serialise exceptions with
all required information properly.
Different types for images.
IncClientWorklistsWebService<I extends InitialIncClientWorklistData,N extends IncClientWorklistData>
This specialisation of
IncWorklistsWebService is required to allow for the additional
attributes in InitialIncClientWorklistData and IncClientWorklistData taken over
from the corresponding client worklist.A specific exception indicating that a
GUIContext cannot be converted to an ILM
compatible one.This is an incomplete context for an execution session which is not running (but selected).
This interface extends the normal worklist by the means for incrementally retrieving worklist
items.
This class extends the normal worklist update by the means to retrieve the update information
incrementally which allows for smaller data transfers.
Parent class for all following (non-incremental) worklist data.
IncWorklistHandler<WJ extends WorklistItem,WI extends WorklistItem,I extends InitialIncWorklistData<WI>,N extends IncWorklistData<WI>>
This class handles incremental worklists by assigning IDs to them and mapping these IDs to the
respective incremental worklist.
IncWorklistRest<WI extends WorklistItem,N extends IncWorklistData<WI>,IRD extends InitialIncWorklistData<WI>,ID extends InitialIncWorklistData<WI>>
IncWorklistsWebService<WJ extends WorklistItem,WI extends WorklistItem,I extends InitialIncWorklistData<WI>,N extends IncWorklistData<WI>>
This class handles incremental worklist updates by assigning IDs to them and mapping these IDs to
the respective incremental worklist update.
An
IndexedAccessDataContainer extends the read-only access to
input parameter from InputDataContainer by indexed access to input
parameter as well as output parameters.This interface defines the individual settings that a user may have per
client worklist item (which also clearly associates it with a single
worklist,
IndividualWorklistItemSettings.getWorklistID()).Represents a process graph induced by a given set of nodes.
An
InheritanceConflictException indicates that a development
version of an activity model entity to be released conflicts with other
entities in the activity model.This interface extends the
InheritedConfiguration by the means
to retrieve configuration values from input parameters and process
configurations.This interface represents a collection that supports inheritance.
This interface resembles a
ChangeableConfiguration by the means
for inheritance.This interface resembles a
ChangeableConfigurationDescription
but extends it by the means for inheritance.This class needs to be duplicated since a sibling class uses the REST-specific
WorklistUpdateConfiguration.This class needs to be duplicated since it uses the REST-specific
WorklistUpdateConfiguration.Parent class for all initial incremental worklist data.
This class needs to be duplicated since a subclass uses the REST-specific
WorklistUpdateConfiguration.This class is similar to
AbstractADEPT2Service.Parent class for all initial remote iterator data.
An init tab entry.
A factory for creating entries for the init tab manager.
Service which executes processes on system boot, shutdown and during
runtime.
The type of an init tab entry.
A class to simplify the implementation of an object that should be injected
into the AristaFlow platform when bootstrapping.
This interface encapsulates the data context of an application for read-only
accessing the values of input parameters of an application.
This interface provides read access to all parameters of an application or a node.
This class just overrides the schema with a
Schema.oneOf().A comparison for
InputDataContext being nullA comparison for
InputDataContext being not nullChange operation for inserting a new node between a set of nodes which should
be executed before and a set of nodes which should be executed after the
newly inserted node.
Change operation for inserting a data edge between a node and a data element.
Change operation for insertion of a new data element.
Inserts an empty block consisting of a split, and a join node, and a single
empty branch between them.
Insert a branch between a split and its corresponding join node.
Change operation for inserting a new node.
The Instance interface is used to represent process instances.
InstanceChanging provides the means for retrieving changeable
instances and committing (or aborting) the changes afterwards.This interface provides the means to control the execution of an instance,
that is, starting, suspending, resuming, stopping and committing.
This class combines several parameters to one (POST) parameter.
The data used to register a REST callback for an
InstanceStateNotification.
The data used to register a SSE callback for an
ExecutionMessageNotification.
An instance data container extends a normal
DataContainer and
allows to conveniently set the input parameters and retrieve the output
parameters of a process instance.This data structure heavily relies on the corresponding
request returning this data.
This interface provides the means for monitoring running and completed process instances.
These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.A deserialiser for instances of
InstanceExecutionStatusComparison.An abstract class handling all comparisons with
ProcessConstants.InstanceExecutionStatus.A comparison for a data attribute being one of several specified
InstanceExecutionStatus values.A comparison for a data attribute being not one of several specified
InstanceExecutionStatus values.This class combines several parameters to one (POST) parameter.
These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.This class combines several parameters to one (POST) parameter.
This class combines several parameters to one (POST) parameter.
The InstanceHistories interface provides getters for various histories
as XML document.
This sub-interface of the process manager handles instances.
These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.A deserialiser for instances of
InstanceMigrationStatusComparison.An abstract class handling all comparisons with
ProcessConstants.InstanceMigrationStatus.A comparison for a data attribute being one of several specified
InstanceMigrationStatus values.A comparison for a data attribute being not one of several specified
InstanceMigrationStatus values.An instance node represents an instance and provides direct access to the corresponding child
instances in the corresponding iteration.
This comparator compares
InstanceReferences by the corresponding
InstanceReference.getBaseTemplateId() and afterwards by
InstanceReference.getID().The lightweight representation of a process instance.
This comparator can be used to compare instance references used in
TreeMaps.This comparator compares
InstanceReferences by the corresponding
template IDs (by delegating to an TemplateReferenceComparator).This class combines several parameters to one (POST) parameter.
This class combines several parameters to one (POST) parameter.
This class combines several parameters to one (POST) parameter.
An event handler for file events, that stores data from an occurred file
event as input parameters in the data container of an instance and starts
this instance afterwards.
An event handler for mail events, that stores data from an occurred mail
event as input parameters in the data container of an instance and starts
this instance afterwards.
To allow for event handler to start process instances, an
InstanceStartEventManager provides some methods of a
TemplateManager and of
InstanceControl.This is a callback for instance states.
This class combines several parameters to one (POST) parameter.
An
InstanceStateListener provides access to an
InstanceStateNotification which is notified when there are
changes in the observed process instance.This interface is used as a callback for the events when a top-level instance
has changed its state.
A stub implementing
InstanceStateCallback and calling a REST service
conforming to InstanceStateNotificationRest.A stub implementing
InstanceStateCallback and sending server-sent events.This class wraps an
InstanceStateCallback and forwards calls to
InstanceStateNotification appropriately.The instance status interface provides access to all instance specific
status information.
These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.This class extends the plugin registry to support the retrieval of used
component instances without needing to know the used instance name at all.
This class combines several parameters to one (POST) parameter.
These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.A deserialiser for instances of
InstantComparison.An abstract class handling all instant comparisons.
A comparison for a data attribute value being equal to an instant value.
A comparison for a data attribute value being greater than or equal to an instant value.
A comparison for a data attribute value being greater than an instant value.
A comparison for a data attribute value being less than or equal to an instant value.
A comparison for a data attribute value being less than an instant value.
A comparison for a data attribute value being different from an instant value.
Plug-in data for the instantiate process measure.
These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.A deserialiser for instances of
IntegerComparison.An abstract class handling all integer comparisons.
A comparison for a data attribute value being equal to an integer value.
A comparison for a data attribute value being greater than or equal to an integer value.
A comparison for a data attribute value being greater than an integer value.
A comparison for a data attribute value being less than or equal to an integer value.
A comparison for a data attribute value being less than an integer value.
A comparison for a data attribute value being different from an integer value.
A
IntegrityException indicates that the integrity of public or
private key or a signature cannot be established.Thrown, if an internal error happened, e.g.
The internal, server-side representation of a worklist.
This class represents worklist items internal to the worklist manager server
and allows to set various attributes.
Interface for tracking changes in properties of an internal worklist item.
Renamed to avoid naming conflicts with
java.lang.InterruptedException when used
without package.This exception will be raised if an activity (a process step) is not in the
right state to perform a desired state transition.
An
InvalidDataContainerException indicates the non-conformance of an expected data
container with the actual data container.An
InvalidDataTypeException indicates the non-conformance of
an expected data type with the actual data type.This Exception is thrown by a method if a forbidden thread tries to
execute that method.
This exception will be raised if a process instance is not in the right state
to perform a desired action.
This exception indicates, that a licence file is invalid (or not present at
all).
An
InvalidListValuedDataContainerException indicates that a
designated data container does not provide the necessary data of the right
type for indexed access.This exception indicates that a transaction should be started for an object
that has already started a transaction but the existing transaction uses
looser options that the transaction to be started.
This exception will be raised if an execution manager cannot resolve the
runtime manager URIs provided by an
EBPInstanceReference.Thrown, if a service refuses to handle the request, because
it is e.g.
This exception indicates that a service is being used in a wrong way.
This exception will be raised if a process template is not in the right state
to perform a desired method.
An
InvalidDataTypeException for incompatible user-defined data
types.This exception will be raised if a worklist item is not in the right state to perform a desired
state transition, for instance, a worklist item may only be delegated in the states
AVAILABLE, ASSIGNED and SUSPENDED.The invocation delegate which is called by the
InvocationHandler for processing API calls
remotely.This InvocationHandler handles invocations to a ADEPT2 service through the
API-Interface designated by the type parameter
T in a
distributed environment.This interface provides the means for late binding of connections.
A class encapsulating all objects required for invocation handling of
global URIs and therefore late binding of connections.
Represents a reference to an input parameter and/or an output parameter.
Parser for strings containing IO parameter references.
Facilitates the process of parameterised strings and replace the parameter
references with values.
A class providing several IO-related tool methods.
This class wraps an
AutoCloseable and logs the exception from
closing.This class wraps an
AutoCloseable and wraps the exception from
closing in a RuntimeException if necessary.This Exception should be thrown by a method if the component does not support
it.
Deprecated.
This interface is subject of change and must not be used yet except for testing
purpose.
This class combines several parameters to one (POST) parameter.
This class combines several parameters to one (POST) parameter.
An instance of this class represents a certain version of a Java VM.
Represents a JDBC data source.
Contains helper methods that are intended to reduce the usual clutter in
JDBC-related code, make it more readable and safer.
A User Defined Type for JSON data.
This interface handles worklists that keep items for observation more or less independent from
their state.
This class handles problems with API changes of the
RemoteIterator API, that is
RemoteIterator.drop() being replaced by RemoteIterator.close().This class contains editions for a licence as well as the features that can be licensed (and are
not part of the
Basic Edition.Licence information.
Deprecated, for removal: This API element is subject to removal in a future version.
For serialisation compatibility with pre-17.0.0.
The licence manager provides the licence information for all services and
clients of the corresponding server.
This exception indicates, that a licence violation occurred when trying to
start a service checking the licence.
The
LightWeightProcess (LWP) is used as a stand-in for
sub-processes.The
LightWeightProcessInstance is an instance of
LightWeightProcessA pipeline executor that has an upper limit for the amount of pipelines.
This class represents a list-structure for values of any
ProcessConstants.AdeptDataType.The serialisation of an inner UDT value.
This interface provides the means for an
ActivityStateListener as simple service
that forwards all incoming activity state notifications to the locally registered
ActivityStateNotifcations.A comparator that can be used to compare locales.
Provides
Locale-specific utility methods.This interface provides the means for an
ExecutionMessageListener as simple service
that forwards all incoming execution messages to the locally registered
ExecutionMessageNotifications.This interface provides the means for an
InstanceStateListener as simple service
that forwards all incoming instance state notifications to the locally registered
InstanceStateNotifcations.Factory related to the localisation of process model objects.
Plug-in data interface for options concerning the localisation of
Transparently resolves translations of localised model objects.
Tool methods for localising log and check report messages.
This class represents a map-structure providing localisation for values of
any
ProcessConstants.AdeptDataType.Identifies a localisable (translatable) return value.
A
ChangeReport providing localisation like a LocalisedCheckReport.A check report extension providing localised messages.
A report entry extension providing localised messages.
This interface allows implementors to provide a (string) representation which is localised.
Implementation to provide a collection of
LocalisedStrings.This interface provides access to a
Locale that is used for localisation.The local service registry extends the
InstanceToInstanceRegistry to support service components.Checks the configuration of the
ServiceRegistry.ServiceExportInformation encapsulates the data which is
needed for exporting a service, which is:
the services for exporting a service (ADEPT2ServiceExport),
the URIs under which the service is exported and which correspond
based on the position in the array to the export service,
whether the service is to be published at the global registry.This interface is used for starting services which requires a start routine
(
Callable.call()) and the service name (LocalServiceRegistry.ServiceStarter.getServiceName()) for
logging purpose.A
LockCountManager provides the means to manage reentrant
locks based on objects by counting lock acquisitions.A
LockException indicates that an object can not be locked or
unlocked due to being locked (by the wrong object).This event extends
FileEvent by additional information to the corresponding lock
file.An event for files and their lock files, that is, an event is produced and
sent as soon as a file (or a directory) is created or stored in a specific
folder.
This interface notifies about the state of
ReentrantLocks.The common superinterface for all specialised logs.
This interface represents an entry in a
Log and provides getters and
setters for each of the supported
data types.As the name implies,
LogEntrySet represents a set or list of log
entries.This class initialises and configures console and file loggers (handler) for
the central logging, that is logging based on class names.
A filter for log records only allowing log records having a specific logger
name prefix and at least a specific level.
Provides commonly used functionality for logging.
Constants for usage by the AristaFlow debug logging.
A future that wraps another future and logs all occurred exceptions and the
result for information purpose if no one was interested in it.
This clean-up task logs the result of a future which no one retrieved.
A scheduled future that wraps another future and logs all occurred exceptions
and the result for information purpose if no one was interested in it.
This class creates logging futures when scheduling.
A log manager is a service to record (i.e.
A
LogService provides logging for an ADEPT2Service
with enhanced capabilities.Simple formatter which is used for
long values in the
plug-in data, which consumes a date value.These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.A deserialiser for instances of
LongComparison.An abstract class handling all long comparisons.
A comparison for a data attribute value being equal to a long value.
A comparison for a data attribute value being greater than or equal to a long value.
A comparison for a data attribute value being greater than a long value.
A comparison for a data attribute value being less than or equal to a long value.
A comparison for a data attribute value being less than a long value.
A comparison for a data attribute value being different from a long value.
An activity reference to an ADEPT2 lightweight-process represented by a node
of a process instance.
Constants used for mails.
An event that is produced to indicate the presence of a mail.
An event handler for mail events, that stores data from an occurred mail
event as output parameter in the data context of the corresponding activity.
A mail event source that takes its configuration from an activity
configuration provided from a process step.
An event for mails, that is, an event is produced and sent as soon as a mail
is stored to a specific folder.
A source for events based on mails in a specific folder (usually the INBOX).
An event handler for setting flags and/or moving messages from mail events.
Plug-in data for the mail notification escalation measure.
This class combines several parameters to one (POST) parameter.
Determines how the addressees are resolved for an item.
Fields which can be replaced by
The mail service provides the means to send mails including attachments.
The mail service provides the means to send mails including attachments and
allows for implementations to do arbitrary things like using the log manager
or executing processes additionally to sending mails.
An event source causing an event based on the presence of a mail.
Various tool methods for processing mails and handling mail events.
A managed callable statement overrides an
ExtendedCallableStatement by returning the
managed JDBC-classes where appropriate.Managed database meta data overrides
DatabaseMetaData by
returning the managed JDBC-classes where appropriate.A managed extended connection extends an
ExtendedConnection by
the means to handle remote iterator.A managed prepared statement overrides an
ExtendedPreparedStatement by returning the
managed JDBC-classes where appropriate.A managed result set extends a
ResultSet by the means to handle
remote iterator.A managed statement overrides a
Statement by returning the
managed JDBC-classes where appropriate.A
MandatoryParameterValueNotSetException indicates that a
mandatory output parameter has not been provided a value.This interface extends the communication service by the means to add a host name mapping
dynamically.
An event handler for file events, that marks the files (rename, move) and afterwards stores data
from an occurred file event as input parameters in the data container of an instance and starts
this instance afterwards.
Tool class providing methods for retrieving the media type of a specific (file) name or content
(
InputStream or byte[]).A
Detector which replaces deprecated media types
returned by Tika.A remote iterator based on a list of elements that are completely in memory.
A
RereadableContent based on memory data.This class implements the cleanup (nulling the byte array) without referring to the
RereadableContent it cleans up.A
MemoryResultSet resembles a ResultSet in a
very simple way.An event that is produced to indicate the presence of specific data in a
JDBC-database or similar.
An event for result sets, that is, an event is produced and sent as soon as a
specific statement yields a non-empty (or empty if desired) result set.
A simple implementation for a
MemoryResultSet.The clean-up task for closing the
Closeable values.An event source causing an event based on the result of a select statement.
This class merges several activity configurations to one configuration.
This class merges several configurations to one configuration.
This class extends the
LocalExecutionMessageNotifier by the means to notify listeners
without a reply and get this reply via another route.Interface for providing messages (and other strings) for a specific locale.
This class provides and caches resource bundles (stemming from properties) encapsulated in
Messages for various locales.Simple class allowing for treating methods and constructors similar.
The
ModelChangeOperations provide methods to alter the
OrgModel (add and delete attributes), add/delete entities, change their
attributes and add/delete relations between entities.The
ModelExplorer provides information about the OrgModel like which
entity types are used, which attributes they have, their data types etc.This class extends the
InstanceToInstanceRegistry to support
all model factories in ADEPT2.Helper methods for managing the model and transforming it into chunks
manageable by EditParts.
Class for localisation of constant strings in various models
(
de.aristaflow.adept2.model).Constants used by the
ModelFactoryRegistry.Allows the creation of typed views on attribute maps.
This interface provides access to classes that in turn provide type-safe
access to
PluginData.Tool class for easier handling of some stuff like localisations or
parameter references / system data consumers.
This builder replaces the standard
AsDeductionTypeDeserializer with
MultiCandidateDeducingTypeDeserialiser choosing the most generic parent class thus
relaxing the constraints required for deduction.This builder replaces the standard
AsDeductionTypeDeserializer with
MultiCandidateDeducingTypeDeserialiser choosing the most specific child class thus
relaxing the constraints required for deduction.Change operation for moving nodes.
A
TypeDeserializer deducing the (sub-)type which to use for deserialisation related to
AsDeductionTypeDeserializer.Plug-in data for the multi level escalation plug-in.
Container for the data for a single escalation level.
Multiple conjunctively filters applied to collections instead of simple attributes like
MultipleFilter.Multiple disjunctively combined collection filters.
Multiple conjunctively combined collection filters.
Multiple disjunctively combined filters.
Multiple conjunctively combined filters.
Represents a filter that logically combines the Boolean outputs of multiple
filters by an operator such as AND or OR.
The
MultiplexingClientService is a broker for service requests
from various web clients.This handler provides the means to handle
NameCallback and AppNameCallback.A filter for log records only allowing log records with one or several specific name prefixes and
at least a specific level.
A simple callback handler providing a name to the appropriate callbacks
(
NameCallback) if required.This handler provides the means to handle
NameCallback,
OrgPositionChoiceCallback, AppNameCallback, and
UserSessionIDCallback.A simple callback handler providing a name and a password to the appropriate
callbacks (
NameCallback and PasswordCallback) if
required.This interface provides the means to get and transform service names from
hierarchical to type and instance name and vice versa.
This class provides rules for XML names which allows to check for whether a
CharSequence is a valid XML name.A resolver looking up the namespace in a map of provided namespaces and in a specific
Document.A wrapping callback handler storing the name provided to a
NameCallback.A wrapping logger that uses the name filters registered for any handlers of a
wrapped logger and its parent loggers and uses these filters when determining
NameWrappingLogger.isLoggable(Level).An instance of
NavFunction represents the definition of a
navigational function that may appear in OrgPolicies, i.e.Represents the instance of a function, i.e.
This class provides tooling related to networking, especially handling of IP addresses with
trailing subnet masks in CIDR notation.
The Node interface is used to represent the nodes of the control flow.
This comparator can be used to compare Nodes.
A default implementation of
DependencyProvider that should be
sufficient for most cases.These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.Class which allows for work on execution orders between nodes.
This represents the relation between two nodes.
These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.A deserialiser for instances of
NodeStateComparison.An abstract class handling all comparisons with
ProcessConstants.NodeState.A comparison for a data attribute being one of several specified
NodeState values.A comparison for a data attribute being not one of several specified
NodeState
values.These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.Implementation to provide constant object (usually string)representations which do not need to be
localised as
LocalisedString.NonTransformingRemoteIteratorWebService<WI,I extends InitialRemoteIteratorData<WI>,N extends RemoteIteratorData<WI>>
This remote iterator web service simplifies
RemoteIteratorWebService by avoiding the
transformation.This exception type may be thrown by methods to indicate that the passed
parameter(s)/parameterID(s) to work on do not exist in the given context.
Plug-in data for
Note / task data.
States for tasks.
The
NullArgumentException is a special
IllegalArgumentException that must be thrown when a parameter
is null and it is not allowed to be.TODO EBPINSTANCE: Adapt the documentation according to the replacement of
Activity by
ActivityInstance
The null execution just signals an application closed to the runtime
environment and returns.Represents a filter that compares an attribute of non-primitive type
(
Class.isPrimitive()) with null (or not null).This GUI context is provided if no GUI context is requested by the
application componenent or if there is no GUI possible that can be provided
to an application component.
The null GUI manager returns the
NullGUIContext as the GUIContext and
may be used for GUI-less clients.Dummy HTTP service for head-less clients.
A special reply message indicating that no explicit reply is expected but
null.A plug-in interface for
MailEventSource as a customisable way to provide an OAuth2 access
token that can be used to access a mailbox via the "XOAUTH2"
authentication mechanism.A class for counting objects thread-safe.
Class with convenience methods for an
ObjectLockManager using
the current thread for locking and using object equality for the locked
objects.This interface defines and allows to control the life cycle of a pooled object.
A manager for locking objects with reentrant locks whereas the locks are
itself object specific.
This one work executor simply uses the normal runtime data that is, it allows for one piece of
work for each object pending before and after a flush.
A runnable for having exactly one runnable per object.
This is the basic interface for an object pool, a facility to support easy
reuse of objects and resources; especially those that are expensive to create
and/or have limited availability.
The intended purpose of this interface is to provide basic information that
concerns how the pool is used by borrowers and which is otherwise hard to
come by.
This interface represents a runnable that is identified via a specific object.
A callable that executes a specific task exclusively without any object work running
concurrently.
Tool methods for objects, similar to
Objects.This interface is a companion to
ObjectLifeCycle, defining and
allowing to control the life cycle of an object wrapper.Attribute meta data for an OM extensions only containing the attributes with a mapping for a
specific OM extension and the attributes specific to this OM extension.
A meta data element for an OM extension allowing wrapping the name and only providing the
attribute mappings for one OM extension.
This class provides attribute/column names for OM extensions, e. g.
This class represents an
Entity for a specific OM extension.This
OneWorkWorklistHandler creates event sources for worklist items with activities
that wait for an event.A filter to replace variables within the attributes of the OpenAPI.
The reader for creating the OpenAPI model.
The
Operation represents a callable part of an
ExecutableComponent.This interface provides the means for managing
Operations which includes retrieval,
creation, updating and managing the states of Operations.The lightweight representation of an
Operation for usage in the
activity repository.A manager for (optimistically) locking objects with reentrant locks whereas
the locks are itself object specific.
When unlocking an object for the last time (count is 0), this will remove
the corresponding locked object from the map containing all locked objects.
Globals constants required in the AristaFlow Org Model.
An
OrgModelException can be thrown for various reasons by
ModelExplorer and ModelChangeOperations, ranging from trying
to use deactivated entity types to trying to access attributes that don't
exist.This interface provides the means to extend the organisational model which are reading and
writing attributes of a uniquely identified entity, authentication of a user as well as
synchronisation of (parts of) the organisational model.
The
OrgModelInitialiser provides the means to initialise the OrgModel during the startup
of the OrgModelManager.This is the central interface of the OrgModelManager service with the
following sub-components:
OrgModelInitialiser: Can initialize and adpat the org model during startup.This interfaces wraps the org model manager and provides just the methods needed for OM
extensions and the synchronisation of external org models with the AristaFlow org model.
An attribute for the OM provided by an
OrgModelExtension.This class contains static methods to provide some common functionality in
the context of the Org Model and org policies / staff assignment rules.
The
OrgModelManager provides facilities to syntactically parse and
verify OrgPolicies and return them as an easy to use object structure.An instance of
OrgPolicyReport is used to store entries for problems
and other issues encountered while parsing an OrgPolicy.An
OrgPolicyReport.Entry is what the name implies: an entry in a
OrgPolicyReport and contains data about one error, warning or other
information about the parsed OrgPolicy.Represents a range within an OrgPolicy.
The
ResultType is used for the overall resultOrg policy script handlers are responsible for evaluating script org
policies.
A stub implementing
OrgPolicyScriptHandler and calling a REST service conforming to
OrgPolicyScriptHandlerRest.A service allowing to register
OrgPolicyScriptHandler dynamically at runtime at the
org model manager.A
SystemDataFormatter
that knows how to format parameter values for org.The data used to register a callback for an
OrgPolicyScriptHandler.
A callback to choose the organisational position/the qualified agent when
authenticating to allow for a combined authentication instead of the normal
2-part authentication.
A socket factory for SSL sockets that accept all SSL certificates, i.e.
An
URLClassLoader that tries to retrieve resources within the
own classpaths first before asking the parent classloader.Class representing a pair of two objects.
The parameter interface describes the common parameter information of the
various data models.
Generic operations do not have a fixed interface but may allow to change
their input and output parameters.
This comparator can be used to compare (process) parameters.
This data context provides access to input parameters as well as the
parameter names and their types.
This exception is used for problems with request parameters.
This exception is used for a missing request parameter.
Represents a reference to a parameter in the strings returned by
SystemDataConsumers.Parser for strings containing parameter references.
Facilitates the process of parameterised strings and replace the parameter
references with values.
This utility class provides methods to deal with
ParameterRef
parameter references in all kinds of strings, used in different places like
SystemDataConsumer-annotated
methods.Generic operations allow to add parameters.
This exception is used for request parameters having the wrong type.
Various tool methods for processing events.
A parent-to-child connection joins the parent attribute of a hierarchical
table with a corresponding child attribute via the designated operator.
A simple callback handler providing a password to the appropriate callback
(
PasswordCallback) if required.A
PasswordPolicyException is thrown when setting or changing a
password and the new password doesn't comply to certain restrictions (like
minimum length).This class represents the strength of a password based on an analysis of a provided (new)
password.
The quality of the password of an agent.
The
PasswordStrengthEstimator provides the means to estimate the strength of a
password thus improving security.This class provides several helper methods for assuring password quality.
An OrgPolicy must always result in a list of agents.
A manager for (pessimistically) locking objects with reentrant locks whereas
the locks are itself object specific.
A runnable that executes all runnables that are present for a specific
object.
This interface represents placeholder for data values.
Abstract class providing the basic methods for a
PlaceholderValue, for instance
PlaceholderValue.AbstractPlaceholderValue.equals(Object) and PlaceholderValue.AbstractPlaceholderValue.hashCode().This class implements the
PlaceholderValue for a value of
ProcessConstants.AdeptDataType.STRING.This class implements the
PlaceholderValue for a value of
ProcessConstants.AdeptDataType.USERDEFINED type.This exception is used for exceptional responses containing content of
text type.Storage of data which is specific for a plug-in.
Data container for storing plug-in-specific data-values in model entities.
While the
AbstractRegistry does not allow to be directly
accessed, this class supports the retrieval of specific component instances
as well as default component instances.Checks that all declared plugin instances are configured properly, that is
they have an implementation class and runtime plugins have a plugin
classpath.
This interface provides methods to deal with OrgPolicies (Bearbeiterformeln), i.e.
This
PolicyResolutionException is thrown by
PolicyResolution's methods when the provided OrgPolicy
(Bearbeiterformel) is syntactically or semantically incorrect.An event source causing an event based on the presence of a file.
A mail event source that polls for mails.
An event source that involves polling for an event.
The purpose of this class is to keep the constructor of
GenericObjectPool simple.Contains general information about the state of the object pool its objects.
This class defines the names of attributes which are always available for org model entities and
agents.
This class defines the names of meta attributes which are always available for the org model.
Data for the priority increase measure.
What to do in the escalation.
This interface provides access to the values (including null) of data
elements for clients which have process knowledge, which means, they are
accessing the data element from a specific and known node instance.
Process check service.
Enumeration for the existing check sets.
ProcessConstants defines constants that are needed in the
context of process templates and instances, for instance, data, node, and
edges types, node, edge, instance, and template states.The data element types.
The ADEPT2 block types
Properties / attributes of data edges.
The properties / attributes of data elements.
The different data mapping types
The scope for querying entities of the delta layer.
Enum for properties / attributes of Edge.
The edge states.
The edge types.
Properties / attributes of Activities and Light Weight Processes.
This enumeration defines constants that declare in which mode activities
should be executed.
The execution status of an instance.
The migration status of an instance.
Properties / attributes of instance.
Constants for using innstance types in filters.
Enum for all node properties.
The node states
The node types.
Constants for using node types in filters.
This class groups identifier for process elements.
This class holds information about the structure of identifier pathes of the process
elements identified by the constants defined in class
ProcessConstants.ProcessElementIdentifier.The buildtime state of a template specifies the modelling phase a template
is in.
Properties / attributes of template.
The usage of a template distinguishes whether it may be used only as a
subprocess and if so whether it is copied and therefore physically
integrated in the surrounding template or it is referenced.
This is a helper class to create and parse URIs identifying process elements.
Predicates for ADEPT2 graphs.
Data representing an image of a process element (a process template or a
process instance).
Service interface for getting template and instance process graphs rendered
as images.
The process manager persists the data of process instances and templates at
runtime and provides access to these objects.
This interface provides access to node and instance counts based on type, node state and instance
execution statuses to be monitored by JMX.
This class provides some useful methods for process manager logic, e.
The factory of the processmodel is used to create new objects.
The factory methods require all properties which belong directly to an object.
The factory methods require all properties which belong directly to an object.
Structural node data.
The Parameter interface describes the connectors on the executable
business process side (activity/sub-process).
These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.Helper methods which are based on the interfaces of the process model.
Constants concerning XML, e.g.
This enum is used for the different schema types.
The XMLExport class allows to export any template or instance data to an xml
file, an DOM document, a string or a byte array (containing XML code).
Helper methods for the XML export of process model classes, i.e.
Contains important functions for both, XML import and export.
This class describes a lock, e.g.
A lightweight data container for serialising process types without a
template proxy.
A lightweight data container for serialising process types without a
template proxy.
Import templates and instances from XML.
All helper methods for the XML import of process model classes, i.e.
This interface provides the context of a node (instance), i.
The process repository is used to manage and browse process templates, the
corresponding changes and process types (trees of process templates) as well
as searching of process and activity templates.
Common interface for all checks on process templates.
Tool for running multiple checks at once - on the template and any embedded
templates - returning the overall result.
The process template manager provides the means to manage process templates
the corresponding change histories (creation, retrieval, storing, purging) as
well as the lifecycle of a template.
Process types organise various process templates logically and provide the
means to manage versions of templates.
This comparator can be used to compare process types by means of the
corresponding root template proxies.
This interface provides access to the values of data elements for clients
which do not have any process knowledge.
A runnable producing an object of type
T and throwing an
exception of type E.This interface have to be implemented by objects that are interested in
providing the progress/execution state of a special task for interested
parties.
This class extends a
PropertiesConfiguration by the means for an underlying file as
well as optionally automatically saving the configuration in case of changes.The definition of a configuration property in a
ConfigurationDescription.The supported data types for
Class to store event information
Configuration exception thrown, if a required property is not
set in the configuration.
This class provides global properties that are needed for the whole AristaFlow-platform.
Interface to access details on what properties of an object have changed
since its creation or the last resetting of the change tracking.
This formats log entries similar to
SimpleFormatter except that it uses a pseudo ISO
format for the timestamp instead of a datetime format using the default locale of the JVM.This class manages a set of
ChangeListeners
for an object which are notified when properties of that object
change.This is required since OpenAPI lets Maps always have a String as key.
A
QualifiedAgent represents an agent (tuple) that has been
authenticated and provides all information the system needs for unique
identification.This comparator can be used to compare qualified agents by means of the agent
and the organisational position ID.
These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.A comparison for
QualifiedAgent being nullA comparison for
QualifiedAgent being not nullThis provides data from the server.
A source for events based on SQL statements creating result sets that are
read only and do not support updating.
The possible actions that can be taken when a
GenericObjectPool
decides that it is time to reclaim an object from a burrower, e.g.The intended task of this change operation is to reconnect an already
existent and already to a parameter connected data edge to a parameter which
is disabled or unconnected.
This exception indicates that reconnecting the worklist manager to the execution
manager failed.
A simple data class for rectangular areas and points.
Represents a reentrant read/write lock or exclusive lock based on objects
instead of threads, for instance for locking based on objects.
The
ReferencedProcess is used to reference another process
template.Various helper methods for reflection.
Interface for visiting a class hierarchy and accumulating the result.
This interface provides components and services initialised and started by
the registry framework with access to other services and components.
A
GlobalRegistryProvider retrieving a list of possible global
registry URIs from its configuration and trying to get a global registry with
this URIs.A
GlobalRegistryProvider retrieving the global registry URI from
the cluster (synchronisation) JDBC data source.A registry wrapper provides access to specific registry methods to a normal
component/service.
This enumeration list all defined relations between
EntityTypes that
are defined in [Berr05].An
ReleaseLockException indicates that the lock on an object
can not be released since the releasing object does not have the lock.This interface is for starting and resuming activities that are bound to
specific client applications which is indicated by the corresponding
GUI context ID (
GUIConstants.CLIENT_APPLICATION).This interface provides access to all necessary information of a running
client, for instance, information concerning the operating system, the logged
on agents as well as the available runtime managers.
This client service extends a worklist client service by the means to execute
activities remotely.
A
RemoteExecutionControlManager extends an
ExecutionControlManager by the means to provide a timeout for
all methods requiring an interaction with an execution session.A
RemoteGUIManager extends a normal GUI manager by the means to
create local GUI contexts based on a transferred GUI context.A simple
HTMLContext that does not create any browsers or alike
but just provides the interaction between webserver and
ExecutableComponent.A GUI manager supporting the
NullGUIContext and a
RemoteHTMLContext as the GUIContext for (nearly)
GUI-less clients with a webserver.A
RemoteIterator allows to retrieve parts of collections instead of whole
collections.Parent class for all following (non-initial) remote iterator data.
This class handles remote iterators by assigning IDs to them and mapping these IDs to the
respective handler.
RemoteIteratorWebService<WJ,WI,I extends InitialRemoteIteratorData<WI>,N extends RemoteIteratorData<WI>>
This remote iterator web service simplifies
AddDataTransformatorRemoteIteratorWebService
by avoiding the additional for the transformation.The interface provides
ProgressMonitors for
clients executing activities proprietarily not using
ExecutableComponent.The interface provides
RuntimeEnvironments for
clients executing activities proprietarily not using
ExecutableComponent.Change operation for the removal/deletion of a nodes' EBP
Call isPossible first to check if the assignment is valid, than call perform
operation to execute the change.
Change operation for removing a system parameter from a node.
Change operation for removing a system data flow.
Various options for rendering process elements as images.
This class is the base class for all reply messages used in the ADEPT system,
i.
Provides check methods whether the current JVM meets the requirements to run
the AristaFlow applications.
The
RereadableContent can be used when the content of an InputStream needs to be
processed multiple times.The
CleanupTask doing the clean-up (RereadableContent.close()) independently from the
RereadableContent.This class is an input stream that also provides the
RereadableContent it has been
created for.A
RereadableContentBuilder provides the means for creating
RereadableContent.The
CleanupTask doing the clean-up (RereadableContentBuilder.close()) independently from the
RereadableContentBuilder.Simple class providing messages from a specific resource bundle.
This class provides resource bundles for various locales which are subclasses of
ResourceBundle.This is a copy of
ResRemoteIteratorRest but with changed operation IDs.ResExprEvalRemoteIteratorRest is a copy of this class with changed operation IDs.This class just overrides the schema with a non-recursive
Resource and a non-recursive
AttributeList.This class provides resource bundles for various locales and caches them (or the corresponding
related objects).
A resource descriptor is used as a reference to an abstract (binary) resource
(for instance 3rd party libraries) in the repository and to store additional
data, like a revision and a name.
This class just overrides the schema with a non-recursive
Resource and a non-recursive
AttributeList.This interface provides the means for managing (binary) resources and
ResourceDescriptors which includes retrieval, creation, updating and managing the
states of ResourceDescriptorss.This interface provides (binary) resources at runtime to the appropriate
clients.
Enumeration of the supported types of restrictions for configuration values
(see
Property.restrictions()
for more information, e.g.This class provides the means to exchange a result between different threads.
An event that is produced to indicate the presence of specific data in a
JDBC-database.
An event for result sets, that is, an event is produced and sent as soon as a
specific statement yields a non-empty (or empty if desired) result set.
This remote iterator encapsulates a result set.
The clean-up task for closing the wrapped result set and dropping created recursion tables.
An event source causing an event based on the result of a select statement.
This runtime manager provides the means to automatically resume a suspended
activity.
A service that is able to automatically resume activities after a
designated time period receives a request for this operation via this
interface.
This class combines several parameters to one (POST) parameter.
Entities are tracked by revisions, whereas each revision is identified by a
system-wide unique count.
A
RevisionConflictException indicates that a development branch
is based on an version that is too old with respect to the latest revision.The interface for the revision management in the activity repository is
separately due to the complexity.
A
RichAgent enhances a QualifiedAgent by providing
far more information and is therefore a "user-friendly" version of
a QualifiedAgent.Deprecated.
This API defines methods by which applications can signal their termination,
respond to external control messages and manage the application state when
suspending and resuming.
This interface describes all "factory" methods used to construct objects in
the base runtimeenvironment package.
The runtime manager provides the means to control the execution of an
activity by the execution manager, the transaction manager or by controlling
the application locally via execution control manager.
The runtime service resembles a runtime manager but it is not actively
executing
ExecutableComponents but just provides the information
for execution passively.This class extends a
MultiCandidateDeducingTypeDeserialiser by the means to handle
scalar values and
arrays.This scheduled one work executor handles the usual pending work for before and after a flush.
This class extends
RuntimeData by a runnable which will be delayed and the
corresponding future stemming from scheduling the runnable in the scheduling executor.A runnable that will enqueue a delayed object runnable as soon as the delay elapsed.
Plug-in data for scheduling process steps.
A
Schema defines an ordered set of columns and is used in the
log manager to
describe the structure of
logs
complex columns and
Log.read(de.aristaflow.adept2.base.sessionmanagement.SessionToken, String, String, int, String...)Provides easy access to the components of a script declaration.
An exception indicating that there is a problem with the environment of a
script, that are problems with input or output parameter or the configuration
of environment variables.
An exception indicating that there is a problem with the evaluation of a
script.
An exception indicating that there is a problem with a script.
Common functionality to detect and parse script declarations etc.
Interface for providing session factories for system components.
A
SecurityTokenIntegrityException indicates that a security
token has no integrity.Tool class for creating
java.security related objects, ie.This class selects the browser based on various criteria.
The event that is signaled to a listener when an executable business process
has been selected (e.g.
An object for signalling the change in a graphical selection of a model
element, for instance selecting a worklist item representing an executable
business process.
This interface must be implemented by objects that are interested in being
informed about a selection change in graphical user interfaces.
Attachments for sending via the
MailService.This class wraps a
SerialisableAttachment in a DataSource to allow for
easily attaching to messages created with Commons Mail.A interface unifying
Comparator and Serializable.Serialisable Apache Commons Configuration.
A data context that is serialisable and therefore provides access to all
managed parameters without having to know their names or their types.
A pair that is serialisable.
A triple that is serialisable.
This is a simple wrapper for an
InputStream as
ServerStream which allows for keeping an
InputStream locally and use it remotely.A server stream establishes a connection between a client and a server and
allows the client to access the stream via the AristaFlow-communication
framework.
This class handles server input streams as iterators and converts their content to
String.This interface resembles a
UDTValue but does not provide all
data at once but as requested, that is, the value of this UDTValue will not
be provided as a whole but incrementally as requested.This interface provides components and services initialised and started by
the registry framework with access to other services and components.
Thrown if the access to the service, to the method, or to the method
concerning the provided parameters, is denied
Service specific extension to the default instance information of the
AbstractRegistry.Service meta data provides data from the corresponding communication service.
A
ServiceNotKnownException will be thrown if a service is
requested but is unknown or at least not all needed information is known
by the called registry.A service registry extends the
LocalServiceRegistry to support
export and publishing of local services as well as accessing remote services.Checks the configuration of the
ServiceRegistry.This class resembles the service state tracking of
ClientService.Listener for events that the availability of the platform within the cluster node has changed.
This interface provides methods for handling threads properly in services.
A
ServletConfigurationPropertyProvider provides the means to
retrieve global properties and the variables to be substituted from system
properties as well as the init parameter of a servlet configuration or of a
servlet context.This exception indicates that deploying or undeploying a servlet (web
application) to a servlet service has failed.
A
ServletService provides the means to publish a servlet at
runtime.A session is a session token without a token.
The session context provides the component with services and information
that is important for their execution.
This is the response to
RemoteActivityStartingWebService.getSimpleSessionContexts(de.aristaflow.ilm.base.sessionmanagement.SessionToken, java.util.Collection, de.aristaflow.adept2.model.globals.ProcessConstants.ExecutionMode, Integer)
combining an activity and the corresponding simple session context or an exceptional response
together in one object.A session factory provides the means to create session tokens, child session
tokens as well as privileged child session tokens allowing to bypass security
checks.
Represents a reentrant read/write lock or exclusive lock based on session
token.
A
LockCountManager counting session tokens with an equality based on the UUID
returned by a Function provided by subclasses.A
LockCountManager counting session tokens with an equality
based on child session IDs.A
LockCountManager considering session tokens and their subsessions (but not vice
versa!) as equal.A
LockCountManager counting session tokens with an equality based on their UUIDs
(of the corresponding top-level session token).A
LockCountManager considering session tokens and their subsessions (but not vice
versa!) as equal.The session state manager provides the means to handle internal states of
running applications.
A session token identifies a session in ADEPT2.
A
SettableDataContext allows to set the arbitrary input and output parameters as
well as the corresponding values.A
SharedPollingSource unifies the polling for several
SharingSource-instances.This interface provides information on whether a class from an
ExecutableComponent is shared between different invocations or
not.A sharing source is an event source that does not poll itself but shares
another event source that unifies several sharing sources, polls for them and
signals them separately.
A security token provides all security-relevant data.
Combines similar changes, for instance the changes refer to the same property
value.
This class provides partial information concerning a cluster node.
These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.Service interface for getting template and instance process graphs rendered
as images.
A session context that is simpler than the normal
one.
This class combines several parameters to one (POST) parameter.
Provides tools to manipulate stack traces (i.e.
Signals the beginning of a change transaction
A state specifies how an entity of the activity model (
ExecutableComponentDescription,
Operation,
ConfigurationSet and
ActivityTemplateDefinition)
may be used.These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.A deserialiser for instances of
StateChangeComparison.An abstract class handling all comparisons with
ExecutionHistory.StateChange.A comparison for a data attribute being one of several specified
StateChange
values.A comparison for a data attribute being not one of several specified
StateChange
values.Status information for synchronising the cluster nodes where only one
provides the AristaFlow server (singleton) while all others are clients of
this server.
This interface provides the means to store an
InheritedActivityConfiguration by using very simple data
structures while simultaneously providing all information needed for
inheritance and overriding.This interface provides the means to store an
ActivityModelParameter which is supported by not inheriting any
attributes from a parent parameter (in contrast to the interface
ActivityModelParameter.This interface provides the means to store an
ActivityTemplateDefinition which is supported by not inheriting
any attributes from a parent parameter (in contrast to the interface
ActivityTemplateDefinition.This interface provides the means to store a
InheritedConfiguration by using very simple data structures
while simultaneously providing all information needed for inheritance and
overriding.This interface provides the means to store a
InheritedConfigurationDescription by using very simple data
structures while simultaneously providing all information needed for
inheritance and overriding.This interface provides the means to store an
ActivityModelParameter which is supported by not inheriting any
attributes from a parent parameter (in contrast to the interface
ActivityModelParameter.This interface provides the means to store an
ExecutableComponentDescription which is supported by not
inheriting any attributes from a parent parameter (in contrast to the
interface ExecutableComponentDescription.This interface provides the means to store an
Operation which is
supported by not inheriting any attributes from a parent parameter (in
contrast to the interface Operation.This interface provides the means to store
ParameterTemplate which is supported by not inheriting any
attributes from a parent parameter template (in contrast to the interface
ParameterTemplate.InputStream and OutputStream related tool methods.These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.A deserialiser for instances of
StringComparison.An abstract class handling all string comparisons.
A comparison for a data attribute value being equal to a string value.
A comparison for a data attribute value being equal ignoring case to a string value.
A comparison for a data attribute value being like a string value (possibly with the usual
wildcards
? and *) ignoring case.A comparison for a data attribute value being different ignoring case from a string value.
A comparison for a data attribute value being different from some similar string value
(possibly with the usual wildcards
? and *) ignoring case.A comparison for a data attribute value being like a string value (possibly with the usual
wildcards
? and *).A comparison for a data attribute value being different from a string value.
A comparison for a string data attribute value matching a regular expression.
/** A comparison for a data attribute value being different from some similar string value
(possibly with the usual wildcards
? and *).This class provides some useful string-related tool methods.
A comparator for objects which are mapped and compared by appropriate strings.
A comparator for strings including
null.These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.A data edge with structural information.
This comparator can be used to compare StructuredDataEdges.
An edge with structural information.
This comparator can be used to compare StructuredEdges.
An
SubInstanceStateListener provides access to an
SubInstanceStateNotification which is notified when there are
changes in the observed subprocess instance.This interface is used as a callback for the events when a subprocess instance
has changed its state.
Messages class wrapping another
Messages and prepending all requested keys with the same
prefix.This interface must be implemented by a manager that is responsible for
executing sub processes.
The intended task of this change operation is to swap the already existent
logical mapping between two data elements and their parameters of an EBP.
This class is an
OutputStream that stores to memory or file (depending on the data
size).The
SWTBrowserContext provides a SWTContext and
allows to deploy content for downloading either as local file or as download
from a webservice.This interface defines a graphical context that could be used by application
components to integrate them into a SWT-GUI on a workflow-client.
This class makes it possible to integrate an application component with an
AWT-GUI into a SWT environment.
This
GUIContext encapsulates the HTML of this context in
a browser widget in SWT.The clean-up task for closing the browser.
This
GUIContext provides a browser widget in SWT for a specific
URL based on a parent context.The clean-up task for closing the browser.
This interface extends
ActivityStarting with the synchronous
start or resuming of activities.This interface provides the means for synchronising external org models via the corresponding
org model extensions asynchronously.
Defines constants related to data elements (especially names of pre-defined UDTs) and system
data (especially
SystemDataProducer).This annotation marks a method of the processmodel (with no arguments
and return type
String) to be able to read a system data element
via a node parameter.Interface for classes that know how to properly format the values when
replacing the parameter references in a specific
SystemDataConsumer.The
SystemDataFormatterFactory creates system data formatter
instances for requested formatter types.This enumeration represents all process model methods that can produce
system data, that is data which can be used normally in the data flow of a
process.
This utility class provides methods to deal with
parameter references in the strings returned by
SystemDataConsumer
annotated methods.This abstract system execution environment extends the abstract execution
environment by a registry for accessing the system directly.
Manages a list of all registered system-specified
Identifiers.A
SystemPropertyProvider provides the means to retrieve global
properties and the variables to be substituted directly from
system properties of the JVM.This class creates and drops tables for a
DatabaseConfiguration.Enumeration class that is used to indicate the different states a component
can be in during runtime.
The Template interface represents process templates.
All string values returned by Template or one of the objects belonging to the template may return
All string values returned by Template or one of the objects belonging to the template may return
null instead of ''.TODO Methods may change - document and implement later.
These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.This sub-interface of the process manager handles all runtime issues of
process templates.
A template can be of different kind: normal (top-level or referenced
subprocess), embedded (as subprocess), specific for one instance (modified
template), an embedded template that is specific to one instance (but
itself unmodified) or an embedded and modified template.
A template node represents a template and provides direct access to the corresponding child
templates.
The lightweight representation of a process template for usage in the process
repository.
This comparator can be used to compare
TemplateProxys.The lightweight representation of a process template.
This comparator can be used to compare
TemplateReferences.This comparator compares
TemplateReferences by the corresponding
template IDs.The TemplateStatus provides access to the state of a template.
This interface is used as a callback to retrieve template status objects for
TemplateReferences (and also InstanceReferences)
from the corresponding storage layers.This class combines several parameters to one (POST) parameter.
This class distinguishes the several termination states of an activity as an
extension to the states of the component of an activity.
An enumeration for the state of an activity after its termination.
Simple shutdown monitor, which allows for watching
This class provides a reentrant read/write-lock based on threads.
Thread-related tool methods.
This interface encapsulates the creation of a new throwable based on an occurred throwable.
This class provides tool methods for handling
Throwable.This class provides the means to incorporate local public holidays when doing
time calculations.
An activity reference for a top-level process instance.
Change operation, which allows to hide nodes in the process graph.
Change operation, which allows toggling sync-edges between nodes of parallel
branches.
A
TokenInfo stores information about one token of an OrgPolicy string
(like begin and end column within the string).A simple map-like container for
TokenInfos, filled in while parsing
an OrgPolicy.A comparator for node IDs of type
Integer determining the order of the node IDs
according to their topological ID.This exception indicates that a transaction is accessed that has already been
finished.
This exception indicates that an object tries to access a transaction but has
not started one.
A simple implementation of the transfer object for a
URLContext.This iterator wraps a remote iterator and transforms all objects before returning them using the
provided transformator.
The clean-up task for closing the wrapped
RemoteIterator.This enumeration lists the available types of transitivity a function
instance (i.e.
Facilitates the getting of setting of translatable attributes and their
translations.
Class representing three objects.
Trust manager that will trust all.
Host name verifier that verifies all.
The "POSITION FILTER op FILTER" filter
A bootstrap registry that bootstraps and shuts down in two phases.
A platform that bootstraps and shuts down in two phases.
Simple (transient) manager for the definition and execution of updates to the
database schema.
This class wraps a
JDBCDataSource and provides the means for
implicit hierarchical transactions and sharing connections.This interface allows arbitrary callers type-safe cloning of the objects
supporting it.
A
UDFException indicates that the execution of a user-defined
function (UDF) has failed.The execution of user-defined functions (UDFs) is carried out by this
interface.
A
UDFNotRegisteredException indicates that the requested
user-defined function (UDF) is not available for the designated user-defined
data type (UDT).A
SerialisableAttachment having an UDTValue as
content.This interface encapsulates the creation and deletion of user-defined data
types (UDTs) and user-defined functions (UDFs) as well as the search for the
usage of a specific UDT in the process repository (buildtime) as well as in
the data type manager (runtime).
This interface encapsulates the value of a user-defined data type (UDT).
Store all UI Settings that can change at runtime.
Represents a filter that applies a unary operator (for example the NOT operator)
to the result of a sub-filter.
This handler provides the means to handle all used callbacks, i.
This exception indicates that a requested entity identified by some
primary key (ID, name,...) does not exist.
Exception thrown by
SystemDataFormatterFactory to indicate that no
implementation was found for the requested system data formatter type.An exception to indicate that an execution session ID is not known (any more)
by a requested service.
A pipeline executor that has a separate pipeline for each registered object
and therefore also no upper limit concerning the amount of pipelines as well
as the amount of threads.
This class is used as parameter for notifying the unloading of
ExecutableComponent classes.This class is used for unregistering a client worklist from receiving asynchronous worklist
updates or the corresponding notifications.
Exception thrown when a value can't be returned because it can't be parsed
because of parameter references, e.g.
This interface marks an object as updateable, that means, the object has
a system-wide unique ID represented as URI.
Change Operation to update the properties of a data edge.
Change Operation to update the properties of a data element.
Use this operation to update/change the mapping between the parameters of an
assigned EBP and its data elements.
Change Operation to update the properties of an executable business process.
Change Operation to update the properties of an instance.
The IUpdateManager Interface specifies a way to receive
notification when a tracked object is altered.
These constants are needed with subprocesses to signal the activation or
termination of a subprocess instance.
Enum for transaction events
Change Operation to update the properties of a node.
Change Operation to update (add/remove) the system parameters referenced by the node property.
Change Operation to update a plug in data container.
Change Operation to update the properties of a template.
Change Operation to update a user attribute.
These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.Some useful methods for
URIs.A
SerialisableAttachment providing a URL for the
content.This configuration manager extends a normal configuration manager by the means for runtime
configurations.
A
URLContext just provides an URL.
This annotation indicates that a method
may be used in a filter.
The UserAttributeContainer provides an interface for all classes using user
defined attributes.
These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.User-defined functions (UDF) represent the only way for the ADEPT2-engine to
interpret a user-defined data type (UDT).
A callback to retrieve user session IDs when using the combined
authentication instead of the normal 2-part authentication.
Deprecated, for removal: This API element is subject to removal in a future version.
The minimum Java version is Java 11, there is no need for this class any more since
all ResourceBundles are UTF-8-encoded.
These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.A deserialiser for instances of
UuidComparison.An abstract class handling all UUID comparisons.
A comparison for a data attribute value being equal to a UUID value.
A comparison for a data attribute value being different from a UUID value.
This class provides a reentrant read/write-lock based on UUIDs.
Tool class for creating and managing UUIDs.
A UUID comparator comparing UUIDs unsigned, that is a leading 7 is less
than a leading 8.
A
ValidationFailedException indicates that the validation of
written values in the data manager has failed.Variable parallelism resembles a
foreach which iterates through
all elements of a list but parallel instead of one after the other.Tool class to find and replace variables of the form
${variable}.Version exceptions are thrown if template or instance files have a format
version that is not or no longer supported.
Checks the model viewer interfaces for consistent annotations.
A dependency provider in the context of a template and a volatile node, i.e.
This enum provides constants that reflects the application's decision in the
vote phase of the 2-phase commit protocol.
This class facilitates the handling and manipulation of WebForm containers.
This class facilitates the handling and manipulation of WebForm subtables.
A simple servlet providing the web UI from a base URL.
This class combines several parameters to one return value.
An error dialogue that displays stack trace information in its details area.
A wrapper for a
MemoryResultSet providing a window for accessing the rows.Deprecated.
use
WebFormContainer instead.Deprecated.
use
WebFormSubtable instead.Contains a completed step from the execution history.
The common interface for server-side and client-side worklist.
This interface allows the administrative supervision of the worklist manager.
Constants used in the context of worklists.
The method of distributing work items used within the worklist manager.
The priority of a worklist item.
The update mode of a worklist.
The state of a worklist item.
The kind of change which happened to a worklist (per item).
A factory for common worklist filters, suitable for
WorklistUpdateConfigurations.This interface is for the communication of worklist managers with an
execution manager.
Represents a worklist item with common properties of server-side and
client-side worklists.
This interface encapsulates all data relevant for a delegation, that is,
the initiator of a delegation, whether the delegation has been due to
absence and an optional comment for the delegation.
These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.This class provides the common fields of all worklist item selections.
Some pre-defined filters for worklists.
Comparator for sorting worklist items based on the item ID.
These classes override the schema appropriately using
Schema.oneOf() and avoiding
inheritance issues with the ILM model.A deserialiser for instances of
WorklistItemStateComparison.An abstract class handling all comparisons with
WorklistConstants.WorklistItemState.A comparison for a data attribute being one of several specified
WorklistItemState
values.A comparison for a data attribute being not one of several specified
WorklistItemState values.This class encapsulates a worklist item update, that is, a worklist item and
how this needs to be adapted (added, changed or removed from the
corresponding worklist) based on a worklist update.
Worklists provide the user with the current process steps (aka.
Interface for the construction of worklist objects.
This class provides various tool methods for the worklist model.
This interface provides the notification of a worklist manager in case of
state changes in the execution manager.
A worklist revision provides the amount of changes of a worklist (worklist updates) and also the
initialisation date of the worklist.
This is required since OpenAPI lets Maps always have a String as key.
A container to communicate updates in a worklist (i.e.
The configuration of a worklist, e.g.
This is required since OpenAPI lets Maps always have a String as key.
Deprecated.
This class is only for a very special use-case.
The
WorklistUpdateManager handles the interaction between a
worklist server and a worklist client.A simple data container for all absence information for a specific agent.
A
RereadableContent based on another RereadableContent.This class is a generic exception that wraps arbitrary exceptions which are not represented as
subclasses of
IlmException.This logger wraps a normal logger and handles setting the log level
appropriately.
This interface resembles
Wrapper.This
Dynamic allows to set the servlet context to allow for wrapping servlet
contexts when adding servlets.This interface provides the means to build a template tree by allowing to add a template node as
child.
This provides data from the server.
This exception is thrown, if either the agent calling the requested operation does not match the
required one or the agent is not member of a specific SAR.
A
WrongClusterException will be thrown if a service is requested
from a specific cluster but the requested registry is in a different cluster.A
WrongExecutionManagerException indicates that the wrong
execution manager has been called.A
WrongRuntimeManagerException indicates that the wrong
runtime manager has been called.Constants concerning XML, e.g.
These methods will be used by both, the activity model and the process model.
Thrown to indicate that parsed XML data was either not well-formed or didn't
conform to a certain XML Schema.
Contains important function for both, XML import and export.
These methods will be used by both, the activity model and the process model.
This class combines several parameters to one (POST) parameter.
This class provides the basic means for a function used within XPath.
This class provides the usual system data:
{}
(xs:long)
{}
(xs:long)
{}
(xs:long)
{}
(xs:long)
{} (xs:long)
{}
(xs:long)
{} (xs:long)
{}
(xs:long)
{} (xs:dateTime)
This class handles variables that can be used in XPath expressions.
RereadableContentinstead.