private ValueContext<?, Object> buildNewLocalExecutionContext(ValueContext<?, Object> valueContext, Object value) { ValueContext<?, Object> newValueContext; if ( value != null ) { newValueContext = ValueContext.getLocalExecutionContext( value, beanMetaDataManager.getBeanMetaData( value.getClass() ), valueContext.getPropertyPath() ); } else { newValueContext = ValueContext.getLocalExecutionContext( valueContext.getCurrentBeanType(), beanMetaDataManager.getBeanMetaData( valueContext.getCurrentBeanType() ), valueContext.getPropertyPath() ); } return newValueContext; }
private boolean isValidationRequired(ValidationContext<?> validationContext, ValueContext<?, ?> valueContext, MetaConstraint<?> metaConstraint) { if ( validationContext.hasMetaConstraintBeenProcessed( valueContext.getCurrentBean(), valueContext.getPropertyPath(), metaConstraint ) ) { return false; } if ( !metaConstraint.getGroupList().contains( valueContext.getCurrentGroup() ) ) { return false; } return isReachable( validationContext, valueContext.getCurrentBean(), valueContext.getPropertyPath(), metaConstraint.getElementType() ); }
private <U> boolean validateConstraintsForSingleDefaultGroupElement(ValidationContext<?> validationContext, ValueContext<U, Object> valueContext, final Map<Class<?>, Class<?>> validatedInterfaces, Class<? super U> clazz, Set<MetaConstraint<?>> metaConstraints, Group defaultSequenceMember) { boolean validationSuccessful = true; valueContext.setCurrentGroup( defaultSequenceMember.getDefiningClass() ); PathImpl currentPath = valueContext.getPropertyPath(); for ( MetaConstraint<?> metaConstraint : metaConstraints ) { // HV-466, an interface implemented more than one time in the hierarchy has to be validated only one // time. An interface can define more than one constraint, we have to check the class we are validating. final Class<?> declaringClass = metaConstraint.getLocation().getDeclaringClass(); if ( declaringClass.isInterface() ) { Class<?> validatedForClass = validatedInterfaces.get( declaringClass ); if ( validatedForClass != null && !validatedForClass.equals( clazz ) ) { continue; } validatedInterfaces.put( declaringClass, clazz ); } boolean tmp = validateConstraint( validationContext, valueContext, false, metaConstraint ); if ( shouldFailFast( validationContext ) ) { return false; } validationSuccessful = validationSuccessful && tmp; // reset property path valueContext.setPropertyPath( currentPath ); } return validationSuccessful; }
ConstraintViolationCreationContext constraintViolationCreationContext = new ConstraintViolationCreationContext( message, valueContext.getPropertyPath() ); ConstraintViolation<T> violation = executionContext.createConstraintViolation(
ConstraintViolationCreationContext constraintViolationCreationContext = new ConstraintViolationCreationContext( message, valueContext.getPropertyPath() ); ConstraintViolation<T> violation = executionContext.createConstraintViolation(
private ValueContext<?, Object> buildNewLocalExecutionContext(ValueContext<?, ?> valueContext, Object value) { ValueContext<?, Object> newValueContext; if ( value != null ) { newValueContext = ValueContext.getLocalExecutionContext( validatorScopedContext.getParameterNameProvider(), value, beanMetaDataManager.getBeanMetaData( value.getClass() ), valueContext.getPropertyPath() ); newValueContext.setCurrentValidatedValue( value ); } else { newValueContext = ValueContext.getLocalExecutionContext( validatorScopedContext.getParameterNameProvider(), valueContext.getCurrentBeanType(), valueContext.getCurrentBeanMetaData(), valueContext.getPropertyPath() ); } return newValueContext; }
public void markCurrentBeanAsProcessed(ValueContext<?, ?> valueContext) { if ( disableAlreadyValidatedBeanTracking ) { return; } markCurrentBeanAsProcessedForCurrentGroup( valueContext.getCurrentBean(), valueContext.getCurrentGroup() ); markCurrentBeanAsProcessedForCurrentPath( valueContext.getCurrentBean(), valueContext.getPropertyPath() ); }
public void markCurrentBeanAsProcessed(ValueContext<?, ?> valueContext) { markCurrentBeanAsProcessedForCurrentGroup( valueContext.getCurrentBean(), valueContext.getCurrentGroup() ); markCurrentBeanAsProcessedForCurrentPath( valueContext.getCurrentBean(), valueContext.getPropertyPath() ); }
value, valueContext.getCurrentGroup(), valueContext.getPropertyPath() ) ) {
private boolean isValidationRequired(ValidationContext<?> validationContext, ValueContext<?, ?> valueContext, MetaConstraint<?> metaConstraint) { // validateProperty()/validateValue() call, but this constraint is for another property if ( validationContext.getValidatedProperty() != null && !Objects.equals( validationContext.getValidatedProperty(), getPropertyName( metaConstraint.getLocation() ) ) ) { return false; } if ( validationContext.hasMetaConstraintBeenProcessed( valueContext.getCurrentBean(), valueContext.getPropertyPath(), metaConstraint ) ) { return false; } if ( !metaConstraint.getGroupList().contains( valueContext.getCurrentGroup() ) ) { return false; } return isReachable( validationContext, valueContext.getCurrentBean(), valueContext.getPropertyPath(), metaConstraint.getElementType() ); }
public boolean validateConstraint(ValidationContext<?> executionContext, ValueContext<?, ?> valueContext) { valueContext.setElementType( getElementType() ); valueContext.setDeclaredTypeOfValidatedElement( location.getTypeForValidatorResolution() ); boolean validationResult = constraintTree.validateConstraints( executionContext, valueContext ); executionContext.markConstraintProcessed( valueContext.getCurrentBean(), valueContext.getPropertyPath(), this ); return validationResult; }
private void validateConstraintsForNonDefaultGroup(ValidationContext<?> validationContext, ValueContext<?, Object> valueContext) { BeanMetaData<?> beanMetaData = beanMetaDataManager.getBeanMetaData( valueContext.getCurrentBeanType() ); PathImpl currentPath = valueContext.getPropertyPath(); for ( MetaConstraint<?> metaConstraint : beanMetaData.getMetaConstraints() ) { validateConstraint( validationContext, valueContext, false, metaConstraint ); if ( shouldFailFast( validationContext ) ) { return; } // reset the path to the state before this call valueContext.setPropertyPath( currentPath ); } validationContext.markCurrentBeanAsProcessed( valueContext ); }
private <T, V> ConstraintValidator<A, V> getConstraintValidatorNoUnwrapping(ValidationContext<T> validationContext, ValueContext<?, V> valueContext) { // make sure no unwrapper is set valueContext.setValidatedValueHandler( null ); Type validatedValueType = valueContext.getDeclaredTypeOfValidatedElement(); ConstraintValidator<A, V> validator = validationContext.getConstraintValidatorManager() .getInitializedValidator( validatedValueType, descriptor, validationContext.getConstraintValidatorFactory() ); if ( validator == null ) { throwExceptionForNullValidator( validatedValueType, valueContext.getPropertyPath().asString() ); } return validator; }
validationContext.getParameterNames(), validationContext.getClockProvider(), valueContext.getPropertyPath(), descriptor, validationContext.getConstraintValidatorPayload()
private void validateCascadedAnnotatedObjectForCurrentGroup(Object value, ValidationContext<?> validationContext, ValueContext<?, Object> valueContext, CascadingMetaData cascadingMetaData) { if ( validationContext.isBeanAlreadyValidated( value, valueContext.getCurrentGroup(), valueContext.getPropertyPath() ) || shouldFailFast( validationContext ) ) { return; } Class<?> originalGroup = valueContext.getCurrentGroup(); Class<?> currentGroup = cascadingMetaData.convertGroup( originalGroup ); // expand the group only if was created by group conversion; // otherwise we're looping through the right validation order // already and need only to pass the current element ValidationOrder validationOrder = validationOrderGenerator.getValidationOrder( currentGroup, currentGroup != originalGroup ); ValueContext<?, Object> cascadedValueContext = buildNewLocalExecutionContext( valueContext, value ); validateInContext( validationContext, cascadedValueContext, validationOrder ); }
private <T, V> ConstraintValidator<A, V> getInitializedValidatorInstanceForWrappedInstance(ValidationContext<T> validationContext, ValueContext<?, V> valueContext, Type validatedValueType, ValidatedValueUnwrapper<V> validatedValueUnwrapper) { // make sure that unwrapper is set if ( validatedValueUnwrapper == null ) { throw log.getNoUnwrapperFoundForTypeException( valueContext.getDeclaredTypeOfValidatedElement() ); } valueContext.setValidatedValueHandler( validatedValueUnwrapper ); validatedValueType = validatedValueUnwrapper.getValidatedValueType( validatedValueType ); ConstraintValidator<A, V> validator = validationContext.getConstraintValidatorManager() .getInitializedValidator( validatedValueType, descriptor, validationContext.getConstraintValidatorFactory() ); if ( validator == null ) { throwExceptionForNullValidator( validatedValueType, valueContext.getPropertyPath().asString() ); } return validator; }
private boolean validateMetaConstraint(ValidationContext<?> validationContext, ValueContext<?, Object> valueContext, Object parent, MetaConstraint<?> metaConstraint) { ValueContext.ValueState<Object> originalValueState = valueContext.getCurrentValueState(); valueContext.appendNode( metaConstraint.getLocation() ); boolean success = true; if ( isValidationRequired( validationContext, valueContext, metaConstraint ) ) { if ( parent != null ) { valueContext.setCurrentValidatedValue( valueContext.getValue( parent, metaConstraint.getLocation() ) ); } success = metaConstraint.validateConstraint( validationContext, valueContext ); validationContext.markConstraintProcessed( valueContext.getCurrentBean(), valueContext.getPropertyPath(), metaConstraint ); } // reset the value context to the state before this call valueContext.resetValueState( originalValueState ); return success; }
protected final <T> ConstraintValidator<A, ?> getInitializedConstraintValidator(ValidationContext<T> validationContext, ValueContext<?, ?> valueContext) { ConstraintValidator<A, ?> validator; if ( validationContext.getConstraintValidatorFactory() == validationContext.getConstraintValidatorManager().getDefaultConstraintValidatorFactory() && validationContext.getConstraintValidatorInitializationContext() == validationContext.getConstraintValidatorManager() .getDefaultConstraintValidatorInitializationContext() ) { validator = constraintValidatorForDefaultConstraintValidatorFactoryAndInitializationContext; if ( validator == null ) { synchronized ( this ) { validator = constraintValidatorForDefaultConstraintValidatorFactoryAndInitializationContext; if ( validator == null ) { validator = getInitializedConstraintValidator( validationContext ); constraintValidatorForDefaultConstraintValidatorFactoryAndInitializationContext = validator; } } } } else { // For now, we don't cache the result in the ConstraintTree if we don't use the default constraint validator // factory. Creating a lot of CHM for that cache might not be a good idea and we prefer being conservative // for now. Note that we have the ConstraintValidatorManager cache that mitigates the situation. // If you come up with a use case where it makes sense, please reach out to us. validator = getInitializedConstraintValidator( validationContext ); } if ( validator == DUMMY_CONSTRAINT_VALIDATOR ) { throw getExceptionForNullValidator( validatedValueType, valueContext.getPropertyPath().asString() ); } return validator; }
if ( isCascadeRequired( validationContext, valueContext.getCurrentBean(), valueContext.getPropertyPath(), elementType ) ) { Object value = getCascadableValue( validationContext, valueContext.getCurrentBean(), cascadable ); CascadingMetaData cascadingMetaData = cascadable.getCascadingMetaData();
private void doValidate(Object value, String nodeName) { if ( value == null || validationContext.isBeanAlreadyValidated( value, valueContext.getCurrentGroup(), valueContext.getPropertyPath() ) || shouldFailFast( validationContext ) ) { return;