Returns <tt>true</tt> if this map maps one or more keys to the
specified value.

@param value value whose presence in this map is to be tested
@return <tt>true</tt> if this map maps one or more keys to the
specified value
766965
public boolean containsValue(Object value) {
        for (LinkedHashMapEntry<K,V> e = head; e != null; e = e.after) {
            V v = e.value;
            if (v == value || (value != null && value.equals(v)))
                return true;
        }
        return false;
    }
976286
public static boolean isSbeJavaName(final String value)
    {
        for (final String token : PATTERN.split(value, -1))
        {
            if (isJavaIdentifier(token))
            {
                if (isJavaKeyword(token))
                {
                    return false;
                }
            }
            else
            {
                return false;
            }
        }

        return true;
    }
552662
public boolean put(K key, V value)
    {
        C collection = this.getIfAbsentPutCollection(key);

        if (collection.add(value))
        {
            this.incrementTotalSize();
            return true;
        }
        return false;
    }
1080175
public boolean removeOne(Object key, V value) {
        List<V> list = map.get(key);
        if (list == null) {
            return false;
        }
        boolean res = list.remove(value);
        if (list.isEmpty()) {
            // Remove the key also if the value set is now empty
            map.remove(key);
        }
        return res;
    }
833898
public boolean remove(K key, V value) {
		key = sanitizeKey(key);
		List<V> values = map.get(key);
		if (values == null) {
			return false;
		}

		boolean success = values.remove(value);
		if (values.isEmpty()) {
			map.remove(key);
		}
		return success;
	}
1095753
public void containsValue(@NullableDecl Object value) {
    check("values()").that(actual().values()).contains(value);
  }
901423
public boolean contains(final int value)
    {
        if (value == MISSING_VALUE)
        {
            return containsMissingValue;
        }

        final int[] values = this.values;
        @DoNotSub final int mask = values.length - 1;
        @DoNotSub int index = Hashing.hash(value, mask);

        while (values[index] != MISSING_VALUE)
        {
            if (values[index] == value)
            {
                return true;
            }

            index = next(index, mask);
        }

        return false;
    }
20506
public boolean remove(V value) {
        // peek at what is in the map
        K key = value.getKey();
        Ref<V> ref = map.get(key);
        // only try to remove the mapping if it matches the provided class loader
        return (ref != null && ref.get() == value) ? map.remove(key, ref) : false;
    }
1113591
public void add(T value) {
        if (value == null)
            return;

        if (map.containsKey(value)) {
            map.put(value, map.get(value) + 1);
        } else {
            map.put(value, 1l);
        }
    }
685813
public boolean containsValue(final Object value) {
	return ! forEachPair( 
		new LongObjectProcedure() {
			public boolean apply(long iterKey, Object iterValue) {
				return (value != iterValue);
			}
		}
	);
}
374590
@Override
	public boolean containsValue(final Object value) {
		lock.readLock().lock();
		try {
			return contains(value);
		} finally {
			lock.readLock().unlock();
		}
	}
879606
public boolean matchKey (final String key) {
        if (key == null) return false;
        for (int i = 0; i < values.length; ++i)
            if (values[i].equals(key)) return true;
        return false;
    }
301528
private boolean removeMapping(Object key, Object value) {
        Object k = maskNull(key);
        Object[] tab = table;
        int len = tab.length;
        int i = hash(k, len);

        while (true) {
            Object item = tab[i];
            if (item == k) {
                if (tab[i + 1] != value)
                    return false;
                modCount++;
                size--;
                tab[i] = null;
                tab[i + 1] = null;
                closeDeletion(i);
                return true;
            }
            if (item == null)
                return false;
            i = nextKeyIndex(i, len);
        }
    }
1293584
public boolean contains(final double VALUE) {
        return (Double.compare(VALUE, getStart()) >= 0 && Double.compare(VALUE, getStop()) <= 0);
    }
288172
@Override
    public boolean containsValue(Object value) {
        if (value == null) {
            throw new NullPointerException();
        }

        for (Map.Entry<K, CachedValue<K, V>> entry : map.entrySet()) {
            CachedValue<K, V> cachedValue = entry.getValue();
            if (cachedValue.getValue().equals(value)) {
                if (isValueExpired(cachedValue)) {
                    if (map.remove(cachedValue.getKey(), cachedValue)) {
                        onValueRemove(cachedValue);
                    }
                } else {
                    readValue(cachedValue);
                    return true;
                }
            }
        }
        return false;
    }
661717
public synchronized boolean containsValue(Object value) {
		if(size == 0) {
			return false;
		} else {
			try {
				XAttributeMap map = deserialize();
				return map.containsValue(value);
			} catch (IOException e) {
				e.printStackTrace();
				return false;
			}
		}
	}
1277297
private boolean appendMap(StringBuilder builder, Object value)
    {
        boolean isPresent = false;
        if (value instanceof Map)
        {
            Map map = ((Map) value);
            isPresent = true;
            builder.append(Constants.OPEN_CURLY_BRACKET);
            for (Object mapKey : map.keySet())
            {
                Object mapValue = map.get(mapKey);
                // Allowing null keys.
                appendValue(builder, mapKey != null ? mapKey.getClass() : null, mapKey, false);
                builder.append(Constants.COLON);
                // Allowing null values.
                appendValue(builder, mapValue != null ? mapValue.getClass() : null, mapValue, false);
                builder.append(Constants.COMMA);
            }
            if (!map.isEmpty())
            {
                builder.deleteCharAt(builder.length() - 1);
            }

            builder.append(Constants.CLOSE_CURLY_BRACKET);
        }
        else
        {
            appendValue(builder, value.getClass(), value, false);
        }
        return isPresent;
    }