Check if the property has the value

@param property
property name
@param value
property value
@return true if property has the value
430869
public boolean hasValue(String property, String value) {
		boolean hasValue = false;
		if (has()) {
			Map<String, Object> fieldValues = buildFieldValues(property, value);
			TResult result = getDao().queryForFieldValues(fieldValues);
			try {
				hasValue = result.getCount() > 0;
			} finally {
				result.close();
			}
		}
		return hasValue;
	}
536650
public boolean addValue(String property, String value) {
		if (!has()) {
			getOrCreate();
		}
		boolean added = false;
		if (!hasValue(property, value)) {
			TRow row = newRow();
			row.setValue(COLUMN_PROPERTY, property);
			row.setValue(COLUMN_VALUE, value);
			getDao().insert(row);
			added = true;
		}
		return added;
	}
1095753
public void containsValue(@NullableDecl Object value) {
    check("values()").that(actual().values()).contains(value);
  }
759417
public static boolean hasProperty(TypeDef typeDef, String property) {
       return unrollHierarchy(typeDef)
       .stream()
       .flatMap(h -> h.getProperties().stream())
       .filter(p -> property.equals(p.getName()))
       .findAny()
       .isPresent();
    }
737951
public boolean isTrue(ExecutionProperty property) {
        return isSet(property) && propertyMap.get(property).size() == 1
            && "true".equalsIgnoreCase(propertyMap.get(property).get(0));
    }
1097251
public boolean isSet(String propName) {
        if (propName.equals("value")) {
            return isSetValue();
        }
        if (propName.equals("lang")) {
            return isSetLang();
        }
        return false;
    }
842353
public boolean shouldSelectProperty(String property) {
        // no restriction
        if (getRoot().eagerLoad || restrictedProperties == null) {
            return true;
        }
        // explicit restriction
        if (getRoot().eagerLoad || restrictedProperties.contains(property)) {
            return true;
        }
        return false;
    }
1141148
public boolean containsValue(Object value) {
        Node<K,V>[] tab; V v;
        if ((tab = table) != null && size > 0) {
            for (int i = 0; i < tab.length; ++i) {
                for (Node<K,V> e = tab[i]; e != null; e = e.next) {
                    if ((v = e.value) == value ||
                        (value != null && value.equals(v)))
                        return true;
                }
            }
        }
        return false;
    }
315869
public static boolean validateProperty(String key, String value) {
        return !StringUtils.isBlank(key) && !StringUtils.isBlank(value);
    }
941932
public boolean getBoolean(String property) {
    return getProperty(property, value -> {
      switch (value.trim().toLowerCase()) {
        case "true":
        case "1":
          return true;
        case "false":
        case "0":
          return false;
        default:
          throw new ConfigurationException("invalid property value: " + property + " must be a boolean");
      }
    });
  }
529769
public static boolean setValue( Object object, String propertyName, Object value )
	{
		return propertyValues.setValue(object, propertyName, 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();
		}
	}
521821
public void addProperty(String propertyName, Object value)
    {
        if (propertyName != null)
        {
            propertyNames.add(propertyName);
            if (value == null)
            {
                properties.remove(propertyName);
            }
            else
            {
                properties.put(propertyName, value);
            }
        }
    }
737490
public int deleteValue(String property, String value) {
		int count = 0;
		if (has()) {
			Map<String, Object> fieldValues = buildFieldValues(property, value);
			count = getDao().delete(fieldValues);
		}
		return count;
	}
431032
public static boolean hasProperty(Object obj, String name) {
		if (obj == null)
			throw new NullPointerException("Object cannot be null");
		if (name == null)
			throw new NullPointerException("Property name cannot be null");

		Class<?> objClass = obj.getClass();

		// Search in fields
		for (Field field : objClass.getFields()) {
			if (matchField(field, name))
				return true;
		}

		// Search in properties
		name = "get" + name;
		for (Method method : objClass.getMethods()) {
			if (matchPropertyGetter(method, name))
				return true;
		}

		return false;
	}
282563
function hasProperty(value, prop) {
    return (value && typeof value === 'object' && prop in value) ||
        value !== null && value !== undefined && value[prop] !== undefined;
}
972559
public boolean hasProperty(String name) {
        for (Property property : allProperties()) {
            if (property.getName().equals(name)) {
                return true;
            }
        }
        return false;
    }