Java ValidationUtils.isGreaterThanOrEqual方法代碼示例

import org.kuali.rice.krad.datadictionary.validation.ValidationUtils; //導入方法依賴的package包/類
protected ConstraintValidationResult processSingleCollectionSizeConstraint(DictionaryValidationResult result,
        Collection<?> collection, CollectionSizeConstraint constraint,
        AttributeValueReader attributeValueReader) throws AttributeValidationException {
    Integer sizeOfCollection = new Integer(0);
    if (collection != null) {
        sizeOfCollection = Integer.valueOf(collection.size());
    }

    Integer maxOccurances = constraint.getMaximumNumberOfElements();
    Integer minOccurances = constraint.getMinimumNumberOfElements();

    Result lessThanMax = ValidationUtils.isLessThanOrEqual(sizeOfCollection, maxOccurances);
    Result greaterThanMin = ValidationUtils.isGreaterThanOrEqual(sizeOfCollection, minOccurances);

    // It's okay for one end of the range to be undefined - that's not an error. It's only an error if one of them is invalid
    if (lessThanMax != Result.INVALID && greaterThanMin != Result.INVALID) {
        // Of course, if they're both undefined then we didn't actually have a real constraint
        if (lessThanMax == Result.UNDEFINED && greaterThanMin == Result.UNDEFINED) {
            return result.addNoConstraint(attributeValueReader, CONSTRAINT_NAME);
        }

        // In this case, we've succeeded
        return result.addSuccess(attributeValueReader, CONSTRAINT_NAME);
    }

    String maxErrorParameter = maxOccurances != null ? maxOccurances.toString() : null;
    String minErrorParameter = minOccurances != null ? minOccurances.toString() : null;

    // If both comparisons happened then if either comparison failed we can show the end user the expected range on both sides.
    if (lessThanMax != Result.UNDEFINED && greaterThanMin != Result.UNDEFINED) {
        return result.addError(attributeValueReader, CONSTRAINT_NAME, RiceKeyConstants.ERROR_QUANTITY_RANGE,
                minErrorParameter, maxErrorParameter);
    }
    // If it's the max comparison that fails, then just tell the end user what the max can be
    else if (lessThanMax == Result.INVALID) {
        return result.addError(attributeValueReader, CONSTRAINT_NAME, RiceKeyConstants.ERROR_MAX_OCCURS,
                maxErrorParameter);
    }
    // Otherwise, just tell them what the min can be
    else {
        return result.addError(attributeValueReader, CONSTRAINT_NAME, RiceKeyConstants.ERROR_MIN_OCCURS,
                minErrorParameter);
    }

    // Obviously the last else above is unnecessary, since anything after it is dead code, but keeping it seems clearer than dropping it
}
 

import org.kuali.rice.krad.datadictionary.validation.ValidationUtils; //導入方法依賴的package包/類
protected ConstraintValidationResult validateLength(DictionaryValidationResult result, String value,
        LengthConstraint constraint, AttributeValueReader attributeValueReader) throws IllegalArgumentException {
    Integer valueLength = Integer.valueOf(value.length());

    Integer maxLength = constraint.getMaxLength();
    Integer minLength = constraint.getMinLength();

    Result lessThanMax = ValidationUtils.isLessThanOrEqual(valueLength, maxLength);
    Result greaterThanMin = ValidationUtils.isGreaterThanOrEqual(valueLength, minLength);

    // It's okay for one end of the range to be undefined - that's not an error. It's only an error if one of them is invalid 
    if (lessThanMax != Result.INVALID && greaterThanMin != Result.INVALID) {
        // Of course, if they're both undefined then we didn't actually have a real constraint
        if (lessThanMax == Result.UNDEFINED && greaterThanMin == Result.UNDEFINED) {
            return result.addNoConstraint(attributeValueReader, CONSTRAINT_NAME);
        }

        // In this case, we've succeeded
        return result.addSuccess(attributeValueReader, CONSTRAINT_NAME);
    }

    String maxErrorParameter = maxLength != null ? maxLength.toString() : null;
    String minErrorParameter = minLength != null ? minLength.toString() : null;

    // If both comparisons happened then if either comparison failed we can show the end user the expected range on both sides.
    if (lessThanMax != Result.UNDEFINED && greaterThanMin != Result.UNDEFINED) {
        return result.addError(RANGE_KEY, attributeValueReader, CONSTRAINT_NAME,
                RiceKeyConstants.ERROR_OUT_OF_RANGE, minErrorParameter, maxErrorParameter);
    }
    // If it's the max comparison that fails, then just tell the end user what the max can be
    else if (lessThanMax == Result.INVALID) {
        return result.addError(MAX_LENGTH_KEY, attributeValueReader, CONSTRAINT_NAME,
                RiceKeyConstants.ERROR_INCLUSIVE_MAX, maxErrorParameter);
    }
    // Otherwise, just tell them what the min can be
    else {
        return result.addError(MIN_LENGTH_KEY, attributeValueReader, CONSTRAINT_NAME,
                RiceKeyConstants.ERROR_EXCLUSIVE_MIN, minErrorParameter);
    }

}