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.xml;
 
 import java.net.URL;
 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.newHashMap;
 import static org.hibernate.validator.internal.util.CollectionHelper.newHashSet;

Author(s):
Hardy Ferentschik
 
 public class XmlMappingParser {
 
 	private static final Log log = LoggerFactory.make();
 	private static final String VALIDATION_MAPPING_XSD = "META-INF/validation-mapping-1.0.xsd";
 	private static final String MESSAGE_PARAM = "message";
 	private static final String GROUPS_PARAM = "groups";
 	private static final String PAYLOAD_PARAM = "payload";
 	private static final String PACKAGE_SEPARATOR = ".";
 
 	private final Set<Class<?>> processedClasses = newHashSet();
 	private final Map<Class<?>, Set<MetaConstraint<?>>> constraintMap;
 	private final Map<Class<?>, List<Member>> cascadedMembers;
 	private final Map<Class<?>, List<Class<?>>> defaultSequences;
 
 	public XmlMappingParser(ConstraintHelper constraintHelper) {
 		this. = constraintHelper;
 	}
 
 	public final void parse(Set<InputStreammappingStreams) {
 
 		Schema schema = getMappingSchema();
 
 		try {
 			JAXBContext jc = JAXBContext.newInstanceConstraintMappingsType.class );
 			Unmarshaller unmarshaller = jc.createUnmarshaller();
 			unmarshaller.setSchemaschema );
 
 			for ( InputStream in : mappingStreams ) {
				ConstraintMappingsType mapping = getValidationConfiginunmarshaller );
				String defaultPackage = mapping.getDefaultPackage();
				parseConstraintDefinitionsmapping.getConstraintDefinition(), defaultPackage );
				for ( BeanType bean : mapping.getBean() ) {
					Class<?> beanClass = getClassbean.getClazz(), defaultPackage );
							beanClass,
					);
					parseClassLevelOverridesbean.getClassType(), beanClassdefaultPackage );
					parseFieldLevelOverridesbean.getField(), beanClassdefaultPackage );
					parsePropertyLevelOverridesbean.getGetter(), beanClassdefaultPackage );
					.addbeanClass );
				}
			}
		}
		catch ( JAXBException e ) {
		}
	}
	public final Set<Class<?>> getXmlConfiguredClasses() {
	}
	}
	public final <T> Set<MetaConstraint<?>> getConstraintsForClass(Class<T> beanClass) {
		Set<MetaConstraint<?>> theValue = .getbeanClass );
		return theValue != null ? theValue : Collections.<MetaConstraint<?>>emptySet();
	}
	public final List<MembergetCascadedMembersForClass(Class<?> beanClass) {
		if ( .containsKeybeanClass ) ) {
			return .getbeanClass );
		}
		else {
			return Collections.emptyList();
		}
	}
	public final List<Class<?>> getDefaultSequenceForClass(Class<?> beanClass) {
		return .getbeanClass );
	}
	@SuppressWarnings("unchecked")
	private void parseConstraintDefinitions(List<ConstraintDefinitionTypeconstraintDefinitionListString defaultPackage) {
		for ( ConstraintDefinitionType constraintDefinition : constraintDefinitionList ) {
			String annotationClassName = constraintDefinition.getAnnotation();
			Class<?> clazz = getClassannotationClassNamedefaultPackage );
			if ( !clazz.isAnnotation() ) {
				throw .getIsNotAnAnnotationExceptionannotationClassName );
			}
			Class<? extends AnnotationannotationClass = (Class<? extends Annotation>) clazz;
			ValidatedByType validatedByType = constraintDefinition.getValidatedBy();
			List<Class<? extends ConstraintValidator<? extends Annotation, ?>>> constraintValidatorClasses = newArrayList();
			if ( validatedByType.getIncludeExistingValidators() != null && validatedByType.getIncludeExistingValidators() ) {
				constraintValidatorClasses.addAllfindConstraintValidatorClassesannotationClass ) );
			}
			for ( String validatorClassName : validatedByType.getValue() ) {
				Class<? extends ConstraintValidator<?, ?>> validatorClass;
				validatorClass = (Class<? extends ConstraintValidator<?, ?>>) ReflectionHelper.loadClass(
						validatorClassName,
						this.getClass()
				);
				if ( !ConstraintValidator.class.isAssignableFromvalidatorClass ) ) {
				}
				constraintValidatorClasses.addvalidatorClass );
			}
					annotationClassconstraintValidatorClasses
			);
		}
	}
	private List<Class<? extends ConstraintValidator<? extends Annotation, ?>>> findConstraintValidatorClasses(Class<? extends AnnotationannotationType) {
		List<Class<? extends ConstraintValidator<? extends Annotation, ?>>> constraintValidatorDefinitionClasses = newArrayList();
		if ( .isBuiltinConstraintannotationType ) ) {
			constraintValidatorDefinitionClasses.addAll.getBuiltInConstraintsannotationType ) );
		}
		else {
			Class<? extends ConstraintValidator<?, ?>>[] validatedBy = annotationType
			constraintValidatorDefinitionClasses.addAll( Arrays.asListvalidatedBy ) );
		}
		return constraintValidatorDefinitionClasses;
	}
	private void checkClassHasNotBeenProcessed(Set<Class<?>> processedClassesClass<?> beanClass) {
		if ( processedClasses.containsbeanClass ) ) {
		}
	}
	private void parseFieldLevelOverrides(List<FieldTypefieldsClass<?> beanClassString defaultPackage) {
		List<StringfieldNames = newArrayList();
		for ( FieldType fieldType : fields ) {
			String fieldName = fieldType.getName();
			if ( fieldNames.containsfieldName ) ) {
				throw .getIsDefinedTwiceInMappingXmlForBeanExceptionfieldNamebeanClass.getName() );
			}
			else {
				fieldNames.addfieldName );
			}
			final boolean containsField = ReflectionHelper.containsDeclaredFieldbeanClassfieldName );
			if ( !containsField ) {
				throw .getBeanDoesNotContainTheFieldExceptionbeanClass.getName(), fieldName );
			}
			final Field field = ReflectionHelper.getDeclaredFieldbeanClassfieldName );
			// ignore annotations
			boolean ignoreFieldAnnotation = fieldType.getIgnoreAnnotations() == null ? false : fieldType.getIgnoreAnnotations();
			if ( ignoreFieldAnnotation ) {
			}
			// valid
			if ( fieldType.getValid() != null ) {
				addCascadedMemberbeanClassfield );
			}
			// constraints
			for ( ConstraintType constraint : fieldType.getConstraint() ) {
				MetaConstraint<?> metaConstraint = createMetaConstraint(
						constraintbeanClassfielddefaultPackage
				);
				addMetaConstraintbeanClassmetaConstraint );
			}
		}
	}
	private void parsePropertyLevelOverrides(List<GetterTypegettersClass<?> beanClassString defaultPackage) {
		List<StringgetterNames = newArrayList();
		for ( GetterType getterType : getters ) {
			String getterName = getterType.getName();
			if ( getterNames.containsgetterName ) ) {
				throw .getIsDefinedTwiceInMappingXmlForBeanExceptiongetterNamebeanClass.getName() );
			}
			else {
				getterNames.addgetterName );
			}
			boolean containsMethod = ReflectionHelper.containsMethodWithPropertyNamebeanClassgetterName );
			if ( !containsMethod ) {
				throw .getBeanDoesNotContainThePropertyExceptionbeanClass.getName(), getterName );
			}
			final Method method = ReflectionHelper.getMethodFromPropertyNamebeanClassgetterName );
			// ignore annotations
			boolean ignoreGetterAnnotation = getterType.getIgnoreAnnotations() == null ? false : getterType.getIgnoreAnnotations();
			if ( ignoreGetterAnnotation ) {
			}
			// valid
			if ( getterType.getValid() != null ) {
				addCascadedMemberbeanClassmethod );
			}
			// constraints
			for ( ConstraintType constraint : getterType.getConstraint() ) {
				MetaConstraint<?> metaConstraint = createMetaConstraint(
						constraintbeanClassmethoddefaultPackage
				);
				addMetaConstraintbeanClassmetaConstraint );
			}
		}
	}
	private void parseClassLevelOverrides(ClassType classTypeClass<?> beanClassString defaultPackage) {
		if ( classType == null ) {
			return;
		}
		// ignore annotation
		if ( classType.getIgnoreAnnotations() != null ) {
					beanClass,
			);
		}
		// group sequence
		List<Class<?>> groupSequence = createGroupSequenceclassType.getGroupSequence(), defaultPackage );
		if ( !groupSequence.isEmpty() ) {
			.putbeanClassgroupSequence );
		}
		// constraints
		for ( ConstraintType constraint : classType.getConstraint() ) {
			MetaConstraint<?> metaConstraint = createMetaConstraintconstraintbeanClassnulldefaultPackage );
			addMetaConstraintbeanClassmetaConstraint );
		}
	}
	private void addMetaConstraint(Class<?> beanClassMetaConstraint<?> metaConstraint) {
		if ( .containsKeybeanClass ) ) {
			.getbeanClass ).addmetaConstraint );
		}
		else {
			Set<MetaConstraint<?>> constraintList = newHashSet();
			constraintList.addmetaConstraint );
			.putbeanClassconstraintList );
		}
	}
	private void addCascadedMember(Class<?> beanClassMember member) {
		if ( .containsKeybeanClass ) ) {
			.getbeanClass ).addmember );
		}
		else {
			List<MembertmpList = newArrayList();
			tmpList.addmember );
			.putbeanClasstmpList );
		}
	}
	private List<Class<?>> createGroupSequence(GroupSequenceType groupSequenceTypeString defaultPackage) {
		List<Class<?>> groupSequence = newArrayList();
		if ( groupSequenceType != null ) {
			for ( String groupName : groupSequenceType.getValue() ) {
				Class<?> group = getClassgroupNamedefaultPackage );
				groupSequence.addgroup );
			}
		}
		return groupSequence;
	}
	private <A extends Annotation, T> MetaConstraint<?> createMetaConstraint(ConstraintType constraintClass<T> beanClassMember memberString defaultPackage) {
		@SuppressWarnings("unchecked")
		Class<A> annotationClass = (Class<A>) getClassconstraint.getAnnotation(), defaultPackage );
		AnnotationDescriptor<A> annotationDescriptor = new AnnotationDescriptor<A>( annotationClass );
		if ( constraint.getMessage() != null ) {
			annotationDescriptor.setValueconstraint.getMessage() );
		}
		annotationDescriptor.setValuegetGroupsconstraint.getGroups(), defaultPackage ) );
		annotationDescriptor.setValuegetPayloadconstraint.getPayload(), defaultPackage ) );
		for ( ElementType elementType : constraint.getElement() ) {
			String name = elementType.getName();
			Class<?> returnType = getAnnotationParameterTypeannotationClassname );
			Object elementValue = getElementValueelementTypereturnType );
			annotationDescriptor.setValuenameelementValue );
		}
annotation;
		try {
			annotation = AnnotationFactory.createannotationDescriptor );
		}
		catch ( RuntimeException e ) {
		}
		if ( member instanceof Method ) {
		}
		else if ( member instanceof Field ) {
		}
		// we set initially ConstraintOrigin.DEFINED_LOCALLY for all xml configured constraints
		// later we will make copies of this constraint descriptor when needed and adjust the ConstraintOrigin
		ConstraintDescriptorImpl<A> constraintDescriptor = new ConstraintDescriptorImpl<A>(
		);
		return new MetaConstraint<A>( constraintDescriptornew BeanConstraintLocationbeanClassmember ) );
	}
	private <A extends AnnotationClass<?> getAnnotationParameterType(Class<A> annotationClassString name) {
		Method m = ReflectionHelper.getMethodannotationClassname );
		if ( m == null ) {
			throw .getAnnotationDoesNotContainAParameterExceptionannotationClass.getName(), name );
		}
		return m.getReturnType();
	}
	private Object getElementValue(ElementType elementTypeClass<?> returnType) {
		boolean isArray = returnType.isArray();
		if ( !isArray ) {
			if ( elementType.getContent().size() != 1 ) {
			}
			return getSingleValueelementType.getContent().get( 0 ), returnType );
		}
		else {
			List<Objectvalues = newArrayList();
			for ( Serializable s : elementType.getContent() ) {
				values.addgetSingleValuesreturnType.getComponentType() ) );
			}
			return values.toArray( (Object[]) Array.newInstancereturnType.getComponentType(), values.size() ) );
		}
	}
	private void removeEmptyContentElements(ElementType elementType) {
		List<SerializablecontentToDelete = newArrayList();
		for ( Serializable content : elementType.getContent() ) {
			if ( content instanceof String && ( (Stringcontent ).matches"[\\n ].*" ) ) {
				contentToDelete.addcontent );
			}
		}
		elementType.getContent().removeAllcontentToDelete );
	}
	private Object getSingleValue(Serializable serializableClass<?> returnType) {
		Object returnValue;
		if ( serializable instanceof String ) {
			String value = (Stringserializable;
			returnValue = convertStringToReturnTypereturnTypevalue );
		}
		else if ( serializable instanceof JAXBElement && ( (JAXBElement<?>) serializable ).getDeclaredType()
				.equalsString.class ) ) {
			JAXBElement<?> elem = (JAXBElement<?>) serializable;
			String value = (Stringelem.getValue();
			returnValue = convertStringToReturnTypereturnTypevalue );
		}
		else if ( serializable instanceof JAXBElement && ( (JAXBElement<?>) serializable ).getDeclaredType()
				.equalsAnnotationType.class ) ) {
			JAXBElement<?> elem = (JAXBElement<?>) serializable;
			AnnotationType annotationType = (AnnotationTypeelem.getValue();
			try {
				@SuppressWarnings("unchecked")
				Class<AnnotationannotationClass = (Class<Annotation>) returnType;
				returnValue = createAnnotationannotationTypeannotationClass );
			}
			catch ( ClassCastException e ) {
			}
		}
		else {
		}
		return returnValue;
	}
	private <A extends AnnotationAnnotation createAnnotation(AnnotationType annotationTypeClass<A> returnType) {
		AnnotationDescriptor<A> annotationDescriptor = new AnnotationDescriptor<A>( returnType );
		for ( ElementType elementType : annotationType.getElement() ) {
			String name = elementType.getName();
			Class<?> parameterType = getAnnotationParameterTypereturnTypename );
			Object elementValue = getElementValueelementTypeparameterType );
			annotationDescriptor.setValuenameelementValue );
		}
		return AnnotationFactory.createannotationDescriptor );
	}
	private Object convertStringToReturnType(Class<?> returnTypeString value) {
		Object returnValue;
		if ( returnType.getName().equalsbyte.class.getName() ) ) {
			try {
				returnValue = Byte.parseBytevalue );
			}
			catch ( NumberFormatException e ) {
				throw .getInvalidNumberFormatException"byte"e );
			}
		}
		else if ( returnType.getName().equalsshort.class.getName() ) ) {
			try {
				returnValue = Short.parseShortvalue );
			}
			catch ( NumberFormatException e ) {
				throw .getInvalidNumberFormatException"short"e );
			}
		}
		else if ( returnType.getName().equalsint.class.getName() ) ) {
			try {
				returnValue = Integer.parseIntvalue );
			}
			catch ( NumberFormatException e ) {
				throw .getInvalidNumberFormatException"int"e );
			}
		}
		else if ( returnType.getName().equalslong.class.getName() ) ) {
			try {
				returnValue = Long.parseLongvalue );
			}
			catch ( NumberFormatException e ) {
				throw .getInvalidNumberFormatException"long"e );
			}
		}
		else if ( returnType.getName().equalsfloat.class.getName() ) ) {
			try {
				returnValue = Float.parseFloatvalue );
			}
			catch ( NumberFormatException e ) {
				throw .getInvalidNumberFormatException"float"e );
			}
		}
		else if ( returnType.getName().equalsdouble.class.getName() ) ) {
			try {
				returnValue = Double.parseDoublevalue );
			}
			catch ( NumberFormatException e ) {
				throw .getInvalidNumberFormatException"double"e );
			}
		}
		else if ( returnType.getName().equalsboolean.class.getName() ) ) {
			returnValue = Boolean.parseBooleanvalue );
		}
		else if ( returnType.getName().equalschar.class.getName() ) ) {
			if ( value.length() != 1 ) {
			}
			returnValue = value.charAt( 0 );
		}
		else if ( returnType.getName().equalsString.class.getName() ) ) {
			returnValue = value;
		}
		else if ( returnType.getName().equalsClass.class.getName() ) ) {
			returnValue = ReflectionHelper.loadClassvaluethis.getClass() );
		}
		else {
			try {
				@SuppressWarnings("unchecked")
				Class<EnumenumClass = (Class<Enum>) returnType;
				returnValue = Enum.valueOfenumClassvalue );
			}
			catch ( ClassCastException e ) {
				throw .getInvalidReturnTypeExceptionreturnTypee );
			}
		}
		return returnValue;
	}
	private void checkNameIsValid(String name) {
		if ( .equalsname ) || .equalsname ) ) {
		}
	}
	private Class<?>[] getGroups(GroupsType groupsTypeString defaultPackage) {
		if ( groupsType == null ) {
			return new Class[] { };
		}
		List<Class<?>> groupList = newArrayList();
		for ( String groupClass : groupsType.getValue() ) {
			groupList.addgetClassgroupClassdefaultPackage ) );
		}
		return groupList.toArraynew Class[groupList.size()] );
	}
	@SuppressWarnings("unchecked")
	private Class<? extends Payload>[] getPayload(PayloadType payloadTypeString defaultPackage) {
		if ( payloadType == null ) {
			return new Class[] { };
		}
		List<Class<? extends Payload>> payloadList = newArrayList();
		for ( String groupClass : payloadType.getValue() ) {
			Class<?> payload = getClassgroupClassdefaultPackage );
			if ( !Payload.class.isAssignableFrompayload ) ) {
			}
			else {
				payloadList.add( (Class<? extends Payload>) payload );
			}
		}
		return payloadList.toArraynew Class[payloadList.size()] );
	}
	private Class<?> getClass(String clazzString defaultPackage) {
		String fullyQualifiedClass;
		if ( isQualifiedClassclazz ) ) {
			fullyQualifiedClass = clazz;
		}
		else {
			fullyQualifiedClass = defaultPackage +  + clazz;
		}
		return ReflectionHelper.loadClassfullyQualifiedClassthis.getClass() );
	}
	private boolean isQualifiedClass(String clazz) {
		return clazz.contains );
	}
	private Schema getMappingSchema() {
		ClassLoader loader = ReflectionHelper.getClassLoaderFromClassXmlMappingParser.class );
		URL schemaUrl = loader.getResource );
		Schema schema = null;
		try {
			schema = sf.newSchemaschemaUrl );
		}
		catch ( SAXException e ) {
		}
		return schema;
	}
		ConstraintMappingsType constraintMappings;
		try {
			// check whether mark is supported, if so we can reset the stream in order to allow reuse of Configuration
			boolean markSupported = in.markSupported();
			if ( markSupported ) {
			}
			StreamSource stream = new StreamSourcenew CloseIgnoringInputStreamin ) );
			JAXBElement<ConstraintMappingsTyperoot = unmarshaller.unmarshalstreamConstraintMappingsType.class );
			constraintMappings = root.getValue();
			if ( markSupported ) {
				try {
					in.reset();
				}
				catch ( IOException e ) {
					.debug"Unable to reset input stream." );
				}
			}
		}
		catch ( JAXBException e ) {
		}
		return constraintMappings;
	}
	// JAXB closes the underlying input stream
	public class CloseIgnoringInputStream extends FilterInputStream {
			superin );
		}
		public void close() {
			// do nothing
		}
	}
New to GrepCode? Check out our FAQ X