GC: ValidatorImpl - org.hibernate.validator.internal.engine.ValidatorImpl (.java)

Maven-Central
/
com.fasterxml.tran.....ransistore-server
/
0.9.0

0.9.8
0.9.7
0.9.5
0.9.2
0.9.0
0.7.1
/
org.hibernate.validator.internal.engine.ValidatorImpl
Find Usages
Diff
Raw
Download
HTML Widget
Stack Overflow Questions
1
   /*
2
   * JBoss, Home of Professional Open Source
3
   * Copyright 2009, Red Hat, Inc. and/or its affiliates, and individual contributors
4
   * by the @authors tag. See the copyright.txt in the distribution for a
5
   * full listing of individual contributors.
6
   *
7
   * Licensed under the Apache License, Version 2.0 (the "License");
8
   * you may not use this file except in compliance with the License.
9
   * You may obtain a copy of the License at
10
  * http://www.apache.org/licenses/LICENSE-2.0
11
  * Unless required by applicable law or agreed to in writing, software
12
  * distributed under the License is distributed on an "AS IS" BASIS,
13
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14
  * See the License for the specific language governing permissions and
15
  * limitations under the License.
16
  */
17
  package org.hibernate.validator.internal.engine;
18
  
19
  import java.lang.annotation.ElementType;
20
  import java.lang.reflect.Field;
21
  import java.lang.reflect.Member;
22
  import java.lang.reflect.Method;
23
  import java.lang.reflect.Type;
24
  import java.util.Arrays;
25
  import java.util.Collections;
26
  import java.util.Iterator;
27
  import java.util.List;
28
  import java.util.Map;
29
  import java.util.Set;
30
  import javax.validation.ConstraintValidatorFactory;
31
  import javax.validation.ConstraintViolation;
32
  import javax.validation.MessageInterpolator;
33
  import javax.validation.Path;
34
  import javax.validation.TraversableResolver;
35
  import javax.validation.Validator;
36
  import javax.validation.groups.Default;
37
  import javax.validation.metadata.BeanDescriptor;
38
  
39
  import org.hibernate.validator.internal.engine.groups.Group;
40
  import org.hibernate.validator.internal.engine.groups.ValidationOrder;
41
  import org.hibernate.validator.internal.engine.groups.ValidationOrderGenerator;
42
  import org.hibernate.validator.internal.engine.groups.Sequence;
43
  import org.hibernate.validator.internal.engine.resolver.SingleThreadCachedTraversableResolver;
44
  import org.hibernate.validator.internal.metadata.BeanMetaDataManager;
45
  import org.hibernate.validator.internal.metadata.aggregated.BeanMetaData;
46
  import org.hibernate.validator.internal.metadata.aggregated.MethodMetaData;
47
  import org.hibernate.validator.internal.metadata.aggregated.ParameterMetaData;
48
  import org.hibernate.validator.internal.metadata.core.MetaConstraint;
49
  import org.hibernate.validator.internal.util.Contracts;
50
  import org.hibernate.validator.internal.util.ReflectionHelper;
51
  import org.hibernate.validator.internal.util.TypeHelper;
52
  import org.hibernate.validator.internal.util.logging.Log;
53
  import org.hibernate.validator.internal.util.logging.LoggerFactory;
54
  import org.hibernate.validator.method.MethodConstraintViolation;
55
  import org.hibernate.validator.method.MethodValidator;
56
  import org.hibernate.validator.method.metadata.TypeDescriptor;
57
  
58
  import static org.hibernate.validator.internal.util.CollectionHelper.newArrayList;
59
  import static org.hibernate.validator.internal.util.CollectionHelper.newHashMap;
60
  import static org.hibernate.validator.internal.util.logging.Messages.MESSAGES;

 The main Bean Validation class. This is the core processing class of Hibernate Validator.

 
 Author(s):Emmanuel BernardHardy FerentschikGunnar MorlingKevin Pollet <kevin.pollet@serli.com> (C) 2011 SERLI
69
  
70
  public class ValidatorImpl implements Validator, MethodValidator {
71
  
72
  	private static final Log log = LoggerFactory.make();

	
 The default group array used in case any of the validate methods is called without a group.
 
76
  
77
  	private static final Class<?>[] DEFAULT_GROUP_ARRAY = new Class<?>[] { Default.class };

	
 Used to resolve the group execution order for a validate call.
 
81
  
82
  	private final transient ValidationOrderGenerator validationOrderGenerator;

	
 Reference to shared ConstraintValidatorFactory.
 
86
  
87
  	private final ConstraintValidatorFactory constraintValidatorFactory;

	
 javax.validation.MessageInterpolator as passed to the constructor of this instance.
 
91
  
92
  	private final MessageInterpolator messageInterpolator;

	
 javax.validation.TraversableResolver as passed to the constructor of this instance.
 Never use it directly, always use getCachingTraversableResolver() to retrieved the single threaded caching wrapper.
 
97
  
98
  	private final TraversableResolver traversableResolver;

	
 Used to get access to the bean meta data. Used to avoid to parsing the constraint configuration for each call
 of a given entity.
 
103
 
104
 	private final BeanMetaDataManager beanMetaDataManager;

	
 Indicates if validation has to be stopped on first constraint violation.
 
108
 
109
 	private final boolean failFast;
110
 
111
 	public ValidatorImpl(ConstraintValidatorFactory constraintValidatorFactory, MessageInterpolator messageInterpolator, TraversableResolver traversableResolver, BeanMetaDataManager beanMetaDataManager, boolean failFast) {
112
 		this.constraintValidatorFactory = constraintValidatorFactory;
113
 		this.messageInterpolator = messageInterpolator;
114
 		this.traversableResolver = traversableResolver;
115
 		this.beanMetaDataManager = beanMetaDataManager;
116
 		this.failFast = failFast;
117
 
118
 		validationOrderGenerator = new ValidationOrderGenerator();
119
 	}
120
 
121
 	public final <T> Set<ConstraintViolation<T>> validate(T object, Class<?>... groups) {
122
 
123
 		Contracts.assertNotNull( object, MESSAGES.validatedObjectMustNotBeNull() );
124
 
125
 		ValidationOrder validationOrder = determineGroupValidationOrder( groups );
126
 
127
 		ValidationContext<T, ConstraintViolation<T>> validationContext = ValidationContext.getContextForValidate(
128
 				object, messageInterpolator, constraintValidatorFactory, getCachingTraversableResolver(), failFast
129
 		);
130
 
131
 		ValueContext<?, T> valueContext = ValueContext.getLocalExecutionContext( object, PathImpl.createRootPath() );
132
 
133
 		return validateInContext( valueContext, validationContext, validationOrder );
134
 	}
135
 
136
 	public final <T> Set<ConstraintViolation<T>> validateProperty(T object, String propertyName, Class<?>... groups) {
137
 
138
 		Contracts.assertNotNull( object, MESSAGES.validatedObjectMustNotBeNull() );
139
 
140
 		sanityCheckPropertyPath( propertyName );
141
 		ValidationOrder validationOrder = determineGroupValidationOrder( groups );
142
 
143
 		ValidationContext<T, ConstraintViolation<T>> context = ValidationContext.getContextForValidateProperty(
144
 				object,
145
 				messageInterpolator,
146
 				constraintValidatorFactory,
147
 				getCachingTraversableResolver(),
148
 				failFast
149
 		);
150
 
151
 		return validatePropertyInContext( context, PathImpl.createPathFromString( propertyName ), validationOrder );
152
 	}
153
 
154
 	public final <T> Set<ConstraintViolation<T>> validateValue(Class<T> beanType, String propertyName, Object value, Class<?>... groups) {
155
 
156
 		Contracts.assertNotNull( beanType, MESSAGES.beanTypeCannotBeNull() );
157
 
158
 		sanityCheckPropertyPath( propertyName );
159
 		ValidationOrder validationOrder = determineGroupValidationOrder( groups );
160
 
161
 		ValidationContext<T, ConstraintViolation<T>> context = ValidationContext.getContextForValidateValue(
162
 				beanType,
163
 				messageInterpolator,
164
 				constraintValidatorFactory,
165
 				getCachingTraversableResolver(),
166
 				failFast
167
 		);
168
 
169
 		return validateValueInContext( context, value, PathImpl.createPathFromString( propertyName ), validationOrder );
170
 	}
171
 
172
 	public final <T> Set<MethodConstraintViolation<T>> validateParameter(T object, Method method, Object parameterValue, int parameterIndex, Class<?>... groups) {
173
 
174
 		Contracts.assertNotNull( object, MESSAGES.validatedObjectMustNotBeNull() );
175
 		Contracts.assertNotNull( method, MESSAGES.validatedMethodMustNotBeNull() );
176
 
177
 		ValidationOrder validationOrder = determineGroupValidationOrder( groups );
178
 
179
 		MethodValidationContext<T> context = ValidationContext.getContextForValidateParameter(
180
 				method,
181
 				parameterIndex,
182
 				object,
183
 				messageInterpolator,
184
 				constraintValidatorFactory,
185
 				getCachingTraversableResolver(),
186
 				failFast
187
 		);
188
 
189
 		Object[] parameterValues = new Object[method.getParameterTypes().length];
190
 		parameterValues[parameterIndex] = parameterValue;
191
 
192
 		validateParametersInContext( context, object, parameterValues, validationOrder );
193
 
194
 		return context.getFailingConstraints();
195
 	}
196
 
197
 	public final <T> Set<MethodConstraintViolation<T>> validateAllParameters(T object, Method method, Object[] parameterValues, Class<?>... groups) {
198
 
199
 		Contracts.assertNotNull( object, MESSAGES.validatedObjectMustNotBeNull() );
200
 		Contracts.assertNotNull( method, MESSAGES.validatedMethodMustNotBeNull() );
201
 
202
 		//this might be the case for parameterless methods
203
 		if ( parameterValues == null ) {
204
 			return Collections.emptySet();
205
 		}
206
 
207
 		ValidationOrder validationOrder = determineGroupValidationOrder( groups );
208
 
209
 		MethodValidationContext<T> context = ValidationContext.getContextForValidateParameters(
210
 				method,
211
 				object,
212
 				messageInterpolator,
213
 				constraintValidatorFactory,
214
 				getCachingTraversableResolver(),
215
 				failFast
216
 		);
217
 
218
 		validateParametersInContext( context, object, parameterValues, validationOrder );
219
 
220
 		return context.getFailingConstraints();
221
 	}
222
 
223
 	public <T> Set<MethodConstraintViolation<T>> validateReturnValue(T object, Method method, Object returnValue, Class<?>... groups) {
224
 
225
 		Contracts.assertNotNull( method, MESSAGES.validatedMethodMustNotBeNull() );
226
 
227
 		ValidationOrder validationOrder = determineGroupValidationOrder( groups );
228
 
229
 		MethodValidationContext<T> context = ValidationContext.getContextForValidateParameters(
230
 				method,
231
 				object,
232
 				messageInterpolator,
233
 				constraintValidatorFactory,
234
 				getCachingTraversableResolver(),
235
 				failFast
236
 		);
237
 
238
 		validateReturnValueInContext( context, object, returnValue, validationOrder );
239
 
240
 		return context.getFailingConstraints();
241
 	}
242
 
243
 	public final BeanDescriptor getConstraintsForClass(Class<?> clazz) {
244
 		return beanMetaDataManager.getBeanMetaData( clazz ).getBeanDescriptor();
245
 	}
246
 
247
 	public final TypeDescriptor getConstraintsForType(Class<?> clazz) {
248
 		return beanMetaDataManager.getBeanMetaData( clazz ).getTypeDescriptor();
249
 	}
250
 
251
 	public final <T> T unwrap(Class<T> type) {
252
 		if ( type.isAssignableFrom( getClass() ) ) {
253
 			return type.cast( this );
254
 		}
255
 		throw log.getTypeNotSupportedException( type );
256
 	}
257
 
258
 	private void sanityCheckPropertyPath(String propertyName) {
259
 		if ( propertyName == null || propertyName.length() == 0 ) {
260
 			throw log.getInvalidPropertyPathException();
261
 		}
262
 	}
263
 
264
 	private ValidationOrder determineGroupValidationOrder(Class<?>[] groups) {
265
 		Contracts.assertNotNull( groups, MESSAGES.groupMustNotBeNull() );
266
 
267
 		Class<?>[] tmpGroups = groups;
268
 		// if no groups is specified use the default
269
 		if ( tmpGroups.length == 0 ) {
270
 			tmpGroups = DEFAULT_GROUP_ARRAY;
271
 		}
272
 
273
 		return validationOrderGenerator.getValidationOrder( Arrays.asList( tmpGroups ) );
274
 	}

	
 Validates the given object using the available context information.

 
 Parameters:valueContext the current validation contextcontext the global validation contextvalidationOrder Contains the information which and in which order groups have to be executed<T> The root bean type<V> The type of the current object on the validation stack Returns:Set of constraint violations or the empty set if there were no violations.
286
 
287
 	private <T, U, V, E extends ConstraintViolation<T>> Set<E> validateInContext(ValueContext<U, V> valueContext, ValidationContext<T, E> context, ValidationOrder validationOrder) {
288
 		if ( valueContext.getCurrentBean() == null ) {
289
 			return Collections.emptySet();
290
 		}
291
 
292
 		BeanMetaData<U> beanMetaData = beanMetaDataManager.getBeanMetaData( valueContext.getCurrentBeanType() );
293
 		if ( beanMetaData.defaultGroupSequenceIsRedefined() ) {
294
 			validationOrder.assertDefaultGroupSequenceIsExpandable( beanMetaData.getDefaultGroupSequence( valueContext.getCurrentBean() ) );
295
 		}
296
 
297
 		// process first single groups. For these we can optimise object traversal by first running all validations on the current bean
298
 		// before traversing the object.
299
 		Iterator<Group> groupIterator = validationOrder.getGroupIterator();
300
 		while ( groupIterator.hasNext() ) {
301
 			Group group = groupIterator.next();
302
 			valueContext.setCurrentGroup( group.getDefiningClass() );
303
 			validateConstraintsForCurrentGroup( context, valueContext );
304
 			if ( shouldFailFast( context ) ) {
305
 				return context.getFailingConstraints();
306
 			}
307
 		}
308
 		groupIterator = validationOrder.getGroupIterator();
309
 		while ( groupIterator.hasNext() ) {
310
 			Group group = groupIterator.next();
311
 			valueContext.setCurrentGroup( group.getDefiningClass() );
312
 			validateCascadedConstraints( context, valueContext );
313
 			if ( shouldFailFast( context ) ) {
314
 				return context.getFailingConstraints();
315
 			}
316
 		}
317
 
318
 		// now we process sequences. For sequences I have to traverse the object graph since I have to stop processing when an error occurs.
319
 		Iterator<Sequence> sequenceIterator = validationOrder.getSequenceIterator();
320
 		while ( sequenceIterator.hasNext() ) {
321
 			Sequence sequence = sequenceIterator.next();
322
 			for ( Group group : sequence.getComposingGroups() ) {
323
 				int numberOfViolations = context.getFailingConstraints().size();
324
 				valueContext.setCurrentGroup( group.getDefiningClass() );
325
 
326
 				validateConstraintsForCurrentGroup( context, valueContext );
327
 				if ( shouldFailFast( context ) ) {
328
 					return context.getFailingConstraints();
329
 				}
330
 
331
 				validateCascadedConstraints( context, valueContext );
332
 				if ( shouldFailFast( context ) ) {
333
 					return context.getFailingConstraints();
334
 				}
335
 
336
 				if ( context.getFailingConstraints().size() > numberOfViolations ) {
337
 					break;
338
 				}
339
 			}
340
 		}
341
 		return context.getFailingConstraints();
342
 	}
343
 
344
 	private <T, U, V, E extends ConstraintViolation<T>> void validateConstraintsForCurrentGroup(ValidationContext<T, E> validationContext, ValueContext<U, V> valueContext) {
345
 		// we are not validating the default group there is nothing special to consider. If we are validating the default
346
 		// group sequence we have to consider that a class in the hierarchy could redefine the default group sequence.
347
 		if ( !valueContext.validatingDefault() ) {
348
 			validateConstraintsForNonDefaultGroup( validationContext, valueContext );
349
 		}
350
 		else {
351
 			validateConstraintsForDefaultGroup( validationContext, valueContext );
352
 		}
353
 	}
354
 
355
 	private <T, U, V, E extends ConstraintViolation<T>> void validateConstraintsForDefaultGroup(ValidationContext<T, E> validationContext, ValueContext<U, V> valueContext) {
356
 		final BeanMetaData<U> beanMetaData = beanMetaDataManager.getBeanMetaData( valueContext.getCurrentBeanType() );
357
 		final Map<Class<?>, Class<?>> validatedInterfaces = newHashMap();
358
 
359
 		// evaluating the constraints of a bean per class in hierarchy, this is necessary to detect potential default group re-definitions
360
 		for ( Class<?> clazz : beanMetaData.getClassHierarchy() ) {
361
 			BeanMetaData<U> hostingBeanMetaData = (BeanMetaData<U>) beanMetaDataManager.getBeanMetaData( clazz );
362
 			boolean defaultGroupSequenceIsRedefined = hostingBeanMetaData.defaultGroupSequenceIsRedefined();
363
 			List<Class<?>> defaultGroupSequence = hostingBeanMetaData.getDefaultGroupSequence( valueContext.getCurrentBean() );
364
 			Set<MetaConstraint<?>> metaConstraints = hostingBeanMetaData.getDirectMetaConstraints();
365
 
366
 			// if the current class redefined the default group sequence, this sequence has to be applied to all the class hierarchy.
367
 			if ( defaultGroupSequenceIsRedefined ) {
368
 				metaConstraints = hostingBeanMetaData.getMetaConstraints();
369
 			}
370
 
371
 			PathImpl currentPath = valueContext.getPropertyPath();
372
 			for ( Class<?> defaultSequenceMember : defaultGroupSequence ) {
373
 				valueContext.setCurrentGroup( defaultSequenceMember );
374
 				boolean validationSuccessful = true;
375
 				for ( MetaConstraint<?> metaConstraint : metaConstraints ) {
376
 					// HV-466, an interface implemented more than one time in the hierarchy has to be validated only one
377
 					// time. An interface can define more than one constraint, we have to check the class we are validating.
378
 					final Class<?> declaringClass = metaConstraint.getLocation().getBeanClass();
379
 					if ( declaringClass.isInterface() ) {
380
 						Class<?> validatedForClass = validatedInterfaces.get( declaringClass );
381
 						if ( validatedForClass != null && !validatedForClass.equals( clazz ) ) {
382
 							continue;
383
 						}
384
 						validatedInterfaces.put( declaringClass, clazz );
385
 					}
386
 
387
 					boolean tmp = validateConstraint(
388
 							validationContext, valueContext, metaConstraint
389
 					);
390
 					if ( shouldFailFast( validationContext ) ) {
391
 						return;
392
 					}
393
 					validationSuccessful = validationSuccessful && tmp;
394
 					valueContext.setPropertyPath( currentPath );
395
 				}
396
 				if ( !validationSuccessful ) {
397
 					break;
398
 				}
399
 			}
400
 			validationContext.markProcessed(
401
 					valueContext.getCurrentBean(),
402
 					valueContext.getCurrentGroup(),
403
 					valueContext.getPropertyPath()
404
 			);
405
 
406
 			// all constraints in the hierarchy has been validated, stop validation.
407
 			if ( defaultGroupSequenceIsRedefined ) {
408
 				break;
409
 			}
410
 		}
411
 	}
412
 
413
 	private <T, U, V> void validateConstraintsForNonDefaultGroup(ValidationContext<T, ?> validationContext, ValueContext<U, V> valueContext) {
414
 		BeanMetaData<U> beanMetaData = beanMetaDataManager.getBeanMetaData( valueContext.getCurrentBeanType() );
415
 		PathImpl currentPath = valueContext.getPropertyPath();
416
 		for ( MetaConstraint<?> metaConstraint : beanMetaData.getMetaConstraints() ) {
417
 			validateConstraint( validationContext, valueContext, metaConstraint );
418
 			if ( shouldFailFast( validationContext ) ) {
419
 				return;
420
 			}
421
 			// reset the path to the state before this call
422
 			valueContext.setPropertyPath( currentPath );
423
 		}
424
 		validationContext.markProcessed(
425
 				valueContext.getCurrentBean(),
426
 				valueContext.getCurrentGroup(),
427
 				valueContext.getPropertyPath()
428
 		);
429
 	}
430
 
431
 	private <T, U, V> boolean validateConstraint(ValidationContext<T, ?> validationContext, ValueContext<U, V> valueContext, MetaConstraint<?> metaConstraint) {
432
 		boolean validationSuccessful = true;
433
 
434
 		if ( metaConstraint.getElementType() != ElementType.TYPE ) {
435
 			valueContext.appendNode( ReflectionHelper.getPropertyName( metaConstraint.getLocation().getMember() ) );
436
 		}
437
 
438
 		if ( isValidationRequired( validationContext, valueContext, metaConstraint ) ) {
439
 			@SuppressWarnings("unchecked")
440
 			V valueToValidate = (V) metaConstraint.getValue( valueContext.getCurrentBean() );
441
 			valueContext.setCurrentValidatedValue( valueToValidate );
442
 			validationSuccessful = metaConstraint.validateConstraint( validationContext, valueContext );
443
 		}
444
 
445
 		return validationSuccessful;
446
 	}

	
 Validates all cascaded constraints for the given bean using the current group set in the execution context.
 This method must always be called after validateConstraints for the same context.

 
 Parameters:validationContext The execution contextvalueContext Collected information for single validation
454
 
455
 	private <T, U, V> void validateCascadedConstraints(ValidationContext<T, ?> validationContext, ValueContext<U, V> valueContext) {
456
 		Set<Member> cascadedMembers = beanMetaDataManager.getBeanMetaData( valueContext.getCurrentBeanType() )
457
 				.getCascadedMembers();
458
 		PathImpl currentPath = valueContext.getPropertyPath();
459
 		for ( Member member : cascadedMembers ) {
460
 			String newNode = ReflectionHelper.getPropertyName( member );
461
 			valueContext.appendNode( newNode );
462
 
463
 			if ( isCascadeRequired( validationContext, valueContext, member ) ) {
464
 				Object value = ReflectionHelper.getValue( member, valueContext.getCurrentBean() );
465
 				if ( value != null ) {
466
 					Type type = value.getClass();
467
 					Iterator<?> iter = createIteratorForCascadedValue( type, value, valueContext );
468
 					boolean isIndexable = isIndexable( type );
469
 					validateCascadedConstraint(
470
 							validationContext,
471
 							iter,
472
 							isIndexable,
473
 							valueContext
474
 					);
475
 					if ( shouldFailFast( validationContext ) ) {
476
 						return;
477
 					}
478
 				}
479
 			}
480
 			// reset the path
481
 			valueContext.setPropertyPath( currentPath );
482
 		}
483
 	}

	
 Validates the cascading parameter or return value specified with the
 given value context. Any further cascading references are followed if
 applicable.

 
 Parameters:validationContext The global context for the current validateParameter(s) or
 validateReturnValue() call.valueContext The local context for validating the given parameter/return
 value.
494
 
495
 	private <T, U, V> void validateCascadedMethodConstraints(MethodValidationContext<T> validationContext, ValueContext<U, V> valueContext) {
496
 
497
 		Object value = valueContext.getCurrentBean();
498
 		Type type = valueContext.getCurrentBeanType();
499
 		Iterator<?> iter = createIteratorForCascadedValue( type, value, valueContext );
500
 		boolean isIndexable = isIndexable( type );
501
 
502
 		validateCascadedConstraint(
503
 				validationContext,
504
 				iter,
505
 				isIndexable,
506
 				valueContext
507
 		);
508
 	}

	
 Called when processing cascaded constraints. This methods inspects the type of the cascaded constraints and in case
 of a list or array creates an iterator in order to validate each element.

 
 Parameters:type the type of the cascaded field or property.value the actual value.valueContext context object containing state about the currently validated instance Returns:An iterator over the value of a cascaded property.
519
 
520
 	private Iterator<?> createIteratorForCascadedValue(Type type, Object value, ValueContext<?, ?> valueContext) {
521
 		Iterator<?> iter;
522
 		if ( ReflectionHelper.isIterable( type ) ) {
523
 			iter = ( (Iterable<?>) value ).iterator();
524
 			valueContext.markCurrentPropertyAsIterable();
525
 		}
526
 		else if ( ReflectionHelper.isMap( type ) ) {
527
 			Map<?, ?> map = (Map<?, ?>) value;
528
 			iter = map.entrySet().iterator();
529
 			valueContext.markCurrentPropertyAsIterable();
530
 		}
531
 		else if ( TypeHelper.isArray( type ) ) {
532
 			List<?> arrayList = Arrays.asList( (Object[]) value );
533
 			iter = arrayList.iterator();
534
 			valueContext.markCurrentPropertyAsIterable();
535
 		}
536
 		else {
537
 			List<Object> list = newArrayList();
538
 			list.add( value );
539
 			iter = list.iterator();
540
 		}
541
 		return iter;
542
 	}

	
 Called when processing cascaded constraints. This methods inspects the type of the cascaded constraints and in case
 of a list or array creates an iterator in order to validate each element.

 
 Parameters:type the type of the cascaded field or property. Returns:An iterator over the value of a cascaded property.
551
 
552
 	private boolean isIndexable(Type type) {
553
 		boolean isIndexable = false;
554
 		if ( ReflectionHelper.isList( type ) ) {
555
 			isIndexable = true;
556
 		}
557
 		else if ( ReflectionHelper.isMap( type ) ) {
558
 			isIndexable = true;
559
 		}
560
 		else if ( TypeHelper.isArray( type ) ) {
561
 			isIndexable = true;
562
 		}
563
 		return isIndexable;
564
 	}
565
 
566
 	private <T> void validateCascadedConstraint(ValidationContext<T, ?> context, Iterator<?> iter, boolean isIndexable, ValueContext<?, ?> valueContext) {
567
 		Object value;
568
 		Object mapKey;
569
 		int i = 0;
570
 		while ( iter.hasNext() ) {
571
 			value = iter.next();
572
 			if ( value instanceof Map.Entry ) {
573
 				mapKey = ( (Map.Entry<?, ?>) value ).getKey();
574
 				valueContext.setKey( mapKey );
575
 				value = ( (Map.Entry<?, ?>) value ).getValue();
576
 			}
577
 			else if ( isIndexable ) {
578
 				valueContext.setIndex( i );
579
 			}
580
 
581
 			if ( !context.isAlreadyValidated(
582
 					value, valueContext.getCurrentGroup(), valueContext.getPropertyPath()
583
 			) ) {
584
 				ValidationOrder validationOrder = validationOrderGenerator.getValidationOrder(
585
 						Arrays.<Class<?>>asList( valueContext.getCurrentGroup() )
586
 				);
587
 
588
 				ValueContext<?, T> newValueContext;
589
 				if ( value != null ) {
590
 					newValueContext = ValueContext.getLocalExecutionContext( value, valueContext.getPropertyPath() );
591
 				}
592
 				else {
593
 					newValueContext = ValueContext.getLocalExecutionContext(
594
 							valueContext.getCurrentBeanType(), valueContext.getPropertyPath()
595
 					);
596
 				}
597
 
598
 				//propagate parameter index/name if required
599
 				if ( valueContext.getParameterIndex() != null ) {
600
 					newValueContext.setParameterIndex( valueContext.getParameterIndex() );
601
 					newValueContext.setParameterName( valueContext.getParameterName() );
602
 				}
603
 
604
 				validateInContext( newValueContext, context, validationOrder );
605
 				if ( shouldFailFast( context ) ) {
606
 					return;
607
 				}
608
 			}
609
 			i++;
610
 		}
611
 	}
612
 
613
 	private <T, U, V> Set<ConstraintViolation<T>> validatePropertyInContext(ValidationContext<T, ConstraintViolation<T>> context, PathImpl propertyPath, ValidationOrder validationOrder) {
614
 		List<MetaConstraint<?>> metaConstraints = newArrayList();
615
 		Iterator<Path.Node> propertyIter = propertyPath.iterator();
616
 		ValueContext<U, V> valueContext = collectMetaConstraintsForPath(
617
 				context.getRootBeanClass(),
618
 				context.getRootBean(),
619
 				propertyIter,
620
 				propertyPath,
621
 				metaConstraints
622
 		);
623
 
624
 		if ( valueContext.getCurrentBean() == null ) {
625
 			throw log.getInvalidPropertyPathException();
626
 		}
627
 
628
 		if ( metaConstraints.size() == 0 ) {
629
 			return context.getFailingConstraints();
630
 		}
631
 
632
 		BeanMetaData<U> beanMetaData = beanMetaDataManager.getBeanMetaData( valueContext.getCurrentBeanType() );
633
 		if ( beanMetaData.defaultGroupSequenceIsRedefined() ) {
634
 			validationOrder.assertDefaultGroupSequenceIsExpandable( beanMetaData.getDefaultGroupSequence( valueContext.getCurrentBean() ) );
635
 		}
636
 
637
 		// process first single groups
638
 		Iterator<Group> groupIterator = validationOrder.getGroupIterator();
639
 		while ( groupIterator.hasNext() ) {
640
 			Group group = groupIterator.next();
641
 			valueContext.setCurrentGroup( group.getDefiningClass() );
642
 			validatePropertyForCurrentGroup( valueContext, context, metaConstraints );
643
 			if ( shouldFailFast( context ) ) {
644
 				return context.getFailingConstraints();
645
 			}
646
 		}
647
 
648
 		// now process sequences, stop after the first erroneous group
649
 		Iterator<Sequence> sequenceIterator = validationOrder.getSequenceIterator();
650
 		while ( sequenceIterator.hasNext() ) {
651
 			Sequence sequence = sequenceIterator.next();
652
 			for ( Group group : sequence.getComposingGroups() ) {
653
 				valueContext.setCurrentGroup( group.getDefiningClass() );
654
 				int numberOfConstraintViolations = validatePropertyForCurrentGroup(
655
 						valueContext, context, metaConstraints
656
 				);
657
 				if ( shouldFailFast( context ) ) {
658
 					return context.getFailingConstraints();
659
 				}
660
 				if ( numberOfConstraintViolations > 0 ) {
661
 					break;
662
 				}
663
 			}
664
 		}
665
 
666
 		return context.getFailingConstraints();
667
 	}
668
 
669
 	private <T, U, V> Set<ConstraintViolation<T>> validateValueInContext(ValidationContext<T, ConstraintViolation<T>> context, V value, PathImpl propertyPath, ValidationOrder validationOrder) {
670
 		List<MetaConstraint<?>> metaConstraints = newArrayList();
671
 		ValueContext<U, V> valueContext = collectMetaConstraintsForPath(
672
 				context.getRootBeanClass(), null, propertyPath.iterator(), propertyPath, metaConstraints
673
 		);
674
 		valueContext.setCurrentValidatedValue( value );
675
 
676
 		if ( metaConstraints.size() == 0 ) {
677
 			return context.getFailingConstraints();
678
 		}
679
 
680
 		BeanMetaData<U> beanMetaData = beanMetaDataManager.getBeanMetaData( valueContext.getCurrentBeanType() );
681
 		if ( beanMetaData.defaultGroupSequenceIsRedefined() ) {
682
 			validationOrder.assertDefaultGroupSequenceIsExpandable( beanMetaData.getDefaultGroupSequence( null ) );
683
 		}
684
 
685
 		// process first single groups
686
 		Iterator<Group> groupIterator = validationOrder.getGroupIterator();
687
 		while ( groupIterator.hasNext() ) {
688
 			Group group = groupIterator.next();
689
 			valueContext.setCurrentGroup( group.getDefiningClass() );
690
 			validatePropertyForCurrentGroup( valueContext, context, metaConstraints );
691
 			if ( shouldFailFast( context ) ) {
692
 				return context.getFailingConstraints();
693
 			}
694
 		}
695
 
696
 		// now process sequences, stop after the first erroneous group
697
 		Iterator<Sequence> sequenceIterator = validationOrder.getSequenceIterator();
698
 		while ( sequenceIterator.hasNext() ) {
699
 			Sequence sequence = sequenceIterator.next();
700
 			for ( Group group : sequence.getComposingGroups() ) {
701
 				valueContext.setCurrentGroup( group.getDefiningClass() );
702
 				int numberOfConstraintViolations = validatePropertyForCurrentGroup(
703
 						valueContext, context, metaConstraints
704
 				);
705
 				if ( shouldFailFast( context ) ) {
706
 					return context.getFailingConstraints();
707
 				}
708
 				if ( numberOfConstraintViolations > 0 ) {
709
 					break;
710
 				}
711
 			}
712
 		}
713
 
714
 		return context.getFailingConstraints();
715
 	}

	
 Validates the property constraints associated to the current ValueContext group.

 
 Parameters:valueContext The current validation context.validationContext The global validation context.metaConstraints All constraints associated to the property. Returns:The number of constraint violations raised when validating the ValueContext current group.
725
 
726
 	private <T, U, V> int validatePropertyForCurrentGroup(ValueContext<U, V> valueContext, ValidationContext<T, ConstraintViolation<T>> validationContext, List<MetaConstraint<?>> metaConstraints) {
727
 		// we do not validate the default group, nothing special to do
728
 		if ( !valueContext.validatingDefault() ) {
729
 			return validatePropertyForNonDefaultGroup( valueContext, validationContext, metaConstraints );
730
 		}
731
 
732
 		// we are validating the default group, we have to consider that a class in the hierarchy could redefine the default group sequence
733
 		return validatePropertyForDefaultGroup( valueContext, validationContext, metaConstraints );
734
 	}

	
 Validates the property constraints for the current ValueContext group.
 
 The current ValueContext group is not the default group.
 
 Parameters:valueContext The current validation context.validationContext The global validation context.metaConstraints All constraints associated to the property. Returns:The number of constraint violations raised when validating the ValueContext current group.
747
 
748
 	private <T, U, V> int validatePropertyForNonDefaultGroup(ValueContext<U, V> valueContext, ValidationContext<T, ConstraintViolation<T>> validationContext, List<MetaConstraint<?>> metaConstraints) {
749
 		int numberOfConstraintViolationsBefore = validationContext.getFailingConstraints().size();
750
 
751
 		for ( MetaConstraint<?> metaConstraint : metaConstraints ) {
752
 			if ( isValidationRequired( validationContext, valueContext, metaConstraint ) ) {
753
 				if ( valueContext.getCurrentBean() != null ) {
754
 					@SuppressWarnings("unchecked")
755
 					V valueToValidate = (V) metaConstraint.getValue( valueContext.getCurrentBean() );
756
 					valueContext.setCurrentValidatedValue( valueToValidate );
757
 				}
758
 				metaConstraint.validateConstraint( validationContext, valueContext );
759
 				if ( shouldFailFast( validationContext ) ) {
760
 					return validationContext.getFailingConstraints()
761
 							.size() - numberOfConstraintViolationsBefore;
762
 				}
763
 			}
764
 		}
765
 		return validationContext.getFailingConstraints().size() - numberOfConstraintViolationsBefore;
766
 	}

	
 Validates the property for the default group.
 
 This method checks that the default group sequence is not redefined in the class hierarchy for a superclass
 hosting constraints for the property to validate.
 
 Parameters:valueContext The current validation context.validationContext The global validation context.constraintList All constraints associated to the property to check. Returns:The number of constraint violations raised when validating the default group.
780
 
781
 	private <T, U, V> int validatePropertyForDefaultGroup(ValueContext<U, V> valueContext, ValidationContext<T, ConstraintViolation<T>> validationContext, List<MetaConstraint<?>> constraintList) {
782
 		final int numberOfConstraintViolationsBefore = validationContext.getFailingConstraints().size();
783
 		final BeanMetaData<U> beanMetaData = beanMetaDataManager.getBeanMetaData( valueContext.getCurrentBeanType() );
784
 		final Map<Class<?>, Class<?>> validatedInterfaces = newHashMap();
785
 
786
 		// evaluating the constraints of a bean per class in hierarchy. this is necessary to detect potential default group re-definitions
787
 		for ( Class<?> clazz : beanMetaData.getClassHierarchy() ) {
788
 			BeanMetaData<U> hostingBeanMetaData = (BeanMetaData<U>) beanMetaDataManager.getBeanMetaData( clazz );
789
 			boolean defaultGroupSequenceIsRedefined = hostingBeanMetaData.defaultGroupSequenceIsRedefined();
790
 			Set<MetaConstraint<?>> metaConstraints = hostingBeanMetaData.getDirectMetaConstraints();
791
 			List<Class<?>> defaultGroupSequence = hostingBeanMetaData.getDefaultGroupSequence( valueContext.getCurrentBean() );
792
 
793
 			if ( defaultGroupSequenceIsRedefined ) {
794
 				metaConstraints = hostingBeanMetaData.getMetaConstraints();
795
 			}
796
 
797
 			for ( Class<?> groupClass : defaultGroupSequence ) {
798
 				boolean validationSuccessful = true;
799
 				valueContext.setCurrentGroup( groupClass );
800
 				for ( MetaConstraint<?> metaConstraint : metaConstraints ) {
801
 					// HV-466, an interface implemented more than one time in the hierarchy has to be validated only one
802
 					// time. An interface can define more than one constraint, we have to check the class we are validating.
803
 					final Class<?> declaringClass = metaConstraint.getLocation().getBeanClass();
804
 					if ( declaringClass.isInterface() ) {
805
 						Class<?> validatedForClass = validatedInterfaces.get( declaringClass );
806
 						if ( validatedForClass != null && !validatedForClass.equals( clazz ) ) {
807
 							continue;
808
 						}
809
 						validatedInterfaces.put( declaringClass, clazz );
810
 					}
811
 
812
 					if ( constraintList.contains( metaConstraint )
813
 							&& isValidationRequired( validationContext, valueContext, metaConstraint ) ) {
814
 
815
 						if ( valueContext.getCurrentBean() != null ) {
816
 							@SuppressWarnings("unchecked")
817
 							V valueToValidate = (V) metaConstraint.getValue( valueContext.getCurrentBean() );
818
 							valueContext.setCurrentValidatedValue( valueToValidate );
819
 						}
820
 						boolean tmp = metaConstraint.validateConstraint( validationContext, valueContext );
821
 						validationSuccessful = validationSuccessful && tmp;
822
 						if ( shouldFailFast( validationContext ) ) {
823
 							return validationContext.getFailingConstraints()
824
 									.size() - numberOfConstraintViolationsBefore;
825
 						}
826
 					}
827
 				}
828
 				if ( !validationSuccessful ) {
829
 					break;
830
 				}
831
 			}
832
 			// all the hierarchy has been validated, stop validation.
833
 			if ( defaultGroupSequenceIsRedefined ) {
834
 				break;
835
 			}
836
 		}
837
 		return validationContext.getFailingConstraints().size() - numberOfConstraintViolationsBefore;
838
 	}
839
 
840
 	private <T> void validateParametersInContext(MethodValidationContext<T> validationContext, T object, Object[] parameterValues, ValidationOrder validationOrder) {
841
 
842
 		BeanMetaData<T> beanMetaData = beanMetaDataManager.getBeanMetaData( validationContext.getRootBeanClass() );
843
 
844
 		//assert that there are no illegal method parameter constraints
845
 		MethodMetaData methodMetaData = beanMetaData.getMetaDataFor( validationContext.getMethod() );
846
 		methodMetaData.assertCorrectnessOfMethodParameterConstraints();
847
 
848
 		if ( beanMetaData.defaultGroupSequenceIsRedefined() ) {
849
 			validationOrder.assertDefaultGroupSequenceIsExpandable( beanMetaData.getDefaultGroupSequence( object ) );
850
 		}
851
 
852
 		// process first single groups
853
 		Iterator<Group> groupIterator = validationOrder.getGroupIterator();
854
 		while ( groupIterator.hasNext() ) {
855
 			validateParametersForGroup( validationContext, object, parameterValues, groupIterator.next() );
856
 			if ( shouldFailFast( validationContext ) ) {
857
 				return;
858
 			}
859
 		}
860
 
861
 		// now process sequences, stop after the first erroneous group
862
 		Iterator<Sequence> sequenceIterator = validationOrder.getSequenceIterator();
863
 		while ( sequenceIterator.hasNext() ) {
864
 			Sequence sequence = sequenceIterator.next();
865
 			for ( Group group : sequence.getComposingGroups() ) {
866
 				int numberOfFailingConstraint = validateParametersForGroup(
867
 						validationContext, object, parameterValues, group
868
 				);
869
 				if ( shouldFailFast( validationContext ) ) {
870
 					return;
871
 				}
872
 				if ( numberOfFailingConstraint > 0 ) {
873
 					break;
874
 				}
875
 			}
876
 		}
877
 	}
878
 
879
 	private <T> int validateParametersForGroup(MethodValidationContext<T> validationContext, T object, Object[] parameterValues, Group group) {
880
 
881
 		int numberOfViolationsBefore = validationContext.getFailingConstraints().size();
882
 
883
 		Method method = validationContext.getMethod();
884
 
885
 		BeanMetaData<T> beanMetaData = beanMetaDataManager.getBeanMetaData( validationContext.getRootBeanClass() );
886
 		MethodMetaData methodMetaData = beanMetaData.getMetaDataFor( method );
887
 
888
 		// TODO GM: define behavior with respect to redefined default sequences. Should only the
889
 		// sequence from the validated bean be honored or also default sequence definitions up in
890
 		// the inheritance tree?
891
 		// For now a redefined default sequence will only be considered if specified at the bean
892
 		// hosting the validated itself, but no other default sequence from parent types
893
 
894
 		List<Class<?>> groupList;
895
 		if ( group.isDefaultGroup() ) {
896
 			groupList = beanMetaData.getDefaultGroupSequence( object );
897
 		}
898
 		else {
899
 			groupList = Arrays.<Class<?>>asList( group.getDefiningClass() );
900
 		}
901
 
902
 		//the only case where we can have multiple groups here is a redefined default group sequence
903
 		for ( Class<?> oneGroup : groupList ) {
904
 
905
 			int numberOfViolationsOfCurrentGroup = 0;
906
 
907
 			for ( int i = 0; i < parameterValues.length; i++ ) {
908
 
909
 				//ignore this parameter if this validation is for a single parameter and this is not the right one
910
 				if ( validationContext.getParameterIndex() != null && !validationContext.getParameterIndex()
911
 						.equals( i ) ) {
912
 					continue;
913
 				}
914
 
915
 				Object value = parameterValues[i];
916
 				String parameterName = methodMetaData.getParameterMetaData( i ).getName();
917
 
918
 				// validate constraints at parameter itself
919
 				ValueContext<T, Object> valueContext = ValueContext.getLocalExecutionContext(
920
 						object, PathImpl.createPathForMethodParameter( method, parameterName ), i, parameterName
921
 				);
922
 				valueContext.setCurrentValidatedValue( value );
923
 				valueContext.setCurrentGroup( oneGroup );
924
 
925
 				numberOfViolationsOfCurrentGroup += validateParameterForGroup(
926
 						validationContext, valueContext, methodMetaData.getParameterMetaData( i )
927
 				);
928
 				if ( shouldFailFast( validationContext ) ) {
929
 					return validationContext.getFailingConstraints().size() - numberOfViolationsBefore;
930
 				}
931
 			}
932
 
933
 			//stop processing after first group with errors occurred
934
 			if ( numberOfViolationsOfCurrentGroup > 0 ) {
935
 				break;
936
 			}
937
 		}
938
 
939
 		// validate parameter beans annotated with @Valid if required
940
 		for ( int i = 0; i < parameterValues.length; i++ ) {
941
 
942
 			//ignore this parameter if this validation is for a single parameter and this is not the right one
943
 			if ( validationContext.getParameterIndex() != null && !validationContext.getParameterIndex().equals( i ) ) {
944
 				continue;
945
 			}
946
 
947
 			Object value = parameterValues[i];
948
 			ParameterMetaData parameterMetaData = methodMetaData.getParameterMetaData( i );
949
 			String parameterName = parameterMetaData.getName();
950
 
951
 			if ( parameterMetaData.isCascading() && value != null ) {
952
 
953
 				ValueContext<Object, ?> cascadingvalueContext = ValueContext.getLocalExecutionContext(
954
 						value, PathImpl.createPathForMethodParameter( method, parameterName ), i, parameterName
955
 				);
956
 				cascadingvalueContext.setCurrentGroup( group.getDefiningClass() );
957
 
958
 				//TODO GM: consider violations from cascaded validation
959
 				validateCascadedMethodConstraints( validationContext, cascadingvalueContext );
960
 				if ( shouldFailFast( validationContext ) ) {
961
 					break;
962
 				}
963
 			}
964
 		}
965
 
966
 		return validationContext.getFailingConstraints().size() - numberOfViolationsBefore;
967
 	}

	
 Validates the constraints at the specified parameter which are part of
 the given value context's current group. Any occurred constraint
 violations are stored in the given validation context.

 
 Parameters:validationContext The validation context for storing constraint violations.valueContext The value context specifying the group and value to validate.parameterMetaData Meta data on the constraints to evaluate. Returns:The number of constraint violations occurred during validation of
         the specified constraints.
980
 
981
 	private <T, U, V> int validateParameterForGroup(MethodValidationContext<T> validationContext, ValueContext<U, V> valueContext, ParameterMetaData parameterMetaData) {
982
 
983
 		int numberOfViolationsBefore = validationContext.getFailingConstraints().size();
984
 
985
 		for ( MetaConstraint<?> metaConstraint : parameterMetaData ) {
986
 
987
 			//ignore constraints not part of the evaluated group
988
 			if ( !metaConstraint.getGroupList().contains( valueContext.getCurrentGroup() ) ) {
989
 				continue;
990
 			}
991
 
992
 			metaConstraint.validateConstraint( validationContext, valueContext );
993
 			if ( shouldFailFast( validationContext ) ) {
994
 				break;
995
 			}
996
 		}
997
 
998
 		return validationContext.getFailingConstraints().size() - numberOfViolationsBefore;
999
 	}
1000
1001
	private <V, T> void validateReturnValueInContext(MethodValidationContext<T> context, T bean, V value, ValidationOrder validationOrder) {
1002
1003
		BeanMetaData<T> beanMetaData = beanMetaDataManager.getBeanMetaData( context.getRootBeanClass() );
1004
1005
		if ( beanMetaData.defaultGroupSequenceIsRedefined() ) {
1006
			validationOrder.assertDefaultGroupSequenceIsExpandable( beanMetaData.getDefaultGroupSequence( bean ) );
1007
		}
1008
1009
		Iterator<Group> groupIterator = validationOrder.getGroupIterator();
1010
1011
		// process first single groups
1012
		while ( groupIterator.hasNext() ) {
1013
			validateReturnValueForGroup( context, bean, value, groupIterator.next() );
1014
			if ( shouldFailFast( context ) ) {
1015
				return;
1016
			}
1017
		}
1018
1019
		// now process sequences, stop after the first erroneous group
1020
		Iterator<Sequence> sequenceIterator = validationOrder.getSequenceIterator();
1021
		while ( sequenceIterator.hasNext() ) {
1022
			Sequence sequence = sequenceIterator.next();
1023
			for ( Group group : sequence.getComposingGroups() ) {
1024
				int numberOfFailingConstraint = validateReturnValueForGroup(
1025
						context, bean, value, group
1026
				);
1027
				if ( shouldFailFast( context ) ) {
1028
					return;
1029
				}
1030
				if ( numberOfFailingConstraint > 0 ) {
1031
					break;
1032
				}
1033
			}
1034
		}
1035
	}
1036
1037
	//TODO GM: if possible integrate with validateParameterForGroup()
1038
	private <T, V> int validateReturnValueForGroup(MethodValidationContext<T> validationContext, T bean, V value, Group group) {
1039
1040
		int numberOfViolationsBefore = validationContext.getFailingConstraints().size();
1041
1042
		Method method = validationContext.getMethod();
1043
1044
		BeanMetaData<T> beanMetaData = beanMetaDataManager.getBeanMetaData( validationContext.getRootBeanClass() );
1045
		MethodMetaData methodMetaData = beanMetaData.getMetaDataFor( method );
1046
1047
		// TODO GM: define behavior with respect to redefined default sequences. Should only the
1048
		// sequence from the validated bean be honored or also default sequence definitions up in
1049
		// the inheritance tree?
1050
		// For now a redefined default sequence will only be considered if specified at the bean
1051
		// hosting the validated itself, but no other default sequence from parent types
1052
1053
		List<Class<?>> groupList;
1054
		if ( group.isDefaultGroup() ) {
1055
			groupList = beanMetaData.getDefaultGroupSequence( bean );
1056
		}
1057
		else {
1058
			groupList = Arrays.<Class<?>>asList( group.getDefiningClass() );
1059
		}
1060
1061
		//the only case where we can have multiple groups here is a redefined default group sequence
1062
		for ( Class<?> oneGroup : groupList ) {
1063
1064
			int numberOfViolationsOfCurrentGroup = 0;
1065
1066
			// validate constraints at return value itself
1067
			ValueContext<T, V> valueContext = ValueContext.getLocalExecutionContext(
1068
					bean, PathImpl.createPathForMethodReturnValue( method )
1069
			);
1070
			valueContext.setCurrentValidatedValue( value );
1071
			valueContext.setCurrentGroup( oneGroup );
1072
1073
			numberOfViolationsOfCurrentGroup +=
1074
					validateReturnValueForGroup(
1075
							validationContext, valueContext, methodMetaData
1076
					);
1077
			if ( shouldFailFast( validationContext ) ) {
1078
				return validationContext.getFailingConstraints().size() - numberOfViolationsBefore;
1079
			}
1080
1081
			//stop processing after first group with errors occurred
1082
			if ( numberOfViolationsOfCurrentGroup > 0 ) {
1083
				break;
1084
			}
1085
		}
1086
1087
		// cascaded validation if required
1088
		if ( methodMetaData.isCascading() && value != null ) {
1089
1090
			ValueContext<V, Object> cascadingvalueContext = ValueContext.getLocalExecutionContext(
1091
					value, PathImpl.createPathForMethodReturnValue( method )
1092
			);
1093
			cascadingvalueContext.setCurrentGroup( group.getDefiningClass() );
1094
1095
			validateCascadedMethodConstraints( validationContext, cascadingvalueContext );
1096
		}
1097
1098
		return validationContext.getFailingConstraints().size() - numberOfViolationsBefore;
1099
	}
1100
1101
	private <T, V> int validateReturnValueForGroup(MethodValidationContext<T> validationContext,
1102
												   ValueContext<T, V> valueContext, MethodMetaData methodMetaData) {
1103
1104
		int numberOfViolationsBefore = validationContext.getFailingConstraints().size();
1105
1106
		for ( MetaConstraint<?> metaConstraint : methodMetaData ) {
1107
1108
			if ( !metaConstraint.getGroupList().contains( valueContext.getCurrentGroup() ) ) {
1109
				continue;
1110
			}
1111
			metaConstraint.validateConstraint( validationContext, valueContext );
1112
			if ( shouldFailFast( validationContext ) ) {
1113
				break;
1114
			}
1115
		}
1116
1117
		return validationContext.getFailingConstraints().size() - numberOfViolationsBefore;
1118
	}

	
 Collects all MetaConstraints which match the given path relative to the specified root class.
 
 This method is called recursively.
 
 Parameters:clazz The class type to check for constraints.value While resolving the property path this instance points to the current object. Might be null.propertyIter An instance of PropertyIterator in order to iterate the items of the original property path.propertyPath The property path for which constraints have to be collected.metaConstraintsList An instance of Map where MetaConstraints which match the given path are saved for each class in the hosting class hierarchy. Returns:Returns an instance of ValueContext which describes the local validation context associated to the given property path.
1133
1134
	private <T, U, V> ValueContext<U, V> collectMetaConstraintsForPath(Class<T> clazz, Object value, Iterator<Path.Node> propertyIter, PathImpl propertyPath, List<MetaConstraint<?>> metaConstraintsList) {
1135
		Path.Node elem = propertyIter.next();
1136
		Object newValue = value;
1137
1138
		BeanMetaData<?> metaData = beanMetaDataManager.getBeanMetaData( clazz );
1139
		//use precomputed method list as ReflectionHelper#containsMember is slow
1140
<