Iterate over the values to see if any match the provided value.
<p>
If value provided is {@link #initialValue()} then it will always return false.

@param value the key to check.
@return true if the map contains value as a mapped value, false otherwise.
960283
public boolean containsValue(final int value)
    {
        boolean found = false;
        if (value != initialValue)
        {
            final int[] entries = this.entries;
            @DoNotSub final int length = entries.length;

            for (@DoNotSub int i = 1; i < length; i += 2)
            {
                if (value == entries[i])
                {
                    found = true;
                    break;
                }
            }
        }

        return found;
    }
1067316
public boolean contains(final double VALUE) {
        return ((Double.compare(VALUE, start) >= 0 && Double.compare(VALUE, stop) <= 0)) ? true : false;
    }
774002
@Override
    public boolean containsValue(Object value) {
        for (V v : values()) {
            if (v.equals(value)) {
                return true;
            }
        }
        return false;
    }
751223
public final BooleanExpression containsValue(V value) {
        return Expressions.booleanOperation(Ops.CONTAINS_VALUE, mixin, ConstantImpl.create(value));
    }
677579
public void checkForValue(final double VALUE) {
        boolean wasInSection = contains(checkedValue);
        boolean isInSection  = contains(VALUE);
        if (!wasInSection && isInSection) {
            fireSectionEvent(ENTERED_EVENT);
        } else if (wasInSection && !isInSection) {
            fireSectionEvent(LEFT_EVENT);
        }
        checkedValue = VALUE;
    }
276732
private static boolean matches(String value, String component, Map<String, String> variableMap) {
        if (Utils.isEmpty(component)) {
            return Utils.isEmpty(value);
        }
        if (component.charAt(0) == '{') {
            // The component is a variable, so it always matches.
            if (!Utils.isEmpty(value)) {
                String varName = getVariableName(component);
                variableMap.put(varName, value);
            }
            return true;
        }
        return component.equals(value);
    }
205551
@Override
	public boolean contains(final Object value) {
		lock.readLock().lock();
		try {
			if (value == null) {
				return false;
			}
			for (@SuppressWarnings("rawtypes")
			final Map.Entry entry : entrySet()) {
				final Object otherValue = entry.getValue();
				if (otherValue != null && otherValue.equals(value)) {
					return true;
				}
			}
			return false;
		} finally {
			lock.readLock().unlock();
		}
	}
153250
public final Condition contains(final V value) {
        return new Condition().withComparisonOperator(CONTAINS).withAttributeValueList(convert(value));
    }
461403
public boolean hasValue(final T value) throws MIDDException {

        //special processing when missing attribute
        if (value == null) {
            return this.isLowerInfinite() || this.isUpperInfinite();
        }


        EndPoint<T> epValue = new EndPoint<>(value);

        int compareLow = this.lowerBound.compareTo(epValue);
        int compareUp = this.upperBound.compareTo(epValue);

        if ((compareLow < 0 || (compareLow == 0 && this.lowerBoundClosed)) &&
                (compareUp > 0 || (compareUp == 0 && this.upperBoundClosed))) {
            return true;
        }

        return false;
    }
1031721
public boolean match(String value) {
    value = StringUtils.removeStart(value, "/");
    value = StringUtils.removeEnd(value, "/");
    return pattern.matcher(value).matches();
  }
930624
public boolean isMatched(String value, Boolean defaultValue)
    {
        // @todo: there isn't a defaultValue for radio button, what should we do here?
        if (value == null)
            return false;
        if (_match != null)
            return value.equals(_match);
        if (_defaultRadio != null)
            return value.equals(_defaultRadio);

        return false;
    }
1059865
@Override
    public boolean containsValue(Object value) {
	// Overridden to take advantage of faster iterator
	if (value == null) {
	    for (Entry e = header.after; e != header; e = e.after)
		if (e.value == null) return true;
	}
	else {
	    for (Entry e = header.after; e != header; e = e.after)
		if (value.equals(e.value)) return true;
	}
	return false;
    }
1198007
private boolean isTruthy(String value) {
    return value != null &&
           value.trim().toLowerCase().startsWith(TRUTHY_INITIAL_CHARACTER);
  }
1214992
public static boolean matches(final Pattern pattern, final String value, final boolean completeMatch) {
        val matcher = pattern.matcher(value);
        LOGGER.debug("Matching value [{}] against pattern [{}]", value, pattern.pattern());
        if (completeMatch) {
            return matcher.matches();
        }
        return matcher.find();
    }
1022370
public boolean containsValue(final Object value) {
    return this._current.containsValue(value)
        || (this._parent != null && this._parent.containsValue(value));
  }
1270318
public boolean isValid(String value) {
        if (value == null) {
            return false;
        }
        for (Pattern pattern : patterns) {
            if (pattern.matcher(value).matches()) {
                return true;
            }
        }
        return false;
    }
1109970
protected boolean evaluate(String value) {
        if (ValidationMatcherUtils.isValidationMatcherExpression(matchingValue)) {
            try {
                ValidationMatcherUtils.resolveValidationMatcher(selectKey, value, matchingValue, context);
                return true;
            } catch (ValidationException e) {
                return false;
            }
        } else {
            return value.equals(matchingValue);
        }
    }