Returns all <code>handler-chain</code> elements
@return list of <code>handler-chain</code>
199740
public List<HandlerChainType<HandlerChainsType<T>>> getAllHandlerChain()
   {
      List<HandlerChainType<HandlerChainsType<T>>> list = new ArrayList<HandlerChainType<HandlerChainsType<T>>>();
      List<Node> nodeList = childNode.get("handler-chain");
      for(Node node: nodeList)
      {
         HandlerChainType<HandlerChainsType<T>>  type = new HandlerChainTypeImpl<HandlerChainsType<T>>(this, "handler-chain", childNode, node);
         list.add(type);
      }
      return list;
   }
677775
public String[] getPaths()
    {
        ServletHandler handler = (ServletHandler)_holder.getHttpHandler();
        Map servletMap = handler.getServletMap();
        ArrayList paths = new ArrayList(servletMap.size());
        Iterator iter = servletMap.entrySet().iterator();
        while (iter.hasNext())
        {
            Map.Entry entry =(Map.Entry)iter.next();
            if (entry.getValue()==_holder)
                paths.add(entry.getKey());
        }
        return (String[])paths.toArray(new String[paths.size()]);
    }
1193110
public ArrayList<String> getThrowsList()
    {
        ArrayList<String> throwsList = new ArrayList<String>();

        if ( _methodDecl == null ||
             _methodDecl.getThrownTypes() == null ||
             _methodDecl.getThrownTypes().size() == 0 )
            return throwsList;
        
        Collection<ReferenceType> thrownTypes = _methodDecl.getThrownTypes();
        for (ReferenceType exceptType : thrownTypes)
            throwsList.add(exceptType.toString());

        return throwsList;
    }
293694
@SafeVarargs
    public static <T> Callback<T> chain(Callback<T>... callbacks)
    {
        return chain(Arrays.asList(callbacks));
    }
490500
public java.util.List<Selector> getSelectors() {
        if (selectors == null) {
            selectors = new com.amazonaws.internal.SdkInternalList<Selector>();
        }
        return selectors;
    }
565968
public List<Assignment> enumerateAllModels(final ModelEnumerationHandler handler) {
        return this.enumerateAllModels((Collection<Variable>) null, handler);
    }
46879
function getHandlers(handlers) {
        if (typeof handlers === 'string') {
          prev[c.script].handlers.push(handlers)
        } else if (Array.isArray(c.handlers)) {
          c.handlers.forEach(h => {
            prev[c.script].handlers.push(h)
          })
        } else {
          Object.keys(handlers).forEach(k => getHandlers(handlers[k]))
        }
      }
1156391
public Set<String> getChains() {
		Set<String> chains = new HashSet<String>();
		List<ResidueRange> rrs = toCanonical().getResidueRanges();
		for (ResidueRange rr : rrs) chains.add(rr.getChainName());
		return chains;
	}

	@Override
	public String getIdentifier() {
		return getCATH();
	}

	@Override
	public SubstructureIdentifier toCanonical() {
		List<ResidueRange> ranges = new ArrayList<ResidueRange>();
		String chain = String.valueOf(getDomainName().charAt(getDomainName().length() - 3));
		for (CathSegment segment : this.getSegments()) {
			ranges.add(new ResidueRange(chain, segment.getStart(), segment.getStop()));
		}

		return new SubstructureIdentifier(getThePdbId(), ranges);
	}

	@Override
	public Structure reduce(Structure input) throws StructureException {
		return toCanonical().reduce(input);
	}

	@Override
	public Structure loadStructure(AtomCache cache) throws StructureException,
			IOException {
		return cache.getStructure(getThePdbId());
	}


}
641515
public List<ServiceRefHandlerType<ServiceRefType<T>>> getAllHandler()
   {
      List<ServiceRefHandlerType<ServiceRefType<T>>> list = new ArrayList<ServiceRefHandlerType<ServiceRefType<T>>>();
      List<Node> nodeList = childNode.get("handler");
      for(Node node: nodeList)
      {
         ServiceRefHandlerType<ServiceRefType<T>>  type = new ServiceRefHandlerTypeImpl<ServiceRefType<T>>(this, "handler", childNode, node);
         list.add(type);
      }
      return list;
   }
1357692
@SuppressWarnings("rawtypes")
    public static List<Handler> sortHandlers(List<Handler> handlers) {

        List<LogicalHandler<?>> logicalHandlers = new ArrayList<LogicalHandler<?>>();
        List<Handler<?>> protocolHandlers = new ArrayList<Handler<?>>();

        for (Handler<?> handler : handlers) {
            if (handler instanceof LogicalHandler) {
                logicalHandlers.add((LogicalHandler<?>) handler);
            } else {
                protocolHandlers.add(handler);
            }
        }

        List<Handler> sortedHandlers = new ArrayList<Handler>(logicalHandlers.size() + protocolHandlers.size());
        sortedHandlers.addAll(logicalHandlers);
        sortedHandlers.addAll(protocolHandlers);
        return sortedHandlers;
    }
897257
public static ClickHandler chain (final ClickHandler... handlers)
    {
        return new ClickHandler() {
            public void onClick (ClickEvent event) {
                for (ClickHandler handler : handlers) {
                    try {
                        handler.onClick(event);
                    } catch (Exception e) {
                        Console.log("Chained click handler failed", "handler", handler, e);
                    }
                }
            }
        };
    }
531527
private List<RequestHandler2> resolveRequestHandlers() {
        return (requestHandlers == null) ? new ArrayList<RequestHandler2>() :
                new ArrayList<RequestHandler2>(requestHandlers);
    }
487017
public List<T> getElements() {
		ArrayList<T> list = new ArrayList<>(nodes.size());
		for (Node<T> node : nodes)
			list.add(node.element);
		return list;
	}
	
	/** Return the number of elements. */
	public int size() { return nodes.size(); }
	
}
624010
public AbstractHandlerMapping getHandlerMapping() {
		Map<String, Object> urlMap = new LinkedHashMap<>();
		for (WebMvcWampWebSocketEndpointRegistration registration : this.registrations) {
			MultiValueMap<HttpRequestHandler, String> mappings = registration
					.getMappings();
			for (HttpRequestHandler httpHandler : mappings.keySet()) {
				for (String pattern : mappings.get(httpHandler)) {
					urlMap.put(pattern, httpHandler);
				}
			}
		}
		SimpleUrlHandlerMapping hm = new SimpleUrlHandlerMapping();
		hm.setUrlMap(urlMap);
		hm.setOrder(this.order);
		if (this.urlPathHelper != null) {
			hm.setUrlPathHelper(this.urlPathHelper);
		}
		return hm;
	}
387782
public List<Set<T>> getCycles() {
        return scc.stream().filter(cc ->
                cc.size() > 1
                        || graph.get(Iterables.getOnlyElement(cc)).contains(Iterables.getOnlyElement(cc))
        )
                .collect(Collectors.toList());
    }
1087147
public java.util.List<? extends com.google.rpc.Help.LinkOrBuilder> 
      getLinksOrBuilderList() {
    return links_;
  }
761815
@Override
    public synchronized ChainData[] getRunningChains() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.entry(tc, "getRunningChains");
        }

        ChainData chainDataArray[] = new ChainData[chainRunningMap.size()];
        ChainDataImpl chainData = null;
        int index = 0;

        Iterator<Chain> chainIter = chainRunningMap.values().iterator();
        while (chainIter.hasNext()) {
            chainData = (ChainDataImpl) chainIter.next().getChainData();
            // Extract the external version, hiding all child channel data objects.
            chainDataArray[index++] = chainData.getExternalChainData();
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.exit(tc, "getRunningChains");
        }
        return chainDataArray;
    }