Events

Introduction

An Event is something that "happens" during the course of a process. These events affect the flow of the process and usually have a cause or an impact. The term "event" is general enough to cover many things in a process such as a start and end of an activity, the change of state of a document, a message that arrives, etc.

There are two categories of events:

• Catching event - Events that catch a trigger. All start events and some intermediate events are catching events.
• Throwing event - Events that throw a result. All end events and some intermediate events are throwing events that may eventually be caught by another event.

In Dirigent, we differentiate four types of events: Start, End, Intermediate, and Boundary

Start event

The event that occurs at the beginning of the process represented as a thin narrow lined circle. Start events are always catching event, which means that it is an event with a defined trigger. They are started once the trigger has actived or has been fired. Every process has to start with an event, and there are four ways you can do this in Dirigent.

None start event

The most common type of start event. Processes that start with such an event are created without any pre-conditions. It is common to usethis event when a human starts a process through a graphical user interface.

Message start event

Process instance is started on receipt of a message. A single thrown message can be caught multiple times by different catching signal events.

Signal start event

Process instance is started based on signaling across different processes. A single thrown signal can be caught multiple times by different catching signal events.

Error start event

Type of start event that can only be used to trigger an event sub-process. It cannot be used to start a process instance.

End event

An event that occurs at the end of the process represented as a thick single-lined circle and is always a throwing type event. Every process has to have at least one red event.

None end event

Untyped end event that typically marks the typical end of a process.

Error end event

Process ends in an error state. As a result, a named error is thrown.

Terminate end event

Triggers the immediate termination of a process instance. All steps still executing in parallel branches are terminated.

Intermediate event

The event that occurs in the middle of the process/between activities represented as a thin double-lined circle. They are not necessary for a process model to be executable. They can be either throwing or catching.

Boundary event

Event to handle an event associated with an activity. A boundary event is always attached to an activity. While the activity (to which the boundary event is attached) is active, meaning the process instance execution is currently executing it right there, the boundary event is listening for a certain type of a trigger.

When the event is caught, the activity is either interrupted and the sequence flow going out of the event is followed (interrupting behavior) or a new execution is created from the boundary event (non-interrupting behavior).

• Timer - Event that acts as a stopwatch and as an alarm clock. When an execution arrives in the activity to which the boundary event is attached, a timer is started. When the timer fires (after a specified interval for example), the activity is interrupted and the sequence flow going out of the timer boundary event is followed.

• Message - Message boundary event is listening for the named message. When it's caught, two things might happen, depending on whether the boundary event is interrupting or non-interrupting.

• Signal - When an execution arrives in the activity to which the signal boundary event is attached, the signal boundary event catches signals with the proper name. A single boundary event does not only catch signal events thrown from the scope it is attached to. It has a global scope, meaning that the signal can be thrown from any place, even from a different process instance.

• Error - Event that catches errors that are thrown within the scope of the activity on which it is defined. When an error event is caught, the activity on which the boundary event is defined is destroyed, also destroying all current executions in there (e.g., concurrent activities, nested subprocesses, etc.). Process execution continues following the outgoing sequence flow of the boundary event.