Returns true if the PropertyMap contains one or more values for the specified
PropertySet, false otherwise
4233
public boolean containsPropertySet(Class<? extends Annotation> propertySet)
    {
        if (_annotElem.isAnnotationPresent(propertySet))
            return true;

        //
        // Call up to superclass for delegation
        //
        return super.containsPropertySet(propertySet);
    }
1315351
public synchronized boolean containsKey(Object key) {
		if(size == 0) {
			return false;
		} else {
			try {
				XAttributeMap map = deserialize();
				return map.containsKey(key);
			} catch (IOException e) {
				e.printStackTrace();
				return false;
			}
		}
	}
214689
public boolean repeat(Map<String, CSSProperty> properties,
			Map<String, Term<?>> values) {
		for (int i = 0; i < times; i++) {
			if (!operation(i, properties, values))
				return false;
		}
		return true;
	}
1224223
@JSFProperty(defaultValue = "false", tagExcluded = true)
    public boolean isLocalValueSet()
    {
        Object value = getStateHelper().get(PropertyKeys.localValueSet);
        if (value != null)
        {
            return (Boolean) value;        
        }
        return false;
    }
685813
public boolean containsValue(final Object value) {
	return ! forEachPair( 
		new LongObjectProcedure() {
			public boolean apply(long iterKey, Object iterValue) {
				return (value != iterValue);
			}
		}
	);
}
863185
private static boolean contains(final Multimap<String, ?> map, final String searchKey) {
        for (String key: map.keys()) {
            if (key.equalsIgnoreCase(searchKey)) {
                return true;
            }
        }
        return false;
    }
1212477
public boolean satisfied( PropertySet properties)
    {
    boolean isSatisfied;
    Iterator<ICondition> conditions;
    
    for( conditions = getConditions(),
           isSatisfied = true;
           

         isSatisfied
           && conditions.hasNext();

         isSatisfied = !conditions.next().satisfied( properties));
    
    return isSatisfied;
    }
1185465
protected function hasProperty(string $propertyName): bool
    {
        if (count($this->values) === 1
          && isset($this->values['__value'])
          && 'value' === $propertyName) {
            return isset($this->values['__value']);
        }

        return isset($this->values[$propertyName]);
    }
858156
public static boolean mapContainsKeys(Map<?, ?> _map, Object... _keys) {
        if (_map == null) {
            return false;
        } else if (_keys == null) {
            return true;
        }
        for (Object key : _keys) {
            if (key != null && !_map.containsKey(key)) {
                return false;
            }
        }
        return true;
    }
541855
public boolean containsValues(
      java.lang.String key) {
    if (key == null) { throw new java.lang.NullPointerException(); }
    return internalGetValues().getMap().containsKey(key);
  }
1152161
private boolean propertiesIncluded(Map<Object, Object> inputMap, Map<Object, Object> existingMap) {
        if (inputMap == null) {
            // If no properties are specified, then success.
            return true;
        } else if (existingMap == null || inputMap.size() > existingMap.size()) {
            // If properties are specified, but none exist in the current map,
            // then fail.
            return false;
        }

        // Loop through input list and search in the search list.
        Object existingValue;
        for (Entry<Object, Object> entry : inputMap.entrySet()) {
            existingValue = existingMap.get(entry.getKey());
            if (existingValue == null || !existingValue.equals(entry.getValue())) {
                return false;
            }
        }
        return true;
    }
1303560
public boolean isAssigned(PropertyFilter<S> propFilter) {
        if (propFilter.isConstant()) {
            return true;
        }

        Map<PropertyFilter<S>, Object> map = mValueMap;

        if (map == null) {
            FilterValues<S> prevValues = mPrevValues;
            if (prevValues == null) {
                return false;
            }

            if (prevValues.mCurrentProperty.getPreviousRemaining() < 3) {
                // Map would have few values in it, so don't bother building it.

                do {
                    if (propFilter == prevValues.mCurrentProperty.getPropertyFilter()) {
                        return true;
                    }
                    prevValues = prevValues.mPrevValues;
                } while (prevValues != null);

                return false;
            }

            map = buildValueMap();
        }

        return map.containsKey(propFilter);
    }
1309613
private static final boolean contains(Collection<String> list, String value) {
        for (String item : list)
            if (item.contains(value))
                return true;
        return false;
    }
774002
@Override
    public boolean containsValue(Object value) {
        for (V v : values()) {
            if (v.equals(value)) {
                return true;
            }
        }
        return false;
    }
1027510
private static boolean contains(int[] values, int searchValue) {
        Objects.requireNonNull(values);
        for (int value : values) {
            if (searchValue == value) {
                return true;
            }
        }
        return false;
    }
553063
public final boolean contains(Object s)
  {

    for (int i = 0; i < m_firstFree; i++)
    {
      if (m_map[i] == s)
        return true;
    }

    return false;
  }
420565
public boolean isIn(HasValueSet<?> hasValueSet){
		Array array = hasValueSet.getArray();
		if(array == null){
			throw new MissingElementException(MissingElementException.formatMessage(XPathUtil.formatElement((Class)hasValueSet.getClass()) + "/" + XPathUtil.formatElement(Array.class)), (PMMLObject)hasValueSet);
		} // End if

		if(array instanceof SetHolder){
			SetHolder setHolder = (SetHolder)array;

			return setHolder.contains(getDataType(), getValue());
		}

		List<?> values = ArrayUtil.getContent(array);

		return values.stream()
			.anyMatch(value -> equalsValue(value));
	}