public ConstraintDefinitionContribution(Class<A> constraintType, List<ConstraintValidatorDescriptor<A>> validatorDescriptors, boolean includeExisting) { this.constraintType = constraintType; this.validatorDescriptors = CollectionHelper.toImmutableList( validatorDescriptors ); this.includeExisting = includeExisting; }
public ValidatableParametersMetaData(List<ParameterMetaData> parameterMetaData) { this.parameterMetaData = CollectionHelper.toImmutableList( parameterMetaData ); this.cascadables = CollectionHelper.toImmutableList( parameterMetaData.stream() .filter( p -> p.isCascading() ) .collect( Collectors.toList() ) ); }
private static <A extends Annotation> void putConstraints(Map<Class<? extends Annotation>, List<ConstraintValidatorDescriptor<?>>> validators, Class<A> constraintType, List<Class<? extends ConstraintValidator<A, ?>>> validatorDescriptors) { List<ConstraintValidatorDescriptor<?>> descriptors = validatorDescriptors.stream() .map( vt -> ConstraintValidatorDescriptor.forClass( vt, constraintType ) ) .collect( Collectors.toList() ); validators.put( constraintType, CollectionHelper.toImmutableList( descriptors ) ); }
private static <A extends Annotation> void putConstraints(Map<Class<? extends Annotation>, List<ConstraintValidatorDescriptor<?>>> validators, Class<A> constraintType, Class<? extends ConstraintValidator<A, ?>> validatorType1, Class<? extends ConstraintValidator<A, ?>> validatorType2) { List<ConstraintValidatorDescriptor<?>> descriptors = Stream.of( validatorType1, validatorType2 ) .map( vt -> ConstraintValidatorDescriptor.forClass( vt, constraintType ) ) .collect( Collectors.toList() ); validators.put( constraintType, CollectionHelper.toImmutableList( descriptors ) ); }
@Override public void initialize(Currency currency) { List<CurrencyUnit> acceptedCurrencies = new ArrayList<CurrencyUnit>(); for ( String currencyCode : currency.value() ) { acceptedCurrencies.add( Monetary.getCurrency( currencyCode ) ); } this.acceptedCurrencies = CollectionHelper.toImmutableList( acceptedCurrencies ); }
public ExecutableDescriptorImpl( Type returnType, String name, Set<ConstraintDescriptorImpl<?>> crossParameterConstraints, ReturnValueDescriptor returnValueDescriptor, List<ParameterDescriptor> parameters, boolean defaultGroupSequenceRedefined, boolean isGetter, List<Class<?>> defaultGroupSequence) { super( returnType, Collections.<ConstraintDescriptorImpl<?>>emptySet(), defaultGroupSequenceRedefined, defaultGroupSequence ); this.name = name; this.parameters = CollectionHelper.toImmutableList( parameters ); this.returnValueDescriptor = returnValueDescriptor; this.crossParameterDescriptor = new CrossParameterDescriptorImpl( crossParameterConstraints, defaultGroupSequenceRedefined, defaultGroupSequence ); this.isGetter = isGetter; }
/** * Registers the given validator descriptors with the given constraint * annotation type. * * @param annotationType The constraint annotation type * @param validatorDescriptors The validator descriptors to register * @param keepExistingClasses Whether already-registered validators should be kept or not * @param <A> the type of the annotation */ public <A extends Annotation> void putValidatorDescriptors(Class<A> annotationType, List<ConstraintValidatorDescriptor<A>> validatorDescriptors, boolean keepExistingClasses) { List<ConstraintValidatorDescriptor<A>> validatorDescriptorsToAdd = new ArrayList<>(); if ( keepExistingClasses ) { List<ConstraintValidatorDescriptor<A>> existingvalidatorDescriptors = getAllValidatorDescriptors( annotationType ); if ( existingvalidatorDescriptors != null ) { validatorDescriptorsToAdd.addAll( 0, existingvalidatorDescriptors ); } } validatorDescriptorsToAdd.addAll( validatorDescriptors ); this.validatorDescriptors.put( annotationType, CollectionHelper.toImmutableList( validatorDescriptorsToAdd ) ); }
public final List<ConstraintViolationCreationContext> getConstraintViolationCreationContexts() { if ( defaultDisabled ) { if ( constraintViolationCreationContexts == null || constraintViolationCreationContexts.size() == 0 ) { throw LOG.getAtLeastOneCustomMessageMustBeCreatedException(); } return CollectionHelper.toImmutableList( constraintViolationCreationContexts ); } if ( constraintViolationCreationContexts == null || constraintViolationCreationContexts.size() == 0 ) { return Collections.singletonList( getDefaultConstraintViolationCreationContext() ); } List<ConstraintViolationCreationContext> returnedConstraintViolationCreationContexts = new ArrayList<>( constraintViolationCreationContexts.size() + 1 ); returnedConstraintViolationCreationContexts.addAll( constraintViolationCreationContexts ); returnedConstraintViolationCreationContexts.add( getDefaultConstraintViolationCreationContext() ); return CollectionHelper.toImmutableList( returnedConstraintViolationCreationContexts ); }
/** * Creates a locator that delivers a resource bundle merged from the given * list of source bundles. * * @param bundleNames A list with source bundle names. The returned bundle will * contain all keys from all source bundles. In case a key occurs * in multiple source bundles, the value will be taken from the * first bundle containing the key. * @param delegate A delegate resource bundle locator. The bundle returned by * this locator will be added to the aggregate bundle after all * source bundles. * @param classLoader The classloader to use for loading the bundle. * @since 5.2 */ public AggregateResourceBundleLocator(List<String> bundleNames, ResourceBundleLocator delegate, ClassLoader classLoader) { super( delegate ); Contracts.assertValueNotNull( bundleNames, "bundleNames" ); this.bundleNames = CollectionHelper.toImmutableList( bundleNames ); this.classLoader = classLoader; }
public ElementDescriptorImpl(Type type, Set<ConstraintDescriptorImpl<?>> constraintDescriptors, boolean defaultGroupSequenceRedefined, List<Class<?>> defaultGroupSequence) { this.type = (Class<?>) TypeHelper.getErasedType( type ); this.constraintDescriptors = CollectionHelper.toImmutableSet( constraintDescriptors ); this.defaultGroupSequenceRedefined = defaultGroupSequenceRedefined; this.defaultGroupSequence = CollectionHelper.toImmutableList( defaultGroupSequence ); }
/** * @param collection the collection to validate * @param constraintValidatorContext context in which the constraint is evaluated * * @return true if the input collection is null or does not contain duplicate elements */ @Override public boolean isValid(Collection collection, ConstraintValidatorContext constraintValidatorContext) { if ( collection == null || collection.size() < 2 ) { return true; } List<Object> duplicates = findDuplicates( collection ); if ( duplicates.isEmpty() ) { return true; } if ( constraintValidatorContext instanceof HibernateConstraintValidatorContext ) { constraintValidatorContext.unwrap( HibernateConstraintValidatorContext.class ) .addMessageParameter( "duplicates", duplicates.stream().map( String::valueOf ).collect( Collectors.joining( ", " ) ) ) .withDynamicPayload( CollectionHelper.toImmutableList( duplicates ) ); } return false; }
this.parameterMetaData = CollectionHelper.toImmutableList( parameterMetaData ); this.hasParameterConstraints = hasParameterConstraints( parameterMetaData ) || !crossParameterConstraints.isEmpty(); this.isGetterMethod = ReflectionHelper.isGetterMethod( executable );
.collect( Collectors.collectingAndThen( Collectors.toList(), CollectionHelper::toImmutableList ) ); List<ConstraintValidatorDescriptor<T>> crossParameterValidatorDescriptors = CollectionHelper.toImmutableList( constraintHelper.findValidatorDescriptors( annotationDescriptor.getType(), ValidationTarget.PARAMETERS ) ); List<ConstraintValidatorDescriptor<T>> genericValidatorDescriptors = CollectionHelper.toImmutableList( constraintHelper.findValidatorDescriptors( annotationDescriptor.getType(), ValidationTarget.ANNOTATED_ELEMENT this.matchingConstraintValidatorDescriptors = CollectionHelper.toImmutableList( genericValidatorDescriptors ); this.matchingConstraintValidatorDescriptors = CollectionHelper.toImmutableList( crossParameterValidatorDescriptors );
this.allMetaConstraints = CollectionHelper.toImmutableSet( allMetaConstraints ); this.classHierarchyWithoutInterfaces = CollectionHelper.toImmutableList( ClassHierarchyHelper.getHierarchy( beanClass, Filters.excludeInterfaces() this.defaultGroupSequence = CollectionHelper.toImmutableList( defaultGroupContext.defaultGroupSequence ); this.validationOrder = defaultGroupContext.validationOrder;
this.parameterMetaDataList = CollectionHelper.toImmutableList( parameterMetaDataList ); this.validatableParametersMetaData = new ValidatableParametersMetaData( parameterMetaDataList ); this.crossParameterConstraints = CollectionHelper.toImmutableSet( crossParameterConstraints );