Takes a list of raw corpus names as given by the #c parameter and returns a
list of corpus names that are known to exist. It also replaces alias names
with the real corpus names.

@param originalNames
@return
429798
private Set<String> getMappedCorpora(List<String> originalNames)
  {
    WebResource rootRes = Helper.getAnnisWebResource();
    Set<String> mappedNames = new HashSet<>();
    // iterate over given corpora and map names if necessary
    for (String selectedCorpusName : originalNames)
    {
      // get the real corpus descriptions by the name (which could be an alias)
      try
      {
        List<AnnisCorpus> corporaByName
          = rootRes.path("query").path("corpora").path(urlPathEscape.escape(
              selectedCorpusName))
          .get(new GenericType<List<AnnisCorpus>>()
          {
          });

        if (corporaByName != null && !corporaByName.isEmpty())
        {
          for (AnnisCorpus c : corporaByName)
          {
            mappedNames.add(c.getName());
          }
        }
      }
      catch (ClientHandlerException ex)
      {
        String msg = "alias mapping does not work for alias: "
          + selectedCorpusName;
        log.error(msg, ex);
        Notification.show(msg, Notification.Type.TRAY_NOTIFICATION);
      }
    }
    return mappedNames;
  }
1358511
@Override
    public Set<String> getIDPEntityNames() {
        Set<String> result = new HashSet<>();
        ExtendedMetadataDelegate delegate = null;
        try {
            delegate = getLocalIdp();
            String idp = getProviderIdpAlias(delegate);
            if (StringUtils.hasText(idp)) {
                result.add(idp);
            }
        } catch (MetadataProviderException e) {
            log.error("Unable to get IDP alias for:" + delegate, e);
        }
        return result;
    }
1314736
private static AuthoritativeNameServerList extractAuthoritativeNameServers(String questionName, DnsResponse res) {
        int authorityCount = res.count(DnsSection.AUTHORITY);
        if (authorityCount == 0) {
            return null;
        }

        AuthoritativeNameServerList serverNames = new AuthoritativeNameServerList(questionName);
        for (int i = 0; i < authorityCount; i++) {
            serverNames.add(res.recordAt(DnsSection.AUTHORITY, i));
        }
        return serverNames.isEmpty() ? null : serverNames;
    }
610797
public static dnscnamerec[] get(nitro_service service) throws Exception{
		dnscnamerec obj = new dnscnamerec();
		dnscnamerec[] response = (dnscnamerec[])obj.get_resources(service);
		return response;
	}
1289279
public ListDomainNamesResult withDomainNames(java.util.Map<String, String> domainNames) {
        setDomainNames(domainNames);
        return this;
    }
438314
public static List<Expression> renameColumns(List<String> inputFields, List<Expression> newAliases) {
		LinkedHashMap<String, Expression> finalFields = new LinkedHashMap<>();

		inputFields.forEach(field -> finalFields.put(field, new UnresolvedReferenceExpression(field)));
		newAliases.forEach(expr -> {
			String name = expr.accept(renameColumnExtractor);
			finalFields.put(name, expr);
		});

		return new ArrayList<>(finalFields.values());
	}
846116
public Collection<String> getNames() {
		Collection<String> names = new HashSet<String>();
		for (InitParam initParam : initParams) {
			names.add(initParam.getName());
		}
		return names;
	}
335297
public List<NamedNativeQuery<OrmDescriptor>> getAllNamedNativeQuery()
   {
      List<NamedNativeQuery<OrmDescriptor>> list = new ArrayList<NamedNativeQuery<OrmDescriptor>>();
      List<Node> nodeList = model.get("named-native-query");
      for(Node node: nodeList)
      {
         NamedNativeQuery<OrmDescriptor>  type = new NamedNativeQueryImpl<OrmDescriptor>(this, "named-native-query", model, node);
         list.add(type);
      }
      return list;
   }
296895
public List<String> getI18nkeys() {
    	if (i18nkeys == null) {
    		return new ArrayList<String>();
    	}
    	Collections.sort(i18nkeys, new Comparator<String>() {

			@Override
			public int compare(String o1, String o2) {				
				return Collator.getInstance().compare(o1, o2);
			}
		});
		return i18nkeys;
	}
136379
def _fake_referencenames(self, namespace, **params):
        
        assert params['ResultClass'] is None or \
            isinstance(params['ResultClass'], CIMClassName)

        rc = None if params['ResultClass'] is None else \
            params['ResultClass'].classname
        role = params['Role']
        obj_name = params['ObjectName']
        classname = obj_name.classname

        if isinstance(obj_name, CIMClassName):
            ref_classnames = self._get_reference_classnames(classname,
                                                            namespace,
                                                            rc, role)

            ref_result = [CIMClassName(classname=cn, host=self.host,
                                       namespace=namespace)
                          for cn in ref_classnames]

            return self._return_assoc_tuple(ref_result)

        assert isinstance(obj_name, CIMInstanceName)
        ref_paths = self._get_reference_instnames(obj_name, namespace,
                                                  rc, role)
        rtn_names = [deepcopy(r) for r in ref_paths]

        for iname in rtn_names:
            if iname.host is None:
                iname.host = self.host

        return self._return_assoc_tuple(rtn_names)
1176467
def get_aliases(lines):
    
    aliases = {}
    for line in lines:
        line = line.strip()
        if len(line) > 0 and line.startswith(SIG_ALIAS):
            _, content = line.split(SIG_ALIAS)
            alias, signature = [t.strip() for t in content.split("=")]
            aliases[alias] = signature
    return aliases
842791
public Collection<String> getLogicTableNames(final String actualTableName) {
        Collection<String> result = new LinkedList<>();
        for (TableRule each : tableRules) {
            if (each.isExisted(actualTableName)) {
                result.add(each.getLogicTable());
            }
        }
        return result;
    }
303795
public java.util.List<AliasConfiguration> getAliases() {
        if (aliases == null) {
            aliases = new com.amazonaws.internal.SdkInternalList<AliasConfiguration>();
        }
        return aliases;
    }
544270
public synchronized Collection<String> getNames() {
        if (map == null) {
            return Collections.emptySet();
        }
        return Collections.unmodifiableSet(new HashMap<String,String>(map).keySet());
    }
1327419
public List<String> replaceRunOnWords(final String original) {
    final List<String> candidates = new ArrayList<String>();
    String wordToCheck = original;
    if (!dictionaryMetadata.getInputConversionPairs().isEmpty()) {
      wordToCheck = DictionaryLookup.applyReplacements(original, dictionaryMetadata.getInputConversionPairs());
    }
    if (!isInDictionary(wordToCheck) && dictionaryMetadata.isSupportingRunOnWords()) {
      for (int i = 1; i < wordToCheck.length(); i++) {
        // chop from left to right
        final CharSequence firstCh = wordToCheck.subSequence(0, i);
        if (isInDictionary(firstCh) && isInDictionary(wordToCheck.subSequence(i, wordToCheck.length()))) {
          if (dictionaryMetadata.getOutputConversionPairs().isEmpty()) {
            candidates.add(firstCh + " " + wordToCheck.subSequence(i, wordToCheck.length()));
          } else {
            candidates.add(DictionaryLookup.applyReplacements(firstCh + " " + wordToCheck.subSequence(i, wordToCheck.length()),
                dictionaryMetadata.getOutputConversionPairs()).toString());
          }
        }
      }
    }
    return candidates;
  }
1119285
public java.util.List<String> getNames() {
        if (names == null) {
            names = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return names;
    }
650338
public static String[] getFormatNames() {

        JsArrayString formatNames = nativeGetFormatNames();
        if ((formatNames == null) || (formatNames.length() == 0)) {
            return null;
        }
        String[] result = new String[formatNames.length()];
        for (int i = 0; i < formatNames.length(); i++) {
            result[i] = formatNames.get(i);
        }
        return result;
    }