How to use

containsValue

method

in

java.util.Map

@Override
public boolean contains(Object o)
{
  if (o instanceof String)
    return termFrequencyMap.containsKey(o);
  else if (o instanceof TermFrequency)
    return termFrequencyMap.containsValue(o);
  return false;
}

private static String findNamespaceTag(final Map tagMap, final Object namespaceURI) {
  if (tagMap.containsValue(namespaceURI)) {
    for (Object o : tagMap.entrySet()) {
      final Map.Entry entry = (Map.Entry) o;
      if (namespaceURI.equals(entry.getValue())) {
        return (String) entry.getKey();
      }
    }
  }
  return null;
}

private String getValidTagAttributeName(String originalName) {
  if (XMLChar.isValidName(originalName)) {
    return originalName;
  }
  if (tagAttrDeobfNames.containsKey(originalName)) {
    return tagAttrDeobfNames.get(originalName);
  }
  String generated;
  do {
    generated = generateTagAttrName();
  }
  while (tagAttrDeobfNames.containsValue(generated));
  tagAttrDeobfNames.put(originalName, generated);
  return generated;
}

private String changeWord(final String word) {
  final String lower = word.toLowerCase();
  if (except.contains(lower) || lower.matches("^[a-f0-9]{6}$")) {
    return word;
  }
  String res = convert.get(word);
  if (res != null) {
    return res;
  }
  int len = word.length();
  if (len < 4) {
    len = 4;
  }
  while (true) {
    final StringBuilder sb = new StringBuilder();
    for (int i = 0; i < len; i++) {
      final char letter = (char) ('a' + rnd.nextInt(26));
      sb.append(letter);
    }
    res = sb.toString();
    if (convert.containsValue(res) == false) {
      convert.put(word, res);
      return res;
    }
  }
}

/**
 * Add the specified mapping if the namespace URI has not been mapped before.
 * 
 * <p>This method will ensure that the mapping is actually unique, that is that
 * the namespace URI correspond to one and only one prefix and that the prefix only
 * corresponds to one and only one namespace URI.
 * 
 * @param uri    The namespace URI to map.
 * @param prefix The prefix to use.
 * 
 * @throws NullPointerException if the URI or prefix is <code>null</code>
 */
public void add(String uri, String prefix) throws NullPointerException {
 if (!this.mappings.containsKey(uri)) {
  int count = 0;
  String actualPrefix = prefix;
  while (this.mappings.containsValue(actualPrefix)) {
   actualPrefix = prefix + count++;
  }
  this.mappings.put(uri, actualPrefix);
 }
}

@ExpectWarning("DMI")
public static void main(String args[]) {
  Set s = new HashSet();
  s.contains(s);
  s.remove(s);
  s.removeAll(s);
  s.retainAll(s);
  s.containsAll(s);
  Map m = new HashMap();
  m.get(m);
  m.remove(m);
  m.containsKey(m);
  m.containsValue(m);
  List lst = new LinkedList();
  lst.indexOf(lst);
  lst.lastIndexOf(lst);
}

/**
 * If a {@link NameCommentRecord} is added or the name it references
 *  is renamed, then this will update the lookup cache for it.
 *
 * @param commentRecord the comment record
 */
public void updateNameCommentRecordCache(final NameCommentRecord commentRecord) {
  if(commentRecords.containsValue(commentRecord)) {
   for(Entry<String,NameCommentRecord> entry : commentRecords.entrySet()) {
     if(entry.getValue().equals(commentRecord)) {
      commentRecords.remove(entry.getKey());
      break;
     }
   }
  }
  commentRecords.put(commentRecord.getNameText(), commentRecord);
}

public void bindArg(RegisterArg arg, BlockNode pred) {
  if (blockBinds.containsValue(pred)) {
    throw new JadxRuntimeException("Duplicate predecessors in PHI insn: " + pred + ", " + this);
  }
  addArg(arg);
  blockBinds.put(arg, pred);
}

public void testPutAllExistingKey() {
 final Map<K, V> map;
 final K keyToPut;
 final V valueToPut;
 try {
  map = makePopulatedMap();
  valueToPut = getValueNotInPopulatedMap();
 } catch (UnsupportedOperationException e) {
  return;
 }
 keyToPut = map.keySet().iterator().next();
 final Map<K, V> mapToPut = Collections.singletonMap(keyToPut, valueToPut);
 int initialSize = map.size();
 if (supportsPut) {
  map.putAll(mapToPut);
  assertEquals(valueToPut, map.get(keyToPut));
  assertTrue(map.containsKey(keyToPut));
  assertTrue(map.containsValue(valueToPut));
 } else {
  try {
   map.putAll(mapToPut);
   fail("Expected UnsupportedOperationException.");
  } catch (UnsupportedOperationException expected) {
  }
 }
 assertEquals(initialSize, map.size());
 assertInvariants(map);
}

String transport = configMap.get("elasticsearch_transport.enabled");
if (transport != null && "true".equals(transport)) {
  String cluster_name = configMap.get("elasticsearch_transport.cluster.name");
  String transport_addresses_string = configMap.get("elasticsearch_transport.addresses");
  if (transport_addresses_string != null && transport_addresses_string.length() > 0) {
  for (Map.Entry<String, String> entry: config.entrySet()) {
    String key = entry.getKey();
    if (key.startsWith("elasticsearch.")) settings.put(key.substring(14), entry.getValue());
boolean noio = configMap.containsValue("noio") && configMap.get("noio").equals("true");
messages = new MessageFactory(noio ? null : elasticsearch_client, IndexName.messages.name(), CACHE_MAXSIZE, EXIST_MAXSIZE);
messages_hour = new MessageFactory(noio ? null : elasticsearch_client, IndexName.messages_hour.name(), CACHE_MAXSIZE, EXIST_MAXSIZE);

public void recalculatePermissionDefaults(Permission perm) {
  if (permissions.containsValue(perm)) {
    defaultPerms.get(true).remove(perm);
    defaultPerms.get(false).remove(perm);
    calculatePermissionDefault(perm);
  }
}

/**
 * Checks map emptiness.
 *
 * @param map Map to check.
 * @throws Exception If failed.
 */
private void checkEmptyMap(Map<?, ?> map) throws Exception {
  assert map.isEmpty();
  assert !map.containsKey("key");
  assert !map.containsValue("value");
  assertEquals(0, map.size());
  assert map.keySet().isEmpty();
  assert map.entrySet().isEmpty();
  assert map.values().isEmpty();
  assert !map.keySet().iterator().hasNext();
  assert !map.entrySet().iterator().hasNext();
  assert !map.values().iterator().hasNext();
}

private String getNewPackageNamePart(String oldPackageNamePart) {
 if (oldPackageNamePart != null && oldToNewPackageNames.containsKey(oldPackageNamePart)) {
  return oldToNewPackageNames.get(oldPackageNamePart);
 }
 int size = 5;
 int tries = 0;
 String newPackageNamePart = "";
 while (newPackageNamePart.length() < NameGenerator.NAME_MAX_LENGTH) {
  synchronized (packageNamesMapLock) {
   if (oldToNewPackageNames.containsValue(newPackageNamePart)) {
    return oldToNewPackageNames.get(newPackageNamePart);
   }
   newPackageNamePart = nameGenerator.generateName(size);
   if (!oldToNewPackageNames.containsValue(newPackageNamePart)) {
    final String key = oldPackageNamePart == null ? newPackageNamePart : oldPackageNamePart;
    oldToNewPackageNames.put(key, newPackageNamePart);
    return newPackageNamePart;
   }
  }
  if (tries++ > size) {
   size++;
   tries = 0;
  }
 }
 throw new IllegalStateException("Cannot generate unique package name part: too long for JVM.");
}

/**
 * Method setDefaultPrefix
 *
 * @param namespace
 * @param prefix
 * @throws XMLSecurityException
 * @throws SecurityException if a security manager is installed and the
 *    caller does not have permission to set the default prefix
 */
public static void setDefaultPrefix(String namespace, String prefix)
  throws XMLSecurityException {
  JavaUtils.checkRegisterPermission();
  if (prefixMappings.containsValue(prefix)) {
    String storedPrefix = prefixMappings.get(namespace);
    if (!storedPrefix.equals(prefix)) {
      Object exArgs[] = { prefix, namespace, storedPrefix };
      throw new XMLSecurityException("prefix.AlreadyAssigned", exArgs);
    }
  }
  
  if (Constants.SignatureSpecNS.equals(namespace)) {
    XMLUtils.setDsPrefix(prefix);
  }
  if (EncryptionConstants.EncryptionSpecNS.equals(namespace)) {
    XMLUtils.setXencPrefix(prefix);
  }
  prefixMappings.put(namespace, prefix);
}
 

/**
 * Adds mapping for class name.
 *
 * @param classNameSource
 *          the class name to rename
 * @param classNameTarget
 *          the new class name
 */
public void addClassNameMapping(String classNameSource, String classNameTarget) {
 synchronized (classNamesMapLock) {
  if (!oldToNewClassNames.containsKey(classNameSource) && !oldToNewClassNames.containsValue(classNameTarget)
    && !BodyBuilder.nameList.contains(classNameTarget)) {
   oldToNewClassNames.put(classNameSource, classNameTarget);
   BodyBuilder.nameList.add(classNameTarget);
   return;
  }
 }
 throw new IllegalStateException("Cannot generate unique name: too long for JVM.");
}

public static boolean entityHaveDifferentLocation(Mention m, Mention a, Dictionaries dict) {
 if ((dict.statesAbbreviation.containsKey(a.spanToString()) || dict.statesAbbreviation.containsValue(a.spanToString()))
    && (m.headString.equalsIgnoreCase("country") || m.headString.equalsIgnoreCase("nation"))) {
  return true;
  if (w.get(CoreAnnotations.NamedEntityTagAnnotation.class).equals("LOCATION")) {
   String loc = text;
   if(dict.statesAbbreviation.containsKey(loc)) loc = dict.statesAbbreviation.get(loc);
   locationM.add(lowercased);
  if (w.get(CoreAnnotations.NamedEntityTagAnnotation.class).equals("LOCATION")) {
   String loc = text;
   if(dict.statesAbbreviation.containsKey(loc)) loc = dict.statesAbbreviation.get(loc);
   locationA.add(lowercased);

public static String getJsonWithUpdatedResources(String jsonConf, Map<String, Double> resourceUpdates) {
  try {
    JSONParser parser = new JSONParser();
    Object obj = parser.parse(jsonConf);
    JSONObject jsonObject = (JSONObject) obj;
    Map<String, Double> componentResourceMap =
      (Map<String, Double>) jsonObject.getOrDefault(
        Config.TOPOLOGY_COMPONENT_RESOURCES_MAP, new HashMap<String, Double>()
      );
    for (Map.Entry<String, Double> resourceUpdateEntry : resourceUpdates.entrySet()) {
      if (NormalizedResources.RESOURCE_NAME_NORMALIZER.getResourceNameMapping().containsValue(resourceUpdateEntry.getKey())) {
        // if there will be legacy values they will be in the outer conf
        jsonObject.remove(getCorrespondingLegacyResourceName(resourceUpdateEntry.getKey()));
        componentResourceMap.remove(getCorrespondingLegacyResourceName(resourceUpdateEntry.getKey()));
      }
      componentResourceMap.put(resourceUpdateEntry.getKey(), resourceUpdateEntry.getValue());
    }
    jsonObject.put(Config.TOPOLOGY_COMPONENT_RESOURCES_MAP, componentResourceMap);
    return jsonObject.toJSONString();
  } catch (ParseException ex) {
    throw new RuntimeException("Failed to parse component resources with json: " + jsonConf);
  }
}

/**
 * Mark that a task has become active and should be tracked by its container
 * ID. Prior to this, the task is not associated with a container.
 *
 * @param task
 */
public void containerAllocated(Task task) {
 assert !activeContainers.containsValue(task);
 assert !allocatingTasks.contains(task);
 assert !pendingTasks.contains(task);
 activeContainers.put(task.getContainerId(), task);
 controller.containerAllocated(task);
}

public void testPutAllNewKey() {
 final Map<K, V> map = makeEitherMap();
 final K keyToPut;
 final V valueToPut;
 try {
  keyToPut = getKeyNotInPopulatedMap();
  valueToPut = getValueNotInPopulatedMap();
 } catch (UnsupportedOperationException e) {
  return;
 }
 final Map<K, V> mapToPut = Collections.singletonMap(keyToPut, valueToPut);
 if (supportsPut) {
  int initialSize = map.size();
  map.putAll(mapToPut);
  assertEquals(valueToPut, map.get(keyToPut));
  assertTrue(map.containsKey(keyToPut));
  assertTrue(map.containsValue(valueToPut));
  assertEquals(initialSize + 1, map.size());
 } else {
  try {
   map.putAll(mapToPut);
   fail("Expected UnsupportedOperationException.");
  } catch (UnsupportedOperationException expected) {
  }
 }
 assertInvariants(map);
}

@Test(dataProvider = "caches")
@CacheSpec(requiresWeakOrSoft = true, expireAfterAccess = Expire.DISABLED,
  expireAfterWrite = Expire.DISABLED, maximumSize = Maximum.DISABLED,
  weigher = CacheWeigher.DEFAULT, population = Population.FULL, stats = Stats.ENABLED,
  removalListener = Listener.CONSUMING)
public void containsValue(Map<Integer, Integer> map, CacheContext context) {
 Integer key = context.firstKey();
 Integer value = context.original().get(key);
 context.clear();
 GcFinalization.awaitFullGc();
 assertThat(map.containsValue(value), is(true));
 key = null;
 GcFinalization.awaitFullGc();
 assertThat(map.containsValue(value), is(not(context.isWeakKeys())));
}