<p>
The events to configure
</p>

@param events
The events to configure
@return Returns a reference to this object so that method calls can be chained together.
970495
public SetCognitoEventsRequest withEvents(java.util.Map<String, String> events) {
        setEvents(events);
        return this;
    }
553687
public java.util.List<EventSubscription> getEventSubscriptionsList() {
        if (eventSubscriptionsList == null) {
            eventSubscriptionsList = new com.amazonaws.internal.SdkInternalList<EventSubscription>();
        }
        return eventSubscriptionsList;
    }
913548
public static TraceEvent getVersion(List<TraceEvent> events)
   {
      for (TraceEvent te : events)
      {
         if (te.getType() == TraceEvent.VERSION)
            return te;
      }

      return null;
   }
1054201
List<EventInfo> getEvents() {
        synchronized (events) {
            List<EventInfo> result = new ArrayList<>(events.size());
            for (ListIterator<EventInfo> iterator = events.listIterator(events.size()); iterator.hasPrevious();) {
                result.add(iterator.previous());
            }
            return result;
        }
    }
1177
public EventDetails withEventMetadata(java.util.Map<String, String> eventMetadata) {
        setEventMetadata(eventMetadata);
        return this;
    }
748399
public java.util.List<StackEvent> getStackEvents() {
        if (stackEvents == null) {
            stackEvents = new com.amazonaws.internal.SdkInternalList<StackEvent>();
        }
        return stackEvents;
    }
619932
private ArrayList<AptEventSet> initEventSets()
    {
        ArrayList<AptEventSet> eventSets = new ArrayList<AptEventSet>();

        if ( _intfDecl == null || _intfDecl.getNestedTypes() == null )
            return eventSets;

        for (TypeDeclaration innerDecl : _intfDecl.getNestedTypes())
        {
            // HACKHACK: There appear to be mirror API bugs where calling getAnnotation()
            // on certain entity types will result in an endless loop.  For now, work around
            // this by a priori filtering... but this mechanism will drop errors that appear
            // on an inapropriate type (see check below)
            if (! (innerDecl instanceof InterfaceDeclaration))
                continue;

            if (innerDecl.getAnnotation(EventSet.class) != null)
            {

                if (! (innerDecl instanceof InterfaceDeclaration))
                {
                    _ap.printError( innerDecl, "eventset.illegal.usage" );
                }
                else
                {
                    eventSets.add(
                        new AptEventSet(this, (InterfaceDeclaration)innerDecl, _ap));
                }
            }
        }
        return eventSets;
    }
1341050
protected String prepareEventHandlers() {
		StringBuffer handlers = new StringBuffer();

		prepareMouseEvents(handlers);
		prepareKeyEvents(handlers);

		return handlers.toString();
	}
133397
public void putEvents(List<Event> events) {
        Exception lastException;
        List<EventType> eventTypes = new ArrayList<EventType>();
        for (Event event : events) {
            EventType eventType = EventMapper.map(event);
            eventTypes.add(eventType);
        }

        int i = 0;
        lastException = null;
        while (i < numberOfRetries) {
            try {
                monitoringService.putEvents(eventTypes);
                break;
            } catch (Exception e) {
                lastException = e;
                i++;
            }
            if(i < numberOfRetries) {
                try {
                    Thread.sleep(delayBetweenRetry);
                } catch (InterruptedException e) {
                    break;
                }
            }
        }

        if (i == numberOfRetries) {
            throw new MonitoringException("1104", "Could not send events to monitoring service after "
                                                  + numberOfRetries + " retries.", lastException, events);
        }
    }
399578
public java.util.List<EventTopic> getEventTopics() {
        if (eventTopics == null) {
            eventTopics = new com.amazonaws.internal.SdkInternalList<EventTopic>();
        }
        return eventTopics;
    }
1284521
public void setSupportedEvents(Collection<Class<? extends ApplicationEvent>> supportedEvents) {
        this.supportedEventsCache.clear();
        if (supportedEvents == null) {
            this.supportedEvents = Collections.emptySet();
        } else {
            this.supportedEvents =
                    new LinkedHashSet<Class<? extends ApplicationEvent>>(supportedEvents);
        }
    }
868714
public void putEvents(List<Event> events) {
        List<Event> filteredEvents = filterEvents(events);
        executeHandlers(filteredEvents);
        for (Event event : filteredEvents) {
            persistenceHandler.writeEvent(event);
        }
    }
703093
public void setEventDestinations(java.util.Collection<EventDestination> eventDestinations) {
        if (eventDestinations == null) {
            this.eventDestinations = null;
            return;
        }

        this.eventDestinations = new java.util.ArrayList<EventDestination>(eventDestinations);
    }
843889
public List<INextGenEvent> getEvents(Long startTime) {
		ArrayList<INextGenEvent> eventList = null;
		
		//Key events where key is equal to or greater (null if nothing is found)
		Long eventKey = events.ceilingKey(startTime); 
		
	    if(eventKey != null) {
	    	eventList = events.get(eventKey);
	    	currentEventTime = eventKey;
	    } 		
		return eventList;
	}
1139533
public void addEvents(List<FlowEvent> events) throws IOException {
    List<Put> puts = new ArrayList<Put>(events.size());
    for (FlowEvent e : events) {
      puts.add(createPutForEvent(e));
    }
    Table eventTable = null;
    try {
      eventTable = hbaseConnection
          .getTable(TableName.valueOf(Constants.FLOW_EVENT_TABLE));
      eventTable.put(puts);
    } finally {
      if (eventTable != null) {
        eventTable.close();
      }
    }
  }
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.");
        }
    }
477526
public void setEventSubscriptions(java.util.Collection<EventSubscription> eventSubscriptions) {
        if (eventSubscriptions == null) {
            this.eventSubscriptions = null;
            return;
        }

        this.eventSubscriptions = new java.util.ArrayList<EventSubscription>(eventSubscriptions);
    }