<p>
The events that match the specified filter criteria.
</p>

@param events
The events that match the specified filter criteria.
503591
public void setEvents(java.util.Collection<Event> events) {
        if (events == null) {
            this.events = null;
            return;
        }

        this.events = new java.util.ArrayList<Event>(events);
    }
738154
public void onSearchRequested(SearchRequestEvent event) {
		final SearchEvent searchEvent = new SearchEvent();
		searchEvent.setCriterion(event.getCriterion());
		fireSearchStartEvent(searchEvent);
		SearchCommService.searchByCriterion(event.getCriterion(), mapWidget,
				new DataCallback<Map<VectorLayer, List<Feature>>>() {
					public void execute(Map<VectorLayer, List<Feature>> result) {
						searchEvent.setResult(result);
						fireSearchDoneEvent(searchEvent);
						fireSearchEndEvent(searchEvent);
					}
				}, new Runnable() {
					public void run() {
						fireSearchEndEvent(searchEvent);
						destroyWindow();
						SC.say(messages.searchControllerFailureMessage());
					}
				});
	}
419157
public void setEventStatusCodes(java.util.Collection<String> eventStatusCodes) {
        if (eventStatusCodes == null) {
            this.eventStatusCodes = null;
            return;
        }

        this.eventStatusCodes = new java.util.ArrayList<String>(eventStatusCodes);
    }
449496
@SuppressWarnings("unchecked")
	public SebListener disable(Class<? extends SebEvent>... events) {
		if (events != null) {
			enabledEvents = null;
			if (disabledEvents == null)
				disabledEvents = new HashSet<>();
			for (Class<? extends SebEvent> event : events) {
				disabledEvents.add(event);
			}
		}
		return this;
	}
870751
private void initEventTypes(IoEventType... eventTypes) {
        if ((eventTypes == null) || (eventTypes.length == 0)) {
            eventTypes = DEFAULT_EVENT_SET;
        }

        // Copy the list of handled events in the event set
        this.eventTypes = EnumSet.of(eventTypes[0], eventTypes);
        
        // Check that we don't have the SESSION_CREATED event in the set
        if (this.eventTypes.contains( IoEventType.SESSION_CREATED )) {
            this.eventTypes = null;
            throw new IllegalArgumentException(IoEventType.SESSION_CREATED
                + " is not allowed.");
        }
    }
686409
public void setEventSelectors(java.util.Collection<EventSelector> eventSelectors) {
        if (eventSelectors == null) {
            this.eventSelectors = null;
            return;
        }

        this.eventSelectors = new com.amazonaws.internal.SdkInternalList<EventSelector>(eventSelectors);
    }
1124447
Collection<Class< ? extends ManagerEvent>> expandEvents(Collection<Class< ? extends ManagerEvent>> events)
    {
        Collection<Class< ? extends ManagerEvent>> requiredEvents = new HashSet<>();
        for (Class< ? extends ManagerEvent> event : events)
        {
            requiredEvents.add(event);
            if (event.equals(BridgeEvent.class))
            {
                requiredEvents.add(UnlinkEvent.class);
                requiredEvents.add(LinkEvent.class);
            }
        }

        return requiredEvents;
    }
888718
@Override
    public void sendEvents(TreeSet<Event> events) {
        if (events == null) {
            throw new IllegalArgumentException("Events must be not null");
        }
        if (events.isEmpty()) {
            return;
        }

        addEvents(events);

        if (distributed) {
            partitionManager.notifyEvents(new ArrayList<>(events));
        }
    }
1276462
@Override
    public void onEvent(final javax.jcr.observation.EventIterator events) {
        Session lookupSession = null;
        try {
            lookupSession = getJcrSession(repository.login());

            @SuppressWarnings("unchecked")
            final Iterator<Event> filteredEvents = filter(events, eventFilter::test);
            eventMapper.apply(iteratorToStream(filteredEvents))
                .map(filterAndDerefResourceTypes(lookupSession))
                .flatMap(handleMoveEvents(lookupSession))
                .forEach(this::post);
        } finally {
            if (lookupSession != null) {
                lookupSession.logout();
            }
        }
    }
961789
public void setResourceLogEvents(java.util.Collection<LogEvent> resourceLogEvents) {
        if (resourceLogEvents == null) {
            this.resourceLogEvents = null;
            return;
        }

        this.resourceLogEvents = new java.util.ArrayList<LogEvent>(resourceLogEvents);
    }
688784
private void sendEvents(final List<Event> events) {
        if (null != handlers) {
            for (EventHandler current : handlers) {
                for (Event event : events) {
                    current.handleEvent(event);
                }
            }
        }

        LOG.info("Put events(" + events.size() + ") to Monitoring Server.");

        try {
            if (sendToEventadmin) {
                EventAdminPublisher.publish(events);
            } else {
                monitoringServiceClient.putEvents(events);
            }
        } catch (MonitoringException e) {
            throw e;
        } catch (Exception e) {
            throw new MonitoringException("002",
                                          "Unknown error while execute put events to Monitoring Server", e);
        }

    }
940360
private void sortAndCacheEvents(List<? extends WeekViewEvent> events) {
        sortEvents(events);
        for (WeekViewEvent event : events) {
            cacheEvent(event);
        }
    }
195039
public void processEvent(EventObject event) {
    if (event instanceof RequestEvent) {
      processRequest((RequestEvent) event);
    } else if (event instanceof ResponseEvent) {
      processResponse((ResponseEvent) event);
    } else if (event instanceof TimeoutEvent) {
      processTimeout((TimeoutEvent) event);
    } else {
      LOG.error("invalid event type received: {}: {}", event.getClass().getName(), event.toString());
    }
  }
1263643
@EventHandler
    public void onSelectFilter(SelectFilterEvent selectFilterEvent){
        for (FacetWidget facetWidget : filterList) {
            if(facetWidget.getFacetField().equals(selectFilterEvent.getFilterName())){
                for (FacetWidgetItem facetWidgetItem : facetWidget.getFacetWidgetItems()) {
                    if(facetWidgetItem.getValue().equals(selectFilterEvent.getFilterValue())){
                        facetWidget.selectItems(Arrays.asList(facetWidgetItem));
                    }
                }
            }
        }

    }
1100004
public EventFilter withEventStatusCodes(EventStatusCode... eventStatusCodes) {
        java.util.ArrayList<String> eventStatusCodesCopy = new java.util.ArrayList<String>(eventStatusCodes.length);
        for (EventStatusCode value : eventStatusCodes) {
            eventStatusCodesCopy.add(value.toString());
        }
        if (getEventStatusCodes() == null) {
            setEventStatusCodes(eventStatusCodesCopy);
        } else {
            getEventStatusCodes().addAll(eventStatusCodesCopy);
        }
        return this;
    }
594999
public void setEvent(int index, int event) {
        if (events == null || index < 0 || index >= events.length) {
            throw new IndexOutOfBoundsException("index = " + index + ", limit = " + (events == null ? "null" : events.length));
        }

        events[index] = (byte)event;
    }
579516
protected List<Event> filterEvents(List<Event> toFilter, Long lastIndex) {
		List<Event> events = toFilter;
		if (lastIndex != null) {
			for (int i = 0; i < events.size(); i++) {
				Event event = events.get(i);
				Long eventIndex = event.getWaitIndex();
				if (lastIndex.equals(eventIndex)) {
					events = events.subList(i + 1, events.size());
					break;
				}
			}
		}
		return events;
	}