Event
is used to log anything interesting happens at a specific time. Such as an exception thrown, a review added by user, a new user registered, an user logged into the system etc.
However, if it could be failure, or last for a long time, such as a remote API call, database call or search engine call etc. It should be logged as a Transaction
All CAT message will be constructed as a message tree and send to back-end for further analysis, and for monitoring. Only Transaction
can be a tree node, all other message will be the tree leaf. The transaction without other messages nested is an atomic transaction.
Event
cannot be created directly. Instead, use the Event
type when returning a native DOM event from JSNI methods. An Event
passed back into JSNI becomes the original DOM event the Event
was created from, and can be accessed in JavaScript code as expected. This is typically done by calling methods in the {@link com.google.gwt.user.client.DOM} class.
Warning: This is a facade provided for use by user code, not for implementation by user code. User implementations of this interface are highly likely to be incompatible with future releases of the product at both binary and source levels.
@mock.generateIf the Event corresponds to the invocation of a Service, then most of this can be filled in by the caller.
TODO Should some space be left in this item for a more extensible system, such as name-value pairs implementing [subject, predicate, object] triples? The subject is clearly the Event, so use 'dc.creator', 'dc.terms.isPartOf', 'planets.process.info' etc?
The ProcessLog should usually be returned by the called Service, and allows the Service to pass back some information about what happened.
Instances of this class are immutable and so can be shared freely.
@author Andy JacksonObject
parameters) and provides support for synchronous processing through the waitUntilProcessed()
and notifyProcessed()
methods. This class can be effectively used in combination with the InputQueue
class to support a synchronization between an external therad (posting events in the InputQueue
) and the Agent thread (processing the events).
@see jade.util.InputQueue
@author Giovanni Caire - TILab
Event
interface represents an event that the portlet has received in the event processing phase. The Event
interface encapsulates the event name and event payload, it does not represent the event object itself.
The portlet must define the events it is able to receive in the portlet deployment descriptor with the supported-processing-event
.
@since 2.0
@see EventPortlet
Event
is similar to the regular JCR Event and adds additional information about the affected item.
Deprecation This class has been deprecated as of camunda BPM 7.1. It has been replaced with the operation log. See {@link UserOperationLogEntry} and {@link UserOperationLogQuery}.
@see {@link TaskService#getTaskEvents(String)} @author Tom BaeyensThis class includes tools to help set and use the contents of the event. Note that it describes DSpace data object types in two ways: by the type identifiers in the Constants class, and also by an Event-specific bitmask (used by its internal filters). All public API calls use the Constants version of the data model types.
Note that the type of the event itself is actually descriptive of the action it performs: ADD, MODIFY, etc. The most significant elements of the event are:
- (Action) Type
- Subject -- DSpace object to which the action applies, e.g. the Collection to which an ADD adds a member.
- Object -- optional, when present it is the other object effected by an action, e.g. the Item ADDed to a Collection by an ADD.
- detail -- a textual summary of what changed, content and its significance varies by the combination of action and subject type.
- timestamp -- exact millisecond timestamp at which event was logged.
@version $Revision: 3762 $
The following features are supported:
The event type is an integral value that identifies the type of event to fire. It is transparent to the {@link EventManager}.
The event listener must implement the {@link EventHandler} interface.
The callback object must be {@link Serializable} and is passed back to the{@link EventHandler} when the event fires.
Most importantly this class is {@link Serializable} so that it can bestored, if required. @version $Revision: 1.1 $ $Date: 2004/11/26 01:50:41 $ @author Jim Alateras
Copyright © 2003-2004 The MITRE Corporation
Executes the given {@link JsScope} statement when a given list of {@link EventLabel}happened.
@author Lionel Armanet @since 0.5Encapsulates event definitions from DOM Events model.
Events matches it's equivalents in JavaScript, where are used "onevent" for binding with event called "event".
Copy of org.jboss.arquillian.ajocado.dom.Event;
@author Lukas FrycRepresents an event, which may have multiple performances with different dates and venues.
Event's principle members are it's relationship to {@link EventCategory} - specifying the type of event it is - and{@link MediaItem} - providing the ability to add media (such as a picture) to the event for display. It also containsmeta-data about the event, such as it's name and a description.
@author Shane Bryzak @author Marius Bogoevici @author Pete MuirAs an example, a "submit" event might signal that a Submit button was pressed in a web browser. A "success" event might signal an action executed successfully. A "finish" event might signal a subflow ended normally.
Why is this not an interface? A specific design choice. An event is not a strategy that defines a generic type or role--it is essentially an immutable value object. It is expected that specializations of this base class be "Events" and not part of some other inheritance hierarchy. @author Keith Donald @author Erwin Vervaet @author Colin Sampaleanu
Event
interface is used to provide contextual information about an event to the handler processing the event. An object which implements the Event
interface is generally passed as the first parameter to an event handler. More specific context information is passed to event handlers by deriving additional interfaces from Event
which contain information directly relating to the type of event they accompany. These derived interfaces are also implemented by the object passed to the event listener.
@since DOM Level 2
Each event is linked to a simulator represented by an instance of {@link Simulator} before it can be scheduled and processed.A default simulator, given by Simulator.getDefaultSimulator, is used if no simulator is linked explicitly with an event. When an event is constructed, it is not scheduled. It must be scheduled separately by calling one of the scheduling methods {@link #schedule schedule}, {@link #scheduleNext scheduleNext}, {@link #scheduleBefore scheduleBefore}, etc. An event can also be cancelled before it occurs.
A scheduled event has an associated time at which it will happen and a priority, which can be queried using the methods {@link #time time} and {@link #priority priority}, respectively. By default, events occur in ascending order of time, and have priority 1. Events with the same time occur in ascending order of priority. For example, if events e1 and e2 occur at the same time with priority 2 and 1 respectively, then e2 will occur before e1. Events with the same time and priority occur in the order they were scheduled.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|