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 [16/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/...
Added: tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/util/reflection/TypeUtils.java
URL: http://svn.apache.org/viewvc/tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/util/reflection/TypeUtils.java?rev=1843674&view=auto
==============================================================================
--- tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/util/reflection/TypeUtils.java (added)
+++ tomee/deps/branches/bval-2/bval-jsr/src/main/java/org/apache/bval/util/reflection/TypeUtils.java Fri Oct 12 15:00:48 2018
@@ -0,0 +1,1557 @@
+/*
+ * 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.util.reflection;
+
+import java.lang.reflect.Array;
+import java.lang.reflect.GenericArrayType;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.lang.reflect.WildcardType;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Stream;
+
+import org.apache.bval.util.ObjectUtils;
+import org.apache.bval.util.Validate;
+
+/**
+ * Taken from commons-lang3.
+ *
+ * <p> Utility methods focusing on type inspection, particularly with regard to
+ * generics. </p>
+ *
+ * @since 1.1.2
+ */
+public class TypeUtils {
+
+ /**
+ * {@link WildcardType} builder.
+ */
+ public static class WildcardTypeBuilder {
+ /**
+ * Constructor
+ */
+ private WildcardTypeBuilder() {
+ }
+
+ private Type[] upperBounds;
+ private Type[] lowerBounds;
+
+ /**
+ * Specify upper bounds of the wildcard type to build.
+ * @param bounds to set
+ * @return {@code this}
+ */
+ public WildcardTypeBuilder withUpperBounds(final Type... bounds) {
+ this.upperBounds = bounds;
+ return this;
+ }
+
+ /**
+ * Specify lower bounds of the wildcard type to build.
+ * @param bounds to set
+ * @return {@code this}
+ */
+ public WildcardTypeBuilder withLowerBounds(final Type... bounds) {
+ this.lowerBounds = bounds;
+ return this;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public WildcardType build() {
+ return new WildcardTypeImpl(upperBounds, lowerBounds);
+ }
+ }
+
+ /**
+ * ParameterizedType implementation class.
+ */
+ private static final class ParameterizedTypeImpl implements ParameterizedType {
+ private final Class<?> raw;
+ private final Type useOwner;
+ private final Type[] typeArguments;
+
+ /**
+ * Constructor
+ * @param raw type
+ * @param useOwner owner type to use, if any
+ * @param typeArguments formal type arguments
+ */
+ private ParameterizedTypeImpl(final Class<?> raw, final Type useOwner, final Type[] typeArguments) {
+ this.raw = raw;
+ this.useOwner = useOwner;
+ this.typeArguments = typeArguments.clone();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public Type getRawType() {
+ return raw;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public Type getOwnerType() {
+ return useOwner;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public Type[] getActualTypeArguments() {
+ return typeArguments.clone();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public String toString() {
+ return TypeUtils.toString(this);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean equals(final Object obj) {
+ return obj == this || obj instanceof ParameterizedType && TypeUtils.equals(this, ((ParameterizedType) obj));
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public int hashCode() {
+ return Objects.hash(raw, useOwner, typeArguments);
+ }
+ }
+
+ /**
+ * WildcardType implementation class.
+ */
+ private static final class WildcardTypeImpl implements WildcardType {
+ private static final Type[] EMPTY_UPPER_BOUNDS = { Object.class };
+ private static final Type[] EMPTY_LOWER_BOUNDS = new Type[0];
+
+ private final Type[] upperBounds;
+ private final Type[] lowerBounds;
+
+ /**
+ * Constructor
+ * @param upperBounds of this type
+ * @param lowerBounds of this type
+ */
+ private WildcardTypeImpl(final Type[] upperBounds, final Type[] lowerBounds) {
+ this.upperBounds = ObjectUtils.isEmptyArray(upperBounds) ? EMPTY_UPPER_BOUNDS : upperBounds;
+ this.lowerBounds = lowerBounds == null ? EMPTY_LOWER_BOUNDS : lowerBounds;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public Type[] getUpperBounds() {
+ return upperBounds.clone();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public Type[] getLowerBounds() {
+ return lowerBounds.clone();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public String toString() {
+ return TypeUtils.toString(this);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean equals(final Object obj) {
+ return obj == this || obj instanceof WildcardType && TypeUtils.equals(this, (WildcardType) obj);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public int hashCode() {
+ return Objects.hash(upperBounds, lowerBounds);
+ }
+ }
+
+ /**
+ * <p>{@code TypeUtils} instances should NOT be constructed in standard
+ * programming. Instead, the class should be used as
+ * {@code TypeUtils.isAssignable(cls, toClass)}.</p> <p>This
+ * constructor is public to permit tools that require a JavaBean instance to
+ * operate.</p>
+ */
+ private TypeUtils() {
+ }
+
+ /**
+ * <p>Checks if the subject type may be implicitly cast to the target type
+ * following the Java generics rules. If both types are {@link Class}
+ * objects, the method returns the result of
+ * {@link Class#isAssignableFrom(Class)}.</p>
+ *
+ * @param type the subject type to be assigned to the target type
+ * @param toType the target type
+ * @return {@code true} if {@code type} is assignable to {@code toType}.
+ */
+ public static boolean isAssignable(final Type type, final Type toType) {
+ return isAssignable(type, toType, null);
+ }
+
+ /**
+ * <p>Checks if the subject type may be implicitly cast to the target type
+ * following the Java generics rules.</p>
+ *
+ * @param type the subject type to be assigned to the target type
+ * @param toType the target type
+ * @param typeVarAssigns optional map of type variable assignments
+ * @return {@code true} if {@code type} is assignable to {@code toType}.
+ */
+ private static boolean isAssignable(final Type type, final Type toType,
+ final Map<TypeVariable<?>, Type> typeVarAssigns) {
+ if (toType == null || toType instanceof Class<?>) {
+ return isAssignable(type, (Class<?>) toType);
+ }
+
+ if (toType instanceof ParameterizedType) {
+ return isAssignable(type, (ParameterizedType) toType, typeVarAssigns);
+ }
+
+ if (toType instanceof GenericArrayType) {
+ return isAssignable(type, (GenericArrayType) toType, typeVarAssigns);
+ }
+
+ if (toType instanceof WildcardType) {
+ return isAssignable(type, (WildcardType) toType, typeVarAssigns);
+ }
+
+ if (toType instanceof TypeVariable<?>) {
+ return isAssignable(type, (TypeVariable<?>) toType, typeVarAssigns);
+ }
+
+ throw new IllegalStateException("found an unhandled type: " + toType);
+ }
+
+ /**
+ * <p>Checks if the subject type may be implicitly cast to the target class
+ * following the Java generics rules.</p>
+ *
+ * @param type the subject type to be assigned to the target type
+ * @param toClass the target class
+ * @return {@code true} if {@code type} is assignable to {@code toClass}.
+ */
+ private static boolean isAssignable(final Type type, final Class<?> toClass) {
+ if (type == null) {
+ // consistency with ClassUtils.isAssignable() behavior
+ return toClass == null || !toClass.isPrimitive();
+ }
+
+ // only a null type can be assigned to null type which
+ // would have cause the previous to return true
+ if (toClass == null) {
+ return false;
+ }
+
+ // all types are assignable to themselves
+ if (toClass.equals(type)) {
+ return true;
+ }
+
+ if (type instanceof Class<?>) {
+ // just comparing two classes
+ // also take primitives into account!
+ return isAssignable((Class<?>) type, toClass);
+ }
+
+ if (type instanceof ParameterizedType) {
+ // only have to compare the raw type to the class
+ return isAssignable(getRawType((ParameterizedType) type), toClass);
+ }
+
+ // *
+ if (type instanceof TypeVariable<?>) {
+ // if any of the bounds are assignable to the class, then the
+ // type is assignable to the class.
+ return Stream.of(((TypeVariable<?>) type).getBounds()).anyMatch(bound -> isAssignable(bound, toClass));
+ }
+
+ // the only classes to which a generic array type can be assigned
+ // are class Object and array classes
+ if (type instanceof GenericArrayType) {
+ return Object.class.equals(toClass)
+ || toClass.isArray()
+ && isAssignable(((GenericArrayType) type).getGenericComponentType(), toClass
+ .getComponentType());
+ }
+
+ // wildcard types are not assignable to a class (though one would think
+ // "? super Object" would be assignable to Object)
+ if (type instanceof WildcardType) {
+ return false;
+ }
+
+ throw new IllegalStateException("found an unhandled type: " + type);
+ }
+
+ private static boolean isAssignable(Class<?> cls, final Class<?> toClass) {
+ if (toClass == null) {
+ return false;
+ }
+ // have to check for null, as isAssignableFrom doesn't
+ if (cls == null) {
+ return !toClass.isPrimitive();
+ }
+
+ if (cls.isPrimitive() && !toClass.isPrimitive()) {
+ cls = Reflection.primitiveToWrapper(cls);
+ if (cls == null) {
+ return false;
+ }
+ }
+ if (toClass.isPrimitive() && !cls.isPrimitive()) {
+ cls = Reflection.wrapperToPrimitive(cls);
+ if (cls == null) {
+ return false;
+ }
+ }
+ if (cls.equals(toClass)) {
+ return true;
+ }
+ if (cls.isPrimitive()) {
+ if (toClass.isPrimitive() == false) {
+ return false;
+ }
+ if (Integer.TYPE.equals(cls)) {
+ return Long.TYPE.equals(toClass)
+ || Float.TYPE.equals(toClass)
+ || Double.TYPE.equals(toClass);
+ }
+ if (Long.TYPE.equals(cls)) {
+ return Float.TYPE.equals(toClass)
+ || Double.TYPE.equals(toClass);
+ }
+ if (Boolean.TYPE.equals(cls)) {
+ return false;
+ }
+ if (Double.TYPE.equals(cls)) {
+ return false;
+ }
+ if (Float.TYPE.equals(cls)) {
+ return Double.TYPE.equals(toClass);
+ }
+ if (Character.TYPE.equals(cls)) {
+ return Integer.TYPE.equals(toClass)
+ || Long.TYPE.equals(toClass)
+ || Float.TYPE.equals(toClass)
+ || Double.TYPE.equals(toClass);
+ }
+ if (Short.TYPE.equals(cls)) {
+ return Integer.TYPE.equals(toClass)
+ || Long.TYPE.equals(toClass)
+ || Float.TYPE.equals(toClass)
+ || Double.TYPE.equals(toClass);
+ }
+ if (Byte.TYPE.equals(cls)) {
+ return Short.TYPE.equals(toClass)
+ || Integer.TYPE.equals(toClass)
+ || Long.TYPE.equals(toClass)
+ || Float.TYPE.equals(toClass)
+ || Double.TYPE.equals(toClass);
+ }
+ // should never get here
+ return false;
+ }
+ return toClass.isAssignableFrom(cls);
+
+ }
+
+ /**
+ * <p>Checks if the subject type may be implicitly cast to the target
+ * parameterized type following the Java generics rules.</p>
+ *
+ * @param type the subject type to be assigned to the target type
+ * @param toParameterizedType the target parameterized type
+ * @param typeVarAssigns a map with type variables
+ * @return {@code true} if {@code type} is assignable to {@code toType}.
+ */
+ private static boolean isAssignable(final Type type, final ParameterizedType toParameterizedType,
+ final Map<TypeVariable<?>, Type> typeVarAssigns) {
+ if (type == null) {
+ return true;
+ }
+
+ // only a null type can be assigned to null type which
+ // would have cause the previous to return true
+ if (toParameterizedType == null) {
+ return false;
+ }
+
+ // all types are assignable to themselves
+ if (toParameterizedType.equals(type)) {
+ return true;
+ }
+
+ // get the target type's raw type
+ final Class<?> toClass = getRawType(toParameterizedType);
+ // get the subject type's type arguments including owner type arguments
+ // and supertype arguments up to and including the target class.
+ final Map<TypeVariable<?>, Type> fromTypeVarAssigns = getTypeArguments(type, toClass, null);
+
+ // null means the two types are not compatible
+ if (fromTypeVarAssigns == null) {
+ return false;
+ }
+
+ // compatible types, but there's no type arguments. this is equivalent
+ // to comparing Map< ?, ? > to Map, and raw types are always assignable
+ // to parameterized types.
+ if (fromTypeVarAssigns.isEmpty()) {
+ return true;
+ }
+
+ // get the target type's type arguments including owner type arguments
+ final Map<TypeVariable<?>, Type> toTypeVarAssigns = getTypeArguments(toParameterizedType,
+ toClass, typeVarAssigns);
+
+ // now to check each type argument
+ for (final TypeVariable<?> var : toTypeVarAssigns.keySet()) {
+ final Type toTypeArg = unrollVariableAssignments(var, toTypeVarAssigns);
+ final Type fromTypeArg = unrollVariableAssignments(var, fromTypeVarAssigns);
+
+ if (toTypeArg == null && fromTypeArg instanceof Class) {
+ continue;
+ }
+
+ // parameters must either be absent from the subject type, within
+ // the bounds of the wildcard type, or be an exact match to the
+ // parameters of the target type.
+ if (fromTypeArg != null
+ && !toTypeArg.equals(fromTypeArg)
+ && !(toTypeArg instanceof WildcardType && isAssignable(fromTypeArg, toTypeArg,
+ typeVarAssigns))) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Look up {@code var} in {@code typeVarAssigns} <em>transitively</em>,
+ * i.e. keep looking until the value found is <em>not</em> a type variable.
+ * @param var the type variable to look up
+ * @param typeVarAssigns the map used for the look up
+ * @return Type or {@code null} if some variable was not in the map
+ */
+ private static Type unrollVariableAssignments(TypeVariable<?> var, final Map<TypeVariable<?>, Type> typeVarAssigns) {
+ Type result;
+ do {
+ result = typeVarAssigns.get(var);
+ if (result instanceof TypeVariable<?> && !result.equals(var)) {
+ var = (TypeVariable<?>) result;
+ continue;
+ }
+ break;
+ } while (true);
+ return result;
+ }
+
+ /**
+ * <p>Checks if the subject type may be implicitly cast to the target
+ * generic array type following the Java generics rules.</p>
+ *
+ * @param type the subject type to be assigned to the target type
+ * @param toGenericArrayType the target generic array type
+ * @param typeVarAssigns a map with type variables
+ * @return {@code true} if {@code type} is assignable to
+ * {@code toGenericArrayType}.
+ */
+ private static boolean isAssignable(final Type type, final GenericArrayType toGenericArrayType,
+ final Map<TypeVariable<?>, Type> typeVarAssigns) {
+ if (type == null) {
+ return true;
+ }
+
+ // only a null type can be assigned to null type which
+ // would have cause the previous to return true
+ if (toGenericArrayType == null) {
+ return false;
+ }
+
+ // all types are assignable to themselves
+ if (toGenericArrayType.equals(type)) {
+ return true;
+ }
+
+ final Type toComponentType = toGenericArrayType.getGenericComponentType();
+
+ if (type instanceof Class<?>) {
+ final Class<?> cls = (Class<?>) type;
+
+ // compare the component types
+ return cls.isArray()
+ && isAssignable(cls.getComponentType(), toComponentType, typeVarAssigns);
+ }
+
+ if (type instanceof GenericArrayType) {
+ // compare the component types
+ return isAssignable(((GenericArrayType) type).getGenericComponentType(),
+ toComponentType, typeVarAssigns);
+ }
+
+ if (type instanceof WildcardType) {
+ // so long as one of the upper bounds is assignable, it's good
+ return Stream.of(getImplicitUpperBounds((WildcardType) type))
+ .anyMatch(bound -> isAssignable(bound, toGenericArrayType));
+ }
+
+ if (type instanceof TypeVariable<?>) {
+ // probably should remove the following logic and just return false.
+ // type variables cannot specify arrays as bounds.
+ return Stream.of(getImplicitBounds((TypeVariable<?>) type))
+ .anyMatch(bound -> isAssignable(bound, toGenericArrayType));
+ }
+
+ if (type instanceof ParameterizedType) {
+ // the raw type of a parameterized type is never an array or
+ // generic array, otherwise the declaration would look like this:
+ // Collection[]< ? extends String > collection;
+ return false;
+ }
+
+ throw new IllegalStateException("found an unhandled type: " + type);
+ }
+
+ /**
+ * <p>Checks if the subject type may be implicitly cast to the target
+ * wildcard type following the Java generics rules.</p>
+ *
+ * @param type the subject type to be assigned to the target type
+ * @param toWildcardType the target wildcard type
+ * @param typeVarAssigns a map with type variables
+ * @return {@code true} if {@code type} is assignable to
+ * {@code toWildcardType}.
+ */
+ private static boolean isAssignable(final Type type, final WildcardType toWildcardType,
+ final Map<TypeVariable<?>, Type> typeVarAssigns) {
+ if (type == null) {
+ return true;
+ }
+
+ // only a null type can be assigned to null type which
+ // would have cause the previous to return true
+ if (toWildcardType == null) {
+ return false;
+ }
+
+ // all types are assignable to themselves
+ if (toWildcardType.equals(type)) {
+ return true;
+ }
+
+ final Type[] toUpperBounds = getImplicitUpperBounds(toWildcardType);
+ final Type[] toLowerBounds = getImplicitLowerBounds(toWildcardType);
+
+ if (type instanceof WildcardType) {
+ final WildcardType wildcardType = (WildcardType) type;
+ final Type[] upperBounds = getImplicitUpperBounds(wildcardType);
+ final Type[] lowerBounds = getImplicitLowerBounds(wildcardType);
+
+ for (Type toBound : toUpperBounds) {
+ // if there are assignments for unresolved type variables,
+ // now's the time to substitute them.
+ toBound = substituteTypeVariables(toBound, typeVarAssigns);
+
+ // each upper bound of the subject type has to be assignable to
+ // each
+ // upper bound of the target type
+ for (final Type bound : upperBounds) {
+ if (!isAssignable(bound, toBound, typeVarAssigns)) {
+ return false;
+ }
+ }
+ }
+
+ for (Type toBound : toLowerBounds) {
+ // if there are assignments for unresolved type variables,
+ // now's the time to substitute them.
+ toBound = substituteTypeVariables(toBound, typeVarAssigns);
+
+ // each lower bound of the target type has to be assignable to
+ // each
+ // lower bound of the subject type
+ for (final Type bound : lowerBounds) {
+ if (!isAssignable(toBound, bound, typeVarAssigns)) {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+
+ for (final Type toBound : toUpperBounds) {
+ // if there are assignments for unresolved type variables,
+ // now's the time to substitute them.
+ if (!isAssignable(type, substituteTypeVariables(toBound, typeVarAssigns),
+ typeVarAssigns)) {
+ return false;
+ }
+ }
+
+ for (final Type toBound : toLowerBounds) {
+ // if there are assignments for unresolved type variables,
+ // now's the time to substitute them.
+ if (!isAssignable(substituteTypeVariables(toBound, typeVarAssigns), type,
+ typeVarAssigns)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * <p>Checks if the subject type may be implicitly cast to the target type
+ * variable following the Java generics rules.</p>
+ *
+ * @param type the subject type to be assigned to the target type
+ * @param toTypeVariable the target type variable
+ * @param typeVarAssigns a map with type variables
+ * @return {@code true} if {@code type} is assignable to
+ * {@code toTypeVariable}.
+ */
+ private static boolean isAssignable(final Type type, final TypeVariable<?> toTypeVariable,
+ final Map<TypeVariable<?>, Type> typeVarAssigns) {
+ if (type == null) {
+ return true;
+ }
+
+ // only a null type can be assigned to null type which
+ // would have cause the previous to return true
+ if (toTypeVariable == null) {
+ return false;
+ }
+
+ // all types are assignable to themselves
+ if (toTypeVariable.equals(type)) {
+ return true;
+ }
+
+ if (type instanceof TypeVariable<?>) {
+ // a type variable is assignable to another type variable, if
+ // and only if the former is the latter, extends the latter, or
+ // is otherwise a descendant of the latter.
+ final Type[] bounds = getImplicitBounds((TypeVariable<?>) type);
+
+ for (final Type bound : bounds) {
+ if (isAssignable(bound, toTypeVariable, typeVarAssigns)) {
+ return true;
+ }
+ }
+ }
+
+ if (type instanceof Class<?> || type instanceof ParameterizedType
+ || type instanceof GenericArrayType || type instanceof WildcardType) {
+ return false;
+ }
+
+ throw new IllegalStateException("found an unhandled type: " + type);
+ }
+
+ /**
+ * <p>Find the mapping for {@code type} in {@code typeVarAssigns}.</p>
+ *
+ * @param type the type to be replaced
+ * @param typeVarAssigns the map with type variables
+ * @return the replaced type
+ * @throws IllegalArgumentException if the type cannot be substituted
+ */
+ private static Type substituteTypeVariables(final Type type, final Map<TypeVariable<?>, Type> typeVarAssigns) {
+ if (type instanceof TypeVariable<?> && typeVarAssigns != null) {
+ final Type replacementType = typeVarAssigns.get(type);
+
+ if (replacementType == null) {
+ throw new IllegalArgumentException("missing assignment type for type variable "
+ + type);
+ }
+ return replacementType;
+ }
+ return type;
+ }
+
+ /**
+ * <p>Retrieves all the type arguments for this parameterized type
+ * including owner hierarchy arguments such as
+ * {@code Outer<K,V>.Inner<T>.DeepInner<E>} .
+ * The arguments are returned in a
+ * {@link Map} specifying the argument type for each {@link TypeVariable}.
+ * </p>
+ *
+ * @param type specifies the subject parameterized type from which to
+ * harvest the parameters.
+ * @return a {@code Map} of the type arguments to their respective type
+ * variables.
+ */
+ public static Map<TypeVariable<?>, Type> getTypeArguments(final ParameterizedType type) {
+ return getTypeArguments(type, getRawType(type), null);
+ }
+
+ /**
+ * <p>Gets the type arguments of a class/interface based on a subtype. For
+ * instance, this method will determine that both of the parameters for the
+ * interface {@link Map} are {@link Object} for the subtype
+ * {@link java.util.Properties Properties} even though the subtype does not
+ * directly implement the {@code Map} interface.</p>
+ * <p>This method returns {@code null} if {@code type} is not assignable to
+ * {@code toClass}. It returns an empty map if none of the classes or
+ * interfaces in its inheritance hierarchy specify any type arguments.</p>
+ * <p>A side effect of this method is that it also retrieves the type
+ * arguments for the classes and interfaces that are part of the hierarchy
+ * between {@code type} and {@code toClass}. So with the above
+ * example, this method will also determine that the type arguments for
+ * {@link java.util.Hashtable Hashtable} are also both {@code Object}.
+ * In cases where the interface specified by {@code toClass} is
+ * (indirectly) implemented more than once (e.g. where {@code toClass}
+ * specifies the interface {@link Iterable Iterable} and
+ * {@code type} specifies a parameterized type that implements both
+ * {@link Set Set} and {@link java.util.Collection Collection}),
+ * this method will look at the inheritance hierarchy of only one of the
+ * implementations/subclasses; the first interface encountered that isn't a
+ * subinterface to one of the others in the {@code type} to
+ * {@code toClass} hierarchy.</p>
+ *
+ * @param type the type from which to determine the type parameters of
+ * {@code toClass}
+ * @param toClass the class whose type parameters are to be determined based
+ * on the subtype {@code type}
+ * @return a {@code Map} of the type assignments for the type variables in
+ * each type in the inheritance hierarchy from {@code type} to
+ * {@code toClass} inclusive.
+ */
+ public static Map<TypeVariable<?>, Type> getTypeArguments(final Type type, final Class<?> toClass) {
+ return getTypeArguments(type, toClass, null);
+ }
+
+ /**
+ * <p>Return a map of the type arguments of @{code type} in the context of {@code toClass}.</p>
+ *
+ * @param type the type in question
+ * @param toClass the class
+ * @param subtypeVarAssigns a map with type variables
+ * @return the {@code Map} with type arguments
+ */
+ private static Map<TypeVariable<?>, Type> getTypeArguments(final Type type, final Class<?> toClass,
+ final Map<TypeVariable<?>, Type> subtypeVarAssigns) {
+ if (type instanceof Class<?>) {
+ return getTypeArguments((Class<?>) type, toClass, subtypeVarAssigns);
+ }
+
+ if (type instanceof ParameterizedType) {
+ return getTypeArguments((ParameterizedType) type, toClass, subtypeVarAssigns);
+ }
+
+ if (type instanceof GenericArrayType) {
+ return getTypeArguments(((GenericArrayType) type).getGenericComponentType(), toClass
+ .isArray() ? toClass.getComponentType() : toClass, subtypeVarAssigns);
+ }
+
+ // since wildcard types are not assignable to classes, should this just
+ // return null?
+ if (type instanceof WildcardType) {
+ for (final Type bound : getImplicitUpperBounds((WildcardType) type)) {
+ // find the first bound that is assignable to the target class
+ if (isAssignable(bound, toClass)) {
+ return getTypeArguments(bound, toClass, subtypeVarAssigns);
+ }
+ }
+
+ return null;
+ }
+
+ if (type instanceof TypeVariable<?>) {
+ for (final Type bound : getImplicitBounds((TypeVariable<?>) type)) {
+ // find the first bound that is assignable to the target class
+ if (isAssignable(bound, toClass)) {
+ return getTypeArguments(bound, toClass, subtypeVarAssigns);
+ }
+ }
+
+ return null;
+ }
+ throw new IllegalStateException("found an unhandled type: " + type);
+ }
+
+ /**
+ * <p>Return a map of the type arguments of a parameterized type in the context of {@code toClass}.</p>
+ *
+ * @param parameterizedType the parameterized type
+ * @param toClass the class
+ * @param subtypeVarAssigns a map with type variables
+ * @return the {@code Map} with type arguments
+ */
+ private static Map<TypeVariable<?>, Type> getTypeArguments(
+ final ParameterizedType parameterizedType, final Class<?> toClass,
+ final Map<TypeVariable<?>, Type> subtypeVarAssigns) {
+ final Class<?> cls = getRawType(parameterizedType);
+
+ // make sure they're assignable
+ if (!isAssignable(cls, toClass)) {
+ return null;
+ }
+
+ final Type ownerType = parameterizedType.getOwnerType();
+ Map<TypeVariable<?>, Type> typeVarAssigns;
+
+ if (ownerType instanceof ParameterizedType) {
+ // get the owner type arguments first
+ final ParameterizedType parameterizedOwnerType = (ParameterizedType) ownerType;
+ typeVarAssigns = getTypeArguments(parameterizedOwnerType,
+ getRawType(parameterizedOwnerType), subtypeVarAssigns);
+ } else {
+ // no owner, prep the type variable assignments map
+ typeVarAssigns = subtypeVarAssigns == null ? new HashMap<>() : new HashMap<>(subtypeVarAssigns);
+ }
+
+ // get the subject parameterized type's arguments
+ final Type[] typeArgs = parameterizedType.getActualTypeArguments();
+ // and get the corresponding type variables from the raw class
+ final TypeVariable<?>[] typeParams = cls.getTypeParameters();
+
+ // map the arguments to their respective type variables
+ for (int i = 0; i < typeParams.length; i++) {
+ final Type typeArg = typeArgs[i];
+ typeVarAssigns.put(typeParams[i], typeVarAssigns.containsKey(typeArg) ? typeVarAssigns
+ .get(typeArg) : typeArg);
+ }
+
+ if (toClass.equals(cls)) {
+ // target class has been reached. Done.
+ return typeVarAssigns;
+ }
+
+ // walk the inheritance hierarchy until the target class is reached
+ return getTypeArguments(getClosestParentType(cls, toClass), toClass, typeVarAssigns);
+ }
+
+ /**
+ * <p>Return a map of the type arguments of a class in the context of @{code toClass}.</p>
+ *
+ * @param cls the class in question
+ * @param toClass the context class
+ * @param subtypeVarAssigns a map with type variables
+ * @return the {@code Map} with type arguments
+ */
+ private static Map<TypeVariable<?>, Type> getTypeArguments(Class<?> cls, final Class<?> toClass,
+ final Map<TypeVariable<?>, Type> subtypeVarAssigns) {
+ // make sure they're assignable
+ if (!isAssignable(cls, toClass)) {
+ return null;
+ }
+
+ // can't work with primitives
+ if (cls.isPrimitive()) {
+ // both classes are primitives?
+ if (toClass.isPrimitive()) {
+ // dealing with widening here. No type arguments to be
+ // harvested with these two types.
+ return new HashMap<>();
+ }
+
+ // work with wrapper the wrapper class instead of the primitive
+ cls = Reflection.primitiveToWrapper(cls);
+ }
+
+ // create a copy of the incoming map, or an empty one if it's null
+ final Map<TypeVariable<?>, Type> typeVarAssigns =
+ subtypeVarAssigns == null ? new HashMap<>() : new HashMap<>(subtypeVarAssigns);
+
+ // has target class been reached?
+ if (toClass.equals(cls)) {
+ return typeVarAssigns;
+ }
+
+ // walk the inheritance hierarchy until the target class is reached
+ return getTypeArguments(getClosestParentType(cls, toClass), toClass, typeVarAssigns);
+ }
+
+ /**
+ * <p>Get the closest parent type to the
+ * super class specified by {@code superClass}.</p>
+ *
+ * @param cls the class in question
+ * @param superClass the super class
+ * @return the closes parent type
+ */
+ private static Type getClosestParentType(final Class<?> cls, final Class<?> superClass) {
+ // only look at the interfaces if the super class is also an interface
+ if (superClass.isInterface()) {
+ // get the generic interfaces of the subject class
+ final Type[] interfaceTypes = cls.getGenericInterfaces();
+ // will hold the best generic interface match found
+ Type genericInterface = null;
+
+ // find the interface closest to the super class
+ for (final Type midType : interfaceTypes) {
+ Class<?> midClass = null;
+
+ if (midType instanceof ParameterizedType) {
+ midClass = getRawType((ParameterizedType) midType);
+ } else if (midType instanceof Class<?>) {
+ midClass = (Class<?>) midType;
+ } else {
+ throw new IllegalStateException("Unexpected generic"
+ + " interface type found: " + midType);
+ }
+
+ // check if this interface is further up the inheritance chain
+ // than the previously found match
+ if (isAssignable(midClass, superClass)
+ && isAssignable(genericInterface, (Type) midClass)) {
+ genericInterface = midType;
+ }
+ }
+
+ // found a match?
+ if (genericInterface != null) {
+ return genericInterface;
+ }
+ }
+
+ // none of the interfaces were descendants of the target class, so the
+ // super class has to be one, instead
+ return cls.getGenericSuperclass();
+ }
+
+ /**
+ * <p>Checks if the given value can be assigned to the target type
+ * following the Java generics rules.</p>
+ *
+ * @param value the value to be checked
+ * @param type the target type
+ * @return {@code true} if {@code value} is an instance of {@code type}.
+ */
+ public static boolean isInstance(final Object value, final Type type) {
+ if (type == null) {
+ return false;
+ }
+
+ return value == null ? !(type instanceof Class<?>) || type == void.class || !((Class<?>) type).isPrimitive()
+ : isAssignable(value.getClass(), type, null);
+ }
+
+ /**
+ * <p>This method strips out the redundant upper bound types in type
+ * variable types and wildcard types (or it would with wildcard types if
+ * multiple upper bounds were allowed).</p> <p>Example, with the variable
+ * type declaration:
+ *
+ * <pre><K extends java.util.Collection<String> &
+ * java.util.List<String>></pre>
+ *
+ * <p>
+ * since {@code List} is a subinterface of {@code Collection},
+ * this method will return the bounds as if the declaration had been:
+ * </p>
+ *
+ * <pre><K extends java.util.List<String>></pre>
+ *
+ * @param bounds an array of types representing the upper bounds of either
+ * {@link WildcardType} or {@link TypeVariable}, not {@code null}.
+ * @return an array containing the values from {@code bounds} minus the
+ * redundant types.
+ */
+ public static Type[] normalizeUpperBounds(final Type[] bounds) {
+ Validate.notNull(bounds, "null value specified for bounds array");
+ // don't bother if there's only one (or none) type
+ if (bounds.length < 2) {
+ return bounds;
+ }
+
+ final Set<Type> types = new HashSet<>(bounds.length);
+
+ for (final Type type1 : bounds) {
+ boolean subtypeFound = false;
+
+ for (final Type type2 : bounds) {
+ if (type1 != type2 && isAssignable(type2, type1, null)) {
+ subtypeFound = true;
+ break;
+ }
+ }
+
+ if (!subtypeFound) {
+ types.add(type1);
+ }
+ }
+
+ return types.toArray(new Type[types.size()]);
+ }
+
+ /**
+ * <p>Returns an array containing the sole type of {@link Object} if
+ * {@link TypeVariable#getBounds()} returns an empty array. Otherwise, it
+ * returns the result of {@link TypeVariable#getBounds()} passed into
+ * {@link #normalizeUpperBounds}.</p>
+ *
+ * @param typeVariable the subject type variable, not {@code null}
+ * @return a non-empty array containing the bounds of the type variable.
+ */
+ public static Type[] getImplicitBounds(final TypeVariable<?> typeVariable) {
+ Validate.notNull(typeVariable, "typeVariable is null");
+ final Type[] bounds = typeVariable.getBounds();
+
+ return bounds.length == 0 ? new Type[] { Object.class } : normalizeUpperBounds(bounds);
+ }
+
+ /**
+ * <p>Returns an array containing the sole value of {@link Object} if
+ * {@link WildcardType#getUpperBounds()} returns an empty array. Otherwise,
+ * it returns the result of {@link WildcardType#getUpperBounds()}
+ * passed into {@link #normalizeUpperBounds}.</p>
+ *
+ * @param wildcardType the subject wildcard type, not {@code null}
+ * @return a non-empty array containing the upper bounds of the wildcard
+ * type.
+ */
+ public static Type[] getImplicitUpperBounds(final WildcardType wildcardType) {
+ Validate.notNull(wildcardType, "wildcardType is null");
+ final Type[] bounds = wildcardType.getUpperBounds();
+
+ return bounds.length == 0 ? new Type[] { Object.class } : normalizeUpperBounds(bounds);
+ }
+
+ /**
+ * <p>Returns an array containing a single value of {@code null} if
+ * {@link WildcardType#getLowerBounds()} returns an empty array. Otherwise,
+ * it returns the result of {@link WildcardType#getLowerBounds()}.</p>
+ *
+ * @param wildcardType the subject wildcard type, not {@code null}
+ * @return a non-empty array containing the lower bounds of the wildcard
+ * type.
+ */
+ public static Type[] getImplicitLowerBounds(final WildcardType wildcardType) {
+ Validate.notNull(wildcardType, "wildcardType is null");
+ final Type[] bounds = wildcardType.getLowerBounds();
+
+ return bounds.length == 0 ? new Type[] { null } : bounds;
+ }
+
+ /**
+ * <p>Transforms the passed in type to a {@link Class} object. Type-checking method of convenience.</p>
+ *
+ * @param parameterizedType the type to be converted
+ * @return the corresponding {@code Class} object
+ * @throws IllegalStateException if the conversion fails
+ */
+ private static Class<?> getRawType(final ParameterizedType parameterizedType) {
+ final Type rawType = parameterizedType.getRawType();
+
+ // check if raw type is a Class object
+ // not currently necessary, but since the return type is Type instead of
+ // Class, there's enough reason to believe that future versions of Java
+ // may return other Type implementations. And type-safety checking is
+ // rarely a bad idea.
+ if (!(rawType instanceof Class<?>)) {
+ throw new IllegalStateException("Wait... What!? Type of rawType: " + rawType);
+ }
+
+ return (Class<?>) rawType;
+ }
+
+ /**
+ * <p>Get the raw type of a Java type, given its context. Primarily for use
+ * with {@link TypeVariable}s and {@link GenericArrayType}s, or when you do
+ * not know the runtime type of {@code type}: if you know you have a
+ * {@link Class} instance, it is already raw; if you know you have a
+ * {@link ParameterizedType}, its raw type is only a method call away.</p>
+ *
+ * @param type to resolve
+ * @param assigningType type to be resolved against
+ * @return the resolved {@link Class} object or {@code null} if
+ * the type could not be resolved
+ */
+ public static Class<?> getRawType(final Type type, final Type assigningType) {
+ if (type instanceof Class<?>) {
+ // it is raw, no problem
+ return (Class<?>) type;
+ }
+
+ if (type instanceof ParameterizedType) {
+ // simple enough to get the raw type of a ParameterizedType
+ return getRawType((ParameterizedType) type);
+ }
+
+ if (type instanceof TypeVariable<?>) {
+ if (assigningType == null) {
+ return null;
+ }
+
+ // get the entity declaring this type variable
+ final Object genericDeclaration = ((TypeVariable<?>) type).getGenericDeclaration();
+
+ // can't get the raw type of a method- or constructor-declared type
+ // variable
+ if (!(genericDeclaration instanceof Class<?>)) {
+ return null;
+ }
+
+ // get the type arguments for the declaring class/interface based
+ // on the enclosing type
+ final Map<TypeVariable<?>, Type> typeVarAssigns = getTypeArguments(assigningType,
+ (Class<?>) genericDeclaration);
+
+ // enclosingType has to be a subclass (or subinterface) of the
+ // declaring type
+ if (typeVarAssigns == null) {
+ return null;
+ }
+
+ // get the argument assigned to this type variable
+ final Type typeArgument = typeVarAssigns.get(type);
+
+ if (typeArgument == null) {
+ return null;
+ }
+
+ // get the argument for this type variable
+ return getRawType(typeArgument, assigningType);
+ }
+
+ if (type instanceof GenericArrayType) {
+ // get raw component type
+ final Class<?> rawComponentType = getRawType(((GenericArrayType) type)
+ .getGenericComponentType(), assigningType);
+
+ // create array type from raw component type and return its class
+ return Array.newInstance(rawComponentType, 0).getClass();
+ }
+
+ // (hand-waving) this is not the method you're looking for
+ if (type instanceof WildcardType) {
+ return null;
+ }
+
+ throw new IllegalArgumentException("unknown type: " + type);
+ }
+
+ /**
+ * Learn whether the specified type denotes an array type.
+ * @param type the type to be checked
+ * @return {@code true} if {@code type} is an array class or a {@link GenericArrayType}.
+ */
+ public static boolean isArrayType(final Type type) {
+ return type instanceof GenericArrayType || type instanceof Class<?> && ((Class<?>) type).isArray();
+ }
+
+ /**
+ * Get the array component type of {@code type}.
+ * @param type the type to be checked
+ * @return component type or null if type is not an array type
+ */
+ public static Type getArrayComponentType(final Type type) {
+ if (type instanceof Class<?>) {
+ final Class<?> clazz = (Class<?>) type;
+ return clazz.isArray() ? clazz.getComponentType() : null;
+ }
+ if (type instanceof GenericArrayType) {
+ return ((GenericArrayType) type).getGenericComponentType();
+ }
+ return null;
+ }
+
+ /**
+ * Get a type representing {@code type} with variable assignments "unrolled."
+ *
+ * @param typeArguments as from {@link TypeUtils#getTypeArguments(Type, Class)}
+ * @param type the type to unroll variable assignments for
+ * @return Type
+ */
+ public static Type unrollVariables(Map<TypeVariable<?>, Type> typeArguments, final Type type) {
+ if (typeArguments == null) {
+ typeArguments = Collections.<TypeVariable<?>, Type> emptyMap();
+ }
+ if (containsTypeVariables(type)) {
+ if (type instanceof TypeVariable<?>) {
+ return unrollVariables(typeArguments, typeArguments.get(type));
+ }
+ if (type instanceof ParameterizedType) {
+ final ParameterizedType p = (ParameterizedType) type;
+ final Map<TypeVariable<?>, Type> parameterizedTypeArguments;
+ if (p.getOwnerType() == null) {
+ parameterizedTypeArguments = typeArguments;
+ } else {
+ parameterizedTypeArguments = new HashMap<>(typeArguments);
+ parameterizedTypeArguments.putAll(TypeUtils.getTypeArguments(p));
+ }
+ final Type[] args = p.getActualTypeArguments();
+ for (int i = 0; i < args.length; i++) {
+ final Type unrolled = unrollVariables(parameterizedTypeArguments, args[i]);
+ if (unrolled != null) {
+ args[i] = unrolled;
+ }
+ }
+ return parameterizeWithOwner(p.getOwnerType(), (Class<?>) p.getRawType(), args);
+ }
+ if (type instanceof WildcardType) {
+ final WildcardType wild = (WildcardType) type;
+ return wildcardType().withUpperBounds(unrollBounds(typeArguments, wild.getUpperBounds()))
+ .withLowerBounds(unrollBounds(typeArguments, wild.getLowerBounds())).build();
+ }
+ }
+ return type;
+ }
+
+ /**
+ * Local helper method to unroll variables in a type bounds array.
+ *
+ * @param typeArguments assignments {@link Map}
+ * @param bounds in which to expand variables
+ * @return {@code bounds} with any variables reassigned
+ */
+ private static Type[] unrollBounds(final Map<TypeVariable<?>, Type> typeArguments, final Type[] bounds) {
+ Type[] result = bounds;
+ int i = 0;
+ for (; i < result.length; i++) {
+ final Type unrolled = unrollVariables(typeArguments, result[i]);
+ if (unrolled == null) {
+ List<Type> types = Arrays.asList(result);
+ types.remove(i--);
+ result = types.toArray(new Type[types.size()]);
+ } else {
+ result[i] = unrolled;
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Learn, recursively, whether any of the type parameters associated with {@code type} are bound to variables.
+ *
+ * @param type the type to check for type variables
+ * @return boolean
+ */
+ public static boolean containsTypeVariables(final Type type) {
+ if (type instanceof TypeVariable<?>) {
+ return true;
+ }
+ if (type instanceof Class<?>) {
+ return ((Class<?>) type).getTypeParameters().length > 0;
+ }
+ if (type instanceof ParameterizedType) {
+ for (final Type arg : ((ParameterizedType) type).getActualTypeArguments()) {
+ if (containsTypeVariables(arg)) {
+ return true;
+ }
+ }
+ return false;
+ }
+ if (type instanceof WildcardType) {
+ final WildcardType wild = (WildcardType) type;
+ return containsTypeVariables(TypeUtils.getImplicitLowerBounds(wild)[0])
+ || containsTypeVariables(TypeUtils.getImplicitUpperBounds(wild)[0]);
+ }
+ return false;
+ }
+
+
+ /**
+ * Create a parameterized type instance.
+ *
+ * @param owner the owning type
+ * @param raw the raw class to create a parameterized type instance for
+ * @param typeArguments the types used for parameterization
+ *
+ * @return {@link ParameterizedType}
+ */
+ public static final ParameterizedType parameterizeWithOwner(final Type owner, final Class<?> raw,
+ final Type... typeArguments) {
+ Validate.notNull(raw, "raw class is null");
+ final Type useOwner;
+ if (raw.getEnclosingClass() == null) {
+ Validate.isTrue(owner == null, "no owner allowed for top-level %s", raw);
+ useOwner = null;
+ } else if (owner == null) {
+ useOwner = raw.getEnclosingClass();
+ } else {
+ Validate.isTrue(TypeUtils.isAssignable(owner, raw.getEnclosingClass()),
+ "%s is invalid owner type for parameterized %s", owner, raw);
+ useOwner = owner;
+ }
+ Validate.isTrue(raw.getTypeParameters().length == typeArguments.length,
+ "invalid number of type parameters specified: expected %d, got %d", raw.getTypeParameters().length,
+ typeArguments.length);
+
+ return new ParameterizedTypeImpl(raw, useOwner, typeArguments);
+ }
+
+ /**
+ * Get a {@link WildcardTypeBuilder}.
+ * @return {@link WildcardTypeBuilder}
+ */
+ public static WildcardTypeBuilder wildcardType() {
+ return new WildcardTypeBuilder();
+ }
+
+ /**
+ * Check equality of types.
+ *
+ * @param t1 the first type
+ * @param t2 the second type
+ * @return boolean
+ */
+ public static boolean equals(final Type t1, final Type t2) {
+ if (t1 == t2) {
+ return true;
+ }
+ if (t1 == null || t2 == null) {
+ return false;
+ }
+
+ if (t1.equals(t2)) {
+ return true;
+ }
+ if (t1 instanceof ParameterizedType) {
+ return equals((ParameterizedType) t1, t2);
+ }
+ if (t1 instanceof GenericArrayType) {
+ return equals((GenericArrayType) t1, t2);
+ }
+ if (t1 instanceof WildcardType) {
+ return equals((WildcardType) t1, t2);
+ }
+ return false;
+ }
+
+ /**
+ * Learn whether {@code t} equals {@code p}.
+ * @param p LHS
+ * @param t RHS
+ * @return boolean
+ */
+ private static boolean equals(final ParameterizedType p, final Type t) {
+ if (t instanceof ParameterizedType) {
+ final ParameterizedType other = (ParameterizedType) t;
+ if (equals(p.getRawType(), other.getRawType()) && equals(p.getOwnerType(), other.getOwnerType())) {
+ return equals(p.getActualTypeArguments(), other.getActualTypeArguments());
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Learn whether {@code t} equals {@code a}.
+ * @param a LHS
+ * @param t RHS
+ * @return boolean
+ */
+ private static boolean equals(final GenericArrayType a, final Type t) {
+ return t instanceof GenericArrayType
+ && equals(a.getGenericComponentType(), ((GenericArrayType) t).getGenericComponentType());
+ }
+
+ /**
+ * Learn whether {@code t} equals {@code w}.
+ * @param w LHS
+ * @param t RHS
+ * @return boolean
+ */
+ private static boolean equals(final WildcardType w, final Type t) {
+ if (t instanceof WildcardType) {
+ final WildcardType other = (WildcardType) t;
+ return equals(getImplicitLowerBounds(w), getImplicitLowerBounds(other))
+ && equals(getImplicitUpperBounds(w), getImplicitUpperBounds(other));
+ }
+ return false;
+ }
+
+ /**
+ * Learn whether {@code t1} equals {@code t2}.
+ * @param t1 LHS
+ * @param t2 RHS
+ * @return boolean
+ */
+ private static boolean equals(final Type[] t1, final Type[] t2) {
+ if (t1.length == t2.length) {
+ for (int i = 0; i < t1.length; i++) {
+ if (!equals(t1[i], t2[i])) {
+ return false;
+ }
+ }
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Present a given type as a Java-esque String.
+ *
+ * @param type the type to create a String representation for, not {@code null}
+ * @return String
+ */
+ public static String toString(final Type type) {
+ Validate.notNull(type);
+ if (type instanceof Class<?>) {
+ return classToString((Class<?>) type);
+ }
+ if (type instanceof ParameterizedType) {
+ return parameterizedTypeToString((ParameterizedType) type);
+ }
+ if (type instanceof WildcardType) {
+ return wildcardTypeToString((WildcardType) type);
+ }
+ if (type instanceof TypeVariable<?>) {
+ return typeVariableToString((TypeVariable<?>) type);
+ }
+ if (type instanceof GenericArrayType) {
+ return genericArrayTypeToString((GenericArrayType) type);
+ }
+ throw new IllegalArgumentException(type.toString());
+ }
+
+
+ /**
+ * Format a {@link Class} as a {@link String}.
+ * @param c {@code Class} to format
+ * @return String
+ */
+ private static String classToString(final Class<?> c) {
+ final StringBuilder buf = new StringBuilder();
+
+ if (c.getEnclosingClass() != null) {
+ buf.append(classToString(c.getEnclosingClass())).append('.').append(c.getSimpleName());
+ } else {
+ buf.append(c.getName());
+ }
+ if (c.getTypeParameters().length > 0) {
+ buf.append('<');
+ appendAllTo(buf, ", ", c.getTypeParameters());
+ buf.append('>');
+ }
+ return buf.toString();
+ }
+
+ /**
+ * Format a {@link TypeVariable} as a {@link String}.
+ * @param v {@code TypeVariable} to format
+ * @return String
+ */
+ private static String typeVariableToString(final TypeVariable<?> v) {
+ final StringBuilder buf = new StringBuilder(v.getName());
+ final Type[] bounds = v.getBounds();
+ if (bounds.length > 0 && !(bounds.length == 1 && Object.class.equals(bounds[0]))) {
+ buf.append(" extends ");
+ appendAllTo(buf, " & ", v.getBounds());
+ }
+ return buf.toString();
+ }
+
+ /**
+ * Format a {@link ParameterizedType} as a {@link String}.
+ * @param p {@code ParameterizedType} to format
+ * @return String
+ */
+ private static String parameterizedTypeToString(final ParameterizedType p) {
+ final StringBuilder buf = new StringBuilder();
+
+ final Type useOwner = p.getOwnerType();
+ final Class<?> raw = (Class<?>) p.getRawType();
+ final Type[] typeArguments = p.getActualTypeArguments();
+ if (useOwner == null) {
+ buf.append(raw.getName());
+ } else {
+ if (useOwner instanceof Class<?>) {
+ buf.append(((Class<?>) useOwner).getName());
+ } else {
+ buf.append(useOwner.toString());
+ }
+ buf.append('.').append(raw.getSimpleName());
+ }
+
+ appendAllTo(buf.append('<'), ", ", typeArguments).append('>');
+ return buf.toString();
+ }
+
+ /**
+ * Format a {@link WildcardType} as a {@link String}.
+ * @param w {@code WildcardType} to format
+ * @return String
+ */
+ private static String wildcardTypeToString(final WildcardType w) {
+ final StringBuilder buf = new StringBuilder().append('?');
+ final Type[] lowerBounds = w.getLowerBounds();
+ final Type[] upperBounds = w.getUpperBounds();
+ if (lowerBounds.length > 1 || lowerBounds.length == 1 && lowerBounds[0] != null) {
+ appendAllTo(buf.append(" super "), " & ", lowerBounds);
+ } else if (upperBounds.length > 1 || upperBounds.length == 1 && !Object.class.equals(upperBounds[0])) {
+ appendAllTo(buf.append(" extends "), " & ", upperBounds);
+ }
+ return buf.toString();
+ }
+
+ /**
+ * Format a {@link GenericArrayType} as a {@link String}.
+ * @param g {@code GenericArrayType} to format
+ * @return String
+ */
+ private static String genericArrayTypeToString(final GenericArrayType g) {
+ return String.format("%s[]", toString(g.getGenericComponentType()));
+ }
+
+ /**
+ * Append {@code types} to @{code buf} with separator {@code sep}.
+ * @param buf destination
+ * @param sep separator
+ * @param types to append
+ * @return {@code buf}
+ */
+ private static StringBuilder appendAllTo(final StringBuilder buf, final String sep, final Type... types) {
+ if (types.length > 0) {
+ buf.append(toString(types[0]));
+ for (int i = 1; i < types.length; i++) {
+ buf.append(sep).append(toString(types[i]));
+ }
+ }
+ return buf;
+ }
+
+}
Added: tomee/deps/branches/bval-2/bval-jsr/src/main/resources/META-INF/services/javax.enterprise.inject.spi.Extension
URL: http://svn.apache.org/viewvc/tomee/deps/branches/bval-2/bval-jsr/src/main/resources/META-INF/services/javax.enterprise.inject.spi.Extension?rev=1843674&view=auto
==============================================================================
--- tomee/deps/branches/bval-2/bval-jsr/src/main/resources/META-INF/services/javax.enterprise.inject.spi.Extension (added)
+++ tomee/deps/branches/bval-2/bval-jsr/src/main/resources/META-INF/services/javax.enterprise.inject.spi.Extension Fri Oct 12 15:00:48 2018
@@ -0,0 +1,17 @@
+# 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.
+org.apache.bval.cdi.BValExtension
\ No newline at end of file
Added: tomee/deps/branches/bval-2/bval-jsr/src/main/resources/META-INF/services/javax.validation.spi.ValidationProvider
URL: http://svn.apache.org/viewvc/tomee/deps/branches/bval-2/bval-jsr/src/main/resources/META-INF/services/javax.validation.spi.ValidationProvider?rev=1843674&view=auto
==============================================================================
--- tomee/deps/branches/bval-2/bval-jsr/src/main/resources/META-INF/services/javax.validation.spi.ValidationProvider (added)
+++ tomee/deps/branches/bval-2/bval-jsr/src/main/resources/META-INF/services/javax.validation.spi.ValidationProvider Fri Oct 12 15:00:48 2018
@@ -0,0 +1,17 @@
+# 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.
+org.apache.bval.jsr.ApacheValidationProvider
Added: tomee/deps/branches/bval-2/bval-jsr/src/main/resources/META-INF/services/org.apache.bval.jsr.metadata.MetadataSource
URL: http://svn.apache.org/viewvc/tomee/deps/branches/bval-2/bval-jsr/src/main/resources/META-INF/services/org.apache.bval.jsr.metadata.MetadataSource?rev=1843674&view=auto
==============================================================================
--- tomee/deps/branches/bval-2/bval-jsr/src/main/resources/META-INF/services/org.apache.bval.jsr.metadata.MetadataSource (added)
+++ tomee/deps/branches/bval-2/bval-jsr/src/main/resources/META-INF/services/org.apache.bval.jsr.metadata.MetadataSource Fri Oct 12 15:00:48 2018
@@ -0,0 +1,17 @@
+# 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.
+org.apache.bval.jsr.xml.ValidationMappingParser
\ No newline at end of file
Added: tomee/deps/branches/bval-2/bval-jsr/src/main/resources/org/apache/bval/jsr/DefaultConstraints.properties
URL: http://svn.apache.org/viewvc/tomee/deps/branches/bval-2/bval-jsr/src/main/resources/org/apache/bval/jsr/DefaultConstraints.properties?rev=1843674&view=auto
==============================================================================
--- tomee/deps/branches/bval-2/bval-jsr/src/main/resources/org/apache/bval/jsr/DefaultConstraints.properties (added)
+++ tomee/deps/branches/bval-2/bval-jsr/src/main/resources/org/apache/bval/jsr/DefaultConstraints.properties Fri Oct 12 15:00:48 2018
@@ -0,0 +1,131 @@
+# 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.
+
+# configuration for mapping of javax.validation.constraints to ConstraintValidator implementations
+# the annotations from the JSR303 validation-api are mentioned here, but you could
+# also extend the configuration to get a default implementation for other constraint-annotations.
+# format: key=constraint-annotation-class value=constraint-validator-class (multiple classes: comma-separated)
+
+javax.validation.constraints.AssertFalse=org.apache.bval.constraints.AssertFalseValidator
+javax.validation.constraints.AssertTrue=org.apache.bval.constraints.AssertTrueValidator
+
+javax.validation.constraints.DecimalMax=\
+ org.apache.bval.constraints.DecimalMaxValidator$ForNumber,\
+ org.apache.bval.constraints.DecimalMaxValidator$ForString
+
+javax.validation.constraints.DecimalMin=\
+ org.apache.bval.constraints.DecimalMinValidator$ForNumber,\
+ org.apache.bval.constraints.DecimalMinValidator$ForString
+
+javax.validation.constraints.Digits=org.apache.bval.constraints.DigitsValidatorForNumber,\
+ org.apache.bval.constraints.DigitsValidatorForString
+
+javax.validation.constraints.Email=org.apache.bval.constraints.EmailValidator
+
+javax.validation.constraints.Future=\
+ org.apache.bval.constraints.FutureValidator$ForCalendar,\
+ org.apache.bval.constraints.FutureValidator$ForDate,\
+ org.apache.bval.constraints.FutureValidator$ForChronoLocalDate,\
+ org.apache.bval.constraints.FutureValidator$ForChronoLocalDateTime,\
+ org.apache.bval.constraints.FutureValidator$ForChronoZonedDateTime,\
+ org.apache.bval.constraints.FutureValidator$ForInstant,\
+ org.apache.bval.constraints.FutureValidator$ForLocalTime,\
+ org.apache.bval.constraints.FutureValidator$ForMonthDay,\
+ org.apache.bval.constraints.FutureValidator$ForOffsetDateTime,\
+ org.apache.bval.constraints.FutureValidator$ForOffsetTime,\
+ org.apache.bval.constraints.FutureValidator$ForYear,\
+ org.apache.bval.constraints.FutureValidator$ForYearMonth
+
+javax.validation.constraints.FutureOrPresent=\
+ org.apache.bval.constraints.FutureOrPresentValidator$ForCalendar,\
+ org.apache.bval.constraints.FutureOrPresentValidator$ForDate,\
+ org.apache.bval.constraints.FutureOrPresentValidator$ForChronoLocalDate,\
+ org.apache.bval.constraints.FutureOrPresentValidator$ForChronoLocalDateTime,\
+ org.apache.bval.constraints.FutureOrPresentValidator$ForChronoZonedDateTime,\
+ org.apache.bval.constraints.FutureOrPresentValidator$ForInstant,\
+ org.apache.bval.constraints.FutureOrPresentValidator$ForLocalTime,\
+ org.apache.bval.constraints.FutureOrPresentValidator$ForMonthDay,\
+ org.apache.bval.constraints.FutureOrPresentValidator$ForOffsetDateTime,\
+ org.apache.bval.constraints.FutureOrPresentValidator$ForOffsetTime,\
+ org.apache.bval.constraints.FutureOrPresentValidator$ForYear,\
+ org.apache.bval.constraints.FutureOrPresentValidator$ForYearMonth
+
+javax.validation.constraints.Max=org.apache.bval.constraints.MaxValidatorForNumber,\
+ org.apache.bval.constraints.MaxValidatorForString
+
+javax.validation.constraints.Min=org.apache.bval.constraints.MinValidatorForNumber,\
+ org.apache.bval.constraints.MinValidatorForString
+
+javax.validation.constraints.Negative=org.apache.bval.constraints.NumberSignValidator$ForNegative
+javax.validation.constraints.NegativeOrZero=org.apache.bval.constraints.NumberSignValidator$ForNegative$OrZero
+
+javax.validation.constraints.NotBlank=org.apache.bval.constraints.NotBlankValidator
+
+javax.validation.constraints.NotEmpty=org.apache.bval.constraints.NotEmptyValidator,\
+ org.apache.bval.constraints.NotEmptyValidatorForCharSequence,\
+ org.apache.bval.constraints.NotEmptyValidatorForCollection,\
+ org.apache.bval.constraints.NotEmptyValidatorForMap
+
+javax.validation.constraints.NotNull=org.apache.bval.constraints.NotNullValidator
+javax.validation.constraints.Null=org.apache.bval.constraints.NullValidator
+
+javax.validation.constraints.Past=\
+ org.apache.bval.constraints.PastValidator$ForCalendar,\
+ org.apache.bval.constraints.PastValidator$ForDate,\
+ org.apache.bval.constraints.PastValidator$ForChronoLocalDate,\
+ org.apache.bval.constraints.PastValidator$ForChronoLocalDateTime,\
+ org.apache.bval.constraints.PastValidator$ForChronoZonedDateTime,\
+ org.apache.bval.constraints.PastValidator$ForInstant,\
+ org.apache.bval.constraints.PastValidator$ForLocalTime,\
+ org.apache.bval.constraints.PastValidator$ForMonthDay,\
+ org.apache.bval.constraints.PastValidator$ForOffsetDateTime,\
+ org.apache.bval.constraints.PastValidator$ForOffsetTime,\
+ org.apache.bval.constraints.PastValidator$ForYear,\
+ org.apache.bval.constraints.PastValidator$ForYearMonth
+
+javax.validation.constraints.PastOrPresent=\
+ org.apache.bval.constraints.PastOrPresentValidator$ForCalendar,\
+ org.apache.bval.constraints.PastOrPresentValidator$ForDate,\
+ org.apache.bval.constraints.PastOrPresentValidator$ForChronoLocalDate,\
+ org.apache.bval.constraints.PastOrPresentValidator$ForChronoLocalDateTime,\
+ org.apache.bval.constraints.PastOrPresentValidator$ForChronoZonedDateTime,\
+ org.apache.bval.constraints.PastOrPresentValidator$ForInstant,\
+ org.apache.bval.constraints.PastOrPresentValidator$ForLocalTime,\
+ org.apache.bval.constraints.PastOrPresentValidator$ForMonthDay,\
+ org.apache.bval.constraints.PastOrPresentValidator$ForOffsetDateTime,\
+ org.apache.bval.constraints.PastOrPresentValidator$ForOffsetTime,\
+ org.apache.bval.constraints.PastOrPresentValidator$ForYear,\
+ org.apache.bval.constraints.PastOrPresentValidator$ForYearMonth
+
+javax.validation.constraints.Positive=org.apache.bval.constraints.NumberSignValidator$ForPositive
+javax.validation.constraints.PositiveOrZero=org.apache.bval.constraints.NumberSignValidator$ForPositive$OrZero
+
+javax.validation.constraints.Size=\
+ org.apache.bval.constraints.SizeValidator$ForArray$OfObject,\
+ org.apache.bval.constraints.SizeValidator$ForArray$OfByte,\
+ org.apache.bval.constraints.SizeValidator$ForArray$OfShort,\
+ org.apache.bval.constraints.SizeValidator$ForArray$OfInt,\
+ org.apache.bval.constraints.SizeValidator$ForArray$OfChar,\
+ org.apache.bval.constraints.SizeValidator$ForArray$OfLong,\
+ org.apache.bval.constraints.SizeValidator$ForArray$OfFloat,\
+ org.apache.bval.constraints.SizeValidator$ForArray$OfDouble,\
+ org.apache.bval.constraints.SizeValidator$ForArray$OfBoolean,\
+ org.apache.bval.constraints.SizeValidator$ForCharSequence,\
+ org.apache.bval.constraints.SizeValidator$ForCollection,\
+ org.apache.bval.constraints.SizeValidator$ForMap
+
+javax.validation.constraints.Pattern=org.apache.bval.constraints.PatternValidator
Added: tomee/deps/branches/bval-2/bval-jsr/src/main/resources/org/apache/bval/jsr/ValidationMessages.properties
URL: http://svn.apache.org/viewvc/tomee/deps/branches/bval-2/bval-jsr/src/main/resources/org/apache/bval/jsr/ValidationMessages.properties?rev=1843674&view=auto
==============================================================================
--- tomee/deps/branches/bval-2/bval-jsr/src/main/resources/org/apache/bval/jsr/ValidationMessages.properties (added)
+++ tomee/deps/branches/bval-2/bval-jsr/src/main/resources/org/apache/bval/jsr/ValidationMessages.properties Fri Oct 12 15:00:48 2018
@@ -0,0 +1,37 @@
+# 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.
+
+# The properties listed below are resolved by the default message resolver.
+
+# standard
+javax.validation.constraints.Null.message=must be null
+javax.validation.constraints.NotNull.message=may not be null
+javax.validation.constraints.AssertTrue.message=must be true
+javax.validation.constraints.AssertFalse.message=must be false
+javax.validation.constraints.Min.message=must be greater than or equal to {value}
+javax.validation.constraints.Max.message=must be less than or equal to {value}
+javax.validation.constraints.Size.message=size must be between {min} and {max}
+javax.validation.constraints.Digits.message=numeric value out of bounds (<{integer} digits>.<{fraction} digits> expected)
+javax.validation.constraints.Past.message=must be a past date
+javax.validation.constraints.Future.message=must be a future date
+javax.validation.constraints.Pattern.message=must match the following regular expression: {regexp}
+javax.validation.constraints.DecimalMax.message=must be less than or equal to {value}
+javax.validation.constraints.DecimalMin.message=must be greater than or equal to {value}
+
+# additional built-ins
+org.apache.bval.constraints.NotEmpty.message=may not be empty
+org.apache.bval.constraints.Email.message=not a well-formed email address
Added: tomee/deps/branches/bval-2/bval-jsr/src/main/resources/org/apache/bval/jsr/ValidationMessages_de.properties
URL: http://svn.apache.org/viewvc/tomee/deps/branches/bval-2/bval-jsr/src/main/resources/org/apache/bval/jsr/ValidationMessages_de.properties?rev=1843674&view=auto
==============================================================================
--- tomee/deps/branches/bval-2/bval-jsr/src/main/resources/org/apache/bval/jsr/ValidationMessages_de.properties (added)
+++ tomee/deps/branches/bval-2/bval-jsr/src/main/resources/org/apache/bval/jsr/ValidationMessages_de.properties Fri Oct 12 15:00:48 2018
@@ -0,0 +1,37 @@
+# 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.
+
+# The properties listed below are resolved by the default message resolver.
+
+# standard
+javax.validation.constraints.Null.message=muss "null" sein
+javax.validation.constraints.NotNull.message=darf nicht "null" sein
+javax.validation.constraints.AssertTrue.message=muss "true" sein
+javax.validation.constraints.AssertFalse.message=muss "false" sein
+javax.validation.constraints.Min.message=muss gr\u00F6\u00DFer oder gleich {value} sein
+javax.validation.constraints.Max.message=muss kleiner oder gleich {value} sein
+javax.validation.constraints.Size.message=Gr\u00F6\u00DFe muss zwischen {min} und {max} liegen
+javax.validation.constraints.Digits.message=numerischer Wert au\u00DFerhalb des G\u00FCltigkeitsbereiches (erwarte: <{integer} digits>.<{fraction} digits>)
+javax.validation.constraints.Past.message=muss Datum in der Vergangenheit sein
+javax.validation.constraints.Future.message=muss Datum in der Zukunft sein
+javax.validation.constraints.Pattern.message=Muss mit regul\u00E4rem Ausdruck \u00FCbereinstimmen: {regexp}
+javax.validation.constraints.DecimalMax.message=muss kleiner oder gleich {value} sein
+javax.validation.constraints.DecimalMin.message=muss gr\u00F6\u00DFer oder gleich {value} sein
+
+# additional built-ins
+org.apache.bval.constraints.NotEmpty.message=darf nicht leer sein
+org.apache.bval.constraints.Email.message=muss g\u00FCltiges Format einer EMail-Adresse sein
Added: tomee/deps/branches/bval-2/bval-jsr/src/main/resources/org/apache/bval/jsr/ValidationMessages_en.properties
URL: http://svn.apache.org/viewvc/tomee/deps/branches/bval-2/bval-jsr/src/main/resources/org/apache/bval/jsr/ValidationMessages_en.properties?rev=1843674&view=auto
==============================================================================
--- tomee/deps/branches/bval-2/bval-jsr/src/main/resources/org/apache/bval/jsr/ValidationMessages_en.properties (added)
+++ tomee/deps/branches/bval-2/bval-jsr/src/main/resources/org/apache/bval/jsr/ValidationMessages_en.properties Fri Oct 12 15:00:48 2018
@@ -0,0 +1,20 @@
+# 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.
+
+# intentionally empty, because english messages are located in the default bundle.
+# this file ensures, that a lookup with an english locale uses the default bundle and not the
+# bundle of the default locale, which is platform specific
\ No newline at end of file
Added: tomee/deps/branches/bval-2/bval-jsr/src/main/resources/org/apache/bval/jsr/ValidationMessages_es.properties
URL: http://svn.apache.org/viewvc/tomee/deps/branches/bval-2/bval-jsr/src/main/resources/org/apache/bval/jsr/ValidationMessages_es.properties?rev=1843674&view=auto
==============================================================================
--- tomee/deps/branches/bval-2/bval-jsr/src/main/resources/org/apache/bval/jsr/ValidationMessages_es.properties (added)
+++ tomee/deps/branches/bval-2/bval-jsr/src/main/resources/org/apache/bval/jsr/ValidationMessages_es.properties Fri Oct 12 15:00:48 2018
@@ -0,0 +1,37 @@
+# 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.
+
+# The properties listed below are resolved by the default message resolver.
+
+# standard
+javax.validation.constraints.Null.message=tiene que ser null
+javax.validation.constraints.NotNull.message=no puede ser null
+javax.validation.constraints.AssertTrue.message=tiene que ser true
+javax.validation.constraints.AssertFalse.message=tiene que ser false
+javax.validation.constraints.Min.message=tiene que ser menor o igual que {value}
+javax.validation.constraints.Max.message=tiene que ser mayor o igual que {value}
+javax.validation.constraints.Size.message=el tama\u00F1o tiene que estar comprendido entre {min} y {max}
+javax.validation.constraints.Digits.message=valor num\u00E9rico fuera de los l\u00EDmites (se espera <{integer} cifras>.<{fraction} cifras>)
+javax.validation.constraints.Past.message=tiene que ser una fecha en el pasado
+javax.validation.constraints.Future.message=tiene que ser una fecha en el futuro
+javax.validation.constraints.Pattern.message=tiene que corresponder a la expresi\u00F3n regular "{regexp}"
+javax.validation.constraints.DecimalMax.message=tiene que ser mayor o igual que {value}
+javax.validation.constraints.DecimalMin.message=tiene que ser menor o igual que {value}
+
+# additional built-ins
+org.apache.bval.constraints.NotEmpty.message=no puede ser vac\u00EDo
+org.apache.bval.constraints.Email.message=tiene que ser un correo email bien formado
Added: tomee/deps/branches/bval-2/bval-jsr/src/main/resources/org/apache/bval/jsr/ValidationMessages_it.properties
URL: http://svn.apache.org/viewvc/tomee/deps/branches/bval-2/bval-jsr/src/main/resources/org/apache/bval/jsr/ValidationMessages_it.properties?rev=1843674&view=auto
==============================================================================
--- tomee/deps/branches/bval-2/bval-jsr/src/main/resources/org/apache/bval/jsr/ValidationMessages_it.properties (added)
+++ tomee/deps/branches/bval-2/bval-jsr/src/main/resources/org/apache/bval/jsr/ValidationMessages_it.properties Fri Oct 12 15:00:48 2018
@@ -0,0 +1,37 @@
+# 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.
+
+# The properties listed below are resolved by the default message resolver.
+
+# standard
+javax.validation.constraints.Null.message=deve essere null
+javax.validation.constraints.NotNull.message=non pu\u00F2 essere null
+javax.validation.constraints.AssertTrue.message=deve essere true
+javax.validation.constraints.AssertFalse.message=deve essere false
+javax.validation.constraints.Min.message=deve essere minore o uguale di {value}
+javax.validation.constraints.Max.message=deve essere maggiore o uguale di {value}
+javax.validation.constraints.Size.message=le dimensioni devono essere tra {min} e {max}
+javax.validation.constraints.Digits.message=valore numerico fuori dai limiti (atteso <{integer} cifre>.<{fraction} cifre>)
+javax.validation.constraints.Past.message=deve essere una data nel passato
+javax.validation.constraints.Future.message=deve essere una data futura
+javax.validation.constraints.Pattern.message=deve corrispondere all'espressione regolare "{regexp}"
+javax.validation.constraints.DecimalMax.message=deve essere maggiore o uguale di {value}
+javax.validation.constraints.DecimalMin.message=deve essere minore o uguale di {value}
+
+# additional built-ins
+org.apache.bval.constraints.NotEmpty.message=non pu\u00F2 essere vuoto
+org.apache.bval.constraints.Email.message=non \u00E8 un indirizzo email ben formato
Added: tomee/deps/branches/bval-2/bval-jsr/src/main/resources/org/apache/bval/jsr/valueextraction/DefaultExtractors.properties
URL: http://svn.apache.org/viewvc/tomee/deps/branches/bval-2/bval-jsr/src/main/resources/org/apache/bval/jsr/valueextraction/DefaultExtractors.properties?rev=1843674&view=auto
==============================================================================
--- tomee/deps/branches/bval-2/bval-jsr/src/main/resources/org/apache/bval/jsr/valueextraction/DefaultExtractors.properties (added)
+++ tomee/deps/branches/bval-2/bval-jsr/src/main/resources/org/apache/bval/jsr/valueextraction/DefaultExtractors.properties Fri Oct 12 15:00:48 2018
@@ -0,0 +1,25 @@
+# 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.
+
+javax.validation.valueextraction.ValueExtractor=\
+ org.apache.bval.jsr.valueextraction.IterableElementExtractor,\
+ org.apache.bval.jsr.valueextraction.ListElementExtractor
+
+javax.validation.valueextraction.ValueExtractor.container=\
+ org.apache.bval.jsr.valueextraction.MapExtractor,\
+ org.apache.bval.jsr.valueextraction.OptionalExtractor,\
+ org.apache.bval.jsr.valueextraction.FxExtractor