Java CollectionSizeConstraint类代码示例

import org.kuali.rice.krad.datadictionary.validation.constraint.CollectionSizeConstraint; //导入依赖的package包/类
@Override
public void init() {
    resolverMap = new HashMap<String, ConstraintResolver<CollectionDefinition>>();
    resolverMap.put(ExistenceConstraint.class.getName(), new DefinitionConstraintResolver<CollectionDefinition>());
    resolverMap.put(CollectionSizeConstraint.class.getName(),
            new DefinitionConstraintResolver<CollectionDefinition>());
}
 

import org.kuali.rice.krad.datadictionary.validation.constraint.CollectionSizeConstraint; //导入依赖的package包/类
/**
 * @see org.kuali.rice.krad.datadictionary.validation.processor.ConstraintProcessor#process(org.kuali.rice.krad.datadictionary.validation.result.DictionaryValidationResult,
 *      Object, org.kuali.rice.krad.datadictionary.validation.constraint.Constraint,
 *      org.kuali.rice.krad.datadictionary.validation.AttributeValueReader)
 */
@Override
public ProcessorResult process(DictionaryValidationResult result, Collection<?> collection,
        CollectionSizeConstraint constraint,
        AttributeValueReader attributeValueReader) throws AttributeValidationException {

    // To accommodate the needs of other processors, the ConstraintProcessor.process() method returns a list of ConstraintValidationResult objects
    // but since a definition that is collection size constrained only provides a single max and minimum, there is effectively a single constraint
    // being imposed.
    return new ProcessorResult(processSingleCollectionSizeConstraint(result, collection, constraint,
            attributeValueReader));
}
 

import org.kuali.rice.krad.datadictionary.validation.constraint.CollectionSizeConstraint; //导入依赖的package包/类
/**
 * @see org.kuali.rice.krad.datadictionary.validation.processor.ConstraintProcessor#getConstraintType()
 */
@Override
public Class<? extends Constraint> getConstraintType() {
    return CollectionSizeConstraint.class;
}
 

import org.kuali.rice.krad.datadictionary.validation.constraint.CollectionSizeConstraint; //导入依赖的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
}