The payloads that the apama.eventMap generates for transportward messages and that it requires for hostward messages are maps. For Java chains, this is java.util.Map<Object, Object>. For C++ chains, this is a map_t.

Each key in the map is the name of a field in the EPL event definition and the value the corresponding EPL value. Each event containing other events is represented as a Map value within the top-level field, allowing nesting of events, dictionaries and sequences. For events sent from chains into the correlator, all fields must have non-empty values and must be present as keys in the map, unless the configuration setting allowMissing is set to true. Keys that do not correspond to fields are ignored by default. There is one exception: an empty value that maps to an optional<type> in EPL is permitted even if allowMissing is false (see also optional).

Events can be annotated with the com.softwareag.connectivity.ExtraFieldsDict annotation (see Adding predefined annotations) which names a dictionary<string,string> field, in which case any unmapped keys are placed into this dictionary field. All unmapped keys must be String keys and have string (or numeric) values. This can be disabled with the extraFields configuration property.

The types are converted as described below:

Non-native conversions (a floating point to integer conversion or vice versa) may lose precision, and conversions to/from strings or decimals are more expensive than float or integer conversions. If anything other than an exact match is found, a debug-level log message is generated; you may wish to verify that there are none if the conversion is performance-sensitive.

The following applies to Java only: an EPL decimal value which is NaN (not a number) or an infinity is mapped to/from a Double representation of NaN or infinity, as the BigDecimal Java type does not support them.

Events containing the following types cannot be sent into the correlator, as they cannot be serialized:

Events containing the following can be sent in, provided allowMissing is set to true in the host plug-in configuration and no value is provided for that field:

Events containing cycles cannot be sent into or out of the correlator, but arbitrary nesting is permitted. Aliases will be flattened.

For Java plug-ins, handling messages from the apama.eventMap plug-in thus involves casting the payload of the message from Object to Map, and then accessing members of that, casting as necessary (or, for flexibility, introspecting their types by using the instanceof operator). For example, for the following event definition, the CustomerOrder is translated to a map with deliveryAddress, userId and items keys, and items will be a list of maps containing itemId, price and qty.

To print the total cost of an order (sum of product of qty and price for each item), the Java code would be as follows:

Note that due to type erasure, the type parameters on Map or List are not checked or guaranteed. In the above example, it is convenient to cast the list representing EPL field sequence<LineItems> to List<Map> to avoid having to cast the entries within it. The Map, however, is still treated as a map of objects as it has different types (String, Double, Long) in it.

For C++ plug-ins, handling messages from the apama.eventMap plug-in involves using the get<map_t> function and accessing the members of that, using get<> as necessary. If code needs to be flexible as to which type it accepts, then use the visitor pattern (see C++ data types). For example, using the event definition above, the following C++ code will print the total cost of the order:

The following constructs and sends an order with one line item into the correlator:

The above can also be written more compactly:

This would typically be done in a more automated fashion, translating data from some other form, rather than laboriously setting each field as needed - though some combination will often be needed.

The equivalent C++code is: