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;
+}


Reply via email to