[hibernate-commits] Hibernate SVN: r16945 - in validator/trunk/hibernate-validator/src/main/java/org/hibernate/validation: metadata and 1 other directory.

Wednesday, 24 June 2009


Author: hardy.ferentschik
Date: 2009-06-24 10:45:17 -0400 (Wed, 24 Jun 2009)
New Revision: 16945

Added:
  
validator/trunk/hibernate-validator/src/main/java/org/hibernate/validation/engine/GlobalExecutionContext.java
  
validator/trunk/hibernate-validator/src/main/java/org/hibernate/validation/engine/LocalExecutionContext.java
Removed:
  
validator/trunk/hibernate-validator/src/main/java/org/hibernate/validation/engine/ExecutionContext.java
Modified:
  
validator/trunk/hibernate-validator/src/main/java/org/hibernate/validation/engine/ConstraintTree.java
  
validator/trunk/hibernate-validator/src/main/java/org/hibernate/validation/engine/PathImpl.java
  
validator/trunk/hibernate-validator/src/main/java/org/hibernate/validation/engine/ValidatorImpl.java
  
validator/trunk/hibernate-validator/src/main/java/org/hibernate/validation/metadata/MetaConstraint.java
Log:
HV-177 While integrating the Path API also refactored the ExecutionContext approach and
got rid of the stack type algorithm.

Modified:
validator/trunk/hibernate-validator/src/main/java/org/hibernate/validation/engine/ConstraintTree.java
===================================================================
---
validator/trunk/hibernate-validator/src/main/java/org/hibernate/validation/engine/ConstraintTree.java	2009-06-24
14:43:50 UTC (rev 16944)
+++
validator/trunk/hibernate-validator/src/main/java/org/hibernate/validation/engine/ConstraintTree.java	2009-06-24
14:45:17 UTC (rev 16945)
@@ -95,38 +95,37 @@
 		return descriptor;
 	}
 
-	/**
-	 * Validates the specified value.
-	 *
-	 * @param value The value to validate
-	 * @param type The type of the value determined from the type the annotation was placed
on.
-	 * @param executionContext The current execution context.
-	 * @param constraintViolations List of constraint violation into which to accumulate all
constraint violation as we traverse
-	 * this <code>ConstraintTree </code>.
-	 * @param <T> Type of the root bean for the current validation.
-	 * @param <V> Type of the value to be validated.
-	 */
-	public <T, V> void validateConstraints(V value, Type type,
ExecutionContext<T> executionContext, List<ConstraintViolation<T>>
constraintViolations) {
+	public <T, U, V> void validateConstraints(Type type,
GlobalExecutionContext<T> executionContext, LocalExecutionContext<U, V>
localExecutionContext, List<ConstraintViolation<T>> constraintViolations) {
 		// first validate composing constraints
 		for ( ConstraintTree<?> tree : getChildren() ) {
-			tree.validateConstraints( value, type, executionContext, constraintViolations );
+			tree.validateConstraints( type, executionContext, localExecutionContext,
constraintViolations );
 		}
 
 		ConstraintValidatorContextImpl constraintValidatorContext = new
ConstraintValidatorContextImpl(
-				executionContext.peekPropertyPath(), descriptor
+				localExecutionContext.getPropertyPath(), descriptor
 		);
 
 		// we could have a composing constraint which does not need its own validator.
 		if ( !descriptor.getConstraintValidatorClasses().isEmpty() ) {
 			if ( log.isTraceEnabled() ) {
-				log.trace( "Validating value {} against constraint defined by {}", value,
descriptor );
+				log.trace(
+						"Validating value {} against constraint defined by {}",
+						localExecutionContext.getCurrentValidatedValue(),
+						descriptor
+				);
 			}
 			ConstraintValidator<A, V> validator = getInitalizedValidator(
-					value, type, executionContext.getConstraintValidatorFactory()
+					localExecutionContext.getCurrentValidatedValue(),
+					type,
+					executionContext.getConstraintValidatorFactory()
 			);
 
 			validateSingleConstraint(
-					value, executionContext, constraintViolations, constraintValidatorContext,
validator
+					executionContext,
+					localExecutionContext,
+					constraintViolations,
+					constraintValidatorContext,
+					validator
 			);
 		}
 
@@ -134,16 +133,20 @@
 			constraintViolations.clear();
 			final String message = ( String ) getParent().getDescriptor().getAttributes().get(
"message" );
 			ConstraintValidatorContextImpl.ErrorMessage error = constraintValidatorContext.new
ErrorMessage(
-					message, executionContext.peekPropertyPath()
+					message, localExecutionContext.getPropertyPath()
 			);
-			constraintViolations.add( executionContext.createConstraintViolation( value, error,
descriptor ) );
+			constraintViolations.add(
+					executionContext.createConstraintViolation(
+							localExecutionContext, error, descriptor
+					)
+			);
 		}
 	}
 
-	private <T, V> void validateSingleConstraint(V value, ExecutionContext<T>
executionContext, List<ConstraintViolation<T>> constraintViolations,
ConstraintValidatorContextImpl constraintValidatorContext, ConstraintValidator<A, V>
validator) {
+	private <T, U, V> void validateSingleConstraint(GlobalExecutionContext<T>
executionContext, LocalExecutionContext<U, V> localExecutionContext,
List<ConstraintViolation<T>> constraintViolations,
ConstraintValidatorContextImpl constraintValidatorContext, ConstraintValidator<A, V>
validator) {
 		boolean isValid;
 		try {
-			isValid = validator.isValid( value, constraintValidatorContext );
+			isValid = validator.isValid( localExecutionContext.getCurrentValidatedValue(),
constraintValidatorContext );
 		}
 		catch ( RuntimeException e ) {
 			throw new ValidationException( "Unexpected exception during isValid call", e
);
@@ -151,7 +154,7 @@
 		if ( !isValid ) {
 			constraintViolations.addAll(
 					executionContext.createConstraintViolations(
-							value, constraintValidatorContext
+							localExecutionContext, constraintValidatorContext
 					)
 			);
 		}

Deleted:
validator/trunk/hibernate-validator/src/main/java/org/hibernate/validation/engine/ExecutionContext.java
===================================================================
---
validator/trunk/hibernate-validator/src/main/java/org/hibernate/validation/engine/ExecutionContext.java	2009-06-24
14:43:50 UTC (rev 16944)
+++
validator/trunk/hibernate-validator/src/main/java/org/hibernate/validation/engine/ExecutionContext.java	2009-06-24
14:45:17 UTC (rev 16945)
@@ -1,374 +0,0 @@
-// $Id$
-/*
-* JBoss, Home of Professional Open Source
-* Copyright 2008, Red Hat Middleware LLC, and individual contributors
-* by the @authors tag. See the copyright.txt in the distribution for a
-* full listing of individual contributors.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-* http://www.apache.org/licenses/LICENSE-2.0
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,  
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-package org.hibernate.validation.engine;
-
-import java.lang.annotation.ElementType;
-import java.lang.reflect.Field;
-import java.lang.reflect.Member;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.IdentityHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.Stack;
-import javax.validation.ConstraintValidatorFactory;
-import javax.validation.ConstraintViolation;
-import javax.validation.MessageInterpolator;
-import javax.validation.TraversableResolver;
-import javax.validation.Path;
-import javax.validation.metadata.ConstraintDescriptor;
-
-import org.hibernate.validation.metadata.MetaConstraint;
-import org.hibernate.validation.util.IdentitySet;
-
-/**
- * Context object keeping track of all processed objects and failing constraints.
- * It also keeps track of the currently validated object, group and property path.
- *
- * @author Hardy Ferentschik
- * @author Emmanuel Bernard
- * @todo Look for ways to improve this data structure. It is quite fragile and depends on
the right oder of calls
- * in order to work.
- */
-public class ExecutionContext<T> {
-
-	/**
-	 * The root bean of the validation.
-	 */
-	private final T rootBean;
-
-	/**
-	 * The root bean class of the validation.
-	 */
-	private Class<T> rootBeanClass;
-
-	/**
-	 * Maps a group to an identity set to keep track of already validated objects. We have
to make sure
-	 * that each object gets only validated once per group and property path.
-	 */
-	private final Map<Class<?>, IdentitySet> processedObjects;
-
-	/**
-	 * Maps an object to a list of paths in which it has been invalidated.
-	 */
-	private final Map<Object, Set<PathImpl>> processedPaths;
-
-	/**
-	 * A list of all failing constraints so far.
-	 */
-	private final List<ConstraintViolation<T>> failingConstraintViolations;
-
-	/**
-	 * The current property path we are validating.
-	 */
-	private PathImpl propertyPath;
-
-	/**
-	 * The current group we are validating.
-	 */
-	private Class<?> currentGroup;
-
-	/**
-	 * Stack for keeping track of the currently validated bean.
-	 */
-	private Stack<Object> beanStack = new Stack<Object>();
-
-	/**
-	 * Flag indicating whether an object can only be validated once per group or once per
group AND validation path.
-	 *
-	 * @todo Make this boolean a configurable item.
-	 */
-	private boolean allowOneValidationPerPath = true;
-
-	/**
-	 * The message resolver which should be used in this context.
-	 */
-	private final MessageInterpolator messageInterpolator;
-
-	/**
-	 * The constraint factory which should be used in this context.
-	 */
-	private final ConstraintValidatorFactory constraintValidatorFactory;
-
-	/**
-	 * Allows a JPA provider to decide whether a property should be validated.
-	 */
-	private final TraversableResolver traversableResolver;
-
-	public static <T> ExecutionContext<T> getContextForValidate(T object,
MessageInterpolator messageInterpolator, ConstraintValidatorFactory
constraintValidatorFactory, TraversableResolver traversableResolver) {
-		@SuppressWarnings("unchecked")
-		Class<T> rootBeanClass = ( Class<T> ) object.getClass();
-		return new ExecutionContext<T>(
-				rootBeanClass, object, object, messageInterpolator, constraintValidatorFactory,
traversableResolver
-		);
-	}
-
-	public static <T> ExecutionContext<T>
getContextForValidateValue(Class<T> rootBeanClass, Object object,
MessageInterpolator messageInterpolator, ConstraintValidatorFactory
constraintValidatorFactory, TraversableResolver traversableResolver) {
-		return new ExecutionContext<T>(
-				rootBeanClass,
-				null,
-				object,
-				messageInterpolator,
-				constraintValidatorFactory,
-				traversableResolver
-		);
-	}
-
-	public static <T> ExecutionContext<T> getContextForValidateProperty(T
rootBean, Object object, MessageInterpolator messageInterpolator,
ConstraintValidatorFactory constraintValidatorFactory, TraversableResolver
traversableResolver) {
-		@SuppressWarnings("unchecked")
-		Class<T> rootBeanClass = ( Class<T> ) rootBean.getClass();
-		return new ExecutionContext<T>(
-				rootBeanClass, rootBean, object, messageInterpolator, constraintValidatorFactory,
traversableResolver
-		);
-	}
-
-	private ExecutionContext(Class<T> rootBeanClass, T rootBean, Object object,
MessageInterpolator messageInterpolator, ConstraintValidatorFactory
constraintValidatorFactory, TraversableResolver traversableResolver) {
-		this.rootBean = rootBean;
-		this.rootBeanClass = rootBeanClass;
-		this.messageInterpolator = messageInterpolator;
-		this.constraintValidatorFactory = constraintValidatorFactory;
-		this.traversableResolver = traversableResolver;
-
-		beanStack.push( object );
-		processedObjects = new HashMap<Class<?>, IdentitySet>();
-		processedPaths = new IdentityHashMap<Object, Set<PathImpl>>();
-		propertyPath = PathImpl.createNewRootPath();
-		failingConstraintViolations = new ArrayList<ConstraintViolation<T>>();
-	}
-
-	public ConstraintValidatorFactory getConstraintValidatorFactory() {
-		return constraintValidatorFactory;
-	}
-
-	public Object peekCurrentBean() {
-		return beanStack.peek();
-	}
-
-	public Class<?> peekCurrentBeanType() {
-		return beanStack.peek().getClass();
-	}
-
-	public void pushCurrentBean(Object validatedBean) {
-		beanStack.push( validatedBean );
-	}
-
-	public void popCurrentBean() {
-		beanStack.pop();
-	}
-
-	public T getRootBean() {
-		return rootBean;
-	}
-
-	public Class<T> getRootBeanClass() {
-		return rootBeanClass;
-	}
-
-	public Class<?> getCurrentGroup() {
-		return currentGroup;
-	}
-
-	public void setCurrentGroup(Class<?> currentGroup) {
-		this.currentGroup = currentGroup;
-		markProcessed();
-	}
-
-	/**
-	 * Returns <code>true</code> if the specified value has already been
validated, <code>false</code> otherwise.
-	 * Each object can only be validated once per group and validation path. The flag {@link
#allowOneValidationPerPath}
-	 * determines whether an object can only be validated once per group or once per group
and validation path.�
-	 *
-	 * @param value The value to be validated.
-	 *
-	 * @return Returns <code>true</code> if the specified value has already been
validated, <code>false</code> otherwise.
-	 */
-	public boolean isAlreadyValidated(Object value) {
-		boolean alreadyValidated;
-		alreadyValidated = isAlreadyValidatedForCurrentGroup( value );
-
-		if ( alreadyValidated && allowOneValidationPerPath ) {
-			alreadyValidated = isAlreadyValidatedForPath( value );
-		}
-		return alreadyValidated;
-	}
-
-	public void addConstraintFailures(List<ConstraintViolation<T>>
failingConstraintViolations) {
-		for ( ConstraintViolation<T> violation : failingConstraintViolations ) {
-			addConstraintFailure( violation );
-		}
-	}
-
-	public List<ConstraintViolation<T>> getFailingConstraints() {
-		return failingConstraintViolations;
-	}
-
-	/**
-	 * Adds a new level to the current property path of this context.
-	 *
-	 * @param property the new property to add to the current path.
-	 */
-	public void pushProperty(String property) {
-		propertyPath.addNode( new NodeImpl( property ) );
-	}
-
-	public void setProperty(PathImpl path) {
-		propertyPath = path;
-	}
-
-	/**
-	 * Drops the last level of the current property path of this context.
-	 */
-	public void popProperty() {
-		propertyPath.removeLeafNode();
-	}
-
-	public void markCurrentPropertyAsIterable() {
-		( ( NodeImpl ) propertyPath.getLeafNode() ).setInIterable( true );
-	}
-
-	public void setPropertyIndex(String index) {
-		( ( NodeImpl ) propertyPath.getLeafNode() ).setIndex( new Integer( index ) );
-	}
-
-	public PathImpl peekPropertyPath() {
-		return new PathImpl( propertyPath );
-	}
-
-	@SuppressWarnings("SimplifiableIfStatement")
-	public boolean isValidationRequired(MetaConstraint metaConstraint) {
-		if ( !metaConstraint.getGroupList().contains( currentGroup ) ) {
-			return false;
-		}
-
-		return traversableResolver.isReachable(
-				peekCurrentBean(),
-				propertyPath.getLeafNode(),
-				getRootBeanClass(),
-				propertyPath.getPathWithoutLeafNode(),
-				metaConstraint.getElementType()
-		);
-	}
-
-	public boolean isCascadeRequired(Member member) {
-		final ElementType type = member instanceof Field ? ElementType.FIELD :
ElementType.METHOD;
-		final Class<T> rootBeanType = getRootBeanClass();
-		final Object traversableobject = peekCurrentBean();
-		return traversableResolver.isReachable(
-				traversableobject,
-				propertyPath.getLeafNode(),
-				rootBeanType,
-				propertyPath.getPathWithoutLeafNode(),
-				type
-		)
-				&& traversableResolver.isCascadable(
-				traversableobject,
-				propertyPath.getLeafNode(),
-				rootBeanType,
-				propertyPath.getPathWithoutLeafNode(),
-				type
-		);
-	}
-
-	public List<ConstraintViolationImpl<T>> createConstraintViolations(Object
value, ConstraintValidatorContextImpl constraintValidatorContext) {
-		List<ConstraintViolationImpl<T>> constraintViolations = new
ArrayList<ConstraintViolationImpl<T>>();
-		for ( ConstraintValidatorContextImpl.ErrorMessage error :
constraintValidatorContext.getErrorMessages() ) {
-			ConstraintViolationImpl<T> violation = createConstraintViolation(
-					value, error, constraintValidatorContext.getConstraintDescriptor()
-			);
-			constraintViolations.add( violation );
-		}
-		return constraintViolations;
-	}
-
-	public ConstraintViolationImpl<T> createConstraintViolation(Object value,
ConstraintValidatorContextImpl.ErrorMessage error, ConstraintDescriptor<?>
descriptor) {
-		String messageTemplate = error.getMessage();
-		String interpolatedMessage = messageInterpolator.interpolate(
-				messageTemplate,
-				new MessageInterpolatorContext( descriptor, peekCurrentBean() )
-		);
-		return new ConstraintViolationImpl<T>(
-				messageTemplate,
-				interpolatedMessage,
-				getRootBeanClass(),
-				getRootBean(),
-				peekCurrentBean(),
-				value,
-				error.getPath(),
-				descriptor
-		);
-	}
-
-	private boolean isAlreadyValidatedForPath(Object value) {
-		Set<PathImpl> pathSet = processedPaths.get( value );
-		if ( pathSet == null ) {
-			return false;
-		}
-
-		for ( PathImpl p : pathSet ) {
-			if ( p.isSubPathOf( peekPropertyPath() ) || peekPropertyPath().isSubPathOf( p ) ) {
-				return true;
-			}
-		}
-
-		return false;
-	}
-
-	private boolean isAlreadyValidatedForCurrentGroup(Object value) {
-		final IdentitySet objectsProcessedInCurrentGroups = processedObjects.get( currentGroup
);
-		return objectsProcessedInCurrentGroups != null &&
objectsProcessedInCurrentGroups.contains( value );
-	}
-
-	private void markProcessed() {
-		markProcessForCurrentGroup();
-		if ( allowOneValidationPerPath ) {
-			markProcessedForCurrentPath();
-		}
-	}
-
-	private void markProcessedForCurrentPath() {
-		if ( processedPaths.containsKey( peekCurrentBean() ) ) {
-			processedPaths.get( peekCurrentBean() ).add( peekPropertyPath() );
-		}
-		else {
-			Set<PathImpl> set = new HashSet<PathImpl>();
-			set.add( peekPropertyPath() );
-			processedPaths.put( peekCurrentBean(), set );
-		}
-	}
-
-
-	private void markProcessForCurrentGroup() {
-		if ( processedObjects.containsKey( currentGroup ) ) {
-			processedObjects.get( currentGroup ).add( peekCurrentBean() );
-		}
-		else {
-			IdentitySet set = new IdentitySet();
-			set.add( peekCurrentBean() );
-			processedObjects.put( currentGroup, set );
-		}
-	}
-
-	private void addConstraintFailure(ConstraintViolation<T>
failingConstraintViolation) {
-		int i = failingConstraintViolations.indexOf( failingConstraintViolation );
-		if ( i == -1 ) {
-			failingConstraintViolations.add( failingConstraintViolation );
-		}
-	}
-}
\ No newline at end of file

Copied:
validator/trunk/hibernate-validator/src/main/java/org/hibernate/validation/engine/GlobalExecutionContext.java
(from rev 16905,
validator/trunk/hibernate-validator/src/main/java/org/hibernate/validation/engine/ExecutionContext.java)
===================================================================
---
validator/trunk/hibernate-validator/src/main/java/org/hibernate/validation/engine/GlobalExecutionContext.java	
                       (rev 0)
+++
validator/trunk/hibernate-validator/src/main/java/org/hibernate/validation/engine/GlobalExecutionContext.java	2009-06-24
14:45:17 UTC (rev 16945)
@@ -0,0 +1,257 @@
+// $Id$
+/*
+* JBoss, Home of Professional Open Source
+* Copyright 2008, Red Hat Middleware LLC, and individual contributors
+* by the @authors tag. See the copyright.txt in the distribution for a
+* full listing of individual contributors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+* http://www.apache.org/licenses/LICENSE-2.0
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,  
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package org.hibernate.validation.engine;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import javax.validation.ConstraintValidatorFactory;
+import javax.validation.ConstraintViolation;
+import javax.validation.MessageInterpolator;
+import javax.validation.TraversableResolver;
+import javax.validation.metadata.ConstraintDescriptor;
+
+import org.hibernate.validation.util.IdentitySet;
+
+/**
+ * Context object keeping track of all important data for a top level {@link
javax.validation.Validator#validate(Object, Class[])} },
+ * {@link javax.validation.Validator#validateValue(Class, String, Object, Class[])}  } or
{@link javax.validation.Validator#validateProperty(Object, String, Class[])}  call.
+ *
+ * we use this object to collect all failing constraints, but also to cache the caching
traversable resolver for a full stack call.
+ *
+ * @author Hardy Ferentschik
+ * @author Emmanuel Bernard
+ */
+public class GlobalExecutionContext<T> {
+
+	/**
+	 * The root bean of the validation.
+	 */
+	private final T rootBean;
+
+	/**
+	 * The root bean class of the validation.
+	 */
+	private final Class<T> rootBeanClass;
+
+	/**
+	 * Maps a group to an identity set to keep track of already validated objects. We have
to make sure
+	 * that each object gets only validated once per group and property path.
+	 */
+	private final Map<Class<?>, IdentitySet> processedObjects;
+
+	/**
+	 * Maps an object to a list of paths in which it has been invalidated.
+	 */
+	private final Map<Object, Set<PathImpl>> processedPaths;
+
+	/**
+	 * A list of all failing constraints so far.
+	 */
+	private final List<ConstraintViolation<T>> failingConstraintViolations;
+
+	/**
+	 * Flag indicating whether an object can only be validated once per group or once per
group AND validation path.
+	 *
+	 * @todo Make this boolean a configurable item.
+	 */
+	private boolean allowOneValidationPerPath = true;
+
+	/**
+	 * The message resolver which should be used in this context.
+	 */
+	private final MessageInterpolator messageInterpolator;
+
+	/**
+	 * The constraint factory which should be used in this context.
+	 */
+	private final ConstraintValidatorFactory constraintValidatorFactory;
+
+	/**
+	 * Allows a JPA provider to decide whether a property should be validated.
+	 */
+	private final TraversableResolver traversableResolver;
+
+	public static <T> GlobalExecutionContext<T> getContextForValidate(T object,
MessageInterpolator messageInterpolator, ConstraintValidatorFactory
constraintValidatorFactory, TraversableResolver traversableResolver) {
+		@SuppressWarnings("unchecked")
+		Class<T> rootBeanClass = ( Class<T> ) object.getClass();
+		return new GlobalExecutionContext<T>(
+				rootBeanClass, object, messageInterpolator, constraintValidatorFactory,
traversableResolver
+		);
+	}
+
+	public static <T> GlobalExecutionContext<T> getContextForValidateProperty(T
rootBean, MessageInterpolator messageInterpolator, ConstraintValidatorFactory
constraintValidatorFactory, TraversableResolver traversableResolver) {
+		@SuppressWarnings("unchecked")
+		Class<T> rootBeanClass = ( Class<T> ) rootBean.getClass();
+		return new GlobalExecutionContext<T>(
+				rootBeanClass, rootBean, messageInterpolator, constraintValidatorFactory,
traversableResolver
+		);
+	}
+
+	public static <T> GlobalExecutionContext<T>
getContextForValidateValue(Class<T> rootBeanClass, MessageInterpolator
messageInterpolator, ConstraintValidatorFactory constraintValidatorFactory,
TraversableResolver traversableResolver) {
+		return new GlobalExecutionContext<T>(
+				rootBeanClass,
+				null,
+				messageInterpolator,
+				constraintValidatorFactory,
+				traversableResolver
+		);
+	}
+
+	private GlobalExecutionContext(Class<T> rootBeanClass, T rootBean,
MessageInterpolator messageInterpolator, ConstraintValidatorFactory
constraintValidatorFactory, TraversableResolver traversableResolver) {
+		this.rootBean = rootBean;
+		this.rootBeanClass = rootBeanClass;
+		this.messageInterpolator = messageInterpolator;
+		this.constraintValidatorFactory = constraintValidatorFactory;
+		this.traversableResolver = traversableResolver;
+
+		processedObjects = new HashMap<Class<?>, IdentitySet>();
+		processedPaths = new IdentityHashMap<Object, Set<PathImpl>>();
+		failingConstraintViolations = new ArrayList<ConstraintViolation<T>>();
+	}
+
+	public T getRootBean() {
+		return rootBean;
+	}
+
+	public Class<T> getRootBeanClass() {
+		return rootBeanClass;
+	}
+
+	public TraversableResolver getTraversableResolver() {
+		return traversableResolver;
+	}
+
+	public MessageInterpolator getMessageInterpolator() {
+		return messageInterpolator;
+	}
+
+	public <U, V> ConstraintViolationImpl<T>
createConstraintViolation(LocalExecutionContext<U, V> localContext,
ConstraintValidatorContextImpl.ErrorMessage error, ConstraintDescriptor<?>
descriptor) {
+		String messageTemplate = error.getMessage();
+		String interpolatedMessage = messageInterpolator.interpolate(
+				messageTemplate,
+				new MessageInterpolatorContext( descriptor, localContext.getCurrentBean() )
+		);
+		return new ConstraintViolationImpl<T>(
+				messageTemplate,
+				interpolatedMessage,
+				getRootBeanClass(),
+				getRootBean(),
+				localContext.getCurrentBean(),
+				localContext.getCurrentValidatedValue(),
+				error.getPath(),
+				descriptor
+		);
+	}
+
+	public <U, V> List<ConstraintViolationImpl<T>>
createConstraintViolations(LocalExecutionContext<U, V> localContext,
ConstraintValidatorContextImpl constraintValidatorContext) {
+		List<ConstraintViolationImpl<T>> constraintViolations = new
ArrayList<ConstraintViolationImpl<T>>();
+		for ( ConstraintValidatorContextImpl.ErrorMessage error :
constraintValidatorContext.getErrorMessages() ) {
+			ConstraintViolationImpl<T> violation = createConstraintViolation(
+					localContext, error, constraintValidatorContext.getConstraintDescriptor()
+			);
+			constraintViolations.add( violation );
+		}
+		return constraintViolations;
+	}
+
+	public ConstraintValidatorFactory getConstraintValidatorFactory() {
+		return constraintValidatorFactory;
+	}
+
+	public boolean isAlreadyValidated(Object value, Class<?> group, PathImpl path) {
+		boolean alreadyValidated;
+		alreadyValidated = isAlreadyValidatedForCurrentGroup( value, group );
+
+		if ( alreadyValidated && allowOneValidationPerPath ) {
+			alreadyValidated = isAlreadyValidatedForPath( value, path );
+		}
+		return alreadyValidated;
+	}
+
+	public void markProcessed(Object value, Class<?> group, PathImpl path) {
+		markProcessForCurrentGroup( value, group );
+		if ( allowOneValidationPerPath ) {
+			markProcessedForCurrentPath( value, path );
+		}
+	}
+
+	private void addConstraintFailure(ConstraintViolation<T>
failingConstraintViolation) {
+		int i = failingConstraintViolations.indexOf( failingConstraintViolation );
+		if ( i == -1 ) {
+			failingConstraintViolations.add( failingConstraintViolation );
+		}
+	}
+
+	public void addConstraintFailures(List<ConstraintViolation<T>>
failingConstraintViolations) {
+		for ( ConstraintViolation<T> violation : failingConstraintViolations ) {
+			addConstraintFailure( violation );
+		}
+	}
+
+	public List<ConstraintViolation<T>> getFailingConstraints() {
+		return failingConstraintViolations;
+	}
+
+	private boolean isAlreadyValidatedForPath(Object value, PathImpl path) {
+		Set<PathImpl> pathSet = processedPaths.get( value );
+		if ( pathSet == null ) {
+			return false;
+		}
+
+		for ( PathImpl p : pathSet ) {
+			if ( p.isSubPathOf( path ) || path.isSubPathOf( p ) ) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	private boolean isAlreadyValidatedForCurrentGroup(Object value, Class<?> group) {
+		final IdentitySet objectsProcessedInCurrentGroups = processedObjects.get( group );
+		return objectsProcessedInCurrentGroups != null &&
objectsProcessedInCurrentGroups.contains( value );
+	}
+
+	private void markProcessedForCurrentPath(Object value, PathImpl path) {
+		if ( processedPaths.containsKey( value ) ) {
+			processedPaths.get( value ).add( path.getPathWithoutLeafNode() );
+		}
+		else {
+			Set<PathImpl> set = new HashSet<PathImpl>();
+			set.add( path.getPathWithoutLeafNode() );
+			processedPaths.put( value, set );
+		}
+	}
+
+
+	private void markProcessForCurrentGroup(Object value, Class<?> group) {
+		if ( processedObjects.containsKey( group ) ) {
+			processedObjects.get( group ).add( value );
+		}
+		else {
+			IdentitySet set = new IdentitySet();
+			set.add( value );
+			processedObjects.put( group, set );
+		}
+	}
+}
\ No newline at end of file

Added:
validator/trunk/hibernate-validator/src/main/java/org/hibernate/validation/engine/LocalExecutionContext.java
===================================================================
---
validator/trunk/hibernate-validator/src/main/java/org/hibernate/validation/engine/LocalExecutionContext.java	
                       (rev 0)
+++
validator/trunk/hibernate-validator/src/main/java/org/hibernate/validation/engine/LocalExecutionContext.java	2009-06-24
14:45:17 UTC (rev 16945)
@@ -0,0 +1,113 @@
+// $Id:$
+/*
+* JBoss, Home of Professional Open Source
+* Copyright 2008, Red Hat Middleware LLC, and individual contributors
+* by the @authors tag. See the copyright.txt in the distribution for a
+* full listing of individual contributors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+* http://www.apache.org/licenses/LICENSE-2.0
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package org.hibernate.validation.engine;
+
+/**
+ * An instance of this class is used to collect all the relevant information for
validating a single entity/bean.
+ *
+ * @author Hardy Ferentschik
+ */
+public class LocalExecutionContext<T,V> {
+
+	/**
+	 * The current bean which gets validated. This is the bean hosting the constraints which
get validated.
+	 */
+	private final T currentBean;
+
+	/**
+	 * The class of the current bean.
+	 */
+	private final Class<T> currentBeanType;
+
+	/**
+	 * The current property path we are validating.
+	 */
+	private PathImpl propertyPath;
+
+	/**
+	 * The current group we are validating.
+	 */
+	private Class<?> currentGroup;
+
+	/**
+	 * The value which gets currently evaluated.
+	 */
+	private V currentValue;
+
+	public static <T,V> LocalExecutionContext<T,V> getLocalExecutionContext(T
value) {
+		@SuppressWarnings("unchecked")
+		Class<T> rootBeanClass = ( Class<T> ) value.getClass();
+		return new LocalExecutionContext<T,V>( value, rootBeanClass );
+	}
+
+	public static <T,V> LocalExecutionContext<T,V>
getLocalExecutionContext(Class<T> type) {
+		return new LocalExecutionContext<T,V>( null, type );
+	}
+
+	public LocalExecutionContext(T currentBean, Class<T> currentBeanType) {
+		this.currentBean = currentBean;
+		this.currentBeanType = currentBeanType;
+	}
+
+	public PathImpl getPropertyPath() {
+		return propertyPath;
+	}
+
+	public Class<?> getCurrentGroup() {
+		return currentGroup;
+	}
+
+	public T getCurrentBean() {
+		return currentBean;
+	}
+
+	public Class<T> getCurrentBeanType() {
+		return currentBeanType;
+	}
+
+	public V getCurrentValidatedValue() {
+		return currentValue;
+	}
+
+	public void setPropertyPath(PathImpl propertyPath) {
+		this.propertyPath = propertyPath;
+	}
+
+	public void setCurrentGroup(Class<?> currentGroup) {
+		this.currentGroup = currentGroup;
+	}
+
+	public void setCurrentValidatedValue(V currentValue) {
+		this.currentValue = currentValue;
+	}
+
+	public void markCurrentPropertyAsIterable() {
+		propertyPath.getLeafNode().setInIterable( true );
+	}
+
+	@Override
+	public String toString() {
+		return "LocalExecutionContext{" +
+				"currentBean=" + currentBean +
+				", currentBeanType=" + currentBeanType +
+				", propertyPath=" + propertyPath +
+				", currentGroup=" + currentGroup +
+				", currentValue=" + currentValue +
+				'}';
+	}
+}

Modified:
validator/trunk/hibernate-validator/src/main/java/org/hibernate/validation/engine/PathImpl.java
===================================================================
---
validator/trunk/hibernate-validator/src/main/java/org/hibernate/validation/engine/PathImpl.java	2009-06-24
14:43:50 UTC (rev 16944)
+++
validator/trunk/hibernate-validator/src/main/java/org/hibernate/validation/engine/PathImpl.java	2009-06-24
14:45:17 UTC (rev 16945)
@@ -67,7 +67,11 @@
 		return new PathImpl();
 	}
 
-	public PathImpl(PathImpl path) {
+	public static PathImpl createShallowCopy(PathImpl path) {
+		return new PathImpl(path);
+	}
+
+	private PathImpl(PathImpl path) {
 		this.nodeList = new ArrayList<Node>();
 		Iterator<Node> iter = path.iterator();
 		while ( iter.hasNext() ) {
@@ -87,7 +91,7 @@
 		}
 	}
 
-	public Path getPathWithoutLeafNode() {
+	public PathImpl getPathWithoutLeafNode() {
 		List<Node> nodes = new ArrayList<Node>( nodeList );
 		if ( nodes.size() > 1 ) {
 			nodes.remove( nodes.size() - 1 );
@@ -154,6 +158,7 @@
 	}
 
 	@Override
+	@SuppressWarnings( "SimplifiableIfStatement")
 	public boolean equals(Object o) {
 		if ( this == o ) {
 			return true;

Modified:
validator/trunk/hibernate-validator/src/main/java/org/hibernate/validation/engine/ValidatorImpl.java
===================================================================
---
validator/trunk/hibernate-validator/src/main/java/org/hibernate/validation/engine/ValidatorImpl.java	2009-06-24
14:43:50 UTC (rev 16944)
+++
validator/trunk/hibernate-validator/src/main/java/org/hibernate/validation/engine/ValidatorImpl.java	2009-06-24
14:45:17 UTC (rev 16945)
@@ -18,6 +18,8 @@
 package org.hibernate.validation.engine;
 
 import java.lang.annotation.Annotation;
+import java.lang.annotation.ElementType;
+import java.lang.reflect.Field;
 import java.lang.reflect.Member;
 import java.lang.reflect.Type;
 import java.util.ArrayList;
@@ -58,23 +60,11 @@
  *
  * @author Emmanuel Bernard
  * @author Hardy Ferentschik
- * @todo Make all properties transient for serializability.
  */
 public class ValidatorImpl implements Validator {
 	private static final Logger log = LoggerFactory.make();
 
 	/**
-	 * Set of classes which can be used as index in a map.
-	 */
-	private static final Set<Class<?>> VALID_MAP_INDEX_CLASSES = new
HashSet<Class<?>>();
-
-	static {
-		VALID_MAP_INDEX_CLASSES.add( Integer.class );
-		VALID_MAP_INDEX_CLASSES.add( Long.class );
-		VALID_MAP_INDEX_CLASSES.add( String.class );
-	}
-
-	/**
 	 * The default group array used in case any of the validate methods is called without a
group.
 	 */
 	private static final Class<?>[] DEFAULT_GROUP_ARRAY = new Class<?>[] {
Default.class };
@@ -82,7 +72,7 @@
 	/**
 	 * Used to resolve the group execution order for a validate call.
 	 */
-	private GroupChainGenerator groupChainGenerator;
+	private final transient GroupChainGenerator groupChainGenerator;
 
 	private final ConstraintValidatorFactory constraintValidatorFactory;
 	private final MessageInterpolator messageInterpolator;
@@ -102,26 +92,22 @@
 		groupChainGenerator = new GroupChainGenerator();
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	public <T> Set<ConstraintViolation<T>> validate(T object,
Class<?>... groups) {
 		if ( object == null ) {
 			throw new IllegalArgumentException( "Validation of a null object" );
 		}
 		GroupChain groupChain = determineGroupExecutionOrder( groups );
 
-		ExecutionContext<T> context = ExecutionContext.getContextForValidate(
+		GlobalExecutionContext<T> context =
GlobalExecutionContext.getContextForValidate(
 				object, messageInterpolator, constraintValidatorFactory,
getCachingTraversableResolver()
 		);
 
-		List<ConstraintViolation<T>> list = validateInContext( context, groupChain
);
+		List<ConstraintViolation<T>> list = validateInContext(
+				object, context, groupChain, PathImpl.createNewRootPath()
+		);
 		return new HashSet<ConstraintViolation<T>>( list );
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	public <T> Set<ConstraintViolation<T>> validateProperty(T object,
String propertyName, Class<?>... groups) {
 		if ( object == null ) {
 			throw new IllegalArgumentException( "Validated object cannot be null." );
@@ -136,9 +122,6 @@
 		return new HashSet<ConstraintViolation<T>>( failingConstraintViolations );
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	public <T> Set<ConstraintViolation<T>> validateValue(Class<T>
beanType, String propertyName, Object value, Class<?>... groups) {
 		if ( beanType == null ) {
 			throw new IllegalArgumentException( "The bean type cannot be null." );
@@ -185,43 +168,51 @@
 	}
 
 	/**
-	 * Validates the object contained in <code>context</code>.
+	 * Validates the given object using the available context information.
 	 *
-	 * @param context A context object containing the object to validate together with other
state information needed
-	 * for validation.
-	 * @param groupChain A <code>GroupChain</code> instance containing the
resolved group sequence to execute
+	 * @param value The value to validate.
+	 * @param context Global context. Used amongst others to collect all failing
constraints.
+	 * @param groupChain Contains the information which and in which oder groups have to be
executed
+	 * @param path The current path of the valiation.
+	 * @param <T> The root bean type.
+	 * @param <V> The type of the current object on the validation stack.
 	 *
-	 * @return List of invalid constraints.
+	 * @return List of constraint violations or the empty set if there were no violations.
 	 */
-	private <T> List<ConstraintViolation<T>>
validateInContext(ExecutionContext<T> context, GroupChain groupChain) {
-		if ( context.peekCurrentBean() == null ) {
+	private <T, U, V> List<ConstraintViolation<T>> validateInContext(U
value, GlobalExecutionContext<T> context, GroupChain groupChain, PathImpl path) {
+		if ( value == null ) {
 			return Collections.emptyList();
 		}
 
-		// process all groups breadth-first
+		path = PathImpl.createShallowCopy( path );
+
+		LocalExecutionContext<U, V> localExecutionContext =
LocalExecutionContext.getLocalExecutionContext( value );
+
+		// process first single groups. For these we can skip some object traversal, by first
running all validations on the current bean
+		// before traversing the object.
 		Iterator<Group> groupIterator = groupChain.getGroupIterator();
 		while ( groupIterator.hasNext() ) {
 			Group group = groupIterator.next();
-			context.setCurrentGroup( group.getGroup() );
-			validateConstraints( context );
+			localExecutionContext.setCurrentGroup( group.getGroup() );
+			validateConstraints( context, localExecutionContext, path );
 		}
 		groupIterator = groupChain.getGroupIterator();
 		while ( groupIterator.hasNext() ) {
 			Group group = groupIterator.next();
-			context.setCurrentGroup( group.getGroup() );
-			validateCascadedConstraints( context );
+			localExecutionContext.setCurrentGroup( group.getGroup() );
+			validateCascadedConstraints( context, localExecutionContext, path );
 		}
 
-		// process group sequences depth-first to guarantee that groups following a violation
within a group won't get executed.
+		// now we process sequences. For sequences I have to traverse the object graph since I
have to stop processing when an error occurs.
 		Iterator<List<Group>> sequenceIterator = groupChain.getSequenceIterator();
 		while ( sequenceIterator.hasNext() ) {
 			List<Group> sequence = sequenceIterator.next();
 			for ( Group group : sequence ) {
 				int numberOfViolations = context.getFailingConstraints().size();
-				context.setCurrentGroup( group.getGroup() );
+				localExecutionContext.setCurrentGroup( group.getGroup() );
 
-				validateConstraints( context );
-				validateCascadedConstraints( context );
+				validateConstraints( context, localExecutionContext, path );
+				validateCascadedConstraints( context, localExecutionContext, path );
 
 				if ( context.getFailingConstraints().size() > numberOfViolations ) {
 					break;
@@ -232,15 +223,18 @@
 	}
 
 	/**
-	 * Validates the non-cascaded constraints.
+	 * Validates non cascaded constraints
 	 *
-	 * @param executionContext The current validation context.
+	 * @param executionContext The global execution context
+	 * @param localExecutionContext Collected information for single validation
+	 * @param path The current path of the validation
+	 * @param <T> The type of the root bean
 	 */
-	private <T> void validateConstraints(ExecutionContext<T> executionContext)
{
+	private <T, U, V> void validateConstraints(GlobalExecutionContext<T>
executionContext, LocalExecutionContext<U, V> localExecutionContext, PathImpl path)
{
 		//casting rely on the fact that root object is at the top of the stack
 		@SuppressWarnings("unchecked")
-		BeanMetaData<T> beanMetaData = getBeanMetaData( ( Class<T> )
executionContext.peekCurrentBeanType() );
-		if ( executionContext.getCurrentGroup().getName().equals( Default.class.getName() ) )
{
+		BeanMetaData<T> beanMetaData = getBeanMetaData( ( Class<T> )
localExecutionContext.getCurrentBeanType() );
+		if ( localExecutionContext.getCurrentGroup().getName().equals( Default.class.getName()
) ) {
 			List<Class<?>> defaultGroupSequence =
beanMetaData.getDefaultGroupSequence();
 			if ( log.isTraceEnabled() && defaultGroupSequence.size() > 0 &&
defaultGroupSequence.get( 0 ) != Default.class ) {
 				log.trace(
@@ -250,56 +244,71 @@
 				);
 			}
 			for ( Class<?> defaultSequenceMember : defaultGroupSequence ) {
-				executionContext.setCurrentGroup( defaultSequenceMember );
-				boolean validationSuccessful = validateConstraintsForCurrentGroup( executionContext,
beanMetaData );
+				localExecutionContext.setCurrentGroup( defaultSequenceMember );
+				boolean validationSuccessful = validateConstraintsForCurrentGroup(
+						executionContext, localExecutionContext, beanMetaData, path
+				);
 				if ( !validationSuccessful ) {
 					break;
 				}
 			}
 		}
 		else {
-			validateConstraintsForCurrentGroup( executionContext, beanMetaData );
+			validateConstraintsForCurrentGroup( executionContext, localExecutionContext,
beanMetaData, path );
 		}
 	}
 
-	/**
-	 * Validates all constraints for the given bean using the current group set in the
execution context.
-	 *
-	 * @param executionContext The execution context.
-	 * @param beanMetaData The bean metadata object for the bean to validate.
-	 *
-	 * @return <code>true</code> if the validation was successful (meaning no
constraint violations), <code>false</code>
-	 *         otherwise.
-	 */
-	private <T> boolean validateConstraintsForCurrentGroup(ExecutionContext<T>
executionContext, BeanMetaData<T> beanMetaData) {
+	private <T, U, V> boolean
validateConstraintsForCurrentGroup(GlobalExecutionContext<T> globalExecutionContext,
LocalExecutionContext<U, V> localExecutionContext, BeanMetaData<T>
beanMetaData, PathImpl path) {
 		boolean validationSuccessful = true;
 		for ( MetaConstraint<T, ?> metaConstraint : beanMetaData.geMetaConstraintList() )
{
-			executionContext.pushProperty( metaConstraint.getPropertyName() );
-			if ( executionContext.isValidationRequired( metaConstraint ) ) {
-				boolean tmp = metaConstraint.validateConstraint( executionContext );
+			PathImpl newPath = PathImpl.createShallowCopy( path );
+			newPath.addNode( new NodeImpl( metaConstraint.getPropertyName() ) );
+			localExecutionContext.setPropertyPath( newPath );
+			if ( isValidationRequired( globalExecutionContext, localExecutionContext,
metaConstraint ) ) {
+				Object valueToValidate = metaConstraint.getValue(
localExecutionContext.getCurrentBean() );
+				localExecutionContext.setCurrentValidatedValue( ( V ) valueToValidate );
+				boolean tmp = metaConstraint.validateConstraint( globalExecutionContext,
localExecutionContext );
 				validationSuccessful = validationSuccessful && tmp;
 			}
-			executionContext.popProperty();
 		}
+		globalExecutionContext.markProcessed(
+				localExecutionContext.getCurrentBean(),
+				localExecutionContext.getCurrentGroup(),
+				localExecutionContext.getPropertyPath()
+		);
 		return validationSuccessful;
 	}
 
-	//this method must always be called after validateConstraints for the same context
-	private <T> void validateCascadedConstraints(ExecutionContext<T> context) {
-		List<Member> cascadedMembers = getBeanMetaData( context.peekCurrentBeanType() )
+	/**
+	 * 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.
+	 *
+	 * @param globalExecutionContext The execution context
+	 * @param localExecutionContext Collected information for single validation
+	 * @param path The current path of the valiation.
+	 */
+	private <T, U, V> void validateCascadedConstraints(GlobalExecutionContext<T>
globalExecutionContext, LocalExecutionContext<U, V> localExecutionContext, PathImpl
path) {
+		List<Member> cascadedMembers = getBeanMetaData(
localExecutionContext.getCurrentBeanType() )
 				.getCascadedMembers();
 		for ( Member member : cascadedMembers ) {
 			Type type = ReflectionHelper.typeOf( member );
-			context.pushProperty( ReflectionHelper.getPropertyName( member ) );
-			if ( context.isCascadeRequired( member ) ) {
-				Object value = ReflectionHelper.getValue( member, context.peekCurrentBean() );
+			PathImpl newPath = PathImpl.createShallowCopy( path );
+			newPath.addNode( new NodeImpl( ReflectionHelper.getPropertyName( member ) ) );
+			localExecutionContext.setPropertyPath( newPath );
+			if ( isCascadeRequired( globalExecutionContext, localExecutionContext, member ) ) {
+				Object value = ReflectionHelper.getValue( member,
localExecutionContext.getCurrentBean() );
 				if ( value != null ) {
-					Iterator<?> iter = createIteratorForCascadedValue( context, type, value );
+					Iterator<?> iter = createIteratorForCascadedValue( localExecutionContext,
type, value );
 					boolean isIndexable = isIndexable( type );
-					validateCascadedConstraint( context, iter, isIndexable );
+					validateCascadedConstraint(
+							globalExecutionContext,
+							iter,
+							isIndexable,
+							localExecutionContext.getCurrentGroup(),
+							localExecutionContext.getPropertyPath()
+					);
 				}
 			}
-			context.popProperty();
 		}
 	}
 
@@ -313,7 +322,7 @@
 	 *
 	 * @return An iterator over the value of a cascaded property.
 	 */
-	private <T> Iterator<?>
createIteratorForCascadedValue(ExecutionContext<T> context, Type type, Object value)
{
+	private <U, V> Iterator<?>
createIteratorForCascadedValue(LocalExecutionContext<U, V> context, Type type,
Object value) {
 		Iterator<?> iter;
 		if ( ReflectionHelper.isIterable( type ) ) {
 			iter = ( ( Iterable<?> ) value ).iterator();
@@ -360,30 +369,36 @@
 	}
 
 	@SuppressWarnings("RedundantArrayCreation")
-	private <T> void validateCascadedConstraint(ExecutionContext<T> context,
Iterator<?> iter, boolean isIndexable) {
-		Object actualValue;
-		String propertyIndex;
+	private <T> void validateCascadedConstraint(GlobalExecutionContext<T>
context, Iterator<?> iter, boolean isIndexable, Class<?> currentGroup,
PathImpl currentPath) {
+		Object value;
+		Integer index;
+		Object mapKey = null;
 		int i = 0;
 		while ( iter.hasNext() ) {
-			actualValue = iter.next();
-			propertyIndex = String.valueOf( i );
-			if ( actualValue instanceof Map.Entry ) {
-				Object key = ( ( Map.Entry ) actualValue ).getKey();
-				if ( VALID_MAP_INDEX_CLASSES.contains( key.getClass() ) ) {
-					propertyIndex = key.toString();
-				}
-				actualValue = ( ( Map.Entry ) actualValue ).getValue();
+			value = iter.next();
+			index = i;
+			if ( value instanceof Map.Entry ) {
+				mapKey = ( ( Map.Entry ) value ).getKey();
+				value = ( ( Map.Entry ) value ).getValue();
 			}
 
-			if ( !context.isAlreadyValidated( actualValue ) ) {
-				if ( isIndexable ) {
-					context.setPropertyIndex( propertyIndex );
-				}
-				context.pushCurrentBean( actualValue );
-				GroupChain groupChain = groupChainGenerator.getGroupChainFor( Arrays.asList( new
Class<?>[] { context.getCurrentGroup() } ) );
-				validateInContext( context, groupChain );
-				context.popCurrentBean();
+			if ( isIndexable ) {
+				// only one of the two values index/mapKey will be set. The other will stay null.
+				currentPath.getLeafNode().setIndex( index );
+				currentPath.getLeafNode().setKey( mapKey );
 			}
+
+			if ( !context.isAlreadyValidated( value, currentGroup, currentPath ) ) {
+
+				GroupChain groupChain = groupChainGenerator.getGroupChainFor(
+						Arrays.asList(
+								new Class<?>[] {
+										currentGroup
+								}
+						)
+				);
+				validateInContext( value, context, groupChain, currentPath );
+			}
 			i++;
 		}
 	}
@@ -445,12 +460,12 @@
 		}
 	}
 
-	private <T> void validatePropertyForGroup(
+	private <T, U, V> void validatePropertyForGroup(
 			T object,
 			PathImpl path,
 			List<ConstraintViolation<T>> failingConstraintViolations,
 			Set<MetaConstraint<T, ?>> metaConstraints,
-			Object hostingBeanInstance,
+			U hostingBeanInstance,
 			Group group,
 			TraversableResolver cachedTraversableResolver) {
 		int numberOfConstraintViolationsBefore = failingConstraintViolations.size();
@@ -467,17 +482,21 @@
 
 		for ( Class<?> groupClass : groupList ) {
 			for ( MetaConstraint<T, ?> metaConstraint : metaConstraints ) {
-				ExecutionContext<T> context = ExecutionContext.getContextForValidateProperty(
+				GlobalExecutionContext<T> context =
GlobalExecutionContext.getContextForValidateProperty(
 						object,
-						hostingBeanInstance,
 						messageInterpolator,
 						constraintValidatorFactory,
 						cachedTraversableResolver
 				);
-				context.setProperty( path );
-				context.setCurrentGroup( groupClass );
-				if ( context.isValidationRequired( metaConstraint ) ) {
-					metaConstraint.validateConstraint( context );
+				LocalExecutionContext<U, V> localContext =
LocalExecutionContext.getLocalExecutionContext(
+						hostingBeanInstance
+				);
+				localContext.setPropertyPath( path );
+				localContext.setCurrentGroup( groupClass );
+				if ( isValidationRequired( context, localContext, metaConstraint ) ) {
+					Object valueToValidate = metaConstraint.getValue( localContext.getCurrentBean() );
+					localContext.setCurrentValidatedValue( ( V ) valueToValidate );
+					metaConstraint.validateConstraint( context, localContext );
 					failingConstraintViolations.addAll( context.getFailingConstraints() );
 				}
 			}
@@ -537,16 +556,16 @@
 		}
 	}
 
-	private <T> void validateValueForGroup(
-			Class<T> beanType,
-			Object value,
+	private <U, V> void validateValueForGroup(
+			Class<U> beanType,
+			V value,
 			PathImpl path,
-			List<ConstraintViolation<T>> failingConstraintViolations,
-			Set<MetaConstraint<T, ?>> metaConstraints,
+			List<ConstraintViolation<U>> failingConstraintViolations,
+			Set<MetaConstraint<U, ?>> metaConstraints,
 			Group group,
 			TraversableResolver cachedTraversableResolver) {
 		int numberOfConstraintViolations = failingConstraintViolations.size();
-		BeanMetaData<T> beanMetaData = getBeanMetaData(
metaConstraints.iterator().next().getBeanClass() );
+		BeanMetaData<U> beanMetaData = getBeanMetaData(
metaConstraints.iterator().next().getBeanClass() );
 
 		List<Class<?>> groupList;
 		if ( group.isDefaultGroup() ) {
@@ -557,16 +576,17 @@
 			groupList.add( group.getGroup() );
 		}
 
-
 		for ( Class<?> groupClass : groupList ) {
-			for ( MetaConstraint<T, ?> metaConstraint : metaConstraints ) {
-				ExecutionContext<T> context = ExecutionContext.getContextForValidateValue(
-						beanType, value, messageInterpolator, constraintValidatorFactory,
cachedTraversableResolver
+			for ( MetaConstraint<U, ?> metaConstraint : metaConstraints ) {
+				GlobalExecutionContext<U> context =
GlobalExecutionContext.getContextForValidateValue(
+						beanType, messageInterpolator, constraintValidatorFactory,
cachedTraversableResolver
 				);
-				context.setProperty( path );
-				context.setCurrentGroup( groupClass );
-				if ( context.isValidationRequired( metaConstraint ) ) {
-					metaConstraint.validateConstraint( value, context );
+				LocalExecutionContext<U, V> localContext =
LocalExecutionContext.getLocalExecutionContext( beanType );
+				localContext.setPropertyPath( path );
+				localContext.setCurrentGroup( groupClass );
+				localContext.setCurrentValidatedValue( value );
+				if ( isValidationRequired( context, localContext, metaConstraint ) ) {
+					metaConstraint.validateConstraint( context, localContext );
 					failingConstraintViolations.addAll( context.getFailingConstraints() );
 				}
 			}
@@ -589,9 +609,7 @@
 	 *
 	 * @return Returns the bean hosting the constraints which match the specified property
path.
 	 */
-	@SuppressWarnings("unchecked")
 	private <T> Object collectMetaConstraintsForPath(Class<T> clazz, Object
value, Iterator<Path.Node> propertyIter, Set<MetaConstraint<T, ?>>
metaConstraints) {
-
 		Path.Node elem = propertyIter.next();
 		if ( elem.getName() == null ) { // skip root node
 			elem = propertyIter.next();
@@ -601,11 +619,11 @@
 		if ( !propertyIter.hasNext() ) {
 
 			//use metadata first as ReflectionHelper#containsMember is slow
-			//TODO store some metadata here?
-			if ( metaData.getPropertyDescriptor( elem.getName() ) == null
-					&& !ReflectionHelper.containsMember( clazz, elem.getName() ) ) {
-				//TODO better error report
-				throw new IllegalArgumentException( "Invalid property path." );
+			if ( metaData.getPropertyDescriptor( elem.getName() ) == null ) {
+				throw new IllegalArgumentException(
+						"Invalid property path. There is no property " + elem.getName() + "
in entity " + metaData.getBeanClass()
+								.getName()
+				);
 			}
 
 			List<MetaConstraint<T, ? extends Annotation>> metaConstraintList =
metaData.geMetaConstraintList();
@@ -630,8 +648,12 @@
 						}
 						type = ReflectionHelper.getIndexedType( type );
 					}
+
+					@SuppressWarnings("unchecked")
+					Class<T> valueClass = ( Class<T> ) ( value == null ? type :
value.getClass() );
+
 					return collectMetaConstraintsForPath(
-							( Class<T> ) ( value == null ? type : value.getClass() ),
+							valueClass,
 							value,
 							propertyIter,
 							metaConstraints
@@ -642,9 +664,6 @@
 		return value;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	private <T> BeanMetaData<T> getBeanMetaData(Class<T> beanClass) {
 		BeanMetaDataImpl<T> metadata = beanMetaDataCache.getBeanMetaData( beanClass );
 		if ( metadata == null ) {
@@ -657,8 +676,43 @@
 	/**
 	 * Must be called and stored for the duration of the stack call
 	 * A new instance is returned each time
+	 *
+	 * @return The resolver for the duration of a full validation.
 	 */
 	private TraversableResolver getCachingTraversableResolver() {
 		return new SingleThreadCachedTraversableResolver( traversableResolver );
 	}
+
+	@SuppressWarnings("SimplifiableIfStatement")
+	private boolean isValidationRequired(GlobalExecutionContext globalContext,
LocalExecutionContext localContext, MetaConstraint metaConstraint) {
+		if ( !metaConstraint.getGroupList().contains( localContext.getCurrentGroup() ) ) {
+			return false;
+		}
+
+		return globalContext.getTraversableResolver().isReachable(
+				localContext.getCurrentBean(),
+				localContext.getPropertyPath().getLeafNode(),
+				globalContext.getRootBeanClass(),
+				localContext.getPropertyPath().getPathWithoutLeafNode(),
+				metaConstraint.getElementType()
+		);
+	}
+
+	private boolean isCascadeRequired(GlobalExecutionContext globalContext,
LocalExecutionContext localContext, Member member) {
+		final ElementType type = member instanceof Field ? ElementType.FIELD :
ElementType.METHOD;
+		return globalContext.getTraversableResolver().isReachable(
+				localContext.getCurrentBean(),
+				localContext.getPropertyPath().getLeafNode(),
+				globalContext.getRootBeanClass(),
+				localContext.getPropertyPath().getPathWithoutLeafNode(),
+				type
+		)
+				&& globalContext.getTraversableResolver().isCascadable(
+				localContext.getCurrentBean(),
+				localContext.getPropertyPath().getLeafNode(),
+				globalContext.getRootBeanClass(),
+				localContext.getPropertyPath().getPathWithoutLeafNode(),
+				type
+		);
+	}
 }

Modified:
validator/trunk/hibernate-validator/src/main/java/org/hibernate/validation/metadata/MetaConstraint.java
===================================================================
---
validator/trunk/hibernate-validator/src/main/java/org/hibernate/validation/metadata/MetaConstraint.java	2009-06-24
14:43:50 UTC (rev 16944)
+++
validator/trunk/hibernate-validator/src/main/java/org/hibernate/validation/metadata/MetaConstraint.java	2009-06-24
14:45:17 UTC (rev 16945)
@@ -26,12 +26,13 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Set;
-import javax.validation.metadata.ConstraintDescriptor;
 import javax.validation.ConstraintViolation;
+import javax.validation.metadata.ConstraintDescriptor;
 
-import org.hibernate.validation.util.ReflectionHelper;
 import org.hibernate.validation.engine.ConstraintTree;
-import org.hibernate.validation.engine.ExecutionContext;
+import org.hibernate.validation.engine.GlobalExecutionContext;
+import org.hibernate.validation.engine.LocalExecutionContext;
+import org.hibernate.validation.util.ReflectionHelper;
 
 /**
  * Instances of this class abstract the constraint type  (class, method or field
constraint) and gives access to
@@ -120,11 +121,11 @@
 		return constraintTree;
 	}
 
-	public <T> boolean validateConstraint(ExecutionContext<T> executionContext)
{
-		final Object leafBeanInstance = executionContext.peekCurrentBean();
-		Object value = getValue( leafBeanInstance );
+	public <T, U, V> boolean validateConstraint(GlobalExecutionContext<T>
executionContext, LocalExecutionContext<U, V> localExecutionContext) {
 		List<ConstraintViolation<T>> constraintViolations = new
ArrayList<ConstraintViolation<T>>();
-		constraintTree.validateConstraints( value, typeOfAnnoatedElement(), executionContext,
constraintViolations );
+		constraintTree.validateConstraints(
+				typeOfAnnoatedElement(), executionContext, localExecutionContext,
constraintViolations
+		);
 		if ( constraintViolations.size() > 0 ) {
 			executionContext.addConstraintFailures( constraintViolations );
 			return false;
@@ -132,14 +133,21 @@
 		return true;
 	}
 
-	public <T> boolean validateConstraint(Object value, ExecutionContext<T>
executionContext) {
-		List<ConstraintViolation<T>> constraintViolations = new
ArrayList<ConstraintViolation<T>>();
-		constraintTree.validateConstraints( value, typeOfAnnoatedElement(), executionContext,
constraintViolations );
-		if ( constraintViolations.size() > 0 ) {
-			executionContext.addConstraintFailures( constraintViolations );
-			return false;
+	/**
+	 * @param o the object from which to retrieve the value.
+	 *
+	 * @return Returns the value for this constraint from the specified object. Depending on
the type either the value itself
+	 *         is returned of method or field access is used to access the value.
+	 */
+	public Object getValue(Object o) {
+		switch ( elementType ) {
+			case TYPE: {
+				return o;
+			}
+			default: {
+				return ReflectionHelper.getValue( member, o );
+			}
 		}
-		return true;
 	}
 
 	private Type typeOfAnnoatedElement() {
@@ -151,28 +159,11 @@
 			}
 			default: {
 				t = ReflectionHelper.typeOf( member );
-				if ( t instanceof Class && ((Class) t).isPrimitive()) {
+				if ( t instanceof Class && ( ( Class ) t ).isPrimitive() ) {
 					t = ReflectionHelper.boxedTyp( t );
 				}
 			}
 		}
 		return t;
 	}
-
-	/**
-	 * @param o the object from which to retrieve the value.
-	 *
-	 * @return Returns the value for this constraint from the specified object. Depending on
the type either the value itself
-	 *         is returned of method or field access is used to access the value.
-	 */
-	private Object getValue(Object o) {
-		switch ( elementType ) {
-			case TYPE: {
-				return o;
-			}
-			default: {
-				return ReflectionHelper.getValue( member, o );
-			}
-		}
-	}
 }


    

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

[hibernate-commits] Hibernate SVN: r16945 - in validator/trunk/hibernate-validator/src/main/java/org/hibernate/validation: metadata and 1 other directory.