<p>
The listeners for the load balancer.
</p>

@return The listeners for the load balancer.
969599
public java.util.List<ListenerDescription> getListenerDescriptions() {
        if (listenerDescriptions == null) {
            listenerDescriptions = new com.amazonaws.internal.SdkInternalList<ListenerDescription>();
        }
        return listenerDescriptions;
    }
1350477
protected final void notifyListeners() {
        Iterator<SMTPClientFutureListener<E>> it = null;
        synchronized (this) {
            if (listeners != null) {
                // notify the listeners
                it  = listeners.iterator();

                listeners = null;
            }
        }
        if (it != null) {
            while(it.hasNext()) {
                SMTPClientFutureListener<E> listener = null;
                try {
                    listener = it.next();
                    listener.operationComplete(this);
                } catch (Throwable e) {
                    LOGGER.warn("Exception thrown while executing " + SMTPClientFutureListener.class.getName() + " " + listener, e);
                }
            }
        }
    }
570807
public void setLoadBalancerDescriptions(java.util.Collection<LoadBalancerDescription> loadBalancerDescriptions) {
        if (loadBalancerDescriptions == null) {
            this.loadBalancerDescriptions = null;
            return;
        }

        this.loadBalancerDescriptions = new com.amazonaws.internal.SdkInternalList<LoadBalancerDescription>(loadBalancerDescriptions);
    }
639878
private List<Class<?>> getAllInternalListeners() {
    Class<?> clazz = entityClass;
    List<Class<?>> allListeners = new ArrayList<>();
    boolean stop = false;
    while (!stop) {
      allListeners.add(0, clazz);
      boolean excludeSuperClassListeners = clazz
          .isAnnotationPresent(ExcludeSuperclassListeners.class);
      clazz = clazz.getSuperclass();
      stop = excludeSuperClassListeners || clazz == null
          || !clazz.isAnnotationPresent(MappedSuperClass.class);
    }
    return allListeners;

  }
455525
List<HttpSenderListener> getHttpSenderListeners() {
        if (httpSenderListeners == null) {
            return Collections.emptyList();
        }
        return Collections.unmodifiableList(httpSenderListeners);
    }
266413
@Override
    public boolean contextListenerStart() {
		boolean ok = super.contextListenerStart();
		//the web listeners couldn't be started so we don't even try to load the sip ones
		if(!ok) {
			return ok;
		}

		if (logger.isDebugEnabled())
            logger.debug("Configuring sip listeners");

        // Instantiate the required listeners
        ClassLoader loader = getLoader().getClassLoader();
        ok = sipListeners.loadListeners(findSipApplicationListeners(), loader);
        if(!ok) {
			return ok;
		}

        List<ServletContextListener> servletContextListeners = sipListeners.getServletContextListeners();
        if (servletContextListeners != null) {
            ServletContextEvent event =
                new ServletContextEvent(getServletContext());
            for (ServletContextListener servletContextListener : servletContextListeners) {
                if (servletContextListener == null)
                    continue;

                try {
                    fireContainerEvent("beforeContextInitialized", servletContextListener);
                    servletContextListener.contextInitialized(event);
                    fireContainerEvent("afterContextInitialized", servletContextListener);
                } catch (Throwable t) {
                    fireContainerEvent("afterContextInitialized", servletContextListener);
//                    getLogger().error
//                        (sm.getString("standardContext.listenerStart",
//                        		servletContextListener.getClass().getName()), t);
                    getLogger().error
                    	(MESSAGES.errorSendingContextInitializedEvent(servletContextListener.getClass().getName()), t);
                    ok = false;
                }

                // TODO Annotation processing
            }
        }

        return (ok);

    }
950795
public MetaClassRegistryChangeEventListener[] getMetaClassRegistryChangeEventListeners() {
        synchronized (changeListenerList) {
            ArrayList<MetaClassRegistryChangeEventListener> ret =
                    new ArrayList<MetaClassRegistryChangeEventListener>(changeListenerList.size()+nonRemoveableChangeListenerList.size());
            ret.addAll(nonRemoveableChangeListenerList);
            ret.addAll(changeListenerList);
            return ret.toArray(new MetaClassRegistryChangeEventListener[ret.size()]);
        }
    }
724836
public List<TriggerListener> getInternalTriggerListeners() {

    synchronized (internalTriggerListeners) {
      return java.util.Collections.unmodifiableList(
          new LinkedList<TriggerListener>(internalTriggerListeners.values()));
    }
  }
385467
public void registerListenerExtensions() {
    if (listenerExtensionsRegistered) {
      throw H2O.fail("Listeners already registered");
    }

    long before = System.currentTimeMillis();
    ServiceLoader<H2OListenerExtension> extensionsLoader = ServiceLoader.load(H2OListenerExtension.class);
    for (H2OListenerExtension ext : extensionsLoader) {
      ext.init();
      listenerExtensions.put(ext.getName(), ext);
    }
    listenerExtensionsRegistered = true;
    registerListenerExtensionsMillis = System.currentTimeMillis() - before;
  }
464121
def create_listeners(name, listeners, region=None, key=None, keyid=None,
                     profile=None):
    '''
    
    '''
    conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)

    if isinstance(listeners, six.string_types):
        listeners = salt.utils.json.loads(listeners)

    _complex_listeners = []
    for listener in listeners:
        _complex_listeners.append(listener_dict_to_tuple(listener))
    try:
        conn.create_load_balancer_listeners(name, [], _complex_listeners)
        log.info('Created ELB listeners on %s', name)
        return True
    except boto.exception.BotoServerError as error:
        log.error('Failed to create ELB listeners on %s: %s', name, error,
                  exc_info_on_loglevel=logging.DEBUG)
        return False
1328810
public void setListeners(final List listeners) {
        // early type check, and avoid aliassing
        this.preListeners = new ArrayList<IReloadablePropertiesListener>();
        for (Object o : listeners) {
            preListeners.add((IReloadablePropertiesListener) o);
        }
    }
1043153
public Listeners<JobXMLDescriptor> getOrCreateListeners()
   {
      Node node = model.getOrCreate("listeners");
      Listeners<JobXMLDescriptor> listeners = new ListenersImpl<JobXMLDescriptor>(this, "listeners", model, node);
      return listeners;
   }
477477
public List<ChannelListener> getChannelListeners() {
        if (changes == null) {
            return (List<ChannelListener>)Collections.EMPTY_LIST;
        }

        List<EventListener> listeners = changes.getListenerList(AMQP);
        if ((listeners == null) || listeners.isEmpty()) {
            return (List<ChannelListener>)Collections.EMPTY_LIST;
        }

        ArrayList<ChannelListener> list = new ArrayList<ChannelListener>();
        for (EventListener listener : listeners) {
            list.add((ChannelListener)listener);
        }

        return list;
    }
12218
public java.util.List<String> getLoadBalancerNames() {
        if (loadBalancerNames == null) {
            loadBalancerNames = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return loadBalancerNames;
    }
802001
private void addLoadBalancerListener() {
        if (!(lbContext.getLoadBalancer() instanceof BaseLoadBalancer)) {
            return;
        }
        
        ((BaseLoadBalancer) lbContext.getLoadBalancer()).addServerListChangeListener(new ServerListChangeListener() {
            @Override
            public void serverListChanged(List<Server> oldList, List<Server> newList) {
                Set<Server> removedServers = new HashSet<Server>(oldList);
                removedServers.removeAll(newList);
                for (Server server: rxClientCache.keySet()) {
                    if (removedServers.contains(server)) {
                        // this server is no longer in UP status
                        removeClient(server);
                    }
                }
            }
        });
    }
770461
List<ConnectionListener> getConnectionListeners(ConnectionManager cm)
   {
      if (cmToCl == null)
         return Collections.unmodifiableList(Collections.emptyList());

      List<ConnectionListener> l = cmToCl.get(cm);
      if (l == null)
         l = Collections.emptyList();
      
      return Collections.unmodifiableList(l);
   }
1015062
protected List<JingleListener> getListenersList() {
        ArrayList<JingleListener> result;

        synchronized (listeners) {
            result = new ArrayList<>(listeners);
        }

        return result;
    }