Checks if the given group of statements contains the given value as the
value of a main snak of some statement.

@param statementGroup
the statement group to scan
@param value
the value to scan for
@return true if value was found
169099
private boolean containsValue(StatementGroup statementGroup, Value value) {
		for (Statement s : statementGroup) {
			if (value.equals(s.getValue())) {
				return true;
			}
		}

		return false;
	}
685813
public boolean containsValue(final Object value) {
	return ! forEachPair( 
		new LongObjectProcedure() {
			public boolean apply(long iterKey, Object iterValue) {
				return (value != iterValue);
			}
		}
	);
}
744246
@Override
    public boolean contains(IEntityGroup group, IGroupMember member) throws GroupsException {
        return (member.isGroup())
                ? containsGroup(group, (IEntityGroup) member)
                : containsEntity(group, member);
    }
330689
public boolean containsValue(String path, Object value) {
        return JSONPath.containsValue(jsonObject, checkPath(path), value);
    }
593699
private boolean find(Clause clause, char[] chars, int[] cursor) {
    int start = cursor[0];
    int end = cursor[1];
    while (end - start >= clause.minlen)
      if (matchClause(clause, chars, cursor))
        return true;
      else
        cursor[0] = ++start;
    return false;
  }
103840
public boolean containsValue(Object value) {
        Entry tab[] = mTable;
        
        if (value == null) {
            for (int i = tab.length ; i-- > 0 ;) {
                for (Entry e = tab[i], prev = null; e != null; e = e.mNext) {
                    if (e.getKey() == null) {
                        // Clean up after a cleared Reference.
                        mModCount++;
                        if (prev != null) {
                            prev.mNext = e.mNext;
                        }
                        else {
                            tab[i] = e.mNext;
                        }
                        mCount--;
                    }
                    else if (e.mValue == null) {
                        return true;
                    }
                    else {
                        prev = e;
                    }
                }
            }
        }
        else {
            for (int i = tab.length ; i-- > 0 ;) {
                for (Entry e = tab[i], prev = null; e != null; e = e.mNext) {
                    if (e.getKey() == null) {
                        // Clean up after a cleared Reference.
                        mModCount++;
                        if (prev != null) {
                            prev.mNext = e.mNext;
                        }
                        else {
                            tab[i] = e.mNext;
                        }
                        mCount--;
                    }
                    else if (value.equals(e.mValue)) {
                        return true;
                    }
                    else {
                        prev = e;
                    }
                }
            }
        }

        return false;
    }
469654
public static boolean containsEntity(String value)
    {
        assert (value != null) : "Parameter 'value' must not be null";

        int pos = value.indexOf('&');
        if (pos == -1)
            return false;

        int end = value.indexOf(';');
        if (end != -1 && pos < end) {
            // extract the entity and then verify it is
            // a valid unicode identifier.
            String entity = value.substring(pos + 1, end);
            if (entity.length() == 0)
                return false;
            char[] chars = entity.toCharArray();

            // verify the start is an indentifier start
            // and the rest is a part.
            if (!Character.isUnicodeIdentifierStart(chars[0])) {
                if (chars[0] == '#' && chars.length > 1) {
                    for (int i = 1; i < chars.length; i++) {
                        if (!Character.isDigit(chars[i]))
                            return false;
                    }
                    return true;
                }
                return false;
            }
            for (int i = 1; i < chars.length; i++) {
                if (!Character.isUnicodeIdentifierPart(chars[i]))
                    return false;
            }
            // good indentifier
            return true;
        }
        return false;
    }
456403
@Override
	public boolean containsValue(Object value) {
		return this.groupedMap.containsValue(DEFAULT_GROUP, Convert.toStr(value));
	}
1116305
public boolean containsValue (int value) {
		K[] keyTable = this.keyTable;
		int[] valueTable = this.valueTable;
		for (int i = capacity + stashSize; i-- > 0;)
			if (keyTable[i] != null && valueTable[i] == value) return true;
		return false;
	}
681756
public static boolean contains(Collection<?> collection, Object value) {
		return isNotEmpty(collection) && collection.contains(value);
	}
265153
@Override
    public boolean containsWithinBounds(Object value) {
        if (value instanceof Comparable) {
            final int result = compareTo(from, (Comparable) value);
            return result == 0 || result < 0 && compareTo(to, (Comparable) value) >= 0;
        }
        return contains(value);
    }
470226
public boolean isInValueSet(Value value) {
        if (value == null) {
            throw new IllegalArgumentException("value cannot be null");
        }

        boolean result = true;
        if (!this.valuesKeySet.isEmpty()) {
            result = this.valuesKeySet.contains(value);
        } else if (this.lowerBound != null || this.upperBound != null) {
            if (this.lowerBound != null
                    && !ValueComparator.GREATER_THAN_OR_EQUAL_TO.compare(
                    value, this.lowerBound)) {
                result = false;
            }
            if (this.upperBound != null
                    && !ValueComparator.LESS_THAN_OR_EQUAL_TO.compare(
                    value, this.upperBound)) {
                result = false;
            }
        }
        return result;
    }
380600
def handle_set_statement_group(self, _, __, tokens: ParseResults) -> ParseResults:
        """"""
        self.statement_group = tokens['group']
        return tokens
669923
private boolean groupInfoMatches(Map<String, List<GroupInfo>> a, Map<String, List<GroupInfo>> b) {
        if (a == null && b == null) {
            return true;
        }

        boolean isMatch = false;
        if (a != null && b != null) {
            if (a.isEmpty() && b.isEmpty()) {
                isMatch = true;
            } else if (a.size() == b.size()) {
                for (Entry<String, List<GroupInfo>> entry : a.entrySet()) {
                    List<GroupInfo> otherList = b.get(entry.getKey());
                    isMatch = (otherList != null);
                    if (!isMatch) {
                        break;
                    }

                    List<GroupInfo> thisList = entry.getValue();
                    isMatch = otherList.containsAll(thisList) && thisList.containsAll(otherList);
                    if (!isMatch) {
                        break;
                    }
                }
            }
        }
        return isMatch;
    }
774002
@Override
    public boolean containsValue(Object value) {
        for (V v : values()) {
            if (v.equals(value)) {
                return true;
            }
        }
        return false;
    }
834201
private static boolean containsSpecialCharacter(String value) {
        for (int x = 0; x < value.length(); x++) {
            char c = value.charAt(x);
            if (c == '?' || c == '*') {
                return true;
            } else if (c == '\\') {
                //skip the next character because it is quoted
                x += 1;
            }
        }
        return false;
    }
363644
public static <T> boolean contains(T[] objectArray, T value)
    {
        return ArrayIterate.anySatisfyWith(objectArray, Predicates2.equal(), value);
    }