Returns true if the given properties partially satisfy the given condition.
488968
public static boolean satisfiesSome( IConjunct condition, PropertySet properties)
    {
    boolean satisfies;
    Iterator<IDisjunct> disjuncts;
    for( disjuncts = condition.getDisjuncts(),
           satisfies = !disjuncts.hasNext();
         
         !satisfies
           && disjuncts.hasNext();

         satisfies = disjuncts.next().satisfied( properties));

    return satisfies;
    }
1335025
public boolean compatible( PropertySet properties)
    {
    boolean isCompatible;
    Iterator<IAssertion> assertions;
    
    for( assertions = getAssertions(),
           isCompatible = !assertions.hasNext();

         !isCompatible
           && assertions.hasNext();

         isCompatible = assertions.next().compatible( properties));
    
    return isCompatible;
    }
1053442
private Boolean constraintsExistsForRelationship(String type, List<String> propertyNames) {
        Schema schema = db.schema();

        for (ConstraintDefinition constraintDefinition : Iterables.asList(schema.getConstraints(RelationshipType.withName(type)))) {
            List<String> properties = Iterables.asList(constraintDefinition.getPropertyKeys());

            if (properties.equals(propertyNames)) {
                return true;
            }
        }

        return false;
    }
367976
def matches(self, properties):
        
        try:
            # Use the comparator
            return self.comparator(self.value, properties[self.name])
        except KeyError:
            # Criterion key is not in the properties
            return False
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;
    }
1292242
def satisfies_constraints(self, possible_solution):
        """"""
        for c in self._constraints:
            values = c.extract_values(possible_solution)
            if values is None or not c(*values):
                return False
        return True
421096
private Boolean booleanProperty(PropertyKey propertyKey) {
        Boolean value = null;
        String property = properties.getProperty(propertyKey.getKey());
        if (property != null) {
            value = Boolean.valueOf(property);
        }
        return value;
    }
640040
function(a, b, aParent, bParent, prop, compares, options){
	var subsetCheck;
	if( !(prop in aParent)) {
		subsetCheck = "subsetB";
	} else if(prop in bParent){
		// property in a and b and not the same
		return false;
	}
	if( !(prop in bParent) ) {
		subsetCheck = "subsetA";
	}
	if(subsetCheck === "subsetB") {
		options.result[prop] = b;
	} else {
		options.result[prop] = a;
	}
	return undefined;
}
1254451
function someProperties(map, predicate) {
        for (var key in map) {
            if (!predicate || predicate(map[key], key))
                return true;
        }
        return false;
    }
251856
private static boolean isConstraintSatisfied(String attribute,
                                                 String value,
                                                 String prop) {
        // For KeySize, prop is the max key size the
        // provider supports for a specific <crypto_service>.<algorithm>.
        if (attribute.equalsIgnoreCase("KeySize")) {
            int requestedSize = Integer.parseInt(value);
            int maxSize = Integer.parseInt(prop);
            if (requestedSize <= maxSize) {
                return true;
            } else {
                return false;
            }
        }

        // For Type, prop is the type of the implementation
        // for a specific <crypto service>.<algorithm>.
        if (attribute.equalsIgnoreCase("ImplementedIn")) {
            return value.equalsIgnoreCase(prop);
        }

        return false;
    }
254369
private static boolean isAttributeAllowed(Schema property) {

        if (property.getType() == SchemaType.ARRAY || property.getType() == SchemaType.OBJECT) {
            return false;
        }

        if (!StringUtils.isBlank(property.getRef())) {
            return false;
        }
        return true;
    }
240696
public boolean hasProperty(final String name) {
        return System.getProperties().containsKey(name) || props.containsKey(name);
    }
370110
function propPathSatisfies(keys, pred, x) {
  if(!isArray(keys)) {
    throw new TypeError(
      'propPathSatisfies: Array of Non-empty Strings or Integers required for first argument'
    )
  }

  if(!isPredOrFunc(pred)) {
    throw new TypeError(
      'propPathSatisfies: Pred or predicate function required for second argument'
    )
  }

  if(isNil(x)) {
    return false
  }

  let target = x
  for(let i = 0; i < keys.length; i++) {
    const key = keys[i]

    if(!(isString(key) && !isEmpty(key) || isInteger(key))) {
      throw new TypeError(
        'propPathSatisfies: Array of Non-empty Strings or Integers required for first argument'
      )
    }

    if(isNil(target)) {
      return false
    }

    target = target[key]
  }

  return !!predOrFunc(pred, target)
}
668032
protected boolean containsProperty(String alias) {
		String k = resolveKey(alias);
		return k == null ? false : resolver.containsProperty(k);
	}
445831
def is_in(property_name, set_values, *, present_optional=False, message=None):
    """"""
    def check(val):
      """Checks that a value is contained within a scope-enclosed set."""
      if val is None:
        return present_optional
      else:
        return val in set_values

    return Validation(check, property_name, message)
1076553
public final boolean appliesTo(final URI property) {

        if (this.properties.isEmpty() || this.properties.contains(property)) {
            return true;
        }
        Preconditions.checkNotNull(property);
        return false;
    }
138520
@SuppressWarnings("unused")
    @Internal
    @UsedByGeneratedCode
    protected final boolean containsProperties(BeanResolutionContext resolutionContext, BeanContext context) {
        return containsProperties(resolutionContext, context, null);
    }