Check if values in the column "property" are written to the bundle descriptor.
@param property the property id of the table column.
@return a flag, indicating if values of the table column are stored to the bundle descriptor.
963488
private boolean isDescriptorProperty(Object property) {

        return (getBundleType().equals(BundleType.DESCRIPTOR)
            || (hasDescriptor()
                && (property.equals(TableProperty.KEY)
                    || property.equals(TableProperty.DEFAULT)
                    || property.equals(TableProperty.DESCRIPTION))));
    }
331365
public Set<String> getValues(String property) {
		Set<String> allValues = new HashSet<>();
		for (PropertiesCoreExtension<T, ?, ?, ?> properties : propertiesMap
				.values()) {
			allValues.addAll(properties.getValues(property));
		}
		return allValues;
	}
184999
private boolean isStringProperty(EntityType entityType, Attribute attribute)
    {
        String discriminatorColumn = ((AbstractManagedType) entityType).getDiscriminatorColumn();

        if (attribute.getName().equals(discriminatorColumn))
        {
            return true;
        }

        return attribute != null ? ((AbstractAttribute) attribute).getBindableJavaType().isAssignableFrom(String.class)
                || ((AbstractAttribute) attribute).getBindableJavaType().isAssignableFrom(Character.class)
                || ((AbstractAttribute) attribute).getBindableJavaType().isAssignableFrom(char.class)
                || ((AbstractAttribute) attribute).getBindableJavaType().isAssignableFrom(Date.class)
                || ((AbstractAttribute) attribute).getBindableJavaType().isAssignableFrom(java.util.Date.class) : false;
    }
806460
public Map<String, Object> getApplicationProperties(Map<String, Object> properties)
    {
        if (properties == null)
            return null;
        Map<String, Object> propApp = new Hashtable<String,Object>();
        if (properties.get(DBParams.LANGUAGE) != null)
            propApp.put(DBParams.LANGUAGE, properties.get(DBParams.LANGUAGE));
        if (properties.get(DBParams.DOMAIN) != null)
            propApp.put(DBParams.DOMAIN, properties.get(DBParams.DOMAIN));
        return propApp;
    }
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;
	}
1372036
public static boolean isEnabled(String property, DatasetDescriptor descriptor) {
    if (descriptor.hasProperty(property)) {
      // return true if and only if the property value is "true"
      return Boolean.valueOf(descriptor.getProperty(property));
    }
    return false;
  }
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;
    }
937411
public static boolean hasProperty(ClassNode classNode, String propertyName) {
        if(classNode == null || propertyName == null || "".equals(propertyName.trim()))
            return false;

        List properties = classNode.getProperties();
        for (Iterator i = properties.iterator(); i.hasNext();) {
            PropertyNode pn = (PropertyNode) i.next();
            if(pn.getName().equals(propertyName))
                return true;
        }
        return false;
    }
773218
<S extends Storable> JDBCStorableProperty<S>
        getJDBCStorableProperty(StorableProperty<S> property)
        throws RepositoryException, SupportException
    {
        JDBCStorableInfo<S> info = examineStorable(property.getEnclosingType());
        JDBCStorableProperty<S> jProperty = info.getAllProperties().get(property.getName());
        if (!jProperty.isSupported()) {
            throw new UnsupportedOperationException
                ("Property is not supported: " + property.getName());
        }
        return jProperty;
    }
301046
public static boolean readPropertiesBoolean(Properties _props, String _property) {
        if (_props.containsKey(_property)) {
            if (_props.getProperty(_property).matches("(?i)(1|yes|true|enabled|on|y)")) {
                return true;
            }
        }
        return false;
    }
1060961
public static boolean isStringSet(PrefsProperty property) {
		boolean isStringSet = false;

		TypeName typeName;
		if (property.hasTypeAdapter()) {
			typeName = TypeUtility.typeName(property.typeAdapter.dataType);
		} else {
			typeName = TypeUtility.typeName(property.getElement().asType());
		}

		// it is parameterized type name for sure

		if (typeName instanceof ParameterizedTypeName && TypeUtility.isSet(typeName)) {
			ParameterizedTypeName parameterizedTypeName = (ParameterizedTypeName) typeName;
			if (TypeUtility.isEquals(parameterizedTypeName.typeArguments.get(0), String.class.getCanonicalName())) {
				isStringSet = true;
			}
		}

		return isStringSet;
	}
203504
public static String getProperty(String base, String property) {
		return getProperty(base, property, true);
	}
329229
protected void setBeanPropertyValue(final String property, final Object bean,
			final Serializable value) {
		if (bean == null) {
			return;
		}

		if (".".equals(property)) {
			LOG.error("Set of entire bean is not supported by this model");
			return;
		}
		try {
			PropertyUtils.setProperty(bean, property, value);
		} catch (Exception e) {
			LOG.error("Failed to set bean property " + property + " on " + bean, e);
		}
	}
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();
    }
585887
public int deleteProperty(String property) {
		int count = 0;
		if (has()) {
			TDao dao = getDao();
			String where = dao.buildWhere(COLUMN_PROPERTY, property);
			String[] whereArgs = dao.buildWhereArgs(property);
			count = dao.delete(where, whereArgs);
		}
		return count;
	}
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");
      }
    });
  }
464706
private void countPropertyQualifier(PropertyIdValue property, int count) {
		PropertyRecord propertyRecord = getPropertyRecord(property);
		propertyRecord.qualifierCount = propertyRecord.qualifierCount + count;
	}