Java 类javax.validation.constraints.Past 实例源码

@Test
public void testPast() {
    Set<ConstraintViolation<ObjectWithValidation>> violations = validator.validate(obj, Past.class);
    assertNotNull(violations);
    assertEquals(violations.size(), 1);

    if (runPeformance) {
        long time = System.currentTimeMillis();
        for (int index = 0; index < 10000; index++) {
            validator.validate(obj, Past.class);
        }
        long used = System.currentTimeMillis() - time;
        System.out.println("Hibernate Validator [Past] check used " + used + "ms, avg. " + ((double) used) / 10000
                + "ms.");
    }
}

private void convert(MetaDataEntry metaData, Map<String, Object> result) {
    if (NotNull.class.getName().equals(metaData.getKey())) {
        result.put(CommonMetaDataKeys.REQUIRED.getKey(), Boolean.TRUE);
    }
    if (Size.class.getName().equals(metaData.getKey())) {
        Size size = (Size) metaData.getValue();
        if (size.max() < Integer.MAX_VALUE) {
            result.put(CommonMetaDataKeys.SIZE.getKey(), size.max());
        }
    }
    if (Past.class.getName().equals(metaData.getKey())) {
        result.put(CommonMetaDataKeys.PAST.getKey(), Boolean.TRUE);
    }
    if (Future.class.getName().equals(metaData.getKey())) {
        result.put(CommonMetaDataKeys.FUTURE.getKey(), Boolean.TRUE);
    }
}

private static boolean isValidSimpleConstraint(String cName, String field, Object actual, LinkedList<String> err) {
    if ("required".equals(cName) && !required().isValid(actual)) {
        err.add(Utils.formatMessage("{0} is required.", field));
        return false;
    } else if (matches(AssertFalse.class, cName) && !falsy().isValid(actual)) {
        err.add(Utils.formatMessage("{0} must be false.", field));
        return false;
    } else if (matches(AssertTrue.class, cName) && !truthy().isValid(actual)) {
        err.add(Utils.formatMessage("{0} must be true.", field));
        return false;
    } else if (matches(Future.class, cName) && !future().isValid(actual)) {
        err.add(Utils.formatMessage("{0} must be in the future.", field));
        return false;
    } else if (matches(Past.class, cName) && !past().isValid(actual)) {
        err.add(Utils.formatMessage("{0} must be in the past.", field));
        return false;
    } else if (matches(URL.class, cName) && !url().isValid(actual)) {
        err.add(Utils.formatMessage("{0} is not a valid URL.", field));
        return false;
    } else if (matches(Email.class, cName) && !email().isValid(actual)) {
        err.add(Utils.formatMessage("{0} is not a valid email.", field));
        return false;
    }
    return true;
}

@Override
public Object process(AnnotationInfo ctx, Object value) throws Exception {
    if (!ctx.isAnnotationPresent(Past.class)) {
        return value;
    }
    return DateUtils.addDays(new Date(), -2);
}

@Override
public void initialize(Past constraintAnnotation) {
}

private static void mapBeanValidationParameter(Annotation annotation, InstanceDescriptor element) {
    SimpleTypeDescriptor typeDescriptor = (SimpleTypeDescriptor) element.getLocalType(false);
if (annotation instanceof AssertFalse)
        typeDescriptor.setTrueQuota(0.);
    else if (annotation instanceof AssertTrue)
        typeDescriptor.setTrueQuota(1.);
    else if (annotation instanceof DecimalMax)
        typeDescriptor.setMax(String.valueOf(DescriptorUtil.convertType(((DecimalMax) annotation).value(), typeDescriptor)));
    else if (annotation instanceof DecimalMin)
        typeDescriptor.setMin(String.valueOf(DescriptorUtil.convertType(((DecimalMin) annotation).value(), typeDescriptor)));
    else if (annotation instanceof Digits) {
        Digits digits = (Digits) annotation;
    typeDescriptor.setGranularity(String.valueOf(Math.pow(10, - digits.fraction())));
    } else if (annotation instanceof Future)
       typeDescriptor.setMin(new SimpleDateFormat("yyyy-MM-dd").format(TimeUtil.tomorrow()));
      else if (annotation instanceof Max)
    typeDescriptor.setMax(String.valueOf(((Max) annotation).value()));
      else if (annotation instanceof Min)
        typeDescriptor.setMin(String.valueOf(((Min) annotation).value()));
    else if (annotation instanceof NotNull) {
        element.setNullable(false);
        element.setNullQuota(0.);
    } else if (annotation instanceof Null) {
        element.setNullable(true);
        element.setNullQuota(1.);
    } else if (annotation instanceof Past)
       typeDescriptor.setMax(new SimpleDateFormat("yyyy-MM-dd").format(TimeUtil.yesterday()));
      else if (annotation instanceof Pattern)
        typeDescriptor.setPattern(String.valueOf(((Pattern) annotation).regexp()));
    else if (annotation instanceof Size) {
        Size size = (Size) annotation;
        typeDescriptor.setMinLength(size.min());
        typeDescriptor.setMaxLength(size.max());
    }
  }

@Past
public Date getBirthDay() {
    return birthDay;
}

/**
 * Acessor de leitura para o campo dataInicio
 * 
 * @return o dataInicio
 */
@Past
@NotNull
public Date getDataInicio() {
    return dataInicio;
}

/**
 * Acessor de leitura para o campo dataFim
 * 
 * @return o dataFim
 */
@Past
@NotNull
public Date getDataFim() {
    return dataFim;
}

@Override
public boolean incudeInValidation(Past pastAnnotation, RequestHandler requestHandler, ValidationContext validationCtx) {
    return true;
}

@Override
public void validate(Past pastAnnotation, String name, ValidationContext validationCtx, Errors errors) {
    Object value = validationCtx.value(name);

    if (value == null)
        return;

    if (!(value instanceof Date))
        errors.add(name, pastAnnotation.message(), value);

    LocalDate inputDate = ((Date) value).toInstant().atZone(ZoneId.systemDefault()).toLocalDate();

    if (yesterday().isAfter(inputDate) || yesterday().isEqual(inputDate))
        errors.add(name, pastAnnotation.message(), value);

}

@Transient
@Past
public Date getBirthdate() {
    return this.birthdate;
}

@Override
public void initialize(Past constraintAnnotation) {
}

@Transient
@Past
public Date getBirthdate() {
    return this.birthdate;
}

@Override
public void initialize(final Past constraintAnnotation) {}

@Override
public void initialize(final Past constraintAnnotation) {}

private void appendPastValidator(SourceWriter w, JField field) {
    Past pastAnnotation = field.getAnnotation(Past.class);
    if (pastAnnotation != null) {
        w.println(", new PastValidator(\"%s\")", pastAnnotation.message());
    }
}

@Override
public void initialize(Past constraintAnnotation) {
}

@Override
public void initialize(Past constraintAnnotation) {
}

@Override
public void initialize(Past constraintAnnotation) {
}

@Override
public void initialize(Past constraintAnnotation) {
}

@Past
public Date getEdited() {
    return edited;
}

@NotNull
@Past
public Date getPosted() {
    return posted;
}

@Past
public Date getPast() {
    return this.past;
}

/**
 * @return date this metric was generated. Roughly equivalent with date of indexing
 */
@NotNull
@Past
public Date getCreated() {
  return created;
}

/**
 * @return date new dataset data was downloaded/harvested last time
 */
@NotNull
@Past
public Date getDownloaded() {
  return downloaded;
}

@Override
public void initialize(Past past) {

}

/**
 * The point in time when the coordinates were measured.
 *
 * <p>
 * The timestamp cannot be null and must be in the past (no kidding).
 *
 * @return the point in time when the coordinates were measured
 */
@Past(message = "{Model.Waypoint.Time.Past}")
@NotNull(message = "{Model.Waypoint.Time.NotNull}")
Instant getTime();

public void methodWithArgumentPast(@Past Date date0) {}