Returns true if the provided property is a mandatory property; false, otherwise.

@return
returned object is {@link boolean}
169401
public boolean isMandatory(String propName) {
        if (mandatoryProperties == null) {
            setMandatoryPropertyNames();
        }
        if (mandatoryProperties.contains(propName)) {
            return true;
        } else {
            return false;
        }
    }
4233
public boolean containsPropertySet(Class<? extends Annotation> propertySet)
    {
        if (_annotElem.isAnnotationPresent(propertySet))
            return true;

        //
        // Call up to superclass for delegation
        //
        return super.containsPropertySet(propertySet);
    }
482003
public static boolean isPropertyType(final Type type) {
        if (type instanceof GenericArrayType) {
            return isPropertyType(((GenericArrayType) type).getGenericComponentType());
        }
        if (type instanceof ParameterizedType) {
            return isPropertyType(((ParameterizedType) type).getRawType());
        }
        return type instanceof Class && isPropertyType((Class) type);
    }
1313243
public static synchronized String getProperty(String base, String property,
			boolean required) {
		return getProperty(
				base + PropertyConstants.PROPERTY_DIVIDER + property, required);
	}
500145
public boolean isAnnotatable() {
		return ObjectUtils.defaultIfNull((Boolean) configurationValues.get(ConfigurationOption.ANNOTATE), Boolean.TRUE)
		            .booleanValue();
	}
372437
public static synchronized String getProperty(String base, String property,
			boolean required) {
		return getProperty(base + JavaPropertyConstants.PROPERTY_DIVIDER
				+ property, required);
	}
718450
@SuppressWarnings("rawtypes")
    public static boolean isPropertyInherited(Class clz, String propertyName) {
        if (clz == null) return false;
        Assert.isTrue(StringUtils.hasText(propertyName), "Argument [propertyName] cannot be null or blank");

        Class<?> superClass = clz.getSuperclass();

        PropertyDescriptor pd = BeanUtils.getPropertyDescriptor(superClass, propertyName);
        if (pd != null && pd.getReadMethod() != null) {
            return true;
        }
        return false;
    }
165584
public boolean getExclusiveMin() {
        if (property instanceof AbstractNumericProperty) {
            AbstractNumericProperty numericProperty = (AbstractNumericProperty) property;
            return BooleanUtils.isTrue(numericProperty.getExclusiveMinimum());
        }
        return false;
    }
953322
public final boolean hasProperty(final String property) {
    final String val = properties.get(property);
    if (val == null)
      return false;
    if (val.isEmpty())
      return false;
    return true;
  }
516284
protected boolean mightBeValidatorAnnotated() {
        for (ActionFormProperty property : propertyMap.values()) {
            final Field field = property.getPropertyDesc().getField();
            if (field == null) { // not field property
                continue;
            }
            for (Annotation anno : field.getAnnotations()) {
                if (isValidatorAnnotation(anno.annotationType())) {
                    return true; // first level only
                }
            }
        }
        return false;
    }
176581
public BooleanProperty isPolygonProperty() {
		if (this.isPolygon == null) {
			this.isPolygon = new ReadOnlyBooleanWrapper(this, MathFXAttributeNames.IS_POLYGON, false);
			this.isPolygon.bind(Bindings.createBooleanBinding(() -> {
				boolean first = true;
				boolean lastIsClose = false;
				for (final PathElementType type : innerTypesProperty()) {
					lastIsClose = false;
					if (first) {
						if (type != PathElementType.MOVE_TO) {
							return false;
						}
						first = false;
					} else if (type == PathElementType.MOVE_TO) {
						return false;
					} else if (type == PathElementType.CLOSE) {
						lastIsClose = true;
					}
				}
				return lastIsClose;
			},
					innerTypesProperty()));
		}
		return this.isPolygon;
	}
1237232
private boolean isValidElement() {

        boolean validElement = false;
        List elementList = new ArrayList();
        try {
            // get Elements of template stored in Property "template-elements"
            String elements = m_cmsObject.readPropertyObject(
                m_template,
                CmsPropertyDefinition.PROPERTY_TEMPLATE_ELEMENTS,
                false).getValue();
            // template may contain more than one Element
            // Elements are separated by the delimiter ","
            if (elements != null) {
                StringTokenizer T = new StringTokenizer(elements, ",");
                while (T.hasMoreTokens()) {
                    // current element probably looks like "body*|Body" <name><mandatory>|<nicename>
                    String currentElement = T.nextToken();
                    int sepIndex = currentElement.indexOf("|");
                    if (sepIndex != -1) {
                        // current element == "body*"
                        currentElement = currentElement.substring(0, sepIndex);
                    }
                    if (currentElement.endsWith("*")) {
                        // current element == "body"
                        currentElement = currentElement.substring(0, currentElement.length() - 1);
                    }
                    elementList.add(currentElement);
                }
            }
            if (elementList.contains(m_element)) {
                validElement = true;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        return validElement;
    }
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");
      }
    });
  }
1264302
public boolean isIndeterminate() {
		Boolean value = (Boolean) getStateHelper().eval(PropertyKeys.indeterminate, false);
		return (boolean) value;
	}
1140051
public BooleanProperty isEmptyProperty() {
		if (this.isEmpty == null) {
			this.isEmpty = new SimpleBooleanProperty(this, MathFXAttributeNames.IS_EMPTY);
			this.isEmpty.bind(Bindings.createBooleanBinding(() -> {
				final PathIterator2ai<PathElement2ifx> pi = getPathIterator();
				while (pi.hasNext()) {
					final PathElement2ifx pe = pi.next();
					if (pe.isDrawable()) {
						return false;
					}
				}
				return true;
			}, innerTypesProperty(), innerPointsProperty()));
		}
		return this.isEmpty;
	}
1274721
@Override
	public Boolean getPropertyBoolean(String key)
	{
		Boolean bVal = null;
		String sVal = getProperty(key);
		if ((sVal != null) && (sVal.length() > 0))
		{
			bVal = Boolean.valueOf(sVal);
		}
		return bVal;
	}
527576
public static boolean isRequired(TypeDeclaration type) {
		if (type == null || type.required() == null) {
			return true;
		} else {
			return type.required();
		}
	}