Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
  * JBoss, Home of Professional Open Source
  * Copyright 2010, 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.core;
 
 import java.util.List;
 
 
 import static org.hibernate.validator.internal.util.CollectionHelper.newArrayList;
 import static org.hibernate.validator.internal.util.logging.Messages.MESSAGES;

Keeps track of builtin constraints and their validator implementations, as well as already resolved validator definitions.

Author(s):
Hardy Ferentschik
Alaa Nassef
Gunnar Morling
public class ConstraintHelper {
	private static final Log log = LoggerFactory.make();
	private static final String JODA_TIME_CLASS_NAME = "org.joda.time.ReadableInstant";
	private final ConcurrentHashMap<Class<? extends Annotation>, List<Class<? extends ConstraintValidator<?, ?>>>> builtinConstraints =
			CollectionHelper.newConcurrentHashMap();
	private final ConcurrentHashMap<Class<? extends Annotation>, List<Class<? extends ConstraintValidator<? extends Annotation, ?>>>> constraintValidatorDefinitions =
			CollectionHelper.newConcurrentHashMap();
	public ConstraintHelper() {
		List<Class<? extends ConstraintValidator<?, ?>>> constraintList = newArrayList();
		constraintList.addAssertFalseValidator.class );
		.putAssertFalse.classconstraintList );
		constraintList = newArrayList();
		constraintList.addAssertTrueValidator.class );
		.putAssertTrue.classconstraintList );
		constraintList = newArrayList();
		constraintList.addDecimalMaxValidatorForNumber.class );
		constraintList.addDecimalMaxValidatorForCharSequence.class );
		.putDecimalMax.classconstraintList );
		constraintList = newArrayList();
		constraintList.addDecimalMinValidatorForNumber.class );
		constraintList.addDecimalMinValidatorForCharSequence.class );
		.putDecimalMin.classconstraintList );
		constraintList = newArrayList();
		constraintList.addDigitsValidatorForCharSequence.class );
		constraintList.addDigitsValidatorForNumber.class );
		.putDigits.classconstraintList );
		constraintList = newArrayList();
		constraintList.addFutureValidatorForCalendar.class );
		constraintList.addFutureValidatorForDate.class );
		if ( isJodaTimeInClasspath() ) {
			constraintList.addFutureValidatorForReadableInstant.class );
			constraintList.addFutureValidatorForReadablePartial.class );
		}
		.putFuture.classconstraintList );
		constraintList = newArrayList();
		constraintList.addMaxValidatorForNumber.class );
		constraintList.addMaxValidatorForCharSequence.class );
		.putMax.classconstraintList );
		constraintList = newArrayList();
		constraintList.addMinValidatorForNumber.class );
		constraintList.addMinValidatorForCharSequence.class );
		.putMin.classconstraintList );
		constraintList = newArrayList();
		constraintList.addNotNullValidator.class );
		.putNotNull.classconstraintList );
		constraintList = newArrayList();
		constraintList.addNullValidator.class );
		.putNull.classconstraintList );
		constraintList = newArrayList();
		constraintList.addPastValidatorForCalendar.class );
		constraintList.addPastValidatorForDate.class );
		if ( isJodaTimeInClasspath() ) {
			constraintList.addPastValidatorForReadableInstant.class );
			constraintList.addPastValidatorForReadablePartial.class );
		}
		.putPast.classconstraintList );
		constraintList = newArrayList();
		constraintList.addPatternValidator.class );
		.putPattern.classconstraintList );
		constraintList = newArrayList();
		constraintList.addSizeValidatorForCharSequence.class );
		constraintList.addSizeValidatorForCollection.class );
		constraintList.addSizeValidatorForArray.class );
		constraintList.addSizeValidatorForMap.class );
		constraintList.addSizeValidatorForArraysOfBoolean.class );
		constraintList.addSizeValidatorForArraysOfByte.class );
		constraintList.addSizeValidatorForArraysOfChar.class );
		constraintList.addSizeValidatorForArraysOfDouble.class );
		constraintList.addSizeValidatorForArraysOfFloat.class );
		constraintList.addSizeValidatorForArraysOfInt.class );
		constraintList.addSizeValidatorForArraysOfLong.class );
		.putSize.classconstraintList );
		constraintList = newArrayList();
		constraintList.addEmailValidator.class );
		.putEmail.classconstraintList );
		constraintList = newArrayList();
		constraintList.addLengthValidator.class );
		.putLength.classconstraintList );
		constraintList = newArrayList();
		constraintList.addModCheckValidator.class );
		.putModCheck.classconstraintList );
		constraintList = newArrayList();
		constraintList.addNotBlankValidator.class );
		.putNotBlank.classconstraintList );
		constraintList = newArrayList();
		constraintList.addSafeHtmlValidator.class );
		.putSafeHtml.classconstraintList );
		constraintList = newArrayList();
		constraintList.addScriptAssertValidator.class );
		.putScriptAssert.classconstraintList );
		constraintList = newArrayList();
		constraintList.addURLValidator.class );
		.putURL.classconstraintList );
	}
	public List<Class<? extends ConstraintValidator<? extends Annotation, ?>>> getBuiltInConstraints(Class<? extends AnnotationannotationClass) {
		final List<Class<? extends ConstraintValidator<?, ?>>> builtInList = .getannotationClass );
		if ( builtInList == null || builtInList.size() == 0 ) {
		}
		List<Class<? extends ConstraintValidator<? extends Annotation, ?>>> constraints = newArrayListbuiltInList.size() );
		for ( Class<? extends ConstraintValidator<?, ?>> validatorClass : builtInList ) {
			//safe cause all CV for a given annotation A are CV<A, ?>
			@SuppressWarnings("unchecked")
			Class<ConstraintValidator<? extends Annotation, ?>> safeValidatorClass = (Class<ConstraintValidator<? extends Annotation, ?>>) validatorClass;
			constraints.addsafeValidatorClass );
		}
		return constraints;
	}
	public boolean isBuiltinConstraint(Class<? extends AnnotationannotationType) {
		return .containsKeyannotationType );
	}

Checks whether a given annotation is a multi value constraint or not.

Parameters:
annotationType the annotation type to check.
Returns:
true if the specified annotation is a multi value constraints, false otherwise.
	public boolean isMultiValueConstraint(Class<? extends AnnotationannotationType) {
		boolean isMultiValueConstraint = false;
		final Method method = ReflectionHelper.getMethodannotationType"value" );
		if ( method != null ) {
			Class<?> returnType = method.getReturnType();
			if ( returnType.isArray() && returnType.getComponentType().isAnnotation() ) {
				@SuppressWarnings("unchecked")
				Class<? extends AnnotationcomponentType = (Class<? extends Annotation>) returnType.getComponentType();
				if ( isConstraintAnnotationcomponentType ) || isBuiltinConstraintcomponentType ) ) {
					isMultiValueConstraint = true;
				}
				else {
					isMultiValueConstraint = false;
				}
			}
		}
		return isMultiValueConstraint;
	}


Checks whether a given annotation is a multi value constraint and returns the contained constraints if so.

Parameters:
annotation the annotation to check.
Returns:
A list of constraint annotations or the empty list if annotation is not a multi constraint annotation.
	public <A extends AnnotationList<AnnotationgetMultiValueConstraints(A annotation) {
		List<AnnotationannotationList = newArrayList();
		try {
			final Method method = ReflectionHelper.getMethodannotation.getClass(), "value" );
			if ( method != null ) {
				Class<?> returnType = method.getReturnType();
				if ( returnType.isArray() && returnType.getComponentType().isAnnotation() ) {
					Annotation[] annotations = (Annotation[]) method.invokeannotation );
					for ( Annotation a : annotations ) {
						Class<? extends AnnotationannotationType = a.annotationType();
						if ( isConstraintAnnotationannotationType ) || isBuiltinConstraintannotationType ) ) {
							annotationList.adda );
						}
					}
				}
			}
		}
		catch ( IllegalAccessException iae ) {
			// ignore
		}
		catch ( InvocationTargetException ite ) {
			// ignore
		}
		return annotationList;
	}

Checks whether the specified annotation is a valid constraint annotation. A constraint annotations has to fulfill the following conditions:
  • Has to contain a ConstraintValidator implementation.
  • Defines a message parameter.
  • Defines a group parameter.
  • Defines a payload parameter.

Parameters:
annotationType The annotation type to test.
Returns:
true if the annotation fulfills the above condtions, false otherwise.
	public boolean isConstraintAnnotation(Class<? extends AnnotationannotationType) {
		Constraint constraint = annotationType.getAnnotationConstraint.class );
		if ( constraint == null ) {
			return false;
		}
		assertMessageParameterExistsannotationType );
		assertGroupsParameterExistsannotationType );
		assertPayloadParameterExistsannotationType );
		return true;
	}
	private void assertNoParameterStartsWithValid(Class<? extends AnnotationannotationType) {
		final Method[] methods = ReflectionHelper.getDeclaredMethodsannotationType );
		for ( Method m : methods ) {
			if ( m.getName().startsWith"valid" ) ) {
			}
		}
	}
	private void assertPayloadParameterExists(Class<? extends AnnotationannotationType) {
		try {
			final Method method = ReflectionHelper.getMethodannotationType"payload" );
			if ( method == null ) {
				throw .getConstraintWithoutMandatoryParameterException"payload"annotationType.getName() );
			}
			Class<?>[] defaultPayload = (Class<?>[]) method.getDefaultValue();
			if ( defaultPayload.length != 0 ) {
			}
		}
		catch ( ClassCastException e ) {
			throw .getWrongTypeForPayloadParameterExceptionannotationType.getName(), e );
		}
	}
	private void assertGroupsParameterExists(Class<? extends AnnotationannotationType) {
		try {
			final Method method = ReflectionHelper.getMethodannotationType"groups" );
			if ( method == null ) {
				throw .getConstraintWithoutMandatoryParameterException"groups"annotationType.getName() );
			}
			Class<?>[] defaultGroups = (Class<?>[]) method.getDefaultValue();
			if ( defaultGroups.length != 0 ) {
			}
		}
		catch ( ClassCastException e ) {
			throw .getWrongTypeForGroupsParameterExceptionannotationType.getName(), e );
		}
	}
	private void assertMessageParameterExists(Class<? extends AnnotationannotationType) {
		final Method method = ReflectionHelper.getMethodannotationType"message" );
		if ( method == null ) {
			throw .getConstraintWithoutMandatoryParameterException"message"annotationType.getName() );
		}
		if ( method.getReturnType() != String.class ) {
		}
	}
	public <T extends AnnotationList<Class<? extends ConstraintValidator<T, ?>>> getConstraintValidatorDefinition
			(Class<T> annotationClass) {
		Contracts.assertNotNullannotationClass.classCannotBeNull() );
		final List<Class<? extends ConstraintValidator<? extends Annotation, ?>>> list = .get(
				annotationClass
		);
		List<Class<? extends ConstraintValidator<T, ?>>> constraintsValidators = newArrayListlist.size() );
		for ( Class<? extends ConstraintValidator<?, ?>> validatorClass : list ) {
			//safe cause all CV for a given annotation A are CV<A, ?>
			@SuppressWarnings("unchecked")
			Class<ConstraintValidator<T, ?>> safeValidatorClass = (Class<ConstraintValidator<T, ?>>) validatorClass;
			constraintsValidators.addsafeValidatorClass );
		}
		return constraintsValidators;
	}
	public <A extends Annotationvoid addConstraintValidatorDefinition(Class<A> annotationClassList<Class<? extends ConstraintValidator<? extends Annotation, ?>>> definitionClasses) {
		.putIfAbsentannotationClassdefinitionClasses );
	}
	public boolean containsConstraintValidatorDefinition(Class<? extends AnnotationannotationClass) {
		return .containsKeyannotationClass );
	}
	public boolean isConstraintComposition(Class<? extends AnnotationannotationType) {
		return annotationType == ConstraintComposition.class;
	}
	private boolean isJodaTimeInClasspath() {
		boolean isInClasspath;
		try {
			ReflectionHelper.loadClassthis.getClass() );
			isInClasspath = true;
		}
		catch ( ValidationException e ) {
			isInClasspath = false;
		}
		return isInClasspath;
	}
New to GrepCode? Check out our FAQ X