You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tomee.apache.org by ra...@apache.org on 2018/10/12 15:00:51 UTC
svn commit: r1843674 [7/22] - in /tomee/deps/branches/bval-2: ./ bundle/
bundle/src/ bundle/src/main/ bundle/src/main/appended-resources/
bundle/src/main/appended-resources/META-INF/ bval-extras/ bval-extras/src/
bval-extras/src/main/ bval-extras/src/m...
Added: tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/ValidatorImpl.java
URL: http://svn.apache.org/viewvc/tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/ValidatorImpl.java?rev=1843674&view=auto
==============================================================================
--- tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/ValidatorImpl.java (added)
+++ tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/ValidatorImpl.java Fri Oct 12 15:00:48 2018
@@ -0,0 +1,141 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.apache.bval.jsr;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.Set;
+
+import javax.validation.ConstraintViolation;
+import javax.validation.ValidationException;
+import javax.validation.executable.ExecutableValidator;
+import javax.validation.metadata.BeanDescriptor;
+
+import org.apache.bval.jsr.job.ValidationJobFactory;
+import org.apache.bval.util.Validate;
+import org.apache.bval.util.reflection.Reflection;
+
+public class ValidatorImpl implements CascadingPropertyValidator, ExecutableValidator {
+
+ private final ApacheFactoryContext validatorContext;
+ private final ValidationJobFactory validationJobFactory;
+
+ ValidatorImpl(ApacheFactoryContext validatorContext) {
+ super();
+ this.validatorContext = Validate.notNull(validatorContext, "validatorContext");
+ this.validationJobFactory = new ValidationJobFactory(validatorContext);
+ }
+
+ @Override
+ public BeanDescriptor getConstraintsForClass(Class<?> clazz) {
+ return validatorContext.getDescriptorManager().getBeanDescriptor(clazz);
+ }
+
+ @Override
+ public <T> Set<ConstraintViolation<T>> validate(T object, Class<?>... groups) {
+ return validationJobFactory.validateBean(object, groups).getResults();
+ }
+
+ @Override
+ public <T> Set<ConstraintViolation<T>> validateProperty(T object, String propertyName, boolean cascade,
+ Class<?>... groups) {
+ return validationJobFactory.validateProperty(object, propertyName, groups).cascade(cascade).getResults();
+ }
+
+ @Override
+ public <T> Set<ConstraintViolation<T>> validateValue(Class<T> beanType, String propertyName, Object value,
+ boolean cascade, Class<?>... groups) {
+ return validationJobFactory.validateValue(beanType, propertyName, value, groups).cascade(cascade).getResults();
+ }
+
+ @Override
+ public ExecutableValidator forExecutables() {
+ return this;
+ }
+
+ @Override
+ public <T> Set<ConstraintViolation<T>> validateParameters(T object, Method method, Object[] parameterValues,
+ Class<?>... groups) {
+ return validationJobFactory.validateParameters(object, method, parameterValues, groups).getResults();
+ }
+
+ @Override
+ public <T> Set<ConstraintViolation<T>> validateReturnValue(T object, Method method, Object returnValue,
+ Class<?>... groups) {
+ return validationJobFactory.validateReturnValue(object, method, returnValue, groups).getResults();
+ }
+
+ @Override
+ public <T> Set<ConstraintViolation<T>> validateConstructorParameters(Constructor<? extends T> constructor,
+ Object[] parameterValues, Class<?>... groups) {
+ return validationJobFactory.<T> validateConstructorParameters(constructor, parameterValues, groups)
+ .getResults();
+ }
+
+ @Override
+ public <T> Set<ConstraintViolation<T>> validateConstructorReturnValue(Constructor<? extends T> constructor,
+ T createdObject, Class<?>... groups) {
+ return validationJobFactory.<T> validateConstructorReturnValue(constructor, createdObject, groups).getResults();
+ }
+
+ @Override
+ public <T> T unwrap(Class<T> type) {
+ // FIXME 2011-03-27 jw:
+ // This code is unsecure.
+ // It should allow only a fixed set of classes.
+ // Can't fix this because don't know which classes this method should support.
+
+ if (type.isAssignableFrom(getClass())) {
+ @SuppressWarnings("unchecked")
+ final T result = (T) this;
+ return result;
+ }
+ if (!(type.isInterface() || Modifier.isAbstract(type.getModifiers()))) {
+ return newInstance(type);
+ }
+ try {
+ final Class<?> cls = Reflection.toClass(type.getName() + "Impl");
+ if (type.isAssignableFrom(cls)) {
+ @SuppressWarnings("unchecked")
+ final Class<? extends T> implClass = (Class<? extends T>) cls;
+ return newInstance(implClass);
+ }
+ } catch (ClassNotFoundException e) {
+ }
+ throw new ValidationException("Type " + type + " not supported");
+ }
+
+ private <T> T newInstance(final Class<T> cls) {
+ final Constructor<T> cons = Reflection.getDeclaredConstructor(cls, ApacheFactoryContext.class);
+ if (cons == null) {
+ throw new ValidationException("Cannot instantiate " + cls);
+ }
+ final boolean mustUnset = Reflection.setAccessible(cons, true);
+ try {
+ return cons.newInstance(validatorContext);
+ } catch (final Exception ex) {
+ throw new ValidationException("Cannot instantiate " + cls, ex);
+ } finally {
+ if (mustUnset) {
+ Reflection.setAccessible(cons, false);
+ }
+ }
+ }
+}
Added: tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/BeanD.java
URL: http://svn.apache.org/viewvc/tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/BeanD.java?rev=1843674&view=auto
==============================================================================
--- tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/BeanD.java (added)
+++ tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/BeanD.java Fri Oct 12 15:00:48 2018
@@ -0,0 +1,122 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.apache.bval.jsr.descriptor;
+
+import java.lang.reflect.Type;
+import java.util.EnumSet;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+
+import javax.validation.metadata.BeanDescriptor;
+import javax.validation.metadata.ConstructorDescriptor;
+import javax.validation.metadata.MethodDescriptor;
+import javax.validation.metadata.MethodType;
+import javax.validation.metadata.PropertyDescriptor;
+
+import org.apache.bval.jsr.groups.GroupStrategy;
+import org.apache.bval.jsr.metadata.Signature;
+import org.apache.bval.jsr.util.ToUnmodifiable;
+import org.apache.bval.util.Exceptions;
+import org.apache.bval.util.StringUtils;
+
+public class BeanD<T> extends ElementD<Class<T>, MetadataReader.ForBean<T>> implements BeanDescriptor {
+
+ private final Class<T> beanClass;
+ private final Map<String, PropertyDescriptor> propertiesMap;
+ private final Set<PropertyDescriptor> properties;
+ private final Map<Signature, ConstructorD<T>> constructors;
+ private final Map<Signature, MethodD> methods;
+ private final GroupStrategy groupStrategy;
+
+ BeanD(MetadataReader.ForBean<T> reader) {
+ super(reader);
+ this.beanClass = reader.meta.getHost();
+
+ groupStrategy = reader.getGroupStrategy();
+ propertiesMap = reader.getProperties(this);
+ properties = propertiesMap.values().stream().filter(DescriptorManager::isConstrained).collect(ToUnmodifiable.set());
+ constructors = reader.getConstructors(this);
+ methods = reader.getMethods(this);
+ }
+
+ @Override
+ public Class<?> getElementClass() {
+ return beanClass;
+ }
+
+ @Override
+ public boolean isBeanConstrained() {
+ return hasConstraints() || properties.stream().anyMatch(DescriptorManager::isConstrained);
+ }
+
+ @Override
+ public PropertyDescriptor getConstraintsForProperty(String propertyName) {
+ return Optional.ofNullable(getProperty(propertyName)).filter(DescriptorManager::isConstrained).orElse(null);
+ }
+
+ @Override
+ public Set<PropertyDescriptor> getConstrainedProperties() {
+ return properties;
+ }
+
+ @Override
+ public MethodDescriptor getConstraintsForMethod(String methodName, Class<?>... parameterTypes) {
+ Exceptions.raiseIf(StringUtils.isBlank(methodName), IllegalArgumentException::new,
+ "method name cannot be null/empty/blank");
+ return methods.get(new Signature(methodName, parameterTypes));
+ }
+
+ @Override
+ public Set<MethodDescriptor> getConstrainedMethods(MethodType methodType, MethodType... methodTypes) {
+ final EnumSet<MethodType> filter = EnumSet.of(methodType, methodTypes);
+ return methods.values().stream().filter(m -> filter.contains(m.getMethodType())).collect(ToUnmodifiable.set());
+ }
+
+ @Override
+ public ConstructorDescriptor getConstraintsForConstructor(Class<?>... parameterTypes) {
+ return constructors.get(new Signature(beanClass.getName(), parameterTypes));
+ }
+
+ @Override
+ public Set<ConstructorDescriptor> getConstrainedConstructors() {
+ return constructors.values().stream().collect(ToUnmodifiable.set());
+ }
+
+ public PropertyDescriptor getProperty(String propertyName) {
+ Exceptions.raiseIf(StringUtils.isBlank(propertyName), IllegalArgumentException::new,
+ "propertyName was null/empty/blank");
+
+ return propertiesMap.get(propertyName);
+ }
+
+ @Override
+ protected BeanD<T> getBean() {
+ return this;
+ }
+
+ @Override
+ public GroupStrategy getGroupStrategy() {
+ return groupStrategy;
+ }
+
+ public final Type getGenericType() {
+ return getElementClass();
+ }
+}
Added: tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/CascadableContainerD.java
URL: http://svn.apache.org/viewvc/tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/CascadableContainerD.java?rev=1843674&view=auto
==============================================================================
--- tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/CascadableContainerD.java (added)
+++ tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/CascadableContainerD.java Fri Oct 12 15:00:48 2018
@@ -0,0 +1,68 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.apache.bval.jsr.descriptor;
+
+import java.lang.reflect.AnnotatedElement;
+import java.util.Set;
+
+import javax.validation.metadata.CascadableDescriptor;
+import javax.validation.metadata.ContainerDescriptor;
+import javax.validation.metadata.ContainerElementTypeDescriptor;
+import javax.validation.metadata.GroupConversionDescriptor;
+
+import org.apache.bval.jsr.groups.GroupConversion;
+import org.apache.bval.jsr.util.ToUnmodifiable;
+import org.apache.bval.util.reflection.TypeUtils;
+
+public abstract class CascadableContainerD<P extends ElementD<?, ?>, E extends AnnotatedElement> extends
+ ElementD.NonRoot<P, E, MetadataReader.ForContainer<E>> implements CascadableDescriptor, ContainerDescriptor {
+
+ private final boolean cascaded;
+ private final Set<GroupConversion> groupConversions;
+ private final Set<ContainerElementTypeD> containerElementTypes;
+
+ protected CascadableContainerD(MetadataReader.ForContainer<E> reader, P parent) {
+ super(reader, parent);
+ cascaded = reader.isCascaded();
+ groupConversions = reader.getGroupConversions();
+ containerElementTypes = reader.getContainerElementTypes(this);
+ }
+
+ @Override
+ public Class<?> getElementClass() {
+ return TypeUtils.getRawType(getGenericType(), parent.getElementClass());
+ }
+
+ @Override
+ public boolean isCascaded() {
+ return cascaded;
+ }
+
+ @SuppressWarnings({ "unchecked", "rawtypes" })
+ @Override
+ public Set<GroupConversionDescriptor> getGroupConversions() {
+ return (Set) groupConversions;
+ }
+
+ @Override
+ public Set<ContainerElementTypeDescriptor> getConstrainedContainerElementTypes() {
+ return containerElementTypes.stream().filter(DescriptorManager::isConstrained)
+ .collect(ToUnmodifiable.set());
+ }
+}
Added: tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ComposedD.java
URL: http://svn.apache.org/viewvc/tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ComposedD.java?rev=1843674&view=auto
==============================================================================
--- tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ComposedD.java (added)
+++ tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ComposedD.java Fri Oct 12 15:00:48 2018
@@ -0,0 +1,127 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.apache.bval.jsr.descriptor;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Stream;
+
+import javax.validation.metadata.CascadableDescriptor;
+import javax.validation.metadata.ConstraintDescriptor;
+import javax.validation.metadata.ContainerDescriptor;
+import javax.validation.metadata.ContainerElementTypeDescriptor;
+import javax.validation.metadata.ElementDescriptor;
+import javax.validation.metadata.GroupConversionDescriptor;
+import javax.validation.metadata.PropertyDescriptor;
+
+import org.apache.bval.jsr.groups.GroupsComputer;
+import org.apache.bval.jsr.util.ToUnmodifiable;
+import org.apache.bval.util.Validate;
+
+public abstract class ComposedD<D extends ElementD<?, ?>> implements ElementDescriptor {
+
+ static abstract class ForCascadableContainer<D extends CascadableContainerD<?, ?>> extends ComposedD<D>
+ implements CascadableDescriptor, ContainerDescriptor {
+
+ ForCascadableContainer(List<D> delegates) {
+ super(delegates);
+ }
+
+ @Override
+ public Set<ContainerElementTypeDescriptor> getConstrainedContainerElementTypes() {
+ return delegates.stream().map(ContainerDescriptor::getConstrainedContainerElementTypes)
+ .flatMap(Collection::stream).collect(ToUnmodifiable.set());
+ }
+
+ @Override
+ public boolean isCascaded() {
+ return delegates.stream().anyMatch(CascadableDescriptor::isCascaded);
+ }
+
+ @Override
+ public Set<GroupConversionDescriptor> getGroupConversions() {
+ return delegates.stream().map(CascadableDescriptor::getGroupConversions).flatMap(Collection::stream)
+ .collect(ToUnmodifiable.set());
+ }
+ }
+
+ static class ForProperty extends ComposedD.ForCascadableContainer<PropertyD<?>> implements PropertyDescriptor {
+
+ ForProperty(List<PropertyD<?>> delegates) {
+ super(delegates);
+ }
+
+ @Override
+ public String getPropertyName() {
+ return delegates.stream().map(PropertyDescriptor::getPropertyName).findFirst()
+ .orElseThrow(IllegalStateException::new);
+ }
+ }
+
+ public static <T extends ElementD<?, ?>> Stream<T> unwrap(ElementDescriptor descriptor, Class<T> delegateType) {
+ final Stream<?> s;
+
+ if (descriptor instanceof ComposedD<?>) {
+ s = ((ComposedD<?>) descriptor).delegates.stream()
+ // unwrap recursively:
+ .flatMap(d -> unwrap(d, delegateType));
+ } else {
+ s = Stream.of(descriptor);
+ }
+ return s.map(delegateType::cast);
+ }
+
+ protected final List<D> delegates;
+
+ ComposedD(List<D> delegates) {
+ super();
+ this.delegates = delegates;
+
+ Validate.notNull(delegates, "delegates");
+ Validate.isTrue(!delegates.isEmpty(), "At least one delegate is required");
+ Validate.isTrue(delegates.stream().noneMatch(Objects::isNull), "null delegates not permitted");
+ }
+
+ @Override
+ public boolean hasConstraints() {
+ return delegates.stream().anyMatch(ElementDescriptor::hasConstraints);
+ }
+
+ @Override
+ public Class<?> getElementClass() {
+ return delegates.stream().map(ElementDescriptor::getElementClass).findFirst()
+ .orElseThrow(IllegalStateException::new);
+ }
+
+ @Override
+ public Set<ConstraintDescriptor<?>> getConstraintDescriptors() {
+ return delegates.stream().map(ElementDescriptor::getConstraintDescriptors).flatMap(Collection::stream)
+ .collect(ToUnmodifiable.set());
+ }
+
+ @Override
+ public ConstraintFinder findConstraints() {
+ final GroupsComputer groupsComputer =
+ unwrap(this, ElementD.class).findFirst().orElseThrow(IllegalStateException::new).groupsComputer;
+
+ return new Finder(groupsComputer, this);
+ }
+}
Added: tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ConstraintD.java
URL: http://svn.apache.org/viewvc/tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ConstraintD.java?rev=1843674&view=auto
==============================================================================
--- tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ConstraintD.java (added)
+++ tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ConstraintD.java Fri Oct 12 15:00:48 2018
@@ -0,0 +1,253 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.apache.bval.jsr.descriptor;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.ElementType;
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Executable;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+import javax.validation.ConstraintDeclarationException;
+import javax.validation.ConstraintDefinitionException;
+import javax.validation.ConstraintTarget;
+import javax.validation.ConstraintValidator;
+import javax.validation.Payload;
+import javax.validation.ReportAsSingleViolation;
+import javax.validation.ValidationException;
+import javax.validation.metadata.ConstraintDescriptor;
+import javax.validation.metadata.Scope;
+import javax.validation.metadata.ValidateUnwrappedValue;
+import javax.validation.valueextraction.Unwrapping;
+import javax.validation.valueextraction.Unwrapping.Skip;
+import javax.validation.valueextraction.Unwrapping.Unwrap;
+
+import org.apache.bval.jsr.ApacheValidatorFactory;
+import org.apache.bval.jsr.ConstraintAnnotationAttributes;
+import org.apache.bval.jsr.ConstraintAnnotationAttributes.Worker;
+import org.apache.bval.jsr.metadata.Meta;
+import org.apache.bval.jsr.util.AnnotationsManager;
+import org.apache.bval.jsr.util.ToUnmodifiable;
+import org.apache.bval.util.Exceptions;
+import org.apache.bval.util.Lazy;
+import org.apache.bval.util.Validate;
+
+public class ConstraintD<A extends Annotation> implements ConstraintDescriptor<A> {
+ private enum Optionality {
+ OPTIONAL, REQUIRED;
+
+ public boolean isOptional() {
+ return this == Optionality.OPTIONAL;
+ }
+ }
+
+ private static <T> Set<T> set(Supplier<T[]> array) {
+ return Stream.of(array.get()).collect(ToUnmodifiable.set());
+ }
+
+ private final A annotation;
+ private final Scope scope;
+ private final Meta<?> meta;
+
+ private final Set<Class<? extends Payload>> payload;
+ private final Set<Class<?>> groups;
+ private final boolean reportAsSingle;
+ private final ValidateUnwrappedValue valueUnwrapping;
+ private final Map<String, Object> attributes;
+ private final ConstraintTarget validationAppliesTo;
+
+ private final Set<ConstraintDescriptor<?>> composingConstraints;
+ private final List<Class<? extends ConstraintValidator<A, ?>>> constraintValidatorClasses;
+ private final Lazy<String> toString =
+ new Lazy<>(() -> String.format("%s: %s", ConstraintD.class.getSimpleName(), getAnnotation()));
+
+ public ConstraintD(A annotation, Scope scope, Meta<?> meta, ApacheValidatorFactory validatorFactory) {
+ this.annotation = Validate.notNull(annotation, "annotation");
+ this.scope = Validate.notNull(scope, "scope");
+ this.meta = Validate.notNull(meta, "meta");
+
+ payload = computePayload();
+ groups = set(() -> read(ConstraintAnnotationAttributes.GROUPS, Optionality.REQUIRED));
+ reportAsSingle = annotation.annotationType().isAnnotationPresent(ReportAsSingleViolation.class);
+ valueUnwrapping = computeValidateUnwrappedValue();
+ attributes = AnnotationsManager.readAttributes(annotation);
+ validationAppliesTo = computeValidationAppliesTo(meta.getElementType());
+
+ Validate.notNull(validatorFactory, "validatorFactory");
+ composingConstraints = computeComposingConstraints(validatorFactory);
+ constraintValidatorClasses = computeConstraintValidatorClasses(validatorFactory);
+ }
+
+ @Override
+ public A getAnnotation() {
+ return annotation;
+ }
+
+ @Override
+ public Set<Class<?>> getGroups() {
+ return groups;
+ }
+
+ @Override
+ public Set<Class<? extends Payload>> getPayload() {
+ return payload;
+ }
+
+ @Override
+ public List<Class<? extends ConstraintValidator<A, ?>>> getConstraintValidatorClasses() {
+ return constraintValidatorClasses;
+ }
+
+ @Override
+ public Map<String, Object> getAttributes() {
+ return attributes;
+ }
+
+ @Override
+ public Set<ConstraintDescriptor<?>> getComposingConstraints() {
+ return composingConstraints;
+ }
+
+ @Override
+ public boolean isReportAsSingleViolation() {
+ return reportAsSingle;
+ }
+
+ @Override
+ public String getMessageTemplate() {
+ return read(ConstraintAnnotationAttributes.MESSAGE, Optionality.REQUIRED);
+ }
+
+ @Override
+ public ConstraintTarget getValidationAppliesTo() {
+ return validationAppliesTo;
+ }
+
+ @Override
+ public ValidateUnwrappedValue getValueUnwrapping() {
+ return valueUnwrapping;
+ }
+
+ @Override
+ public <U> U unwrap(Class<U> type) throws ValidationException {
+ try {
+ return type.cast(this);
+ } catch (ClassCastException e) {
+ throw new ValidationException(e);
+ }
+ }
+
+ public Scope getScope() {
+ return scope;
+ }
+
+ public Class<?> getDeclaringClass() {
+ return meta.getDeclaringClass();
+ }
+
+ public ElementType getDeclaredOn() {
+ return meta.getElementType();
+ }
+
+ @Override
+ public String toString() {
+ return toString.get();
+ }
+
+ private <T> T read(ConstraintAnnotationAttributes attr) {
+ return read(attr, Optionality.OPTIONAL);
+ }
+
+ private <T> T read(ConstraintAnnotationAttributes attr, Optionality optionality) {
+ final Class<? extends Annotation> constraintType = annotation.annotationType();
+ final Optional<T> result =
+ Optional.of(constraintType).map(attr::analyze).filter(Worker::isValid).map(w -> w.<T> read(annotation));
+
+ Exceptions.raiseUnless(optionality.isOptional() || result.isPresent(), ConstraintDefinitionException::new,
+ "Required attribute %s missing from constraint type %s",
+ f -> f.args(attr.getAttributeName(), constraintType));
+
+ return result.orElse(null);
+ }
+
+ private Set<ConstraintDescriptor<?>> computeComposingConstraints(ApacheValidatorFactory validatorFactory) {
+ return Stream.of(validatorFactory.getAnnotationsManager().getComposingConstraints(annotation))
+ .map(c -> new ConstraintD<>(c, scope, meta, validatorFactory)).collect(ToUnmodifiable.set());
+ }
+
+ @SuppressWarnings("unchecked")
+ private List<Class<? extends ConstraintValidator<A, ?>>> computeConstraintValidatorClasses(
+ ApacheValidatorFactory validatorFactory) {
+ return validatorFactory.getConstraintsCache()
+ .getConstraintValidatorClasses((Class<A>) annotation.annotationType());
+ }
+
+ private ValidateUnwrappedValue computeValidateUnwrappedValue() {
+ final Set<Class<? extends Payload>> p = getPayload();
+ final boolean unwrap = p.contains(Unwrap.class);
+ final boolean skip = p.contains(Skip.class);
+ if (unwrap) {
+ Validate.validState(!skip, "Cannot specify both %s and %s", Unwrap.class.getSimpleName(),
+ Skip.class.getSimpleName());
+ return ValidateUnwrappedValue.UNWRAP;
+ }
+ return skip ? ValidateUnwrappedValue.SKIP : ValidateUnwrappedValue.DEFAULT;
+ }
+
+ private Set<Class<? extends Payload>> computePayload() {
+ final Set<Class<? extends Payload>> result =
+ set(() -> read(ConstraintAnnotationAttributes.PAYLOAD, Optionality.REQUIRED));
+ if (result.containsAll(Arrays.asList(Unwrapping.Unwrap.class, Unwrapping.Skip.class))) {
+ Exceptions.raise(ConstraintDeclarationException::new,
+ "Constraint %s declared at %s specifies conflicting value unwrapping hints", annotation,
+ meta.getHost());
+ }
+ return result;
+ }
+
+ private ConstraintTarget computeValidationAppliesTo(ElementType elementType) {
+ final ConstraintTarget result = read(ConstraintAnnotationAttributes.VALIDATION_APPLIES_TO);
+ if (result != null && result != ConstraintTarget.IMPLICIT) {
+ final AnnotatedElement host = meta.getHost();
+ Exceptions.raiseUnless(host instanceof Executable, ConstraintDeclarationException::new, "Illegal %s on %s",
+ result, host);
+
+ switch (result) {
+ case PARAMETERS:
+ Exceptions.raiseIf(((Executable) host).getParameterCount() == 0, ConstraintDeclarationException::new,
+ "Illegal specification of %s on %s with no parameters", result, elementType);
+ break;
+ case RETURN_VALUE:
+ Exceptions.raiseIf(Void.TYPE.equals(meta.getType()), ConstraintDeclarationException::new,
+ "Illegal %s on %s method %s", result, Void.TYPE, host);
+ break;
+ default:
+ Exceptions.raise(IllegalStateException::new, "Unknown %s %s", ConstraintTarget.class.getSimpleName(),
+ result);
+ }
+ }
+ return result;
+ }
+}
Added: tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ConstructorD.java
URL: http://svn.apache.org/viewvc/tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ConstructorD.java?rev=1843674&view=auto
==============================================================================
--- tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ConstructorD.java (added)
+++ tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ConstructorD.java Fri Oct 12 15:00:48 2018
@@ -0,0 +1,36 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.apache.bval.jsr.descriptor;
+
+import java.lang.reflect.Constructor;
+
+import javax.validation.metadata.ConstructorDescriptor;
+
+public class ConstructorD<T> extends ExecutableD<Constructor<? extends T>, MetadataReader.ForConstructor<T>, ConstructorD<T>>
+ implements ConstructorDescriptor {
+
+ ConstructorD(MetadataReader.ForConstructor<T> reader, BeanD<T> parent) {
+ super(reader, parent);
+ }
+
+ @Override
+ public Class<?> getElementClass() {
+ return getParent().getElementClass();
+ }
+}
Added: tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ContainerElementTypeD.java
URL: http://svn.apache.org/viewvc/tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ContainerElementTypeD.java?rev=1843674&view=auto
==============================================================================
--- tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ContainerElementTypeD.java (added)
+++ tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ContainerElementTypeD.java Fri Oct 12 15:00:48 2018
@@ -0,0 +1,52 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.apache.bval.jsr.descriptor;
+
+import java.lang.reflect.AnnotatedType;
+
+import javax.validation.metadata.ContainerElementTypeDescriptor;
+
+import org.apache.bval.jsr.metadata.ContainerElementKey;
+import org.apache.bval.util.Validate;
+
+public class ContainerElementTypeD extends CascadableContainerD<CascadableContainerD<?, ?>, AnnotatedType>
+ implements ContainerElementTypeDescriptor {
+
+ private final ContainerElementKey key;
+
+ ContainerElementTypeD(ContainerElementKey key, MetadataReader.ForContainer<AnnotatedType> reader,
+ CascadableContainerD<?, ?> parent) {
+ super(reader, parent);
+ this.key = Validate.notNull(key, "key");
+ }
+
+ @Override
+ public Class<?> getContainerClass() {
+ return key.getContainerClass();
+ }
+
+ @Override
+ public Integer getTypeArgumentIndex() {
+ return Integer.valueOf(key.getTypeArgumentIndex());
+ }
+
+ public ContainerElementKey getKey() {
+ return key;
+ }
+}
Added: tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/CrossParameterD.java
URL: http://svn.apache.org/viewvc/tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/CrossParameterD.java?rev=1843674&view=auto
==============================================================================
--- tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/CrossParameterD.java (added)
+++ tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/CrossParameterD.java Fri Oct 12 15:00:48 2018
@@ -0,0 +1,34 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.apache.bval.jsr.descriptor;
+
+import java.lang.reflect.Executable;
+
+import javax.validation.metadata.CrossParameterDescriptor;
+
+public class CrossParameterD<P extends ExecutableD<?, ?, P>, E extends Executable>
+ extends ElementD.NonRoot<P, E, MetadataReader.ForElement<E, ?>> implements CrossParameterDescriptor {
+
+ protected CrossParameterD(MetadataReader.ForElement<E, ?> reader, P parent) {
+ super(reader, parent);
+ }
+
+ @Override
+ public Class<?> getElementClass() {
+ return Object[].class;
+ }
+}
Added: tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/DescriptorManager.java
URL: http://svn.apache.org/viewvc/tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/DescriptorManager.java?rev=1843674&view=auto
==============================================================================
--- tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/DescriptorManager.java (added)
+++ tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/DescriptorManager.java Fri Oct 12 15:00:48 2018
@@ -0,0 +1,110 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.apache.bval.jsr.descriptor;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+import javax.validation.metadata.BeanDescriptor;
+import javax.validation.metadata.CascadableDescriptor;
+import javax.validation.metadata.ContainerDescriptor;
+import javax.validation.metadata.ElementDescriptor;
+import javax.validation.metadata.ExecutableDescriptor;
+
+import org.apache.bval.jsr.ApacheValidatorFactory;
+import org.apache.bval.jsr.metadata.AnnotationBehaviorMergeStrategy;
+import org.apache.bval.jsr.metadata.CompositeBuilder;
+import org.apache.bval.jsr.metadata.DualBuilder;
+import org.apache.bval.jsr.metadata.HierarchyBuilder;
+import org.apache.bval.jsr.metadata.MetadataBuilder;
+import org.apache.bval.jsr.metadata.ReflectionBuilder;
+import org.apache.bval.util.Validate;
+
+public class DescriptorManager {
+ public static <D extends ElementDescriptor & CascadableDescriptor & ContainerDescriptor> boolean isConstrained(
+ D descriptor) {
+ return descriptor != null && (descriptor.hasConstraints() || descriptor.isCascaded()
+ || !descriptor.getConstrainedContainerElementTypes().isEmpty());
+ }
+
+ public static <D extends ElementDescriptor & CascadableDescriptor & ContainerDescriptor> boolean isCascaded(
+ D descriptor) {
+ return descriptor != null && (descriptor.isCascaded()
+ || descriptor.getConstrainedContainerElementTypes().stream().anyMatch(DescriptorManager::isCascaded));
+ }
+
+ public static <E extends ExecutableDescriptor> boolean isConstrained(E descriptor) {
+ return descriptor != null && (descriptor.hasConstrainedParameters() || descriptor.hasConstrainedReturnValue());
+ }
+
+ private final ApacheValidatorFactory validatorFactory;
+ private final ConcurrentMap<Class<?>, BeanD<?>> beanDescriptors = new ConcurrentHashMap<>();
+ private final ReflectionBuilder reflectionBuilder;
+
+ public DescriptorManager(ApacheValidatorFactory validatorFactory) {
+ super();
+ this.validatorFactory = Validate.notNull(validatorFactory, "validatorFactory");
+ this.reflectionBuilder = new ReflectionBuilder(validatorFactory);
+ }
+
+ public <T> BeanDescriptor getBeanDescriptor(Class<T> beanClass) {
+ Validate.notNull(beanClass, IllegalArgumentException::new, "beanClass");
+
+ // cannot use computeIfAbsent due to recursion being the usual case:
+ if (beanDescriptors.containsKey(beanClass)) {
+ return beanDescriptors.get(beanClass);
+ }
+ final MetadataReader.ForBean<T> reader =
+ new MetadataReader(validatorFactory, beanClass).forBean(builder(beanClass));
+ final BeanD<T> beanD = new BeanD<>(reader);
+ @SuppressWarnings("unchecked")
+ final BeanD<T> result =
+ Optional.ofNullable((BeanD<T>) beanDescriptors.putIfAbsent(beanClass, beanD)).orElse(beanD);
+ return result;
+ }
+
+ public void clear() {
+ beanDescriptors.clear();
+ }
+
+ private <T> MetadataBuilder.ForBean<T> builder(Class<T> beanClass) {
+ final MetadataBuilder.ForBean<T> primaryBuilder =
+ new HierarchyBuilder(validatorFactory, reflectionBuilder::forBean).forBean(beanClass);
+
+ final MetadataBuilder.ForBean<T> customBuilder =
+ new HierarchyBuilder(validatorFactory, this::customBuilder).forBean(beanClass);
+
+ return customBuilder.isEmpty() ? primaryBuilder
+ : DualBuilder.forBean(beanClass, primaryBuilder, customBuilder, validatorFactory);
+ }
+
+ private <T> MetadataBuilder.ForBean<T> customBuilder(Class<T> beanClass) {
+ final List<MetadataBuilder.ForBean<T>> customBuilders =
+ validatorFactory.getMetadataBuilders().getCustomBuilders(beanClass);
+
+ if (customBuilders.isEmpty()) {
+ return null;
+ }
+ if (customBuilders.size() == 1) {
+ return customBuilders.get(0);
+ }
+ return customBuilders.stream()
+ .collect(CompositeBuilder.with(validatorFactory, AnnotationBehaviorMergeStrategy.consensus()).compose());
+ }
+}
Added: tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ElementD.java
URL: http://svn.apache.org/viewvc/tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ElementD.java?rev=1843674&view=auto
==============================================================================
--- tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ElementD.java (added)
+++ tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ElementD.java Fri Oct 12 15:00:48 2018
@@ -0,0 +1,128 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.apache.bval.jsr.descriptor;
+
+import java.lang.annotation.ElementType;
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.util.Map;
+import java.util.Set;
+
+import javax.validation.metadata.ConstraintDescriptor;
+import javax.validation.metadata.ElementDescriptor;
+
+import org.apache.bval.jsr.groups.GroupStrategy;
+import org.apache.bval.jsr.groups.GroupsComputer;
+import org.apache.bval.jsr.metadata.Meta;
+import org.apache.bval.util.Validate;
+import org.apache.bval.util.reflection.TypeUtils;
+
+public abstract class ElementD<E extends AnnotatedElement, R extends MetadataReader.ForElement<E, ?>>
+ implements ElementDescriptor {
+
+ public static abstract class NonRoot<P extends ElementD<?, ?>, E extends AnnotatedElement, R extends MetadataReader.ForElement<E, ?>>
+ extends ElementD<E, R> {
+
+ protected final P parent;
+
+ protected NonRoot(R reader, P parent) {
+ super(reader);
+ this.parent = Validate.notNull(parent, "parent");
+ }
+
+ public P getParent() {
+ return parent;
+ }
+
+ @Override
+ public final Type getGenericType() {
+ if (TypeUtils.containsTypeVariables(genericType)) {
+ final Map<TypeVariable<?>, Type> args =
+ TypeUtils.getTypeArguments(parent.getGenericType(), Object.class);
+ return TypeUtils.unrollVariables(args, genericType);
+ }
+ return genericType;
+ }
+
+ @Override
+ final protected BeanD<?> getBean() {
+ return parent.getBean();
+ }
+
+ @Override
+ public final GroupStrategy getGroupStrategy() {
+ return getBean().getGroupStrategy();
+ }
+ }
+
+ protected final Type genericType;
+ final GroupsComputer groupsComputer;
+
+ private final Meta<E> meta;
+ private final Set<ConstraintD<?>> constraints;
+
+ protected ElementD(R reader) {
+ super();
+ Validate.notNull(reader, "reader");
+ this.meta = reader.meta;
+ this.genericType = reader.meta.getType();
+ this.constraints = reader.getConstraints();
+ this.groupsComputer = reader.getValidatorFactory().getGroupsComputer();
+ }
+
+ @Override
+ public final boolean hasConstraints() {
+ return !constraints.isEmpty();
+ }
+
+ @SuppressWarnings({ "unchecked", "rawtypes" })
+ @Override
+ public final Set<ConstraintDescriptor<?>> getConstraintDescriptors() {
+ return (Set) constraints;
+ }
+
+ @Override
+ public final ConstraintFinder findConstraints() {
+ return new Finder(groupsComputer, this);
+ }
+
+ public final ElementType getElementType() {
+ return meta.getElementType();
+ }
+
+ public final E getTarget() {
+ return meta.getHost();
+ }
+
+ public final Class<?> getDeclaringClass() {
+ return meta.getDeclaringClass();
+ }
+
+ public abstract Type getGenericType();
+
+ public abstract GroupStrategy getGroupStrategy();
+
+ @Override
+ public String toString() {
+ return String.format("%s: %s", getClass().getSimpleName(), meta.describeHost());
+ }
+
+ protected abstract BeanD<?> getBean();
+}
Added: tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ExecutableD.java
URL: http://svn.apache.org/viewvc/tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ExecutableD.java?rev=1843674&view=auto
==============================================================================
--- tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ExecutableD.java (added)
+++ tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ExecutableD.java Fri Oct 12 15:00:48 2018
@@ -0,0 +1,78 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.apache.bval.jsr.descriptor;
+
+import java.lang.reflect.Executable;
+import java.util.List;
+
+import javax.validation.metadata.CrossParameterDescriptor;
+import javax.validation.metadata.ExecutableDescriptor;
+import javax.validation.metadata.ParameterDescriptor;
+import javax.validation.metadata.ReturnValueDescriptor;
+
+public abstract class ExecutableD<E extends Executable, R extends MetadataReader.ForExecutable<E, R>, SELF extends ExecutableD<E, R, SELF>>
+ extends ElementD.NonRoot<BeanD<?>, E, R> implements ExecutableDescriptor {
+
+ private final String name;
+ private final ReturnValueD<SELF, E> returnValue;
+ private final List<ParameterD<SELF>> parameters;
+ private final CrossParameterD<SELF, E> crossParameter;
+
+ @SuppressWarnings("unchecked")
+ protected ExecutableD(R reader, BeanD<?> parent) {
+ super(reader, parent);
+
+ name = reader.meta.getName();
+
+ returnValue = reader.getReturnValueDescriptor((SELF) this);
+ parameters = reader.getParameterDescriptors((SELF) this);
+ crossParameter = reader.getCrossParameterDescriptor((SELF) this);
+ }
+
+ @Override
+ public final String getName() {
+ return name;
+ }
+
+ @SuppressWarnings({ "unchecked", "rawtypes" })
+ @Override
+ public final List<ParameterDescriptor> getParameterDescriptors() {
+ return (List) parameters;
+ }
+
+ @Override
+ public final CrossParameterDescriptor getCrossParameterDescriptor() {
+ return crossParameter;
+ }
+
+ @Override
+ public final ReturnValueDescriptor getReturnValueDescriptor() {
+ return returnValue;
+ }
+
+ @Override
+ public final boolean hasConstrainedParameters() {
+ return parameters.stream().anyMatch(DescriptorManager::isConstrained) || getCrossParameterDescriptor().hasConstraints();
+ }
+
+ @Override
+ public final boolean hasConstrainedReturnValue() {
+ return DescriptorManager.isConstrained(returnValue);
+ }
+}
Added: tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/Finder.java
URL: http://svn.apache.org/viewvc/tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/Finder.java?rev=1843674&view=auto
==============================================================================
--- tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/Finder.java (added)
+++ tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/Finder.java Fri Oct 12 15:00:48 2018
@@ -0,0 +1,150 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.apache.bval.jsr.descriptor;
+
+import java.lang.annotation.ElementType;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.LinkedHashSet;
+import java.util.Objects;
+import java.util.Set;
+import java.util.function.Predicate;
+import java.util.function.UnaryOperator;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import javax.validation.GroupDefinitionException;
+import javax.validation.GroupSequence;
+import javax.validation.groups.Default;
+import javax.validation.metadata.ConstraintDescriptor;
+import javax.validation.metadata.ElementDescriptor;
+import javax.validation.metadata.ElementDescriptor.ConstraintFinder;
+import javax.validation.metadata.Scope;
+
+import org.apache.bval.jsr.groups.Group;
+import org.apache.bval.jsr.groups.Groups;
+import org.apache.bval.jsr.groups.GroupsComputer;
+import org.apache.bval.jsr.util.ToUnmodifiable;
+import org.apache.bval.util.Exceptions;
+import org.apache.bval.util.Lazy;
+import org.apache.bval.util.Validate;
+
+class Finder implements ConstraintFinder {
+ private static Stream<Group> allGroups(Groups groups) {
+ return Stream.concat(groups.getGroups().stream(),
+ groups.getSequences().stream().map(Group.Sequence::getGroups).flatMap(Collection::stream));
+ }
+
+ private volatile Predicate<ConstraintD<?>> groups = c -> true;
+ private volatile Predicate<ConstraintD<?>> scope;
+ private volatile Predicate<ConstraintD<?>> elements;
+
+ private final GroupsComputer groupsComputer;
+ private final ElementDescriptor owner;
+ private final Lazy<Groups> getDefaultSequence = new Lazy<>(this::computeDefaultSequence);
+ private final Lazy<Class<?>> beanClass;
+
+ Finder(GroupsComputer groupsComputer, ElementDescriptor owner) {
+ this.groupsComputer = Validate.notNull(groupsComputer, "groupsComputer");
+ this.owner = Validate.notNull(owner, "owner");
+ this.beanClass = new Lazy<>(() -> firstAtomicElementDescriptor().getBean().getElementClass());
+ }
+
+ @Override
+ public ConstraintFinder unorderedAndMatchingGroups(Class<?>... groups) {
+ final Set<Class<?>> allGroups = computeAll(groups);
+ this.groups = c -> !Collections.disjoint(allGroups, c.getGroups());
+ return this;
+ }
+
+ @Override
+ public ConstraintFinder lookingAt(Scope scope) {
+ this.scope = scope == Scope.HIERARCHY ? null : c -> c.getScope() == scope;
+ return this;
+ }
+
+ @Override
+ public ConstraintFinder declaredOn(ElementType... types) {
+ this.elements = c -> Stream.of(types).filter(Objects::nonNull)
+ .collect(Collectors.toCollection(() -> EnumSet.noneOf(ElementType.class))).contains(c.getDeclaredOn());
+
+ return this;
+ }
+
+ @Override
+ public Set<ConstraintDescriptor<?>> getConstraintDescriptors() {
+ return getConstraints().filter(filter()).collect(ToUnmodifiable.set());
+ }
+
+ @Override
+ public boolean hasConstraints() {
+ return getConstraints().anyMatch(filter());
+ }
+
+ private Stream<ConstraintD<?>> getConstraints() {
+ return owner.getConstraintDescriptors().stream().<ConstraintD<?>> map(c -> c.unwrap(ConstraintD.class));
+ }
+
+ private Predicate<ConstraintD<?>> filter() {
+ Predicate<ConstraintD<?>> result = groups;
+ if (scope != null) {
+ result = result.and(scope);
+ }
+ if (elements != null) {
+ result = result.and(elements);
+ }
+ return result;
+ }
+
+ private ElementD<?,?> firstAtomicElementDescriptor() {
+ return ComposedD.unwrap(owner, ElementD.class).findFirst().orElseThrow(IllegalStateException::new);
+ }
+
+ private Groups computeDefaultSequence() {
+ final ElementD<?, ?> element = firstAtomicElementDescriptor();
+ Collection<Class<?>> redef =
+ element.getGroupStrategy().getGroups().stream().map(Group::getGroup).collect(Collectors.toList());
+
+ if (redef == null) {
+ return GroupsComputer.DEFAULT_GROUPS;
+ }
+ final Class<?> t = this.beanClass.get();
+ if (redef.contains(Default.class)) {
+ Exceptions.raise(GroupDefinitionException::new, "%s for %s cannot include %s.class",
+ GroupSequence.class.getSimpleName(), t, Default.class.getSimpleName());
+ }
+ redef = redef.stream()
+ .map(substituteDefaultGroup())
+ .collect(Collectors.toCollection(LinkedHashSet::new));
+
+ return groupsComputer.computeGroups(redef);
+ }
+
+ private Set<Class<?>> computeAll(Class<?>[] groups) {
+ final Groups preliminaryGroups = groupsComputer.computeGroups(Stream.of(groups).map(substituteDefaultGroup()));
+ return allGroups(preliminaryGroups)
+ .flatMap(g -> g.isDefault() ? allGroups(getDefaultSequence.get()) : Stream.of(g)).map(Group::getGroup)
+ .collect(Collectors.toCollection(LinkedHashSet::new));
+ }
+
+ private UnaryOperator<Class<?>> substituteDefaultGroup() {
+ return t -> t.isAssignableFrom(beanClass.get()) ? Default.class : t;
+ }
+}
Added: tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/MetadataReader.java
URL: http://svn.apache.org/viewvc/tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/MetadataReader.java?rev=1843674&view=auto
==============================================================================
--- tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/MetadataReader.java (added)
+++ tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/MetadataReader.java Fri Oct 12 15:00:48 2018
@@ -0,0 +1,412 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.apache.bval.jsr.descriptor;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.AnnotatedType;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Executable;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Deque;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+import javax.validation.ConstraintDeclarationException;
+import javax.validation.GroupDefinitionException;
+import javax.validation.GroupSequence;
+import javax.validation.ParameterNameProvider;
+import javax.validation.Valid;
+import javax.validation.groups.ConvertGroup;
+import javax.validation.groups.Default;
+import javax.validation.metadata.PropertyDescriptor;
+import javax.validation.metadata.Scope;
+
+import org.apache.bval.jsr.ApacheValidatorFactory;
+import org.apache.bval.jsr.ConstraintAnnotationAttributes;
+import org.apache.bval.jsr.groups.Group;
+import org.apache.bval.jsr.groups.GroupConversion;
+import org.apache.bval.jsr.groups.GroupStrategy;
+import org.apache.bval.jsr.groups.GroupsComputer;
+import org.apache.bval.jsr.metadata.ContainerElementKey;
+import org.apache.bval.jsr.metadata.EmptyBuilder;
+import org.apache.bval.jsr.metadata.Meta;
+import org.apache.bval.jsr.metadata.MetadataBuilder;
+import org.apache.bval.jsr.metadata.Signature;
+import org.apache.bval.jsr.util.AnnotationsManager;
+import org.apache.bval.jsr.util.Methods;
+import org.apache.bval.jsr.util.ToUnmodifiable;
+import org.apache.bval.jsr.xml.AnnotationProxyBuilder;
+import org.apache.bval.util.Exceptions;
+import org.apache.bval.util.ObjectUtils;
+import org.apache.bval.util.Validate;
+import org.apache.bval.util.reflection.Reflection;
+import org.apache.bval.util.reflection.Reflection.Interfaces;
+import org.apache.commons.weaver.privilizer.Privilizing;
+import org.apache.commons.weaver.privilizer.Privilizing.CallTo;
+
+@Privilizing(@CallTo(Reflection.class))
+class MetadataReader {
+
+ class ForElement<E extends AnnotatedElement, B extends MetadataBuilder.ForElement<E>> {
+ final Meta<E> meta;
+ protected final B builder;
+
+ ForElement(Meta<E> meta, B builder) {
+ super();
+ this.meta = Validate.notNull(meta, "meta");
+ this.builder = Validate.notNull(builder, "builder");
+ }
+
+ Set<ConstraintD<?>> getConstraints() {
+ return builder.getConstraintDeclarationMap(meta).entrySet().stream().filter(e -> e.getValue().length > 0)
+ .flatMap(e -> {
+ final Meta<E> m = e.getKey();
+ final Class<?> declaredBy = m.getDeclaringClass();
+ final Scope scope = declaredBy.equals(beanClass) ? Scope.LOCAL_ELEMENT : Scope.HIERARCHY;
+ return Stream.of(e.getValue()).peek(
+ c -> validatorFactory.getAnnotationsManager().validateConstraintDefinition(c.annotationType()))
+ .map(c -> rewriteConstraint(c, declaredBy))
+ .map(c -> new ConstraintD<>(c, scope, m, validatorFactory));
+ }).collect(ToUnmodifiable.set());
+ }
+
+ ApacheValidatorFactory getValidatorFactory() {
+ return validatorFactory;
+ }
+
+ private <A extends Annotation> A rewriteConstraint(A constraint, Class<?> declaredBy) {
+ boolean mustRewrite = false;
+ Class<?>[] groups =
+ ConstraintAnnotationAttributes.GROUPS.analyze(constraint.annotationType()).read(constraint);
+ if (groups.length == 0) {
+ mustRewrite = true;
+ groups = GroupsComputer.DEFAULT_GROUP;
+ }
+ if (!(declaredBy.equals(beanClass) || beanClass.isInterface())) {
+ if (ObjectUtils.arrayContains(groups, Default.class)
+ && !ObjectUtils.arrayContains(groups, declaredBy)) {
+ mustRewrite = true;
+ groups = ObjectUtils.arrayAdd(groups, declaredBy);
+ }
+ }
+ if (mustRewrite) {
+ final AnnotationProxyBuilder<A> builder = new AnnotationProxyBuilder<A>(constraint);
+ builder.setGroups(groups);
+ return builder.createAnnotation();
+ }
+ return constraint;
+ }
+ }
+
+ class ForBean<T> extends MetadataReader.ForElement<Class<T>, MetadataBuilder.ForClass<T>> {
+ private final MetadataBuilder.ForBean<T> beanBuilder;
+
+ ForBean(Meta<Class<T>> meta, MetadataBuilder.ForBean<T> builder) {
+ super(meta, Validate.notNull(builder, "builder").getClass(meta));
+ this.beanBuilder = builder;
+ }
+
+ Map<String, PropertyDescriptor> getProperties(BeanD<T> parent) {
+ final Map<String, List<PropertyD<?>>> properties = new LinkedHashMap<>();
+ final Function<? super String, ? extends List<PropertyD<?>>> descriptorList = k -> new ArrayList<>();
+
+ beanBuilder.getFields(meta).forEach((f, builder) -> {
+ final Field fld = Reflection.find(meta.getHost(), t -> Reflection.getDeclaredField(t, f));
+ properties.computeIfAbsent(f, descriptorList).add(
+ new PropertyD.ForField(new MetadataReader.ForContainer<>(new Meta.ForField(fld), builder), parent));
+ });
+ beanBuilder.getGetters(meta).forEach((g, builder) -> {
+ final Method getter = Methods.getter(meta.getHost(), g);
+
+ if (getter == null) {
+ Exceptions.raise(IllegalStateException::new, "Getter method for property %s not found", g);
+ }
+ properties.computeIfAbsent(g, descriptorList).add(new PropertyD.ForMethod(
+ new MetadataReader.ForContainer<>(new Meta.ForMethod(getter), builder), parent));
+ });
+ return properties.entrySet().stream().collect(ToUnmodifiable.map(Map.Entry::getKey, e -> {
+ final List<PropertyD<?>> delegates = e.getValue();
+
+ if (delegates.size() == 1) {
+ return delegates.get(0);
+ }
+ final Set<PropertyD<?>> constrained =
+ delegates.stream().filter(DescriptorManager::isConstrained).collect(Collectors.toSet());
+ if (constrained.isEmpty()) {
+ return delegates.get(0);
+ }
+ if (constrained.size() == 1) {
+ return constrained.iterator().next();
+ }
+ return new ComposedD.ForProperty(delegates);
+ }));
+ }
+
+ Map<Signature, MethodD> getMethods(BeanD<T> parent) {
+ final Map<Signature, MetadataBuilder.ForExecutable<Method>> methodBuilders = beanBuilder.getMethods(meta);
+ if (methodBuilders.isEmpty()) {
+ return Collections.emptyMap();
+ }
+ final Map<Signature, MethodD> result = new LinkedHashMap<>();
+
+ methodBuilders.forEach((sig, builder) -> {
+ final Method m = Reflection.find(meta.getHost(),
+ t -> Reflection.getDeclaredMethod(t, sig.getName(), sig.getParameterTypes()));
+
+ final MethodD descriptor =
+ new MethodD(new MetadataReader.ForMethod(new Meta.ForMethod(m), builder), parent);
+ if (DescriptorManager.isConstrained(descriptor)) {
+ result.put(sig, descriptor);
+ }
+ });
+ return Collections.unmodifiableMap(result);
+ }
+
+ Map<Signature, ConstructorD<T>> getConstructors(BeanD<T> parent) {
+ final Map<Signature, MetadataBuilder.ForExecutable<Constructor<? extends T>>> ctorBuilders =
+ beanBuilder.getConstructors(meta);
+
+ if (ctorBuilders.isEmpty()) {
+ return Collections.emptyMap();
+ }
+ final Map<Signature, ConstructorD<T>> result = new LinkedHashMap<>();
+
+ ctorBuilders.forEach((sig, builder) -> {
+ final Constructor<?> c = Reflection.getDeclaredConstructor(meta.getHost(), sig.getParameterTypes());
+ @SuppressWarnings({ "unchecked", "rawtypes" })
+ final Meta.ForConstructor<T> metaCtor = (Meta.ForConstructor) new Meta.ForConstructor<>(c);
+ final ConstructorD<T> descriptor =
+ new ConstructorD<>(new MetadataReader.ForConstructor<T>(metaCtor, builder), parent);
+ if (DescriptorManager.isConstrained(descriptor)) {
+ result.put(sig, descriptor);
+ }
+ });
+ return Collections.unmodifiableMap(result);
+ }
+
+ GroupStrategy getGroupStrategy() {
+ final Class<T> host = meta.getHost();
+ if (host.isInterface()) {
+ return validatorFactory.getGroupsComputer().computeGroups(host).asStrategy();
+ }
+ final GroupStrategy parentStrategy = Optional.ofNullable(host.getSuperclass()).filter(JDK.negate())
+ .map(validatorFactory.getDescriptorManager()::getBeanDescriptor).map(BeanD.class::cast)
+ .map(BeanD::getGroupStrategy).orElse(null);
+
+ final List<Class<?>> groupSequence = builder.getGroupSequence(meta);
+
+ final Set<Group> parentGroups = parentStrategy == null ? null : parentStrategy.getGroups();
+
+ Group localGroup = Group.of(host);
+ if (groupSequence == null) {
+ final Set<Group> groups = new HashSet<>();
+ groups.add(localGroup);
+
+ for (Class<?> t : Reflection.hierarchy(host, Interfaces.INCLUDE)) {
+ if (JDK.test(t)) {
+ continue;
+ }
+ if (!t.isInterface()) {
+ continue;
+ }
+ if (AnnotationsManager.isAnnotationDirectlyPresent(t, GroupSequence.class)) {
+ continue;
+ }
+ final Group g = Group.of(t);
+ if (parentGroups != null && parentGroups.contains(g)) {
+ continue;
+ }
+ groups.add(g);
+ }
+ final GroupStrategy strategy = GroupStrategy.simple(groups);
+ return parentStrategy == null ? strategy : GroupStrategy.composite(strategy, parentStrategy);
+ }
+ if (groupSequence.contains(Default.class)) {
+ Exceptions.raise(GroupDefinitionException::new, "@%s for %s must not contain %s",
+ GroupSequence.class.getSimpleName(), host, Default.class.getName());
+ }
+ if (!groupSequence.contains(host)) {
+ Exceptions.raise(GroupDefinitionException::new, "@%s for %s must contain %<s",
+ GroupSequence.class.getSimpleName(), host);
+ }
+ final Group.Sequence result =
+ Group.sequence(groupSequence.stream().map(Group::of).collect(Collectors.toList()));
+
+ final Deque<Group> expanded = new ArrayDeque<>();
+ for (Class<?> t : Reflection.hierarchy(host, Interfaces.INCLUDE)) {
+ if (JDK.test(t)) {
+ continue;
+ }
+ if (t.isInterface() && AnnotationsManager.isAnnotationDirectlyPresent(t, GroupSequence.class)) {
+ continue;
+ }
+ expanded.push(Group.of(t));
+ }
+ if (expanded.size() == 1) {
+ return result;
+ }
+ return result.redefining(Collections.singletonMap(localGroup, GroupStrategy.simple(expanded)));
+ }
+ }
+
+ class ForContainer<E extends AnnotatedElement> extends ForElement<E, MetadataBuilder.ForContainer<E>> {
+
+ ForContainer(Meta<E> meta, MetadataBuilder.ForContainer<E> builder) {
+ super(meta, builder);
+ }
+
+ boolean isCascaded() {
+ return builder.isCascade(meta);
+ }
+
+ Set<GroupConversion> getGroupConversions() {
+ final Set<GroupConversion> groupConversions = builder.getGroupConversions(meta);
+ if (!groupConversions.isEmpty()) {
+ if (!isCascaded()) {
+ Exceptions.raise(ConstraintDeclarationException::new, "@%s declared without @%s on %s",
+ ConvertGroup.class.getSimpleName(), Valid.class.getSimpleName(), meta.describeHost());
+ }
+ if (groupConversions.stream().map(GroupConversion::getFrom).distinct().count() < groupConversions
+ .size()) {
+ Exceptions.raise(ConstraintDeclarationException::new, "%s has duplicate 'from' group conversions",
+ meta.describeHost());
+ }
+ groupConversions.stream().map(GroupConversion::getFrom)
+ .forEach(from -> Exceptions.raiseIf(from.isAnnotationPresent(GroupSequence.class),
+ ConstraintDeclarationException::new,
+ "Invalid group conversion declared on %s from group sequence %s",
+ f -> f.args(meta.describeHost(), from)));
+ }
+ return groupConversions;
+ }
+
+ Set<ContainerElementTypeD> getContainerElementTypes(CascadableContainerD<?, ?> parent) {
+ final Map<ContainerElementKey, MetadataBuilder.ForContainer<AnnotatedType>> containerElementTypes =
+ builder.getContainerElementTypes(meta);
+
+ if (containerElementTypes.isEmpty()) {
+ return Collections.emptySet();
+ }
+ final Set<ContainerElementTypeD> result =
+ new TreeSet<>(Comparator.comparing(ContainerElementTypeD::getKey));
+
+ containerElementTypes.forEach((k, builder) -> {
+ result.add(new ContainerElementTypeD(k,
+ new MetadataReader.ForContainer<>(new Meta.ForContainerElement(meta, k), builder), parent));
+ });
+ return Collections.unmodifiableSet(result);
+ }
+ }
+
+ abstract class ForExecutable<E extends Executable, SELF extends ForExecutable<E, SELF>>
+ extends ForElement<E, MetadataBuilder.ForElement<E>> {
+ private final MetadataBuilder.ForExecutable<E> executableBuilder;
+
+ ForExecutable(Meta<E> meta, MetadataBuilder.ForExecutable<E> executableBuilder) {
+ super(meta, EmptyBuilder.instance().forElement());
+ this.executableBuilder = Validate.notNull(executableBuilder, "executableBuilder");
+ }
+
+ <X extends ExecutableD<E, SELF, X>> List<ParameterD<X>> getParameterDescriptors(X parent) {
+ final Parameter[] parameters = meta.getHost().getParameters();
+
+ final List<String> parameterNames =
+ getParameterNames(validatorFactory.getParameterNameProvider(), meta.getHost());
+
+ final List<MetadataBuilder.ForContainer<Parameter>> builders = executableBuilder.getParameters(meta);
+
+ return IntStream.range(0, parameters.length).mapToObj(i -> {
+ final Meta.ForParameter param = new Meta.ForParameter(parameters[i], parameterNames.get(i));
+ final MetadataBuilder.ForContainer<Parameter> parameterBuilder =
+ builders.size() > i ? builders.get(i) : EmptyBuilder.instance().forContainer();
+ return new ParameterD<>(param, i, new MetadataReader.ForContainer<>(param, parameterBuilder), parent);
+ }).collect(ToUnmodifiable.list());
+ }
+
+ <X extends ExecutableD<E, SELF, X>> CrossParameterD<X, E> getCrossParameterDescriptor(X parent) {
+ final Meta.ForCrossParameter<E> cp = new Meta.ForCrossParameter<>(meta);
+ return new CrossParameterD<>(new MetadataReader.ForElement<>(cp, executableBuilder.getCrossParameter(cp)),
+ parent);
+ }
+
+ <X extends ExecutableD<E, SELF, X>> ReturnValueD<X, E> getReturnValueDescriptor(X parent) {
+ return new ReturnValueD<>(new MetadataReader.ForContainer<>(meta, executableBuilder.getReturnValue(meta)),
+ parent);
+ }
+
+ abstract List<String> getParameterNames(ParameterNameProvider parameterNameProvider, E host);
+ }
+
+ class ForMethod extends ForExecutable<Method, ForMethod> {
+ ForMethod(Meta<Method> meta, MetadataBuilder.ForExecutable<Method> builder) {
+ super(meta, builder);
+ }
+
+ @Override
+ List<String> getParameterNames(ParameterNameProvider parameterNameProvider, Method host) {
+ return parameterNameProvider.getParameterNames(host);
+ }
+ }
+
+ class ForConstructor<T> extends ForExecutable<Constructor<? extends T>, ForConstructor<T>> {
+
+ ForConstructor(Meta<Constructor<? extends T>> meta,
+ MetadataBuilder.ForExecutable<Constructor<? extends T>> builder) {
+ super(meta, builder);
+ }
+
+ @Override
+ List<String> getParameterNames(ParameterNameProvider parameterNameProvider, Constructor<? extends T> host) {
+ return parameterNameProvider.getParameterNames(host);
+ }
+ }
+
+ private static final Predicate<Class<?>> JDK = t -> t.getName().startsWith("java.");
+
+ private final ApacheValidatorFactory validatorFactory;
+ private final Class<?> beanClass;
+
+ MetadataReader(ApacheValidatorFactory validatorFactory, Class<?> beanClass) {
+ super();
+ this.validatorFactory = Validate.notNull(validatorFactory, "validatorFactory");
+ this.beanClass = Validate.notNull(beanClass, "beanClass");
+ }
+
+ @SuppressWarnings("unchecked")
+ <T> MetadataReader.ForBean<T> forBean(MetadataBuilder.ForBean<T> builder) {
+ return new MetadataReader.ForBean<>(new Meta.ForClass<>((Class<T>) beanClass), builder);
+ }
+}
Added: tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/MethodD.java
URL: http://svn.apache.org/viewvc/tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/MethodD.java?rev=1843674&view=auto
==============================================================================
--- tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/MethodD.java (added)
+++ tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/MethodD.java Fri Oct 12 15:00:48 2018
@@ -0,0 +1,44 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.apache.bval.jsr.descriptor;
+
+import java.lang.reflect.Method;
+
+import javax.validation.metadata.MethodDescriptor;
+import javax.validation.metadata.MethodType;
+
+import org.apache.bval.jsr.util.Methods;
+
+class MethodD extends ExecutableD<Method, MetadataReader.ForMethod, MethodD> implements MethodDescriptor {
+ private final MethodType methodType;
+
+ MethodD(MetadataReader.ForMethod reader, BeanD<?> parent) {
+ super(reader, parent);
+ methodType = Methods.isGetter(reader.meta.getHost()) ? MethodType.GETTER : MethodType.NON_GETTER;
+ }
+
+ @Override
+ public Class<?> getElementClass() {
+ return getTarget().getReturnType();
+ }
+
+ MethodType getMethodType() {
+ return methodType;
+ }
+}
Added: tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ParameterD.java
URL: http://svn.apache.org/viewvc/tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ParameterD.java?rev=1843674&view=auto
==============================================================================
--- tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ParameterD.java (added)
+++ tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ParameterD.java Fri Oct 12 15:00:48 2018
@@ -0,0 +1,92 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.apache.bval.jsr.descriptor;
+
+import java.lang.reflect.Array;
+import java.lang.reflect.GenericArrayType;
+import java.lang.reflect.Parameter;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+
+import javax.validation.metadata.ParameterDescriptor;
+
+import org.apache.bval.jsr.metadata.Meta;
+import org.apache.bval.util.Validate;
+import org.apache.bval.util.reflection.TypeUtils;
+
+public class ParameterD<P extends ExecutableD<?, ?, P>> extends CascadableContainerD<P, Parameter>
+ implements ParameterDescriptor {
+
+ private final int index;
+ private final String name;
+ private final Class<?> type;
+
+ ParameterD(Meta.ForParameter meta, int index, MetadataReader.ForContainer<Parameter> reader, P parent) {
+ super(reader, parent);
+
+ Validate.isTrue(index >= 0 && index < meta.getHost().getDeclaringExecutable().getParameterCount(),
+ "Invalid parameter index %d", index);
+
+ this.index = index;
+
+ name = reader.meta.getName();
+ type = resolveType();
+ }
+
+ @Override
+ public Class<?> getElementClass() {
+ return type;
+ }
+
+ @Override
+ public int getIndex() {
+ return index;
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+
+ private Class<?> resolveType() {
+ final Class<?> declaringClass = getTarget().getDeclaringExecutable().getDeclaringClass();
+
+ Type t = getTarget().getParameterizedType();
+
+ int arrayDepth = 0;
+ while (t instanceof GenericArrayType) {
+ arrayDepth++;
+ t = ((GenericArrayType) t).getGenericComponentType();
+ }
+
+ Class<?> result = null;
+
+ while (result == null) {
+ result = TypeUtils.getRawType(t, declaringClass);
+ if (result != null) {
+ break;
+ }
+ if (t instanceof TypeVariable<?>) {
+ final TypeVariable<?> tv = (TypeVariable<?>) t;
+ t = tv.getBounds()[0];
+ }
+ }
+ return arrayDepth > 0 ? Array.newInstance(result, new int[arrayDepth]).getClass() : result;
+ }
+}
Added: tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/PropertyD.java
URL: http://svn.apache.org/viewvc/tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/PropertyD.java?rev=1843674&view=auto
==============================================================================
--- tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/PropertyD.java (added)
+++ tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/PropertyD.java Fri Oct 12 15:00:48 2018
@@ -0,0 +1,112 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.apache.bval.jsr.descriptor;
+
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.stream.Stream;
+
+import javax.validation.ValidationException;
+import javax.validation.metadata.PropertyDescriptor;
+
+import org.apache.bval.jsr.GraphContext;
+import org.apache.bval.jsr.util.Methods;
+import org.apache.bval.jsr.util.PathImpl;
+import org.apache.bval.util.Validate;
+import org.apache.bval.util.reflection.Reflection;
+import org.apache.commons.weaver.privilizer.Privilizing;
+import org.apache.commons.weaver.privilizer.Privilizing.CallTo;
+
+@Privilizing(@CallTo(Reflection.class))
+public abstract class PropertyD<E extends AnnotatedElement> extends CascadableContainerD<BeanD<?>, E>
+ implements PropertyDescriptor {
+
+ static class ForField extends PropertyD<Field> {
+
+ ForField(MetadataReader.ForContainer<Field> reader, BeanD<?> parent) {
+ super(reader, parent);
+ }
+
+ @Override
+ public String getPropertyName() {
+ return getTarget().getName();
+ }
+
+ @Override
+ public Object getValue(Object parent) throws Exception {
+ final boolean mustUnset = Reflection.setAccessible(getTarget(), true);
+ try {
+ return getTarget().get(parent);
+ } catch (IllegalAccessException e) {
+ throw new IllegalArgumentException(e);
+ } finally {
+ if (mustUnset) {
+ Reflection.setAccessible(getTarget(), false);
+ }
+ }
+ }
+ }
+
+ static class ForMethod extends PropertyD<Method> {
+
+ ForMethod(MetadataReader.ForContainer<Method> reader, BeanD<?> parent) {
+ super(reader, parent);
+ }
+
+ @Override
+ public String getPropertyName() {
+ return Methods.propertyName(getTarget());
+ }
+
+ @Override
+ public Object getValue(Object parent) throws Exception {
+ final boolean mustUnset = Reflection.setAccessible(getTarget(), true);
+ try {
+ return getTarget().invoke(parent);
+ } catch (IllegalAccessException | InvocationTargetException e) {
+ throw new IllegalArgumentException(e);
+ } finally {
+ if (mustUnset) {
+ Reflection.setAccessible(getTarget(), false);
+ }
+ }
+ }
+ }
+
+ protected PropertyD(MetadataReader.ForContainer<E> reader, BeanD<?> parent) {
+ super(reader, parent);
+ }
+
+ public final Stream<GraphContext> read(GraphContext context) {
+ Validate.notNull(context);
+ if (context.getValue() == null) {
+ return Stream.empty();
+ }
+ try {
+ final Object value = getValue(context.getValue());
+ final PathImpl p = context.getPath();
+ p.addProperty(getPropertyName());
+ return Stream.of(context.child(p, value));
+ } catch (Exception e) {
+ throw e instanceof ValidationException ? (ValidationException) e : new ValidationException(e);
+ }
+ }
+
+ public abstract Object getValue(Object parent) throws Exception;
+}