All Classes and Interfaces
Class
Description
Denotes an 'activity' in the sense of BPMN 2.0: a parent class for all tasks, subprocess and callActivity.
A data association (Input or Output) between a source and a target
Abstract superclass for the common properties of all
Entity implementations.Abstract superclass for the common properties of all
Entity implementations.Abstract job entity class.
Abstract superclass for all native query types.
Abstract superclass for all operation interfaces (which are
Runnable instances),
exposing some shared helper methods and member fields to subclasses.Abstract superclass for all query types.
A Transformer is responsible of transforming an object into a different object
Abstract query class that adds methods to query for variable values.
An
ActivitiEvent related to cancel event being sent to an activity.An
ActivitiActivityCancelledEvent implementation.An
ActivitiEvent related to an activity within an execution;Implementation of an
ActivitiActivityEvent.An
ActivitiEvent related to cancel event being sent when activiti object is cancelled.Runtime exception indicating the requested class was not found or an error occurred while loading the class.
This class extends
Agenda with activiti specific operationsAn
ActivitiEvent related to a single entity.Base class for all
ActivitiEvent implementations, related to entities.Base class for all
ActivitiEvent implementations, represents an exception occurred, related to an entity.An
ActivitiEntityEvent related to a single entity.Base class for all
ActivitiEntityEvent implementations, related to entities with variables.An
ActivitiEvent related to an error being sent to an activity.Implementation of an
ActivitiErrorEvent.Describes an event that occurred in the Activiti Engine which is dispatched to external listeners, if any.
Builder class used to create
ActivitiEvent implementations.Dispatcher which allows for adding and removing
ActivitiEventListener s to the Activiti Engine as well as dispatching ActivitiEvent to all the listeners registered.Class capable of dispatching events.
Base class for all
ActivitiEvent implementations.Describes a class that listens for
ActivitiEvents dispatched by the engine.Class that allows adding and removing event listeners and dispatching events to the appropriate listeners.
Enumeration containing all possible types of
ActivitiEvents.Runtime exception that is the superclass of all Activiti exceptions.
Indicates the
ActivitiEvent also contains information about a Throwable that occurred, triggering the event.An exception indicating that an illegal argument has been supplied in an Activiti API-call, an illegal value was configured in the engine's configuration or an illegal value has been supplied or an
illegal value is used in a process-definition.
An event related to group memberships.
Implementation of
ActivitiMembershipEvent.An
ActivitiEvent related to an message being sent to an activity.An
ActivitiSignalEvent implementation.An exception indicating that the object that is required or actioned on does not exist.
Exception that is thrown when an optimistic locking occurs in the datastore caused by concurrent access of the same data entry.
An
ActivitiCancelledEvent implementation.An
ActivitiEvent related to start event being sent when activiti process
instance is started.An
ActivitiCancelledEvent implementation.Convenience for ProcessEngine and services initialization in the form of a JUnit rule.
An
ActivitiEvent that indicates a certain sequence flow has been taken.An
ActivitiEvent related to a signal being sent to an activity.An
ActivitiSignalEvent implementation.This exception is thrown when you try to claim a task that is already claimed by someone else.
Convenience for ProcessEngine and services initialization in the form of a JUnit base class.
An
ActivitiEvent related to a single variable.Implementation of
ActivitiVariableEvent.An
ActivitiVariableEvent for an update variable event.This class is used for auto-upgrade purposes.
Exception that is thrown when the Activiti engine discovers a mismatch between the database schema version and the engine version.
Factory class used by the
BpmnParser and BpmnParse to instantiate the behaviour classes.Command that adds an event-listener to the Activiti engine.
Implementation of the BPMN 2.0 ad-hoc subprocess.
An Activiti BusinessCalendar for cycle based schedules that takes into account a different daylight savings time zone than the one that the server is configured for.
Provides an interface for versioned due date resolvers.
Resolves a due date using the original Activiti due date resolver.
Resolves a due date taking into account the specified time zone.
For each API call (and thus
Command) being executed, a new agenda instance is created.Implementation of the BPMN 2.0 'assignment'
Deprecated.
this interface and its implementations are going to be removed in future iterations
Atttachments doesn't belong to the Process/Task Runtime
Deprecated.
Deprecated.
Deprecated.
Deprecated.
Base implementation of a
ActivitiEventListener, used when creating event-listeners that are part of a BPMN definition.Base event listener that can be used when implementing an
ActivitiEventListener to get notified when an entity is created, updated, deleted or if another entity-related event occurs.Callback interface to be notified of execution events like starting a process instance, ending an activity instance or taking a transition.
Transforms a
BigDecimal to a StringUtil class for manipulating bit-flag in ints.
XML
NamespaceContext containing the namespaces used by BPMN 2.0 XML documents.Helper class for implementing BPMN 2.0 activities, offering convenience methods specific to BPMN 2.0.
Methods for working with deployments.
Special exception that can be used to throw a BPMN Error from
JavaDelegates and expressions.An Interface defines a set of operations that are implemented by services external to the process.
Represents an implementation of a
BpmnInterfaceSpecific parsing of one BPMN 2.0 XML file, created by the
BpmnParser.Allows to hook into the parsing of one or more elements during the parsing of a BPMN 2.0 process.
Parser for BPMN 2.0 process models.
Marker interface to indicate the entity can be deleted in bulk.
Use this to execute a dedicated delete statement.
This class implements business calendar based on internal clock
Encapsulates the logic for transparently working with
ByteArrayEntity .MyBatis TypeHandler for
ByteArrayRef.Interface to abstract the JPA cacheable setting
Interface to express a condition whether or not a cached entity should be used in the return result of a query.
Updates caches and artifacts for a deployment, its process definitions,
and its process definition infos.
Implementation of the BPMN 2.0 call activity (limited currently to calling a subprocess and not (yet) a global task).
Send job cancelled event and delete job
This provides static methods to convert comma delimited text into a JSONArray, and to covert a JSONArray into comma delimited text.
Helper class for bpmn constructs that allow class delegation.
Constructs
ClassDelegates.Represents a structure encapsulated in a class
This interface provides full access to the clock
This interface provides clock reading functionality
helper/convenience methods for working with collections.
Configuration settings for the command interceptor chain.
A listener that can be used to be notified of lifecycle events of the
CommandContext.The command executor for internal usage.
Command executor that passes commands to the first interceptor in the chain.
Deprecated.
this interface and its implementations are going to be removed in future iterations
Comments doesn't belong to the Process/Task Runtime
Deprecated.
Deprecated.
Deprecated.
Deprecated.
Applies a list of transformers to the input object
Special operation when executing an instance of a multi-instance.
Operation that takes the current
FlowElement set on the ExecutionEntity
and executes the associated ActivityBehavior.Convert a web browser cookie specification to a JSONObject and back.
Convert a web browser cookie list string to a JSONObject and back.
Provides a parser and evaluator for unix-like cron expressions.
Defines property resolution behavior on JsonNodes.
Custom object type
Can be used to pass a custom properties
HashMap to a TransactionDependentExecutionListener
or to a TransactionDependentTaskListenerImplementation of the BPMN 2.0 'dataInput' and 'dataOutput'
Implementation of the BPMN 2.0 'dataInputRef' and 'dataOutputRef'
Suspended jobs are stored separately to increase the normal job query performance
DeadLetterJob entity, necessary for persistence.
Allows programmatic querying of
Jobs.Default implementation of the
ActivityBehaviorFactory.Default implementation, simply proceeding the call.
Default cache: keep everything in memory, unless a limit is set.
Manager class that centralises recording of all history-related operations that are originated from inside the engine.
Default implementation of the
ListenerFactory.An
ActivitiEventListener implementation which uses a classname to create a delegate ActivitiEventListener instance to use for event notification.Execution used in
JavaDelegates and ExecutionListeners.An
ActivitiEventListener implementation which resolves an expression to a delegate ActivitiEventListener instance and uses this for event notification.Class that provides helper operations for use in the
JavaDelegate,
ActivityBehavior, ExecutionListener and TaskListener
interfaces.Interceptor responsible for handling calls to 'user code'.
Provides context about the invocation of usercode and handles the actual invocation
Defines the different states of delegation that a task can be in.
Represents a deployment that is already present in the process repository.
Annotation for a test method to create and delete a deployment around a test method.
Builder for creating new deployments.
Interface for cache implementations.
Allows programmatic querying of
Deployments.Contains the possible properties that can be used in a
DeploymentQuery.Destroys a scope (for example a subprocess): this means that all child executions,
tasks, jobs, variables, etc within that scope are deleted.
Stores waypoints of a diagram edge.
Stores the position of a waypoint of a diagram edge.
Represents a diagram node.
Stores position and dimensions of a diagram node.
Command that dispatches an event.
A
ELResolver for dynamic bean propertiesService providing access to the repository of process definitions and deployments.
This operations ends an execution and follows the typical BPMN rules to continue the process (if possible).
Maintains a list of all the entities in order of dependency.
Class containing meta-data about Entity-classes.
Represents a BPMN Error definition, whereas
BpmnError represents an actual instance of an Error.This class is responsible for finding and executing error handlers for BPMN Errors.
An
ActivitiEventListener that throws a error event when an event is dispatched to it.Exposes twitter-like feeds for tasks and process instances.
An event log entry can only be inserted (and maybe deleted).
An event log entry can only be inserted (and maybe deleted).
Implementation of the BPMN 2.0 event subprocess start event.
Implementation of the BPMN 2.0 event subprocess message start event.
Manages event subscriptions for newly-deployed process definitions and their previous versions.
implementation of the Exclusive Gateway/XOR gateway/exclusive data-based gateway as defined in the BPMN specification.
A
TransactionListener that invokes an ExecutionListener.Operation that usually gets scheduled as last operation of handling a
Command.Deprecated.
multi-tenant code will be removed in future version of Activiti and Activiti Cloud
A
TransactionListener that invokes an ExecutionListener.Represent a 'path of execution' in a process instance.
Callback interface to be notified of execution events like starting a process instance, ending an activity instance or taking a transition.
Class handling invocations of ExecutionListeners
Allows programmatic querying of
Executions.Contains the possible properties that can be used in a
ExecutionQuery .Iterates over an
ExecutionTree using breadth-first searchPrints a nicely tree-looking overview of the executions.
An
AsyncExecutor that has one AsyncExecutor per tenant.An
CustomPropertiesResolver that evaluates a Expression when notified.An
ExecutionListener that evaluates a Expression when notified.Class responsible for handling Expression.getValue invocations
Baseclass responsible for handling invocations of Expressions
Central manager for all expressions.
Class responsible for handling Expression.setValue() invocations.
Represents a structure definition based on fields
An instance of
FieldBaseStructureDefinitionRepresents a field declaration in object form:
<field name='someField> <string ...
Expression that always returns the same value when
getValue is called.Superclass for all 'connectable' BPMN 2.0 process elements: tasks, gateways and events.
super class for all gateway activity implementations.
Gives access to a deployed process model, e.g., a BPMN 2.0 XML file, through a stream of bytes.
Entities that are using revisions for optimistic locking, need to implement this interface.
Represents one execution of an activity and it's stored permanent for statistics, audit and other business intelligence purposes.
Programmatic querying for
HistoricActivityInstances.Contains the possible properties which can be used in a
HistoricActivityInstanceQuery.Base class for all kinds of information that is related to either a
HistoricProcessInstance or a HistoricActivityInstance.Programmatic querying for
HistoricDetails.Contains the possible properties which can be used in a
HistoricDetailQuery.Historic counterpart of
IdentityLink that represents the current state if any runtime link.Subclass of
JPAEntityListVariableType which is cacheable, unlike the super-class.Subclass of
JPAEntityVariableType which is cacheable, unlike the super-class.A single execution of a whole process definition that is stored permanently.
Allows programmatic querying of
HistoricProcessInstances.Contains the possible properties which can be used in a
HistoricProcessInstanceQueryProperty.Represents a historic task instance (waiting, finished or deleted) that is stored permanent for statistics, audit and other business intelligence purposes.
Allows programmatic querying for
HistoricTaskInstances.List that initialises binary variable values if command-context is active.
A single process variable containing the last value when its process instance has finished.
Programmatic querying for
HistoricVariableInstances.Contains the possible properties which can be used in a
HistoricVariableInstanceQuery.Update of a process variable.
Enum that contains all possible history-levels.
Service exposing information about ongoing and past process instances.
Convert an HTTP header to a JSONObject and back.
The HTTPTokener extends the JSONTokener to provide additional methods for the parsing of HTTP headers.
An identity link is used to associate a task with a certain identity.
Contains constants for all types of identity links that can be used to involve a user or group with a certain task.
generates
IdBlocks that are used to assign ids to new objects.If the behaviour of an element in a process implements this interface, it has a 'background job' functionality.
Implementation of the Inclusive Gateway/OR gateway/inclusive data-based gateway as defined in the BPMN specification.
Implementation of the BPMN 2.0 'ioSpecification'
Implementation of the BPMN 2.0 'itemDefinition'
An instance of
ItemDefinitionImplementation of the BPMN 2.0 'itemKind'
Convenience class that should be used when a Java delegation in a BPMN 2.0 process is required (for example, to call custom business logic).
Class handling invocations of JavaDelegates
Represents one job (timer, async job, etc.).
Represents an async job: a piece of logic that needs to be executed asynchronously.
Job entity.
EntityManager responsible for the JobEntity class.Contains methods that are not tied to any specific job type (async, timer, suspended or deadletter),
but which are generally applicable or are about going from one type to another.
This exception is thrown when you try to execute a job that is not found (may be due to cancelActiviti="true" for instance)..
Allows programmatic querying of
Jobs.Contains the possible properties that can be used in a
JobQuery.The various types of
JobEntity subtypes, as enum.Variable type capable of storing a list of reference to JPA-entities.
Scans class and creates
EntityMetaData based on it.Variable type capable of storing reference to JPA-entities.
A JSONArray is an ordered sequence of values.
The JSONException is thrown by the JSON.org classes when things are amiss.
This provides static methods to convert an XML text into a JSONArray or JSONObject, and to covert a JSONArray or JSONObject into an XML text using the JsonML transform.
A JSONObject is an unordered collection of name/value pairs.
The
JSONString interface allows a toJSONString() method so that a class can change the behavior of JSONObject.toString(), JSONArray.toString(),
and JSONWriter.value(Object).JSONStringer provides a quick and convenient way of producing JSON text.
A JSONTokener takes a source string and extracts characters and tokens from it.
JSONWriter provides a quick and convenient way of producing JSON text.
We cannot perform a retry if we are called in an existing transaction.
Expression implementation backed by a JUEL
ValueExpression.ScriptEngine that used JUEL for script evaluation and compilation (JSR-223).
Factory to create
JuelScriptEngines.Factory class used by the
BpmnParser and BpmnParse to instantiate the behaviour classes for TaskListener and ExecutionListener usages.Constants and functions for MDC (Mapped Diagnostic Context) logging
Simple JSR-236 async job executor to allocate threads through
ManagedThreadFactory.Service for admin and maintenance operations on the process engine.
Implementation of the BPMN 2.0 'manual task': a task that is external to the BPMS and to which there is no reference to IT systems whatsoever.
Implementation of the BPMN 2.0 'message'
An implicit data input association between a source and a target.
An implicit data output association between a source and a target.
An instance of a
MessageDefinitionAn
ActivitiEventListener that throws a message event when an event is dispatched to it.This is a bridge resolver, making available any objects registered through
Mocks.register(java.lang.String, java.lang.Object) inside scripts supported by Activiti.Registry for mock objects.
Represents a model that is stored in the model repository.
Allows programmatic querying of
Models.Contains the possible properties that can be used in a
ModelQuery.Implementation of the multi-instance functionality as described in the BPMN 2.0 spec.
Deprecated.
multi-tenant code will be removed in future version of Activiti and Activiti Cloud
Allows querying of
Deployments via native (SQL) queriesAllows querying of
Executions via native (SQL) queriesAllows querying of
HistoricActivityInstanceQuerys via native (SQL) queriesAllows querying of
HistoricDetails via native (SQL) queriesAllows querying of
HistoricTaskInstanceQuerys via native (SQL) queriesAllows querying of
HistoricTaskInstanceQuerys via native (SQL) queriesAllows querying of
HistoricVariableInstances via native (SQL) queriesAllows querying of
Models via native (SQL) queriesAllows querying of
ProcessDefinitions via native (SQL) queriesAllows querying of
ProcessInstances via native (SQL) queriesDescribes basic methods for doing native queries
Allows querying of
Tasks via native (SQL) queriesAn abstract superclass for
Command implementations that want to verify the provided task is always active (ie.Variable-scope only used to resolve variables when NO execution is active but expression-resolving is needed.
implementation of the 'none start event': a start event that has no specific trigger but the programmatic one (processService.startProcessInstanceXXX()).
An Operation is part of an
BpmnInterface and it defines Messages that are consumed and (optionally) produced when the Operation is called.Represents an implementation of a
Operationholds the parameters of a page (partial result) for a query.
Implementation of the Parallel Gateway/AND gateway as defined in the BPMN 2.0 specification.
An intermediate representation of a DeploymentEntity which keeps track of all of the entity's
ProcessDefinitionEntities and resources, and BPMN parses, models, and processes associated
with each ProcessDefinitionEntity - all produced by parsing the deployment.
Simple implementation of the
ELContext used during parsings.Base class for the activiti test cases.
Represents a structure based on a primitive class
An instance of
PrimitiveStructureDefinitionAn object structure representing an executable process composed of activities and transitions.
Default cache: keep everything in memory, unless a limit is set.
Allows programmatic querying of
ProcessDefinitions.Contains the possible properties that can be used in a
ProcessDefinitionQuery.A utility class that hides the complexity of
ProcessDefinitionEntity and Process lookup.Provides access to all the services that expose the BPM and workflow operations.
Configuration information from which a process engine can be build.
Implementations of this class can be plugged into a
ProcessEngineConfigurationImpl.Represents information about the initialization of the process engine.
Interface describing a listener that gets notified when certain event occurs, related to the process-engine lifecycle it is attached to.
Helper for initializing and closing process engines in server environments.
Represents one execution of a
ProcessDefinition.Helper for starting new ProcessInstance.
A trail of data for a given process instance.
Allows to fetch the
ProcessInstanceHistoryLog for a process instance.Allows programmatic querying of
ProcessInstances.Contains the possible properties that can be used in a
ProcessInstanceQuery.Describes basic methods for querying.
Used to indicate the operator that should be used to comparing values in a query clause.
Describes a property that can be used in a Query.
Represents a variable value used in queries.
A receive task is a wait state that waits for the receival of some message.
Command that removes an event-listener to the Activiti engine.
Service providing access to the repository of process definitions and deployments.
Runnable that checks the
Job entities periodically for 'expired' jobs.Static methods for working with BPMN and image resource names.
Intercepts
ActivitiOptimisticLockingException and tries to run the same command again.activity implementation of the BPMN 2.0 script task.
ActivityBehavior used when 'delegateExpression' is used for a serviceTask.ActivityBehavior that evaluates an expression when executed.
Command that changes the process definition version of an existing process instance.Command that changes the business key of an existing process instance.Multi tenant
AsyncExecutor.Represents a bpmn signal definition
An
ActivitiEventListener that throws a signal event when an event is dispatched to it.A simple data input association between a source and a target with assignments
Represents a simple in memory structure
Interface to express a condition whether or not one specific cached entity should be used in the return result of a query.
Transforms a
String to a BigDecimalIdGenerator implementation based on the current time and the ethernet address of the machine it is running on.Represents a definition of a structure used to exchange information
An instance of
StructureDefinitionImplementation of the BPMN 2.0 subprocess (formally known as 'embedded' subprocess): a subprocess defined within another process definition.
behavior for activities that delegate to a complete separate execution of a process definition.
Suspended jobs are stored separately to increase the normal job query performance
TimerJob entity, necessary for persistence.
Allows programmatic querying of
Jobs.Contains a predefined set of states for process definitions and process instances
Deprecated.
due integrations will be delegated to extenal components and the use of the Connector interface
Deprecated.
Structure containing meta data (column names, column types, etc.) about a certain database table.
Data structure used for retrieving database table content.
Allows programmatic querying of
TablePages.Operation that leaves the
FlowElement where the ExecutionEntity is currently at
and leaves it following the sequence flow.Represents one task for a human user.
Parent class for all BPMN 2.0 task types such as ServiceTask, ScriptTask, UserTask, etc.
Interface containing shared methods between the
TaskQuery and the HistoricTaskInstanceQuery.This is a helper class to help you work with the
TaskInfoQuery, without having to care about the awful generics.Class handling invocations of
TaskListenersAllows programmatic querying of
Tasks;Contains the possible properties that can be used in a
TaskQuery.Represents a variable value used in a task query.
Service which provides access to
Task and form related operations.Extends the default
AcquireAsyncJobsDueRunnable by setting the 'tenant' context before executing.Extends the default
AcquireTimerJobsRunnable by setting the 'tenant' context before executing.Interface for
AsyncExecutor implementations used in conjucntion with the
MultiSchemaMultiTenantProcessEngineConfiguration.Factory used by the
ExecutorPerTenantAsyncExecutor async executor.Deprecated.
multi-tenant code will be removed in future version of Activiti and Activiti Cloud
Extends the default
ExecuteAsyncRunnable by setting the 'tenant' context before executing.Deprecated.
multi-tenant code will be removed in future version of Activiti and Activiti Cloud
Definition of a stage for staged builder.
Definition of a stage for staged builder.
Builder to build
ThrowMessage.Class handling invocations of ThrowMessageDelegate
Stub of the common parts of a Job.
TimerJob entity, necessary for persistence.
EntityManager responsible for TimerJobEntity instances.Allows programmatic querying of
Jobs.Manages timers for newly-deployed process definitions and their previous versions.
Callback interface to be notified of transaction events.
Enumeration that represents the transaction propagation behaviours supported by the command executor.
A transformation based data output association
A Transformer is responsible of transforming an object into a different object
A dummy implementation of
VariableInstance, used for storing transient variables
on a VariableScope, as the VariableScope works with instances of VariableInstance
and not with raw key/values.Operation that triggers a wait state and continues the process, leaving that activity.
Condition that resolves an UEL expression at runtime.Common interface for regular and historic variable entities.
List that initialises binary variable values if command-context is active.
Generic variable class that can be reused for Activiti 6 and 5 engine
Interface for class that acts as a scope for variables: i.e.
Implementation of an
ELResolver that resolves expressions with the
process variables of a given VariableScope as context.Interface describing a container for all available
VariableTypes of variables.A
CommandContextCloseListener that holds one DeserializedObject instance that
is added by the SerializableType.An activity behavior that allows calling Web services
Deprecated.
Deprecated.
This provides static methods to convert an XML text into a JSONObject, and to covert a JSONObject into an XML text.
A XML importer
The XMLTokener extends the JSONTokener to provide additional methods for the parsing of XML texts.