Checks if the given {@link SLProperties} fulfills all assertions specified for this matcher.

@param properties the properties to be checked
@return <code>true</code> iff if all assertions are fulfilled
424398
public boolean isMatching(SLProperties properties) {
        for (Map.Entry<String, String> matcher : matchers) {
            if (!properties.includesValues(matcher.getKey(), matcher.getValue())) {
                return false;
            }
        }
        return true;
    }
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;
    }
102049
public static final boolean hasProperty(Object bean, String property)
    {
        try
        {
            return (boolean) doFor(
                bean, 
                property, 
                null,
                (Object a, int i)->{return true;},
                (List l, int i)->{return true;},
                (Object b, Class c, String p)->{getField(c, p);return true;}, 
                (Object b, Method m)->{return true;});
        }
        catch (BeanHelperException ex)
        {
            return false;
        }
    }
192300
public List<T> hasValue(String property, String value) {
		List<T> geoPackages = new ArrayList<>();
		for (PropertiesCoreExtension<T, ?, ?, ?> properties : propertiesMap
				.values()) {
			if (properties.hasValue(property, value)) {
				geoPackages.add(properties.getGeoPackage());
			}
		}
		return geoPackages;
	}
969689
public static void validateAllOrNone(Props props, String... keys) {
    Objects.requireNonNull(keys);

    boolean allExist = true;
    boolean someExist = false;
    for (String key : keys) {
      Object val = props.get(key);
      allExist &= val != null;
      someExist |= val != null;
    }

    if (someExist && !allExist) {
      throw new IllegalArgumentException(
          "Either all of properties exist or none of them should exist for " + Arrays
              .toString(keys));
    }
  }
1187340
public boolean isValidProperty(String strProperty)
    {
        if (m_rgstrValidParams != null)
        {
            for (int i = 0; i < m_rgstrValidParams.length; i++)
            {
                if (m_rgstrValidParams[i].equalsIgnoreCase(strProperty))
                { // Valid property
                    if (m_strCurrentProperty != strProperty)
                    {
                        return true;    // Valid property
                    }
                }
            }
        }
        return false;   // Not a valid property
    }
370192
private static boolean isValidPropertyClass(final PropertyDescriptor _property) {
        final Class type = _property.getPropertyType();
        return Number.class.isAssignableFrom(type) || type == String.class || Date.class.isAssignableFrom(type) || type == Boolean.class;
    }
704956
public static Report validate(final Properties props, final List<Property> properties) {
        final Report report = new Report();
        validate(props, report, properties, null);
        return report;
    }
346417
public boolean setProperties(Dictionary<String, String> properties)
    {
        boolean success = super.setProperties(properties);
        if (success)
        {
            baseURL = null;
            if (this.getProperty(BASE_PATH) != null) {
                try {
                    baseURL = new URL(this.getProperty(BASE_PATH));
                } catch (MalformedURLException e) {
                    // Ignore errors. Probably a relative path to be added on send
                }
            }
        }
        return success;
    }
657965
public final boolean isPropertyInExterns(String propertyName) {
    Property p = getSlot(propertyName);
    return p == null ? false : p.isFromExterns();
  }
1190168
@SuppressWarnings("unchecked")
  public static void checkProperties(Properties properties, Properties defaults) {
    Set<String> names = Generics.newHashSet();
    for (Enumeration<String> e = (Enumeration<String>) properties.propertyNames();
         e.hasMoreElements(); ) {
      names.add(e.nextElement());
    }
    for (Enumeration<String> e = (Enumeration<String>) defaults.propertyNames();
         e.hasMoreElements(); ) {
      names.remove(e.nextElement());
    }
    if (!names.isEmpty()) {
      if (names.size() == 1) {
        throw new IllegalArgumentException("Unknown property: " + names.iterator().next());
      } else {
        throw new IllegalArgumentException("Unknown properties: " + names);
      }
    }
  }
791119
private Boolean constraintsExists(String labelName, List<String> propertyNames) {
        Schema schema = db.schema();

        for (ConstraintDefinition constraintDefinition : Iterables.asList(schema.getConstraints(Label.label(labelName)))) {
            List<String> properties = Iterables.asList(constraintDefinition.getPropertyKeys());

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

        return false;
    }
446007
function propertyMatch(property) {
        for (let count = 0; count < options.match.length; count++) {
            if (property.indexOf(options.match[count]) > -1) {
                return true;
            }
        }

        return false;
    }
1349267
public static boolean isValidJmxPropertyValue(String s) {
        if ((s.indexOf(":") >= 0)
            || (s.indexOf("*") >= 0)
            || (s.indexOf('"') >= 0)
            || (s.indexOf("?") >= 0)
            || (s.indexOf(",") >= 0)
            || (s.indexOf("=") >= 0)) {
            return false;
        } else
            return true;
    }
537862
@Override
    public boolean match(Statement s) {
        if (s.getObject() == null) {
            return false;
        }
        if (s.getObject().getTerm() == null) {
            return false;
        }
        final RelationshipType r = s.getRelationshipType();
        if (!r.isDirected()) {
            return true;
        }
        return false;
    }
1219063
public static boolean hasProperty(ClassNode classNode, String propertyName) {
        if (classNode == null || !StringUtils.hasText(propertyName)) {
            return false;
        }

        final MethodNode method = classNode.getMethod(GrailsNameUtils.getGetterName(propertyName), Parameter.EMPTY_ARRAY);
        if (method != null) return true;

        // check read-only field with setter
        if( classNode.getField(propertyName) != null && !classNode.getMethods(GrailsNameUtils.getSetterName(propertyName)).isEmpty()) {
            return true;
        }

        for (PropertyNode pn : classNode.getProperties()) {
            if (pn.getName().equals(propertyName) && !pn.isPrivate()) {
                return true;
            }
        }

        return false;
    }
1312603
public boolean containsPropertySet(Class<? extends Annotation> propertySet)
    {
        // If we have an annotation type instance and it matches up with the requested
        // type, then return true
        if (_annot != null && _annot.getClass().equals(propertySet))
            return true;

        if (_propertySets.contains(propertySet))
            return true;

        //
        // Call up to superclass, for delegation model
        //
        return super.containsPropertySet(propertySet);
    }