Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
  * JBoss, Home of Professional Open Source
  * Copyright 2011, 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.provider;
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 
 import static org.hibernate.validator.internal.util.CollectionHelper.newArrayList;
 import static org.hibernate.validator.internal.util.CollectionHelper.newHashSet;
 import static org.hibernate.validator.internal.util.CollectionHelper.partition;

A MetaDataProvider based on the programmatic constraint API.

Author(s):
Gunnar Morling
 
 @SuppressWarnings("deprecation")
 
 	private static final Log log = LoggerFactory.make();
 
 	public ProgrammaticMetaDataProvider(ConstraintHelper constraintHelperSet<ConstraintMappingprogrammaticMappings) {
 		superconstraintHelper );
 		Contracts.assertNotNullprogrammaticMappings );
 		ConstraintMappingContext mergedContext = createMergedMappingContextprogrammaticMappings );
 		initProgrammaticConfigurationmergedContext );
 	}
 
 	}

Reads the configuration from context and creates the appropriate meta-data structures.

Parameters:
context the pre-processed configuration information
 
 		for ( Class<?> clazz : context.getConfiguredClasses() ) {
 			initClassclazzcontext );
 		}
 	}
 
 	private <T> void initClass(Class<T> clazzConstraintMappingContext context) {
 
 		Set<ConstrainedElementconstrainedElements =
 						context.getConstraintConfig().getclazz ),
 						context.getCascadeConfig().getclazz )
 				);
 
 		Set<ConstrainedElementmethodMetaData =
						context.getMethodCascadeConfig().getclazz ),
						context.getMethodConstraintConfig().getclazz )
				);
		constrainedElements.addAllmethodMetaData );
		DefaultGroupSequenceProvider<? super T> sequenceProvider = getDefaultGroupSequenceProviderclazzcontext );
				clazz,
						clazz,
						constrainedElements,
						context.getDefaultSequenceclazz ),
						sequenceProvider
				)
		);
	}
		Class<? extends DefaultGroupSequenceProvider<? super T>> providerClass = context.getDefaultGroupSequenceProvider(
				beanType
		);
		//retrieve provider from new annotation
		if ( providerClass != null ) {
			DefaultGroupSequenceProvider<? super T> provider = ReflectionHelper.newInstance(
					providerClass,
					"default group sequence provider"
			);
			return provider;
		}
		Class<? extends org.hibernate.validator.group.DefaultGroupSequenceProvider<? super T>> deprecatedProviderClass = context
		//retrieve provider from deprecated annotation and wrap into adapter
		if ( deprecatedProviderClass != null ) {
			org.hibernate.validator.group.DefaultGroupSequenceProvider<? super T> provider = ReflectionHelper.newInstance(
					deprecatedProviderClass,
					"default group sequence provider"
			);
			return DefaultGroupSequenceProviderAdapter.getInstanceprovider );
		}
		return null;
	}
				constraints,
		);
		if ( cascades == null ) {
			cascades = Collections.emptySet();
		}
		Set<BeanConstraintLocationallConfiguredProperties = new HashSet<BeanConstraintLocation>( cascades );
		allConfiguredProperties.addAllconstraintsByLocation.keySet() );
		Set<ConstrainedElementallPropertyMetaData = newHashSet();
		for ( BeanConstraintLocation oneConfiguredProperty : allConfiguredProperties ) {
			if ( oneConfiguredProperty.getElementType() == . ) {
				allPropertyMetaData.add(
								oneConfiguredProperty,
								asMetaConstraintsconstraintsByLocation.getoneConfiguredProperty ) ),
								cascades.containsoneConfiguredProperty )
						)
				);
			}
			else {
				allPropertyMetaData.add(
								oneConfiguredProperty,
								asMetaConstraintsconstraintsByLocation.getoneConfiguredProperty ) )
						)
				);
			}
		}
		return allPropertyMetaData;
	}
		Map<MethodSet<MethodConstraintLocation>> cascadesByMethod = partition(
				methodCascadescascadesByMethod()
		);
				methodConstraintsconstraintsByMethod()
		);
		Set<MethodallConfiguredMethods = new HashSet<Method>( cascadesByMethod.keySet() );
		allConfiguredMethods.addAllconstraintsByMethod.keySet() );
		Set<ConstrainedElementallMethodMetaData = newHashSet();
		for ( Method oneMethod : allConfiguredMethods ) {
			Map<IntegerSet<MethodConstraintLocation>> cascadesByParameter = partition(
					cascadesByMethod.get(
							oneMethod
			);
					constraintsByMethod.getoneMethod ), constraintsByParameterIndex()
			);
			List<ConstrainedParameterparameterMetaDataList = newArrayList();
			for ( int i = 0; i < oneMethod.getParameterTypes().lengthi++ ) {
				parameterMetaDataList.add(
								new MethodConstraintLocationoneMethodi ),
								asMetaConstraintsconstraintsByParameter.geti ) ),
								cascadesByParameter.containsKeyi )
						)
				);
			}
			ConstrainedMethod methodMetaData = new ConstrainedMethod(
					new MethodConstraintLocationoneMethod ),
					parameterMetaDataList,
					asMetaConstraintsconstraintsByParameter.getnull ) ),
					cascadesByParameter.containsKeynull )
			);
			allMethodMetaData.addmethodMetaData );
		}
		return allMethodMetaData;
	}
	private Set<MetaConstraint<?>> asMetaConstraints(Set<? extends ConfiguredConstraint<?, ?>> constraints) {
		if ( constraints == null ) {
			return Collections.emptySet();
		}
		Set<MetaConstraint<?>> theValue = newHashSet();
		for ( ConfiguredConstraint<?, ? extends ConstraintLocationoneConfiguredConstraint : constraints ) {
			theValue.addasMetaConstraintoneConfiguredConstraint ) );
		}
		return theValue;
	}
	private <A extends AnnotationMetaConstraint<A> asMetaConstraint(ConfiguredConstraint<A, ? extends ConstraintLocationconfig) {
		ConstraintDescriptorImpl<A> constraintDescriptor = new ConstraintDescriptorImpl<A>(
		);
		return new MetaConstraint<A>( constraintDescriptorconfig.getLocation() );
	}
				return location.getMember();
			}
		};
	}
				return location.getParameterIndex();
			}
		};
	}
				return constraint.getLocation().getMember();
			}
		};
	}
			}
		};
	}

Creates a single merged ConstraintMappingContext in case multiple programmatic mappings are provided.

Parameters:
programmaticMappings set of constraint mappings to merge into a single context
Returns:
a single merged constraint context
		// if we only have one mapping we can return the context of just this mapping
		if ( programmaticMappings.size() == 1 ) {
			return ConstraintMappingContext.getFromMappingprogrammaticMappings.iterator().next() );
		}
		for ( ConstraintMapping mapping : programmaticMappings ) {
			ConstraintMappingContext context = ConstraintMappingContext.getFromMappingmapping );
			for ( Set<ConfiguredConstraint<?, BeanConstraintLocation>> propertyConstraints : context.getConstraintConfig()
					.values() ) {
				for ( ConfiguredConstraint<?, BeanConstraintLocationconstraint : propertyConstraints ) {
					mergedContext.addConstraintConfigconstraint );
				}
			}
			for ( Set<BeanConstraintLocationbeanConstraintLocations : context.getCascadeConfig().values() ) {
				for ( BeanConstraintLocation beanLocation : beanConstraintLocations ) {
					mergedContext.addCascadeConfigbeanLocation );
				}
			}
			for ( Set<ConfiguredConstraint<?, MethodConstraintLocation>> methodConstraints : context.getMethodConstraintConfig()
					.values() ) {
				for ( ConfiguredConstraint<?, MethodConstraintLocationmethodConstraint : methodConstraints ) {
					mergedContext.addMethodConstraintConfigmethodConstraint );
				}
			}
			for ( Set<MethodConstraintLocationcascadedMethodConstraints : context.getMethodCascadeConfig()
					.values() ) {
				for ( MethodConstraintLocation methodCascade : cascadedMethodConstraints ) {
					mergedContext.addMethodCascadeConfigmethodCascade );
				}
			}
			mergeGroupSequenceAndGroupSequenceProvidermergedContextcontext );
		}
		return mergedContext;
	}
		for ( Class<?> clazz : context.getConfiguredClasses() ) {
			mergeSequenceAndProviderForClassmergedContextcontextclazz );
		}
	}
	private <T> void mergeSequenceAndProviderForClass(ConstraintMappingContext mergedContextConstraintMappingContext contextClass<T> clazz) {
		if ( context.getDefaultGroupSequenceProviderclazz ) != null ) {
			if ( mergedContext.getDefaultGroupSequenceProviderclazz ) != null ) {
			}
					clazz,
			);
		}
		if ( context.getDeprecatedDefaultGroupSequenceProviderclazz ) != null ) {
			if ( mergedContext.getDeprecatedDefaultGroupSequenceProviderclazz ) != null ) {
			}
					clazz,
			);
		}
		if ( context.getDefaultSequenceclazz ) != null ) {
			if ( mergedContext.getDefaultSequenceclazz ) != null ) {
			}
					clazz,
					context.getDefaultSequenceclazz )
			);
		}
	}
				return constraint.getLocation();
			}
		};
	}
New to GrepCode? Check out our FAQ X