org.apache.ignite.internal

## Class IgniteEventsImpl

- java.lang.Object
- - org.apache.ignite.internal.AsyncSupportAdapter<IgniteEvents>
  - - org.apache.ignite.internal.IgniteEventsImpl

All Implemented Interfaces:
  Externalizable, Serializable, IgniteEvents, IgniteAsyncSupport

    public class IgniteEventsImpl
    extends AsyncSupportAdapter<IgniteEvents>
    implements IgniteEvents, Externalizable

`IgniteEvents` implementation.

See Also:
  Serialized Form

### Field Summary

### Fields inherited from class org.apache.ignite.internal.AsyncSupportAdapter

`curFut`

### Constructor Summary

Constructors
Constructor and Description
`IgniteEventsImpl()` Required by `Externalizable`.
`IgniteEventsImpl(GridKernalContext ctx, ClusterGroupAdapter prj, boolean async)`

### Method Summary

All Methods Instance Methods Concrete Methods
`ClusterGroup` `clusterGroup()` Gets cluster group to which this `IgniteEvents` instance belongs.
`protected IgniteEvents` `createAsyncInstance()` Creates component with asynchronous mode enabled.
`void` `disableLocal(int[] types)` Disables provided events.
`int[]` `enabledEvents()` Gets types of enabled events.
`void` `enableLocal(int[] types)` Enables provided events.
`boolean` `isEnabled(int type)` Check if event is enabled.
`void` `localListen(IgnitePredicate<? extends Event> lsnr, int[] types)` Adds an event listener for local events.
`<T extends Event> Collection<T>` `localQuery(IgnitePredicate<T> p, int... types)` Queries local node for events using passed-in predicate filter for event selection.
`void` `readExternal(ObjectInput in)`
`protected Object` `readResolve()` Reconstructs object on unmarshalling.
`void` `recordLocal(Event evt)` Records customer user generated event.
`<T extends Event> UUID` `remoteListen(@Nullable IgniteBiPredicate<UUID,T> locLsnr, @Nullable IgnitePredicate<T> rmtFilter, int... types)` Adds event listener for specified events to all nodes in the cluster group (possibly including local node if it belongs to the cluster group as well).
`<T extends Event> UUID` `remoteListen(int bufSize, long interval, boolean autoUnsubscribe, @Nullable IgniteBiPredicate<UUID,T> locLsnr, @Nullable IgnitePredicate<T> rmtFilter, int... types)` Adds event listener for specified events to all nodes in the cluster group (possibly including local node if it belongs to the cluster group as well).
`<T extends Event> IgniteFuture<UUID>` `remoteListenAsync(@Nullable IgniteBiPredicate<UUID,T> locLsnr, @Nullable IgnitePredicate<T> rmtFilter, int... types)` Asynchronously adds event listener for specified events to all nodes in the cluster group (possibly including local node if it belongs to the cluster group as well).
`<T extends Event> IgniteFuture<UUID>` `remoteListenAsync(int bufSize, long interval, boolean autoUnsubscribe, @Nullable IgniteBiPredicate<UUID,T> locLsnr, @Nullable IgnitePredicate<T> rmtFilter, int... types)` Asynchronously adds event listener for specified events to all nodes in the cluster group (possibly including local node if it belongs to the cluster group as well).
`<T extends Event> List<T>` `remoteQuery(IgnitePredicate<T> p, long timeout, int... types)` Queries nodes in this cluster group for events using passed in predicate filter for event selection.
`<T extends Event> IgniteFuture<List<T>>` `remoteQueryAsync(IgnitePredicate<T> p, long timeout, int... types)` Asynchronously queries nodes in this cluster group for events using passed in predicate filter for event selection.
`boolean` `stopLocalListen(IgnitePredicate<? extends Event> lsnr, int... types)` Removes local event listener.
`void` `stopRemoteListen(UUID opId)` Stops listening to remote events.
`IgniteFuture<Void>` `stopRemoteListenAsync(UUID opId)` Asynchronously stops listening to remote events.
`<T extends Event> T` `waitForLocal(@Nullable IgnitePredicate<T> filter, int... types)` Waits for the specified events.
`<T extends Event> IgniteFuture<T>` `waitForLocalAsync(@Nullable IgnitePredicate<T> filter, int... types)` Create future to wait for the specified events.
`void` `writeExternal(ObjectOutput out)`

### Methods inherited from class org.apache.ignite.internal.AsyncSupportAdapter

`createFuture, future, future, isAsync, saveOrGet, withAsync`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Methods inherited from interface org.apache.ignite.IgniteEvents

`withAsync`

### Methods inherited from interface org.apache.ignite.lang.IgniteAsyncSupport

`future, isAsync`

### Constructor Detail

#### IgniteEventsImpl

    public IgniteEventsImpl()

Required by `Externalizable`.

#### IgniteEventsImpl

    public IgniteEventsImpl(GridKernalContext ctx,
                            ClusterGroupAdapter prj,
                            boolean async)

Parameters:
  `ctx` - Kernal context.
  `prj` - Projection.
  `async` - Async support flag.

### Method Detail

#### clusterGroup

    public ClusterGroup clusterGroup()

Gets cluster group to which this `IgniteEvents` instance belongs.

Specified by:
  `clusterGroup` in interface `IgniteEvents`
Returns:
  Cluster group to which this `IgniteEvents` instance belongs.

#### remoteQuery

    public <T extends Event> List<T> remoteQuery(IgnitePredicate<T> p,
                                                 long timeout,
                                                 @Nullable
                                                 int... types)

Queries nodes in this cluster group for events using passed in predicate filter for event selection.

Specified by:
  `remoteQuery` in interface `IgniteEvents`
Parameters:
  `p` - Predicate filter used to query events on remote nodes.
  `timeout` - Maximum time to wait for result, `0` to wait forever.
  `types` - Event types to be queried.
Returns:
  Collection of grid events returned from specified nodes.

#### remoteQueryAsync

    public <T extends Event> IgniteFuture<List<T>> remoteQueryAsync(IgnitePredicate<T> p,
                                                                    long timeout,
                                                                    @Nullable
                                                                    int... types)
                                                             throws IgniteException

Asynchronously queries nodes in this cluster group for events using passed in predicate filter for event selection.

Specified by:
  `remoteQueryAsync` in interface `IgniteEvents`
Parameters:
  `p` - Predicate filter used to query events on remote nodes.
  `timeout` - Maximum time to wait for result, `0` to wait forever.
  `types` - Event types to be queried.
Returns:
  a Future representing pending completion of the query. The completed future contains collection of grid events returned from specified nodes.
Throws:
  `IgniteException` - If query failed.

#### remoteListen

    public <T extends Event> UUID remoteListen(@Nullable
                                               @Nullable IgniteBiPredicate<UUID,T> locLsnr,
                                               @Nullable
                                               @Nullable IgnitePredicate<T> rmtFilter,
                                               @Nullable
                                               int... types)

Adds event listener for specified events to all nodes in the cluster group (possibly including local node if it belongs to the cluster group as well). This means that all events occurring on any node within this cluster group that pass remote filter will be sent to local node for local listener notifications.

The listener can be unsubscribed automatically if local node stops, if `locLsnr` callback returns `false` or if `IgniteEvents.stopRemoteListen(UUID)` or `IgniteEvents.stopRemoteListenAsync(UUID)` are called.

Specified by:
  `remoteListen` in interface `IgniteEvents`
Type Parameters:
  `T` - Type of the event.
Parameters:
  `locLsnr` - Listener callback that is called on local node. If `null`, this events will be handled on remote nodes by passed in `rmtFilter`.
  `rmtFilter` - Filter callback that is called on remote node. Only events that pass the remote filter will be sent to local node. If `null`, all events of specified types will be sent to local node. This remote filter can be used to pre-handle events remotely, before they are passed in to local callback. It will be auto-unsubsribed on the node where event occurred in case if it returns `false`.
  `types` - Types of events to listen for. If not provided, all events that pass the provided remote filter will be sent to local node.
Returns:
  `Operation ID` that can be passed to `IgniteEvents.stopRemoteListen(UUID)` or `IgniteEvents.stopRemoteListenAsync(UUID)` methods to stop listening.

#### remoteListenAsync

    public <T extends Event> IgniteFuture<UUID> remoteListenAsync(@Nullable
                                                                  @Nullable IgniteBiPredicate<UUID,T> locLsnr,
                                                                  @Nullable
                                                                  @Nullable IgnitePredicate<T> rmtFilter,
                                                                  @Nullable
                                                                  int... types)
                                                           throws IgniteException

Asynchronously adds event listener for specified events to all nodes in the cluster group (possibly including local node if it belongs to the cluster group as well). This means that all events occurring on any node within this cluster group that pass remote filter will be sent to local node for local listener notifications.

The listener can be unsubscribed automatically if local node stops, if `locLsnr` callback returns `false` or if `IgniteEvents.stopRemoteListen(UUID)` or `IgniteEvents.stopRemoteListenAsync(UUID)` are called.

Specified by:
  `remoteListenAsync` in interface `IgniteEvents`
Type Parameters:
  `T` - Type of the event.
Parameters:
  `locLsnr` - Listener callback that is called on local node. If `null`, this events will be handled on remote nodes by passed in `rmtFilter`.
  `rmtFilter` - Filter callback that is called on remote node. Only events that pass the remote filter will be sent to local node. If `null`, all events of specified types will be sent to local node. This remote filter can be used to pre-handle events remotely, before they are passed in to local callback. It will be auto-unsubsribed on the node where event occurred in case if it returns `false`.
  `types` - Types of events to listen for. If not provided, all events that pass the provided remote filter will be sent to local node.
Returns:
  a Future representing pending completion of the operation. The completed future contains `Operation ID` that can be passed to `IgniteEvents.stopRemoteListen(UUID)` or `IgniteEvents.stopRemoteListenAsync(UUID)` methods to stop listening.
Throws:
  `IgniteException` - If failed to add listener.

#### remoteListen

    public <T extends Event> UUID remoteListen(int bufSize,
                                               long interval,
                                               boolean autoUnsubscribe,
                                               @Nullable
                                               @Nullable IgniteBiPredicate<UUID,T> locLsnr,
                                               @Nullable
                                               @Nullable IgnitePredicate<T> rmtFilter,
                                               @Nullable
                                               int... types)

Adds event listener for specified events to all nodes in the cluster group (possibly including local node if it belongs to the cluster group as well). This means that all events occurring on any node within this cluster group that pass remote filter will be sent to local node for local listener notification.

Supports asynchronous execution (see `IgniteAsyncSupport`).

Specified by:
  `remoteListen` in interface `IgniteEvents`
Type Parameters:
  `T` - Type of the event.
Parameters:
  `bufSize` - Remote events buffer size. Events from remote nodes won't be sent until buffer is full or time interval is exceeded.
  `interval` - Maximum time interval after which events from remote node will be sent. Events from remote nodes won't be sent until buffer is full or time interval is exceeded.
  `autoUnsubscribe` - Flag indicating that event listeners on remote nodes should be automatically unregistered if master node (node that initiated event listening) leaves topology. If this flag is `false`, listeners will be unregistered only when `IgniteEvents.stopRemoteListen(UUID)` method is called, or the `'callback (locLsnr)'` passed in returns `false`.
  `locLsnr` - Callback that is called on local node. If this predicate returns `true`, the implementation will continue listening to events. Otherwise, events listening will be stopped and listeners will be unregistered on all nodes in the cluster group. If `null`, this events will be handled on remote nodes by passed in `rmtFilter` until local node stops (if `'autoUnsubscribe'` is `true`) or until `IgniteEvents.stopRemoteListen(UUID)` is called.
  `rmtFilter` - Filter callback that is called on remote node. Only events that pass the remote filter will be sent to local node. If `null`, all events of specified types will be sent to local node. This remote filter can be used to pre-handle events remotely, before they are passed in to local callback. It will be auto-unsubsribed on the node where event occurred in case if it returns `false`.
  `types` - Types of events to listen for. If not provided, all events that pass the provided remote filter will be sent to local node.
Returns:
  `Operation ID` that can be passed to `IgniteEvents.stopRemoteListen(UUID)` or `IgniteEvents.stopRemoteListen(UUID)` methods to stop listening.
See Also:
  `IgniteEvents.stopRemoteListen(UUID)`, `IgniteEvents.stopRemoteListenAsync(UUID)`

#### remoteListenAsync

    public <T extends Event> IgniteFuture<UUID> remoteListenAsync(int bufSize,
                                                                  long interval,
                                                                  boolean autoUnsubscribe,
                                                                  @Nullable
                                                                  @Nullable IgniteBiPredicate<UUID,T> locLsnr,
                                                                  @Nullable
                                                                  @Nullable IgnitePredicate<T> rmtFilter,
                                                                  @Nullable
                                                                  int... types)
                                                           throws IgniteException

Asynchronously adds event listener for specified events to all nodes in the cluster group (possibly including local node if it belongs to the cluster group as well). This means that all events occurring on any node within this cluster group that pass remote filter will be sent to local node for local listener notification.

Specified by:
  `remoteListenAsync` in interface `IgniteEvents`
Type Parameters:
  `T` - Type of the event.
Parameters:
  `bufSize` - Remote events buffer size. Events from remote nodes won't be sent until buffer is full or time interval is exceeded.
  `interval` - Maximum time interval after which events from remote node will be sent. Events from remote nodes won't be sent until buffer is full or time interval is exceeded.
  `autoUnsubscribe` - Flag indicating that event listeners on remote nodes should be automatically unregistered if master node (node that initiated event listening) leaves topology. If this flag is `false`, listeners will be unregistered only when `IgniteEvents.stopRemoteListen(UUID)` method is called, or the `'callback (locLsnr)'` passed in returns `false`.
  `locLsnr` - Callback that is called on local node. If this predicate returns `true`, the implementation will continue listening to events. Otherwise, events listening will be stopped and listeners will be unregistered on all nodes in the cluster group. If `null`, this events will be handled on remote nodes by passed in `rmtFilter` until local node stops (if `'autoUnsubscribe'` is `true`) or until `IgniteEvents.stopRemoteListen(UUID)` is called.
  `rmtFilter` - Filter callback that is called on remote node. Only events that pass the remote filter will be sent to local node. If `null`, all events of specified types will be sent to local node. This remote filter can be used to pre-handle events remotely, before they are passed in to local callback. It will be auto-unsubsribed on the node where event occurred in case if it returns `false`.
  `types` - Types of events to listen for. If not provided, all events that pass the provided remote filter will be sent to local node.
Returns:
  a Future representing pending completion of the operation. The completed future contains `Operation ID` that can be passed to `IgniteEvents.stopRemoteListen(UUID)` or `IgniteEvents.stopRemoteListen(UUID)` methods to stop listening.
Throws:
  `IgniteException` - If failed to add listener.
See Also:
  `IgniteEvents.stopRemoteListen(UUID)`, `IgniteEvents.stopRemoteListenAsync(UUID)`

#### stopRemoteListen

    public void stopRemoteListen(UUID opId)

Stops listening to remote events. This will unregister all listeners identified with provided operation ID on all nodes defined by `IgniteEvents.clusterGroup()`.

Supports asynchronous execution (see `IgniteAsyncSupport`).

Specified by:
  `stopRemoteListen` in interface `IgniteEvents`
Parameters:
  `opId` - Operation ID that was returned from `IgniteEvents.remoteListen(IgniteBiPredicate, IgnitePredicate, int...)` method.
See Also:
  `IgniteEvents.remoteListen(IgniteBiPredicate, IgnitePredicate, int...)`, `IgniteEvents.remoteListenAsync(int, long, boolean, IgniteBiPredicate, IgnitePredicate, int...)`

#### stopRemoteListenAsync

    public IgniteFuture<Void> stopRemoteListenAsync(UUID opId)
                                             throws IgniteException

Asynchronously stops listening to remote events. This will unregister all listeners identified with provided operation ID on all nodes defined by `IgniteEvents.clusterGroup()`.

Specified by:
  `stopRemoteListenAsync` in interface `IgniteEvents`
Parameters:
  `opId` - Operation ID that was returned from `IgniteEvents.remoteListen(IgniteBiPredicate, IgnitePredicate, int...)` method.
Returns:
  a Future representing pending completion of the operation.
Throws:
  `IgniteException` - If failed to stop listeners.
See Also:
  `IgniteEvents.remoteListen(IgniteBiPredicate, IgnitePredicate, int...)`, `IgniteEvents.remoteListenAsync(int, long, boolean, IgniteBiPredicate, IgnitePredicate, int...)`

#### waitForLocal

    public <T extends Event> T waitForLocal(@Nullable
                                            @Nullable IgnitePredicate<T> filter,
                                            @Nullable
                                            int... types)

Waits for the specified events.

Supports asynchronous execution (see `IgniteAsyncSupport`).

Specified by:
  `waitForLocal` in interface `IgniteEvents`
Parameters:
  `filter` - Optional filtering predicate. Only if predicates evaluates to `true` will the event end the wait.
  `types` - Types of the events to wait for. If not provided, all events will be passed to the filter.
Returns:
  Grid event.

#### waitForLocalAsync

    public <T extends Event> IgniteFuture<T> waitForLocalAsync(@Nullable
                                                               @Nullable IgnitePredicate<T> filter,
                                                               @Nullable
                                                               int... types)
                                                        throws IgniteException

Create future to wait for the specified events.

Specified by:
  `waitForLocalAsync` in interface `IgniteEvents`
Parameters:
  `filter` - Optional filtering predicate. Only if predicates evaluates to `true` will the event end the wait.
  `types` - Types of the events to wait for. If not provided, all events will be passed to the filter.
Returns:
  a Future representing pending completion of the operation. The completed future contains grid event.
Throws:
  `IgniteException` - If wait was interrupted.

#### localQuery

    public <T extends Event> Collection<T> localQuery(IgnitePredicate<T> p,
                                                      @Nullable
                                                      int... types)

Queries local node for events using passed-in predicate filter for event selection.

Specified by:
  `localQuery` in interface `IgniteEvents`
Parameters:
  `p` - Predicate to filter events. All predicates must be satisfied for the event to be returned.
  `types` - Event types to be queried.
Returns:
  Collection of grid events found on local node.

#### recordLocal

    public void recordLocal(Event evt)

Records customer user generated event. All registered local listeners will be notified.

NOTE: all types in range from 1 to 1000 are reserved for internal Ignite events and should not be used by user-defined events. Attempt to record internal event with this method will cause `IllegalArgumentException` to be thrown.

Specified by:
  `recordLocal` in interface `IgniteEvents`
Parameters:
  `evt` - Locally generated event.

#### localListen

    public void localListen(IgnitePredicate<? extends Event> lsnr,
                            int[] types)

Adds an event listener for local events. Note that listener will be added regardless of whether local node is in this cluster group or not.

Specified by:
  `localListen` in interface `IgniteEvents`
Parameters:
  `lsnr` - Predicate that is called on each received event. If predicate returns `false`, it will be unregistered and will stop receiving events.
  `types` - Event types for which this listener will be notified.

#### stopLocalListen

    public boolean stopLocalListen(IgnitePredicate<? extends Event> lsnr,
                                   @Nullable
                                   int... types)

Removes local event listener.

Specified by:
  `stopLocalListen` in interface `IgniteEvents`
Parameters:
  `lsnr` - Local event listener to remove.
  `types` - Types of events for which to remove listener. If not specified, then listener will be removed for all types it was registered for.
Returns:
  `true` if listener was removed, `false` otherwise.

#### enableLocal

    public void enableLocal(int[] types)

Enables provided events. Allows to start recording events that were disabled before. Note that specified events will be enabled regardless of whether local node is in this cluster group or not.

Specified by:
  `enableLocal` in interface `IgniteEvents`
Parameters:
  `types` - Events to enable.

#### disableLocal

    public void disableLocal(int[] types)

Disables provided events. Allows to stop recording events that were enabled before. Note that specified events will be disabled regardless of whether local node is in this cluster group or not.

Specified by:
  `disableLocal` in interface `IgniteEvents`
Parameters:
  `types` - Events to disable.

#### enabledEvents

    public int[] enabledEvents()

Gets types of enabled events.

Specified by:
  `enabledEvents` in interface `IgniteEvents`
Returns:
  Types of enabled events.

#### isEnabled

    public boolean isEnabled(int type)

Check if event is enabled.

Specified by:
  `isEnabled` in interface `IgniteEvents`
Parameters:
  `type` - Event type.
Returns:
  `True` if event of passed in type is enabled.

#### createAsyncInstance

    protected IgniteEvents createAsyncInstance()

Creates component with asynchronous mode enabled.

Overrides:
  `createAsyncInstance` in class `AsyncSupportAdapter<IgniteEvents>`
Returns:
  Component with asynchronous mode enabled.

#### writeExternal

    public void writeExternal(ObjectOutput out)
                       throws IOException

Specified by:
  `writeExternal` in interface `Externalizable`
Throws:
  `IOException`

#### readExternal

    public void readExternal(ObjectInput in)
                      throws IOException,
                             ClassNotFoundException

Specified by:
  `readExternal` in interface `Externalizable`
Throws:
  `IOException`
  `ClassNotFoundException`

#### readResolve

    protected Object readResolve()
                          throws ObjectStreamException

Reconstructs object on unmarshalling.

Returns:
  Reconstructed object.
Throws:
  `ObjectStreamException` - Thrown in case of unmarshalling error.

${current.year} Copyright © Apache Software Foundation

Follow @ApacheIgnite

Ignite Database and Caching Platform | : ver. 2.10.0
Release Date | : March 10 2021