Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
  * JBoss, Home of Professional Open Source
  * Copyright 2009, Red Hat, Inc. and/or its affiliates, 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.validator.internal.metadata.descriptor;
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 
 import static org.hibernate.validator.constraints.CompositionType.AND;

Describes a single constraint (including it's composing constraints).

Author(s):
Emmanuel Bernard
Hardy Ferentschik
Federico Mancini
Dag Hovland
 
 public class ConstraintDescriptorImpl<T extends Annotationimplements ConstraintDescriptor<T>, Serializable {
 
 	private static final long serialVersionUID = -2563102960314069246L;
 	private static final Log log = LoggerFactory.make();
 	private static final int OVERRIDES_PARAMETER_DEFAULT_INDEX = -1;
 	private static final String GROUPS = "groups";
 	private static final String PAYLOAD = "payload";

A list of annotations which can be ignored when investigating for composing constraints.
 
 	private static final List<StringNON_COMPOSING_CONSTRAINT_ANNOTATIONS = new ArrayList<String>();
 
 	static {
 	}

The actual constraint annotation.
 
 	private final T annotation;

The type of the annotation made instance variable, because annotation.annotationType() is quite expensive.
 
 	private final Class<T> annotationType;

The set of classes implementing the validation for this constraint. See also ConstraintValidator resolution algorithm.
 
 	private final List<Class<? extends ConstraintValidator<T, ?>>> constraintValidatorDefinitionClasses;

The groups for which to apply this constraint.
	private final Set<Class<?>> groups;

The constraint parameters as map. The key is the parameter name and the value the parameter value as specified in the constraint.
	private final Map<StringObjectattributes;

The specified payload of the constraint.
	private final Set<Class<? extends Payload>> payloads;

The composing constraints for this constraint.
Flag indicating if in case of a composing constraint a single error or multiple errors should be raised.
	private final boolean isReportAsSingleInvalidConstraint;

Describes on which level (TYPE, METHOD, FIELD) the constraint was defined on.
	private final ElementType elementType;

The origin of the constraint. Defined on the actual root class or somehwere in the class hierarchy
	private final ConstraintOrigin definedOn;

Type indicating how composing constraints should be combined. By default this is set to ConstraintComposition.CompositionType.AND.
Handle to the built-in constraint implementations.
	//TODO Can be made transient since it is only used during object construction. It would be better if we would not have to pass it at all
	private final transient ConstraintHelper constraintHelper;
	public ConstraintDescriptorImpl(T annotationConstraintHelper constraintHelperClass<?> implicitGroupElementType typeConstraintOrigin definedOn) {
		this. = annotation;
		this. = constraintHelper;
		this. = type;
		this. = definedOn;
		);
		// HV-181 - To avoid and thread visibility issues we are building the different data structures in tmp variables and
		// then assign them to the final variables
		this. = buildAnnotationParameterMapannotation );
		this. = buildGroupSetimplicitGroup );
		this. = buildPayloadSetannotation );
	}
	public ConstraintDescriptorImpl(T annotationConstraintHelper constraintHelperElementType typeConstraintOrigin definedOn) {
		thisannotationconstraintHelpernulltypedefinedOn );
	}
	private Set<Class<? extends Payload>> buildPayloadSet(T annotation) {
		Set<Class<? extends Payload>> payloadSet = new HashSet<Class<? extends Payload>>();
		Class<Payload>[] payloadFromAnnotation;
		try {
			//TODO be extra safe and make sure this is an array of Payload
			payloadFromAnnotation = ReflectionHelper.getAnnotationParameterannotationClass[].class );
		}
		catch ( ValidationException e ) {
			//ignore people not defining payloads
			payloadFromAnnotation = null;
		}
		if ( payloadFromAnnotation != null ) {
			payloadSet.addAll( Arrays.asListpayloadFromAnnotation ) );
		}
		return Collections.unmodifiableSetpayloadSet );
	}
	private Set<Class<?>> buildGroupSet(Class<?> implicitGroup) {
		Set<Class<?>> groupSet = new HashSet<Class<?>>();
		final Class<?>[] groupsFromAnnotation = ReflectionHelper.getAnnotationParameter(
		);
		if ( groupsFromAnnotation.length == 0 ) {
			groupSet.addDefault.class );
		}
		else {
			groupSet.addAll( Arrays.asListgroupsFromAnnotation ) );
		}
		// if the constraint is part of the Default group it is automatically part of the implicit group as well
		if ( implicitGroup != null && groupSet.containsDefault.class ) ) {
			groupSet.addimplicitGroup );
		}
		return Collections.unmodifiableSetgroupSet );
	}
		final List<Class<? extends ConstraintValidator<T, ?>>> constraintValidatorClasses = new ArrayList<Class<? extends ConstraintValidator<T, ?>>>();
			for ( Class<? extends ConstraintValidator<T, ?>> validator : 
				constraintValidatorClasses.addvalidator );
			}
			return Collections.unmodifiableListconstraintValidatorClasses );
		}
		List<Class<? extends ConstraintValidator<? extends Annotation, ?>>> constraintDefinitionClasses = new ArrayList<Class<? extends ConstraintValidator<? extends Annotation, ?>>>();
			constraintDefinitionClasses.addAll.getBuiltInConstraints ) );
		}
		else {
			Class<? extends ConstraintValidator<?, ?>>[] validatedBy = 
			constraintDefinitionClasses.addAll( Arrays.asListvalidatedBy ) );
		}
				constraintDefinitionClasses
		);
		for ( Class<? extends ConstraintValidator<? extends Annotation, ?>> validator : constraintDefinitionClasses ) {
			@SuppressWarnings("unchecked")
			Class<? extends ConstraintValidator<T, ?>> safeValidator = (Class<? extends ConstraintValidator<T, ?>>) validator;
			constraintValidatorClasses.addsafeValidator );
		}
		return Collections.unmodifiableListconstraintValidatorClasses );
	}
	public T getAnnotation() {
		return ;
	}
	public Set<Class<?>> getGroups() {
		return ;
	}
	public Set<Class<? extends Payload>> getPayload() {
		return ;
	}
	}
	public Map<StringObjectgetAttributes() {
		return ;
	}
	}
	public boolean isReportAsSingleViolation() {
	}
		return ;
	}
		return ;
	}
	public boolean equals(Object o) {
		if ( this == o ) {
			return true;
		}
		if ( o == null || getClass() != o.getClass() ) {
			return false;
		}
		if (  != null ? !.equalsthat.annotation ) : that.annotation != null ) {
			return false;
		}
		return true;
	}
	public int hashCode() {
		return  != null ? .hashCode() : 0;
	}
	public String toString() {
		final StringBuilder sb = new StringBuilder();
		sb.append"ConstraintDescriptorImpl" );
		sb.append"{annotation=" ).append.getName() );
		sb.append", payloads=" ).append );
		sb.append", hasComposingConstraints=" ).append.isEmpty() );
		sb.append", isReportAsSingleInvalidConstraint=" ).append );
		sb.append", elementType=" ).append );
		sb.append", definedOn=" ).append );
		sb.append", groups=" ).append );
		sb.append", attributes=" ).append );
		sb.append'}' );
		return sb.toString();
	}
		final Method[] declaredMethods = ReflectionHelper.getDeclaredMethodsannotation.annotationType() );
		Map<StringObjectparameters = new HashMap<StringObject>( declaredMethods.length );
		for ( Method m : declaredMethods ) {
			try {
				parameters.putm.getName(), m.invokeannotation ) );
			}
			catch ( IllegalAccessException e ) {
			}
			catch ( InvocationTargetException e ) {
			}
		}
		return Collections.unmodifiableMapparameters );
	}
	private Object getMethodValue(Annotation annotationMethod m) {
		Object value;
		try {
			value = m.invokeannotation );
		}
		// should never happen
		catch ( IllegalAccessException e ) {
		}
		catch ( InvocationTargetException e ) {
		}
		return value;
	}
		Map<ClassIndexWrapperMap<StringObject>> overrideParameters = new HashMap<ClassIndexWrapperMap<StringObject>>();
		final Method[] methods = ReflectionHelper.getDeclaredMethods );
		for ( Method m : methods ) {
			if ( m.getAnnotationOverridesAttribute.class ) != null ) {
						overrideParametersmm.getAnnotationOverridesAttribute.class )
				);
			}
			else if ( m.getAnnotationOverridesAttribute.List.class ) != null ) {
						overrideParameters,
						m,
				);
			}
		}
		return overrideParameters;
	}
	private void addOverrideAttributes(Map<ClassIndexWrapperMap<StringObject>> overrideParametersMethod mOverridesAttribute... attributes) {
		Object value = getMethodValuem );
		for ( OverridesAttribute overridesAttribute : attributes ) {
			ensureAttributeIsOverridablemoverridesAttribute );
					overridesAttribute.constraint(), overridesAttribute.constraintIndex()
			);
			Map<StringObjectmap = overrideParameters.getwrapper );
			if ( map == null ) {
				map = new HashMap<StringObject>();
				overrideParameters.putwrappermap );
			}
			map.putoverridesAttribute.name(), value );
		}
	}
	private void ensureAttributeIsOverridable(Method mOverridesAttribute overridesAttribute) {
		final Method method = ReflectionHelper.getMethodoverridesAttribute.constraint(), overridesAttribute.name() );
		if ( method == null ) {
		}
		Class<?> returnTypeOfOverriddenConstraint = method.getReturnType();
		if ( !returnTypeOfOverriddenConstraint.equalsm.getReturnType() ) ) {
					returnTypeOfOverriddenConstraint.getName(),
			);
		}
	}
		Set<ConstraintDescriptor<?>> composingConstraintsSet = new HashSet<ConstraintDescriptor<?>>();
		for ( Annotation declaredAnnotation : .getDeclaredAnnotations() ) {
			Class<? extends AnnotationdeclaredAnnotationType = declaredAnnotation.annotationType();
			if ( .containsdeclaredAnnotationType.getName() ) ) {
				// ignore the usual suspects which will be in almost any constraint, but are no composing constraint
				continue;
			}
			//If there is a @ConstraintCompositionType annotation, set its value as the local compositionType field
			if ( .isConstraintCompositiondeclaredAnnotationType ) ) {
				this.setCompositionType( ( (ConstraintCompositiondeclaredAnnotation ).value() );
				if ( .isDebugEnabled() ) {
					.debugf"Adding Bool %s."declaredAnnotationType.getName() );
				}
				continue;
			}
			if ( .isConstraintAnnotationdeclaredAnnotationType )
					|| .isBuiltinConstraintdeclaredAnnotationType ) ) {
						declaredAnnotationoverrideParameters
				);
				composingConstraintsSet.adddescriptor );
				.debugf"Adding composing constraint: %s."descriptor );
			}
			else if ( .isMultiValueConstraintdeclaredAnnotationType ) ) {
				List<AnnotationmultiValueConstraints = .getMultiValueConstraintsdeclaredAnnotation );
				int index = 0;
				for ( Annotation constraintAnnotation : multiValueConstraints ) {
							constraintAnnotationoverrideParametersindex
					);
					composingConstraintsSet.adddescriptor );
					.debugf"Adding composing constraint: %s."descriptor );
					index++;
				}
			}
		}
		return Collections.unmodifiableSetcomposingConstraintsSet );
	}
	private <U extends AnnotationConstraintDescriptorImpl<U> createComposingConstraintDescriptor(U declaredAnnotationMap<ClassIndexWrapperMap<StringObject>> overrideParametersint index) {
		@SuppressWarnings("unchecked")
		final Class<U> annotationType = (Class<U>) declaredAnnotation.annotationType();
				overrideParameters,
				index,
				declaredAnnotation,
				annotationType
		);
	}
	private <U extends AnnotationConstraintDescriptorImpl<U> createComposingConstraintDescriptor(Map<ClassIndexWrapperMap<StringObject>> overrideParametersint index, U constraintAnnotationClass<U> annotationType) {
		// use a annotation proxy
		AnnotationDescriptor<U> annotationDescriptor = new AnnotationDescriptor<U>(
				annotationTypebuildAnnotationParameterMapconstraintAnnotation )
		);
		// get the right override parameters
		Map<StringObjectoverrides = overrideParameters.get(
						annotationTypeindex
				)
		);
		if ( overrides != null ) {
			for ( Map.Entry<StringObjectentry : overrides.entrySet() ) {
				annotationDescriptor.setValueentry.getKey(), entry.getValue() );
			}
		}
		// groups get inherited from the parent
		annotationDescriptor.setValue.toArraynew Class<?>[.size()] ) );
		// HV-183 - payloads are propagated to composing constraints
		annotationDescriptor.setValue.toArraynew Class<?>[.size()] ) );
annotationProxy = AnnotationFactory.createannotationDescriptor );
		return new ConstraintDescriptorImpl<U>(
		);
	}

Parameters:
compositionType the compositionType to set
	public void setCompositionType(CompositionType compositionType) {
		this. = compositionType;
	}

Returns:
the compositionType
	}

A wrapper class to keep track for which composing constraints (class and index) a given attribute override applies to.
	private class ClassIndexWrapper {
		final Class<?> clazz;
		final int index;
		ClassIndexWrapper(Class<?> clazzint index) {
			this. = clazz;
			this. = index;
		}
		@SuppressWarnings("SimplifiableIfStatement")
		public boolean equals(Object o) {
			if ( this == o ) {
				return true;
			}
			if ( o == null || getClass() != o.getClass() ) {
				return false;
			}
			@SuppressWarnings("unchecked"// safe due to the check above
			if (  != that.index ) {
				return false;
			}
			if (  != null && !.equalsthat.clazz ) ) {
				return false;
			}
			if (  == null && that.clazz != null ) {
				return false;
			}
			return true;
		}
		public int hashCode() {
			int result =  != null ? .hashCode() : 0;
			result = 31 * result + ;
			return result;
		}
	}
New to GrepCode? Check out our FAQ X