<p>
A list of event subscriptions.
</p>

@param eventSubscriptionsList
A list of event subscriptions.
430127
public void setEventSubscriptionsList(java.util.Collection<EventSubscription> eventSubscriptionsList) {
        if (eventSubscriptionsList == null) {
            this.eventSubscriptionsList = null;
            return;
        }

        this.eventSubscriptionsList = new java.util.ArrayList<EventSubscription>(eventSubscriptionsList);
    }
725444
@SuppressWarnings("unchecked")
  public List<EventSubscriptionEntity> findSignalEventSubscriptionsByEventName(String eventName) {
    final String query = "selectSignalEventSubscriptionsByEventName";
    Set<EventSubscriptionEntity> eventSubscriptions = new HashSet<EventSubscriptionEntity>( getDbEntityManager().selectList(query, configureParameterizedQuery(eventName)));

    // add events created in this command (not visible yet in query)
    for (EventSubscriptionEntity entity : createdSignalSubscriptions) {
      if(eventName.equals(entity.getEventName())) {
        eventSubscriptions.add(entity);
      }
    }
    return new ArrayList<EventSubscriptionEntity>(eventSubscriptions);
  }
180850
public void setEventCategories(java.util.Collection<String> eventCategories) {
        if (eventCategories == null) {
            this.eventCategories = null;
            return;
        }

        this.eventCategories = new com.amazonaws.internal.SdkInternalList<String>(eventCategories);
    }
508346
public void setStandardsSubscriptions(java.util.Collection<StandardsSubscription> standardsSubscriptions) {
        if (standardsSubscriptions == null) {
            this.standardsSubscriptions = null;
            return;
        }

        this.standardsSubscriptions = new java.util.ArrayList<StandardsSubscription>(standardsSubscriptions);
    }
526266
@SuppressWarnings("unchecked")
  public List<EventSubscriptionEntity> findSignalEventSubscriptionsByEventNameAndTenantId(String eventName, String tenantId) {
    final String query = "selectSignalEventSubscriptionsByEventNameAndTenantId";

    Map<String, Object> parameter = new HashMap<String, Object>();
    parameter.put("eventName", eventName);
    parameter.put("tenantId", tenantId);
    Set<EventSubscriptionEntity> eventSubscriptions = new HashSet<EventSubscriptionEntity>( getDbEntityManager().selectList(query, parameter));

    // add events created in this command (not visible yet in query)
    for (EventSubscriptionEntity entity : createdSignalSubscriptions) {
      if(eventName.equals(entity.getEventName()) && hasTenantId(entity, tenantId)) {
        eventSubscriptions.add(entity);
      }
    }
    return new ArrayList<EventSubscriptionEntity>(eventSubscriptions);
  }
1070445
protected void adjustStartEventSubscriptions(ProcessDefinitionEntity newLatestProcessDefinition, ProcessDefinitionEntity oldLatestProcessDefinition) {
  	removeObsoleteTimers(newLatestProcessDefinition);
  	addTimerDeclarations(newLatestProcessDefinition);

  	removeObsoleteEventSubscriptions(newLatestProcessDefinition, oldLatestProcessDefinition);
  	addEventSubscriptions(newLatestProcessDefinition);
  }
942083
public void subscribe(final Class<? extends Notification> notificationClass, final Subscription subscription) {
        if (!SUBSCRIPTION_MAP.containsKey(notificationClass)) {
            SUBSCRIPTION_MAP.put(notificationClass, new ArrayList<>());
        }
        final ArrayList<Subscription> subscriptions = SUBSCRIPTION_MAP.get(notificationClass);
        if (!subscriptions.contains(subscription)) {
            subscriptions.add(subscription);
        }
    }
1176133
protected <E extends Event> void subscribeEvent(Class<E> eventClass, final Listener<E> listener) {
        locator.inject(listener);
        locator.postConstruct(listener);
        subscribe(eventClass, listener);
    }
1279109
public void subscribe(Class<? extends Event> eventType, Class<? extends Subscriber> subscriberType) {
        if (!subscriptionMap.containsKey(eventType)) {
            subscriptionMap.put(eventType, new ArrayList<>());
        }
        final ArrayList<Class<? extends Subscriber>> subscribers = subscriptionMap.get(eventType);
        if (!subscribers.contains(subscriberType)) {
            subscribers.add(subscriberType);
        }
    }
1105780
public void setServerEvents(java.util.Collection<ServerEvent> serverEvents) {
        if (serverEvents == null) {
            this.serverEvents = null;
            return;
        }

        this.serverEvents = new java.util.ArrayList<ServerEvent>(serverEvents);
    }
589146
public void setSubscriptions(List<String> subscriptions) {
        this.subscriptions.clear();
        if(subscriptions == null) return;
        for(String currentSubscription: subscriptions) {
            if (this.getNotifierName().equals(AlertService.SupportedNotifier.GUS.getName())) {
                if (currentSubscription.isEmpty() || currentSubscription.length() < 10)
                    throw new IllegalArgumentException("GUS Subscription has to contain subjectId with more than 10 characters.");
            } else if (this.getNotifierName().equals(AlertService.SupportedNotifier.EMAIL.getName())) {

                if (currentSubscription.isEmpty() || !currentSubscription.contains("@")) {
                    String errorMessage = MessageFormat.format("Email Address {0} is not allowed as @ not present.",
                            currentSubscription);
                    throw new IllegalArgumentException(errorMessage);
                }
            } else if (this.getNotifierName().equals(AlertService.SupportedNotifier.CALLBACK.getName()) && currentSubscription.isEmpty()) {
                throw new IllegalArgumentException("Callback Notifier Subscription cannot be empty.");
            }
        }
        if (subscriptions != null && !subscriptions.isEmpty()) {
            this.subscriptions.addAll(subscriptions);
        }
    }
672027
public void setEventDestinations(java.util.Collection<EventDestination> eventDestinations) {
        if (eventDestinations == null) {
            this.eventDestinations = null;
            return;
        }

        this.eventDestinations = new com.amazonaws.internal.SdkInternalList<EventDestination>(eventDestinations);
    }
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);
    }
225189
public static void removeSubscription(Subscription subscription) {
        mSubscriptions.remove(subscription);
        LiveQueryClient.executeQuery(subscription.getQuery().unsubscribeQueryToString());
    }
228858
void register(Object listener) {
    Multimap<Class<?>, Subscriber> listenerMethods = findAllSubscribers(listener);

    for (Map.Entry<Class<?>, Collection<Subscriber>> entry : listenerMethods.asMap().entrySet()) {
      Class<?> eventType = entry.getKey();
      Collection<Subscriber> eventMethodsInListener = entry.getValue();

      CopyOnWriteArraySet<Subscriber> eventSubscribers = subscribers.get(eventType);

      if (eventSubscribers == null) {
        CopyOnWriteArraySet<Subscriber> newSet = new CopyOnWriteArraySet<Subscriber>();
        eventSubscribers =
            MoreObjects.firstNonNull(subscribers.putIfAbsent(eventType, newSet), newSet);
      }

      eventSubscribers.addAll(eventMethodsInListener);
    }
  }
703093
public void setEventDestinations(java.util.Collection<EventDestination> eventDestinations) {
        if (eventDestinations == null) {
            this.eventDestinations = null;
            return;
        }

        this.eventDestinations = new java.util.ArrayList<EventDestination>(eventDestinations);
    }
1189583
private void unclaim(String subscription, Collection<EventList> eventLists) {
        List<String> eventIdsToUnclaim = Lists.newArrayList();
        for (EventList unclaimEvents : eventLists) {
            for (Pair<String, UUID> eventAndChangeId : unclaimEvents.getEventAndChangeIds()) {
                eventIdsToUnclaim.add(eventAndChangeId.first());
            }
        }
        _eventStore.renew(subscription, eventIdsToUnclaim, Duration.ZERO, false);

    }