@Override public <A extends Annotation> ConstraintDefinitionContext<A> constraintDefinition(Class<A> annotationClass) { Contracts.assertNotNull( annotationClass, MESSAGES.annotationTypeMustNotBeNull() ); Contracts.assertTrue( annotationClass.isAnnotationPresent( Constraint.class ), MESSAGES.annotationTypeMustBeAnnotatedWithConstraint() ); if ( definedConstraints.contains( annotationClass ) ) { // Fail fast for easy-to-detect definition conflicts; other conflicts are handled in ValidatorFactoryImpl throw log.getConstraintHasAlreadyBeenConfiguredViaProgrammaticApiException( annotationClass ); } ConstraintDefinitionContextImpl<A> constraintContext = new ConstraintDefinitionContextImpl<A>( this, annotationClass ); constraintContexts.add( constraintContext ); definedConstraints.add( annotationClass ); return constraintContext; }
@Override public final <C> TypeConstraintMappingContext<C> type(Class<C> type) { Contracts.assertNotNull( type, MESSAGES.beanTypeMustNotBeNull() ); if ( configuredTypes.contains( type ) ) { throw LOG.getBeanClassHasAlreadyBeConfiguredViaProgrammaticApiException( type ); } TypeConstraintMappingContextImpl<C> typeContext = new TypeConstraintMappingContextImpl<>( this, type ); typeContexts.add( typeContext ); configuredTypes.add( type ); return typeContext; }
Contracts.assertNotNull( annotationType, MESSAGES.classCannotBeNull() );
log.info( MESSAGES.unableToUseResourceBundleAggregation() ); return false;
@SuppressWarnings("unchecked") public <T> BeanMetaData<T> getBeanMetaData(Class<T> beanClass) { Contracts.assertNotNull( beanClass, MESSAGES.beanTypeCannotBeNull() ); BeanMetaData<T> beanMetaData = (BeanMetaData<T>) beanMetaDataCache.computeIfAbsent( beanClass, bc -> createBeanMetaData( bc ) ); return beanMetaData; }
/** * Finds type arguments constraints for parameters. * * @param executable the executable * @param i the parameter index * * @return a set of type arguments constraints, or an empty set if no constrained type arguments are found */ protected Set<MetaConstraint<?>> findTypeAnnotationConstraintsForExecutableParameter(Executable executable, int i, AnnotatedType parameterAnnotatedType) { try { return findTypeArgumentsConstraints( executable, new TypeArgumentExecutableParameterLocation( executable, i ), parameterAnnotatedType ); } catch (ArrayIndexOutOfBoundsException ex) { LOG.warn( MESSAGES.constraintOnConstructorOfNonStaticInnerClass(), ex ); return Collections.emptySet(); } }
private void sanityCheckGroups(Class<?>[] groups) { Contracts.assertNotNull( groups, MESSAGES.groupMustNotBeNull() ); for ( Class<?> clazz : groups ) { if ( clazz == null ) { throw new IllegalArgumentException( MESSAGES.groupMustNotBeNull() ); } } }
@Override public final HibernateValidatorConfiguration addMapping(InputStream stream) { Contracts.assertNotNull( stream, MESSAGES.inputStreamCannotBeNull() ); validationBootstrapParameters.addMapping( stream.markSupported() ? stream : new BufferedInputStream( stream ) ); return this; }
public static GetClassLoader fromClass(Class<?> clazz) { Contracts.assertNotNull( clazz, MESSAGES.classIsNull() ); return new GetClassLoader( clazz ); }
private static boolean determineAvailabilityOfResourceBundleControl() { try { final ResourceBundle.Control dummyControl = ValidatorBundleLocator.AggregateResourceBundle.CONTROL; if (dummyControl == null) { return false; } else { final Method getModule = (Method) run(GetMethod.action(Class.class, "getModule")); if (getModule == null) { return true; } else { final Object module = getModule.invoke(ValidatorBundleLocator.class); final Method isNamedMethod = (Method) run(GetMethod.action(module.getClass(), "isNamed")); final boolean isNamed = (Boolean) isNamedMethod.invoke(module); return !isNamed; } } } catch (final Throwable var5) { LOGGER.info(Messages.MESSAGES.unableToUseResourceBundleAggregation()); return false; } }
@Override public final <T> Set<ConstraintViolation<T>> validateValue(Class<T> beanType, String propertyName, Object value, Class<?>... groups) { Contracts.assertNotNull( beanType, MESSAGES.beanTypeCannotBeNull() ); if ( !beanMetaDataManager.isConstrained( beanType ) ) { return Collections.emptySet(); } sanityCheckPropertyPath( propertyName ); ValidationOrder validationOrder = determineGroupValidationOrder( groups ); ValidationContext<T> context = getValidationContext().forValidateValue( beanType ); return validateValueInContext( context, value, PathImpl.createPathFromString( propertyName ), validationOrder ); }
private CascadingMetaDataBuilder findCascadingMetaData(Executable executable, Parameter[] parameters, int i, AnnotatedType parameterAnnotatedType) { Parameter parameter = parameters[i]; TypeVariable<?>[] typeParameters = parameter.getType().getTypeParameters(); Map<TypeVariable<?>, CascadingMetaDataBuilder> containerElementTypesCascadingMetaData = getTypeParametersCascadingMetadata( parameterAnnotatedType, typeParameters ); try { return getCascadingMetaData( ReflectionHelper.typeOf( parameter.getDeclaringExecutable(), i ), parameter, containerElementTypesCascadingMetaData ); } catch (ArrayIndexOutOfBoundsException ex) { LOG.warn( MESSAGES.constraintOnConstructorOfNonStaticInnerClass(), ex ); return CascadingMetaDataBuilder.nonCascading(); } }
private ValidationOrder determineGroupValidationOrder(Class<?>[] groups) { Contracts.assertNotNull( groups, MESSAGES.groupMustNotBeNull() ); for ( Class<?> clazz : groups ) { if ( clazz == null ) { throw new IllegalArgumentException( MESSAGES.groupMustNotBeNull() ); } } Collection<Class<?>> resultGroups; // if no groups is specified use the default if ( groups.length == 0 ) { resultGroups = DEFAULT_GROUPS; } else { resultGroups = Arrays.asList( groups ); } return validationOrderGenerator.getValidationOrder( resultGroups ); }
@Override public final HibernateValidatorConfiguration addMapping(InputStream stream) { Contracts.assertNotNull( stream, MESSAGES.inputStreamCannotBeNull() ); validationBootstrapParameters.addMapping( stream.markSupported() ? stream : new BufferedInputStream( stream ) ); return this; }
public static GetClassLoader fromClass(Class<?> clazz) { Contracts.assertNotNull( clazz, MESSAGES.classIsNull() ); return new GetClassLoader( clazz ); }
log.info( MESSAGES.unableToUseResourceBundleAggregation() ); return false;
@Override public <A extends Annotation> ConstraintDefinitionContext<A> constraintDefinition(Class<A> annotationClass) { Contracts.assertNotNull( annotationClass, MESSAGES.annotationTypeMustNotBeNull() ); Contracts.assertTrue( annotationClass.isAnnotationPresent( Constraint.class ), MESSAGES.annotationTypeMustBeAnnotatedWithConstraint() ); if ( definedConstraints.contains( annotationClass ) ) { // Fail fast for easy-to-detect definition conflicts; other conflicts are handled in ValidatorFactoryImpl throw LOG.getConstraintHasAlreadyBeenConfiguredViaProgrammaticApiException( annotationClass ); } ConstraintDefinitionContextImpl<A> constraintContext = new ConstraintDefinitionContextImpl<>( this, annotationClass ); constraintContexts.add( constraintContext ); definedConstraints.add( annotationClass ); return constraintContext; }
@Override public final <T> Set<ConstraintViolation<T>> validateValue(Class<T> beanType, String propertyName, Object value, Class<?>... groups) { Contracts.assertNotNull( beanType, MESSAGES.beanTypeCannotBeNull() ); sanityCheckPropertyPath( propertyName ); sanityCheckGroups( groups ); ValidationContext<T> validationContext = getValidationContextBuilder().forValidateValue( beanType ); if ( !validationContext.getRootBeanMetaData().hasConstraints() ) { return Collections.emptySet(); } ValidationOrder validationOrder = determineGroupValidationOrder( groups ); return validateValueInContext( validationContext, value, PathImpl.createPathFromString( propertyName ), validationOrder ); }
@Override protected Set<MetaConstraint<?>> findTypeAnnotationConstraintsForExecutableParameter(Member member, int i) { Parameter parameter = ( (Executable) member ).getParameters()[i]; try { return findTypeArgumentsConstraints( member, parameter.getAnnotatedType(), parameter.isAnnotationPresent( Valid.class ) ); } catch (ArrayIndexOutOfBoundsException ex) { log.warn( MESSAGES.constraintOnConstructorOfNonStaticInnerClass(), ex ); return Collections.emptySet(); } }
/** * Returns the constraint validator classes for the given constraint * annotation type, as retrieved from * * <ul> * <li>{@link Constraint#validatedBy()}, * <li>internally registered validators for built-in constraints</li> * <li>XML configuration and</li> * <li>programmatically registered validators (see * {@link org.hibernate.validator.cfg.ConstraintMapping#constraintDefinition(Class)}).</li> * </ul> * * The result is cached internally. * * @param annotationType The constraint annotation type. * @param <A> the type of the annotation * * @return The validator classes for the given type. */ public <A extends Annotation> List<ConstraintValidatorDescriptor<A>> getAllValidatorDescriptors(Class<A> annotationType) { Contracts.assertNotNull( annotationType, MESSAGES.classCannotBeNull() ); return validatorDescriptors.computeIfAbsent( annotationType, a -> getDefaultValidatorDescriptors( a ) ); }