Java tutorial
/* * Copyright 2000-2018 Vaadin Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ package com.vaadin.data.validator; import java.util.Comparator; import java.util.Objects; import com.vaadin.data.ValidationResult; import com.vaadin.data.ValueContext; /** * Verifies that a value is within the given range. * * @param <T> * the type to validate * @author Vaadin Ltd. * @since 8.0 */ public class RangeValidator<T> extends AbstractValidator<T> { private T minValue = null; private T maxValue = null; private boolean minValueIncluded = true; private boolean maxValueIncluded = true; private final Comparator<? super T> comparator; /** * Creates a new range validator of the given type. Passing null to either * {@code minValue} or {@code maxValue} means there is no limit in that * direction. Both limits may be null; this can be useful if the limits are * resolved programmatically. The result of passing null to {@code apply} * depends on the given comparator. * * @param errorMessage * the error message to return if validation fails, not null * @param comparator * the comparator to compare with, not null * @param minValue * the least value of the accepted range or null for no limit * @param maxValue * the greatest value of the accepted range or null for no limit */ public RangeValidator(String errorMessage, Comparator<? super T> comparator, T minValue, T maxValue) { super(errorMessage); Objects.requireNonNull(comparator, "comparator cannot be null"); this.minValue = minValue; this.maxValue = maxValue; this.minValueIncluded = minValue != null; this.maxValueIncluded = maxValue != null; this.comparator = comparator; } /** * Returns a {@code RangeValidator} comparing values of a {@code Comparable} * type using their <i>natural order</i>. Passing null to either * {@code minValue} or {@code maxValue} means there is no limit in that * direction. Both limits may be null; this can be useful if the limits are * resolved programmatically. * <p> * Null is considered to be less than any non-null value. This means null * never passes validation if a minimum value is specified. * * @param <C> * the {@code Comparable} value type * @param errorMessage * the error message to return if validation fails, not null * @param minValue * the least value of the accepted range or null for no limit * @param maxValue * the greatest value of the accepted range or null for no limit * @return the new validator */ public static <C extends Comparable<? super C>> RangeValidator<C> of(String errorMessage, C minValue, C maxValue) { return new RangeValidator<>(errorMessage, Comparator.nullsFirst(Comparator.naturalOrder()), minValue, maxValue); } /** * Returns {@code Result.ok} if the value is within the specified bounds, * {@code Result.error} otherwise. If null is passed to {@code apply}, the * behavior depends on the used comparator. */ @Override public ValidationResult apply(T value, ValueContext context) { return toResult(value, isValid(value)); } /** * Returns whether the minimum value is part of the accepted range. * * @return true if the minimum value is part of the range, false otherwise */ public boolean isMinValueIncluded() { return minValueIncluded; } /** * Sets whether the minimum value is part of the accepted range. * * @param minValueIncluded * true if the minimum value should be part of the range, false * otherwise */ public void setMinValueIncluded(boolean minValueIncluded) { this.minValueIncluded = minValueIncluded; } /** * Returns whether the maximum value is part of the accepted range. * * @return true if the maximum value is part of the range, false otherwise */ public boolean isMaxValueIncluded() { return maxValueIncluded; } /** * Sets whether the maximum value is part of the accepted range. * * @param maxValueIncluded * true if the maximum value should be part of the range, false * otherwise */ public void setMaxValueIncluded(boolean maxValueIncluded) { this.maxValueIncluded = maxValueIncluded; } /** * Returns the minimum value of the range. * * @return the minimum value */ public T getMinValue() { return minValue; } /** * Sets the minimum value of the range. Use * {@link #setMinValueIncluded(boolean)} to control whether this value is * part of the range or not. * * @param minValue * the minimum value */ public void setMinValue(T minValue) { this.minValue = minValue; } /** * Gets the maximum value of the range. * * @return the maximum value */ public T getMaxValue() { return maxValue; } /** * Sets the maximum value of the range. Use * {@link #setMaxValueIncluded(boolean)} to control whether this value is * part of the range or not. * * @param maxValue * the maximum value */ public void setMaxValue(T maxValue) { this.maxValue = maxValue; } @Override public String toString() { T min = getMinValue(); T max = getMaxValue(); return String.format("%s %c%s, %s%c", getClass().getSimpleName(), isMinValueIncluded() ? '[' : '(', min != null ? min : "-", max != null ? max : "", isMaxValueIncluded() ? ']' : ')'); } /** * Returns whether the given value lies in the valid range. * * @param value * the value to validate * @return true if the value is valid, false otherwise */ protected boolean isValid(T value) { if (value == null) { return true; } if (getMinValue() != null) { int result = comparator.compare(value, getMinValue()); if (result < 0) { return false; } else if (result == 0 && !isMinValueIncluded()) { return false; } } if (getMaxValue() != null) { int result = comparator.compare(value, getMaxValue()); if (result > 0) { return false; } else if (result == 0 && !isMaxValueIncluded()) { return false; } } return true; } }