Builds a temporary list of all listeners, both global and local

@return
544435
private List<AnalyzerChangeListener> getAllListeners() {
        List<AnalyzerChangeListener> globalChangeListeners = getAnalysisJobBuilder().getAnalyzerChangeListeners();
        List<AnalyzerChangeListener> list = new ArrayList<AnalyzerChangeListener>(globalChangeListeners.size()
                + _localChangeListeners.size());
        list.addAll(globalChangeListeners);
        list.addAll(_localChangeListeners);
        return list;
    }
878322
public static MethodInterface[] getAllValues()
    {
        // This list must be created every time, to insure the caller does
        // not modify an internal list. Declaring a static final list does
        // not work, since it only protects the reference to the list, and
        // not the list entries.
        return new MethodInterface[]
        {
         REMOTE,
         HOME,
         LOCAL,
         LOCAL_HOME,
         SERVICE_ENDPOINT,
         TIMED_OBJECT,
         MESSAGE_LISTENER,
         LIFECYCLE_INTERCEPTOR, // F743-1751
        };
    }
398569
@SuppressWarnings("unchecked")
    private List<ListenerRegistration> addListenerToRegistry() {
        List<ListenerRegistration> registrationsBuilder = newArrayList();
        for (Pair<IdMatcher, Watcher> guiceWatcherRegistration : getRegisteredWatchers()) {
            Watcher watcher = guiceWatcherRegistration.right();
            IdMatcher idMatcher = guiceWatcherRegistration.left();
            Registration registration = registry.addWatcher(idMatcher, watcher);
            ListenerRegistration listenerRegistration = new ListenerRegistration(registration, idMatcher, watcher);
            registrationsBuilder.add(listenerRegistration);
        }
        return registrationsBuilder;
    }
431905
private ArrayList<RunListener> instantiateRunListeners() throws Exception {
    ArrayList<RunListener> instances = new ArrayList<>();

    if (runListeners != null) {
      for (String className : Arrays.asList(runListeners.split(","))) {
        instances.add((RunListener) this.instantiate(className).newInstance());
      }
    }

    return instances;
  }
404373
public ListenerContainer<NodeCacheListener> getListenable()
    {
        Preconditions.checkState(state.get() != State.CLOSED, "Closed");

        return listeners;
    }
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;

  }
490303
public List<ListenerType<TldTaglibType<T>>> getAllListener()
   {
      List<ListenerType<TldTaglibType<T>>> list = new ArrayList<ListenerType<TldTaglibType<T>>>();
      List<Node> nodeList = childNode.get("listener");
      for(Node node: nodeList)
      {
         ListenerType<TldTaglibType<T>>  type = new ListenerTypeImpl<TldTaglibType<T>>(this, "listener", childNode, node);
         list.add(type);
      }
      return list;
   }
455228
protected Set<Entry<ADDRESST, EventListener>> listenersEntrySet() {
		final Object mutex = mutex();
		synchronized (mutex) {
			return Collections3.synchronizedSet(this.listeners.entrySet(), mutex);
		}
	}
353258
public List<LocalTime> asList() {
        List<LocalTime> times = new ArrayList<>();
        for (LocalTime time : this) {
            times.add(time);
        }
        return times;
    }
446644
private ArrayList getListener()
    {
        if (_listeners != null)
            return _listeners;
        synchronized (this) {
            if (_listeners != null)
                return _listeners;
            _listeners = new ArrayList();
        }
        return _listeners;
    }
22030
private List<String> processAllListeners(View rootView) {
        List<String> refinementAttributes = new ArrayList<>();

        // Register any AlgoliaResultsListener (unless it has a different variant than searcher)
        final List<AlgoliaResultsListener> resultListeners = LayoutViews.findByClass((ViewGroup) rootView, AlgoliaResultsListener.class);
        if (resultListeners.isEmpty()) {
            throw new IllegalStateException(Errors.LAYOUT_MISSING_RESULT_LISTENER);
        }
        for (AlgoliaResultsListener listener : resultListeners) {
            if (!this.resultListeners.contains(listener)) {
                final String variant = BindingHelper.getVariantForView((View) listener);
                if (variant == null || searcher.variant.equals(variant)) {
                    this.resultListeners.add(listener);
                    searcher.registerResultListener(listener);
                    prepareWidget(listener, refinementAttributes);
                }
            }
        }

        // Register any AlgoliaErrorListener (unless it has a different variant than searcher)
        final List<AlgoliaErrorListener> errorListeners = LayoutViews.findByClass((ViewGroup) rootView, AlgoliaErrorListener.class);
        for (AlgoliaErrorListener listener : errorListeners) {
            if (!this.errorListeners.contains(listener)) {
                final String variant = BindingHelper.getVariantForView((View) listener);
                if (variant == null || searcher.variant.equals(variant)) {
                    this.errorListeners.add(listener);
                }
            }
            searcher.registerErrorListener(listener);
            prepareWidget(listener, refinementAttributes);
        }

        // Register any AlgoliaSearcherListener (unless it has a different variant than searcher)
        final List<AlgoliaSearcherListener> searcherListeners = LayoutViews.findByClass((ViewGroup) rootView, AlgoliaSearcherListener.class);
        for (AlgoliaSearcherListener listener : searcherListeners) {
            final String variant = BindingHelper.getVariantForView((View) listener);
            if (variant == null || searcher.variant.equals(variant)) {
                listener.initWithSearcher(searcher);
                prepareWidget(listener, refinementAttributes);
            }
        }

        return refinementAttributes;
    }
847808
def get_listeners(self):
        """"""
        return [(name, getattr(self, method_name)) for name, method_name in self.__cog_listeners__]
1176859
List<ConnectRequestProxyListener> getConnectRequestProxyListeners() {
        if (connectRequestProxyListeners == null) {
            return Collections.emptyList();
        }
        return Collections.unmodifiableList(connectRequestProxyListeners);
    }
442208
public List<EntityListener<EntityListeners<T>>> getAllEntityListener()
   {
      List<EntityListener<EntityListeners<T>>> list = new ArrayList<EntityListener<EntityListeners<T>>>();
      List<Node> nodeList = childNode.get("entity-listener");
      for(Node node: nodeList)
      {
         EntityListener<EntityListeners<T>>  type = new EntityListenerImpl<EntityListeners<T>>(this, "entity-listener", childNode, node);
         list.add(type);
      }
      return list;
   }
101693
Collection<T> getAllListeners() {
        final Collection<T> toReturn = new ArrayList<>();
        for (ListenerHolder<T> listener : listeners) {
            toReturn.add(listener.delegate);
        }
        return toReturn;
    }
1219131
protected List<SebListener> getDefaultListeners() {
		return new ArrayList<>(Arrays.asList(new ConfigListener(), new LoggingListener(), new SebLogListener(),
				new WebDriverLogListener(), new PageSourceListener(), new ScreenshotListener()));
	}
1091065
public List<DelegateListener<? extends BaseDelegateExecution>> getListeners(String eventName) {
    List<DelegateListener<? extends BaseDelegateExecution>> listenerList = getListeners().get(eventName);
    if (listenerList != null) {
      return listenerList;
    }
    return Collections.emptyList();
  }