About event types

Apama events are strongly typed. Each event must be of a specific known type, henceforth called the event type. An event type defines the name of the event, and its particular set of parameters. Every parameter is named and can be one of a selection of data types. Every event instance of a given event type is therefore identical in structure; every instance has the same set (and order) of parameters.

Before the correlator can understand and process events of a specific event type, it needs to have been provided with an event type definition. This allows it to understand the event messages it is passed, create optimal indexing structures, and allows listeners to be set up to look for event sequences involving events of that type.

An event type definition defines the event type’s name and the name, type and order of each of its parameters. Parameters can be of any of the following types:

com.apama.jmon.Location type — This type corresponds to either a spatial point represented by two coordinates, or a rectangular space expressed in terms of its two bounding corners.

Apama’s Java API supports Java generic maps. Apama recommends that you use these when possible instead of the Event.getMapFieldTypes() method. Doing so lets you gain the benefits of compile-time type safety as well as a simpler class definition.

However, while it is valid to declare a parameter to be an array of generic maps, assignment of values to the map elements is not type-safe, and will be rejected by the Java compiler. If you need a parameter that is an array of maps, use the Event.getMapFieldTypes() method instead of generic maps.

You can nest a plain Map as a value (not a key) at any depth in a parameterized Map. You cannot nest a parameterized Map in a plain Map. This is because you would not be able to specify the parameterized types to be returned from the getMapFieldTypes() method. Of course, you can nest a parameterized Map as a value (but not a key) in a parameterized Map. For example:

Event BadComplexEventExample {
Dictionary < string , dictionary < string, SimpleEvent > > complex;
}

Import java.util.Map;
Import java.util.HashMap;
Import com.apama.jmon.Event;
Public class BadComplexEventExample extends Event {
// By using a non-parameterized map you lose the information that the field
// is a dictionary with values that are also dictionaries.
Public Map complex;

Public BadComplexEventExample() {
This(new HashMap());
}

Public BadComplexEventExample(Map complex) {
This.complex = complex;
}
}