Gets all of the lexicon entries used in {@code parses}.

@param parses
@return
190386
private static Set<LexiconEntry> getLexiconEntriesFromParses(Collection<CcgParse> parses) {
    // Generate candidate lexicon entries from the correct max parses.
    Set<LexiconEntry> candidateEntries = Sets.newHashSet();
    for (CcgParse correctMaxParse : parses) {
      for (LexiconEntryInfo info : correctMaxParse.getSpannedLexiconEntries()) {
        CcgCategory category = info.getCategory();
        Object trigger = info.getLexiconTrigger();
        List<String> words = (List<String>) trigger;
                
        candidateEntries.add(new LexiconEntry(words, category));
      }
    }
    return candidateEntries;
  }
313464
public List<Match<E>> findAll(List<E> tokens) {
        List<Match<E>> results = new ArrayList<Match<E>>();

        int start = 0;
        Match<E> match;
        do {
            match = this.find(tokens, start);

            if (match != null) {
                start = match.endIndex();

                // match may be empty query string has all optional parts
                if (!match.isEmpty()) {
                    results.add(match);
                }
            }
        } while (match != null);

        return results;
    }
219636
private Set<String> loadVerbStemSet(String[] verbStems) {
  HashSet<String> set = new HashSet<String>(verbStems.length);
  for (String stem : verbStems) {
    set.add(stem);
  }
  return set;
}
804076
public List<LexiconEntryInfo> getSpannedLexiconEntries() {
    if (isTerminal()) {
      return Arrays.asList(lexiconEntry);
    } else {
      List<LexiconEntryInfo> lexiconEntries = Lists.newArrayList();
      lexiconEntries.addAll(left.getSpannedLexiconEntries());
      lexiconEntries.addAll(right.getSpannedLexiconEntries());
      return lexiconEntries;
    }
  }
1339855
public static List<ParserDescription> getAvailableParsers() {
        Set<String> groups = Sets.newHashSet();
        for (AbstractWarningsParser parser : getAllParsers()) {
            groups.add(parser.getGroup());
        }

        List<ParserDescription> sorted = Lists.newArrayList();
        for (String group : groups) {
            sorted.add(new ParserDescription(group, getParser(group).getParserName()));
        }
        Collections.sort(sorted);
        return sorted;
    }
388221
protected List<String> parseNameList( DdlTokenStream tokens ) throws ParsingException {
        List<String> names = new LinkedList<String>();

        while (true) {
            names.add(parseName(tokens));

            if (!tokens.canConsume(COMMA)) {
                break;
            }
        }

        return names;
    }
322582
public List<String> extractFeatSingle(int i, final String[] tokens, final String[] pos) {
        List<String> currentFeats = new ArrayList<>();

        for (int index = Math.max(0, i - 2); index < Math.min(i + 3, tokens.length); index++) { // [-2,2]
            IFeatureExtractor.addFeat(currentFeats, "w" + (index - i), tokens[index]);
            IFeatureExtractor.addFeat(currentFeats, "pos" + (index - i), pos[index]);

            if (index == i - 1) {
                IFeatureExtractor.addFeat(currentFeats, "w-10", tokens[i - 1], tokens[i]);
                IFeatureExtractor.addFeat(currentFeats, "pos-10", pos[i - 1], pos[i]);
            } else if (index == i + 1) {
                IFeatureExtractor.addFeat(currentFeats, "w0+1", tokens[i], tokens[i + 1]);
                IFeatureExtractor.addFeat(currentFeats, "pos0+1", pos[i], pos[i + 1]);
            } else if (index == i - 2) {
                IFeatureExtractor.addFeat(currentFeats, "pos-2-1", pos[i - 2], pos[i - 1]);
                IFeatureExtractor.addFeat(currentFeats, "pos-2-10", pos[i - 2], pos[i - 1], pos[i]);
            } else if (index == i + 2) {
                IFeatureExtractor.addFeat(currentFeats, "pos+1+2", pos[i + 1], pos[i + 2]);
            }

            if (index == i - 1 && i < tokens.length - 1) {
                IFeatureExtractor.addFeat(currentFeats, "pos-10+1", pos[i - 1], pos[i], pos[i + 1]);
            }

            if (index == i + 2) {
                IFeatureExtractor.addFeat(currentFeats, "pos0+1+2", pos[i], pos[i + 1], pos[i + 2]);
            }
        }

        currentFeats.addAll(BrownFeatExtractor.extractBrownFeat(i, -2, 2, tokens));
        return currentFeats;
    }
251171
public static Set<Method> getAllMethods(Class<?> classs) {
    Set<Method> set = new HashSet<>();
    Class<?> c = classs;
    while (c != null) {
      set.addAll(Arrays.asList(c.getDeclaredMethods()));
      c = c.getSuperclass();
    }
    return set;
  }
414292
@Override
	public Set<String> getPrefixes() {
		lock.readLock().lock();
		try {
			return new TreeSet<String>(prefixes);
		} finally {
			lock.readLock().unlock();
		}
	}
45348
public Set<DbLicense> resolveLicenses(List<String> licStrings) {
        Set<DbLicense> result = new HashSet<>();

        licStrings
                .stream()
                .map(this::getMatchingLicenses)
                .forEach(result::addAll);

        return result;
    }
1167657
public final List<SequenceLabel> getSequencesFromSpans(final String[] tokens,
      final Span[] seqSpans) {
    final List<SequenceLabel> sequences = new ArrayList<SequenceLabel>();
    for (final Span seqSpan : seqSpans) {
      final String seqString = seqSpan.getCoveredText(tokens);
      final String seqType = seqSpan.getType();
      final SequenceLabel sequence = this.sequenceFactory
          .createSequence(seqString, seqType, seqSpan);
      sequences.add(sequence);
    }
    return sequences;
  }
651577
public List<Tree> getTrees(String sentences) throws Exception {
        List<Tree> ret = new ArrayList<>();
        List<Tree> baseTrees = parser.getTrees(sentences);
        for (Tree t : baseTrees) {
            Tree binarized = treeTransformer.transform(t);
            binarized = cnfTransformer.transform(binarized);
            ret.add(binarized);
        }

        return ret;

    }
859161
protected List<Map<String, ?>> generateLiterals(Set<String> literals) {
		final List<Map<String, ?>> list = new ArrayList<>();
		if (!literals.isEmpty()) {
			list.add(pattern(it -> {
				it.matches(keywordRegex(literals));
				it.style(LITERAL_STYLE);
				it.comment("SARL Literals and Constants"); //$NON-NLS-1$
			}));
		}
		return list;
	}
1300352
public static Collection<DisqueNode> parse(String nodes) {
        List<DisqueNode> result = new ArrayList<>();

        Iterator<String> iterator = TOKEN_PATTERN.splitAsStream(nodes).iterator();

        try {
            while (iterator.hasNext()) {
                String node = iterator.next();
                DisqueNode partition = parseNode(node);
                result.add(partition);
            }

        } catch (Exception e) {
            throw new RedisException("Cannot parse " + nodes, e);
        }

        return result;
    }
7588
public Set<Map.Entry<String, String>> getSetEntries() {
      Set<Map.Entry<String, String>> entries = optionSet.stream()
                                                        .filter(this::isSet)
                                                        .map(no -> Tuple2.of(no.getName(),
                                                                             Convert.convert(no.getValue(),
                                                                                             String.class)))
                                                        .collect(Collectors.toSet());
      entries.addAll(unamedOptions.entrySet());
      return entries;
   }
572753
public static List<AbstractWarningsParser> getParsers(final Collection<String> parserGroups) {
        List<AbstractWarningsParser> actualParsers = new ArrayList<AbstractWarningsParser>();
        for (String name : parserGroups) {
            for (AbstractWarningsParser warningsParser : getAllParsers()) {
                if (warningsParser.isInGroup(name)) {
                    actualParsers.add(warningsParser);
                }
            }
        }
        return actualParsers;
    }
439012
public Set<java.util.Map.Entry<String, T>> entrySet()
	{
		return lookupMap.entrySet();
	}