Add all strings to existing candidates.
420147
public void addAll(final Iterable<String> strings) {
    checkNotNull(strings);
    for (String string : strings) {
      add(string);
    }
  }
658315
def _add_match(self, match_key, match_value, match):
        """"""
        if match_key is None:
            raise NullArgument()
        if match is None:
            match = True
        if match:
            inin = '$in'
        else:
            inin = '$nin'
        if match_key in self._query_terms:
            if inin in self._query_terms[match_key]:
                self._query_terms[match_key][inin].append(match_value)
            else:
                self._query_terms[match_key][inin] = [match_value]
        else:
            self._query_terms[match_key] = {inin: [match_value]}
1209459
def add_matches(self, matcher, lhs,
                    match_params=[], include_params=[], exclude_params=[],
                    numq=1, flatten=None):
        
        matcher = adapt_matcher(matcher)
        notmatcher = negate(matcher)
        self.add_and_matches(matcher, lhs, match_params, numq, flatten)
        self.add_or_matches(matcher, lhs, include_params, numq, flatten)
        self.add_and_matches(notmatcher, lhs, exclude_params, numq, flatten)
275198
def add_params(self, p):
        """"""
        new_params = p.copy()
        for key,val in new_params.items():
            if not isinstance(val, collections.Iterable):
                new_params[key] = [new_params[key]]
            #_check_comb_param(key, val)
        self.comb_params.update(new_params)
151879
def _flds_append(flds, addthese, dont_add):
        """"""
        for fld in addthese:
            if fld not in flds and fld not in dont_add:
                flds.append(fld)
247069
@Override
    void completeCandidates(CommandContext ctx, String buffer, int cursor, List<String> candidates) {
        if (candidates.isEmpty()) {
            if (buffer.startsWith("\"") && buffer.length() >= 2) {
                // Quotes are added back by super class.
                buffer = buffer.substring(1);
            }
            if (buffer.length() == 2 && buffer.endsWith(":")) {
                candidates.add(buffer + File.separator);
            }
        }
    }
186712
private void replaceStringsWithAliases() {
    for (Entry<String, StringInfo> entry : stringInfoMap.entrySet()) {
      String literal = entry.getKey();
      StringInfo info = entry.getValue();
      if (shouldReplaceWithAlias(literal, info)) {
        for (StringOccurrence occurrence : info.occurrences) {
          replaceStringWithAliasName(
              occurrence, info.getVariableName(literal), info);
        }
      }
    }
  }
544633
public void addValues(String name, List<V> values) {
        List<V> lo = get(name);
        if (lo == null) {
            lo = new ArrayList<>();
        }
        lo.addAll(values);
        put(name, lo);
    }
141263
public static void addToListIfNotExists(List<String> list, String value) {
        boolean found = false;
        for (String item : list) {
            if (item.equalsIgnoreCase(value)) {
                found = true;
                break;
            }
        }
        if (!found) {
            list.add(value);
        }
    }
1286574
private static String foundCandidatesString(Tuple<Decl.Callable> candidates) {
		ArrayList<String> candidateStrings = new ArrayList<>();
		for (Decl.Callable c : candidates) {
			candidateStrings.add(candidateString(c, null));
		}
		Collections.sort(candidateStrings); // make error message deterministic!
		StringBuilder msg = new StringBuilder();
		for (String s : candidateStrings) {
			msg.append("\n\tfound ");
			msg.append(s);
		}
		return msg.toString();
	}
342763
def _string_in_table(self, candidate: str) -> List[str]:
        
        candidate_column_names: List[str] = []
        # First check if the entire candidate occurs as a cell.
        if candidate in self._string_column_mapping:
            candidate_column_names = self._string_column_mapping[candidate]
        # If not, check if it is a substring pf any cell value.
        if not candidate_column_names:
            for cell_value, column_names in self._string_column_mapping.items():
                if candidate in cell_value:
                    candidate_column_names.extend(column_names)
        candidate_column_names = list(set(candidate_column_names))
        return candidate_column_names
813724
public void addString(String str)
    {
        if (sourceNode != null)
        {
            addStringInternal(str);
            replaceOrRegister(sourceNode, str);
        }
        else
        {
            unSimplify();
            addString(str);
        }
    }
1305905
public final void addString(String key, String... values) {
        if (values == null || Array.getLength(values) == 0) {
            return;
        }
        List<String> list = parameters.get(key);
        if (list == null) {
            list = new ArrayList<>();
        }
        list.addAll(Arrays.asList(values));
        parameters.put(key, list);
    }
398884
def process(self, unordered_candidates):
        
        ordered_candidates = []
        # make a new list of candidates in order of ordered_locators
        for locator in self.ordered_locators:
            for uc in unordered_candidates[:]:
                if uc.locator == locator:
                    ordered_candidates.append(uc)
                    unordered_candidates.remove(uc)
        # add all the candidates that are still left
        # (whose locator values are not in ordered_locators)
        # and return the new list
        return ordered_candidates + unordered_candidates
440676
public static <SOURCE, TARGET> AddAll<SOURCE, TARGET> to(Position.Readable<TARGET> targetPosition,
        Position.Readable<SOURCE> sourcePosition) {
        return new AddAll<>(sourcePosition, targetPosition);
    }
659194
def load_merge_candidate(self, filename=None, config=None):
        """"""
        self.config_replace = False
        self._load_candidate(filename, config, False)
1184603
public void replaceStringChildren(List<String> strings) {
		ArrayList<StringEntity> entities = new ArrayList<>();
		for (String string : strings) {
			StringEntity entity = new StringEntity();
			entity.setValue(string);
			entities.add(entity);
		}
		replaceAll(entities);
	}