You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@bval.apache.org by mb...@apache.org on 2018/02/25 20:10:40 UTC
[5/8] bval git commit: remove obsolete modules,
moving required core code to jsr
http://git-wip-us.apache.org/repos/asf/bval/blob/ed299e4f/bval-core/src/main/java/org/apache/bval/util/reflection/TypeUtils.java
----------------------------------------------------------------------
diff --git a/bval-core/src/main/java/org/apache/bval/util/reflection/TypeUtils.java b/bval-core/src/main/java/org/apache/bval/util/reflection/TypeUtils.java
deleted file mode 100644
index a75e1ad..0000000
--- a/bval-core/src/main/java/org/apache/bval/util/reflection/TypeUtils.java
+++ /dev/null
@@ -1,1557 +0,0 @@
-/*
- * 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.isEmpty(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;
- }
-
-}
http://git-wip-us.apache.org/repos/asf/bval/blob/ed299e4f/bval-core/src/test/java/org/apache/bval/ValidationResultsTest.java
----------------------------------------------------------------------
diff --git a/bval-core/src/test/java/org/apache/bval/ValidationResultsTest.java b/bval-core/src/test/java/org/apache/bval/ValidationResultsTest.java
deleted file mode 100644
index 785621e..0000000
--- a/bval-core/src/test/java/org/apache/bval/ValidationResultsTest.java
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * 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;
-
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-import org.apache.bval.model.MetaProperty;
-import org.junit.Before;
-import org.junit.Test;
-
-/**
- * ValidationResults Tester.
- */
-public class ValidationResultsTest {
- private ValidationResults results;
-
- @Before
- public void setUp() throws Exception {
- results = new ValidationResults();
- }
-
- @Test
- public void testValidationResults() throws Exception {
- assertTrue(results.isEmpty());
- BeanValidationContext<ValidationResults> ctx = new BeanValidationContext<ValidationResults>(results);
- ctx.setBean(this);
- ctx.setMetaProperty(new MetaProperty());
- ctx.getMetaProperty().setName("prop");
- results.addError("test", ctx);
- assertFalse(results.isEmpty());
- assertTrue(results.hasErrorForReason("test"));
- assertTrue(results.hasError(this, "prop"));
- assertTrue(results.hasError(this, null));
- assertFalse(results.hasError(this, "prop2"));
- }
-
-}
http://git-wip-us.apache.org/repos/asf/bval/blob/ed299e4f/bval-core/src/test/java/org/apache/bval/model/ExampleEnum.java
----------------------------------------------------------------------
diff --git a/bval-core/src/test/java/org/apache/bval/model/ExampleEnum.java b/bval-core/src/test/java/org/apache/bval/model/ExampleEnum.java
deleted file mode 100644
index 10f87a9..0000000
--- a/bval-core/src/test/java/org/apache/bval/model/ExampleEnum.java
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * 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.model;
-
-/**
- * Description: <br>
- * User: roman.stumm<br>
- * Date: 17.06.2010<br>
- * Time: 18:00:12<br>
- */
-public enum ExampleEnum {
- VALUE1, VALUE2, VALUE3
-}
http://git-wip-us.apache.org/repos/asf/bval/blob/ed299e4f/bval-core/src/test/java/org/apache/bval/model/MetaPropertyTest.java
----------------------------------------------------------------------
diff --git a/bval-core/src/test/java/org/apache/bval/model/MetaPropertyTest.java b/bval-core/src/test/java/org/apache/bval/model/MetaPropertyTest.java
deleted file mode 100644
index 88a34ba..0000000
--- a/bval-core/src/test/java/org/apache/bval/model/MetaPropertyTest.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * 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.model;
-
-import static org.junit.Assert.assertEquals;
-
-import org.junit.Test;
-
-/**
- * MetaProperty Tester.
- *
- * @author <Authors name>
- * @since <pre>02/12/2009</pre>
- * @version 1.0
- */
-public class MetaPropertyTest {
-
- @Test
- public void testGetTypeClass() throws Exception {
- MetaProperty prop = new MetaProperty();
- prop.setType(String.class);
- assertEquals(String.class, prop.getTypeClass());
- assertEquals(String.class, prop.getType());
- prop.setType(new DynaTypeEnum(ExampleEnum.class, ExampleEnum.VALUE1.name(), ExampleEnum.VALUE3.name()));
- assertEquals(ExampleEnum.class, prop.getTypeClass());
- assertEquals(2, ((DynaTypeEnum) prop.getType()).getEnumConstants().length);
- }
-
-}
http://git-wip-us.apache.org/repos/asf/bval/blob/ed299e4f/bval-core/src/test/java/org/apache/bval/util/StringUtilsTest.java
----------------------------------------------------------------------
diff --git a/bval-core/src/test/java/org/apache/bval/util/StringUtilsTest.java b/bval-core/src/test/java/org/apache/bval/util/StringUtilsTest.java
deleted file mode 100644
index 1939081..0000000
--- a/bval-core/src/test/java/org/apache/bval/util/StringUtilsTest.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * 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;
-
-import org.junit.Assert;
-import org.junit.Test;
-
-public class StringUtilsTest {
-
- @Test
- public void testStringSplit() {
- Assert.assertArrayEquals(new String[0], StringUtils.split(null));
- Assert.assertArrayEquals(new String[0], StringUtils.split(""));
- Assert.assertArrayEquals(new String[0], StringUtils.split(" "));
- Assert.assertArrayEquals(new String[0], StringUtils.split(" \n "));
- Assert.assertArrayEquals(new String[] { "a", "bbb", "cccc" }, StringUtils.split(" a bbb cccc"));
- }
-}
http://git-wip-us.apache.org/repos/asf/bval/blob/ed299e4f/bval-core/src/test/resources/log4j.xml
----------------------------------------------------------------------
diff --git a/bval-core/src/test/resources/log4j.xml b/bval-core/src/test/resources/log4j.xml
deleted file mode 100644
index 3c4bb67..0000000
--- a/bval-core/src/test/resources/log4j.xml
+++ /dev/null
@@ -1,41 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
- 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.
--->
-<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
-
-<!-- ===================================================================== -->
-<!-- -->
-<!-- Log4j Configuration -->
-<!-- -->
-<!-- ===================================================================== -->
-
-<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/" debug="false">
-
- <appender name="CONSOLE" class="org.apache.log4j.ConsoleAppender">
- <param name="Threshold" value="DEBUG"/>
- <layout class="org.apache.log4j.PatternLayout">
- <param name="ConversionPattern" value="%d %-5p %c - %m%n"/>
- </layout>
- </appender>
-
- <root>
- <appender-ref ref="CONSOLE"/>
- </root>
-
-</log4j:configuration>
http://git-wip-us.apache.org/repos/asf/bval/blob/ed299e4f/bval-json/pom.xml
----------------------------------------------------------------------
diff --git a/bval-json/pom.xml b/bval-json/pom.xml
deleted file mode 100644
index 59dcb17..0000000
--- a/bval-json/pom.xml
+++ /dev/null
@@ -1,76 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
- 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.
--->
-<!--
- Maven release plugin requires the project tag to be on a single line.
--->
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-
- <modelVersion>4.0.0</modelVersion>
-
- <parent>
- <groupId>org.apache.bval</groupId>
- <artifactId>bval-parent</artifactId>
- <version>2.0.0-SNAPSHOT</version>
- </parent>
-
- <artifactId>bval-json</artifactId>
- <name>Apache BVal :: bval-json (optional)</name>
- <packaging>bundle</packaging>
-
- <description>BVal - Optional JSON Component</description>
-
- <dependencies>
- <dependency>
- <groupId>org.apache.bval</groupId>
- <artifactId>bval-core</artifactId>
- <version>${project.version}</version>
- </dependency>
- <dependency>
- <groupId>org.apache.bval</groupId>
- <artifactId>bval-xstream</artifactId>
- <version>${project.version}</version>
- </dependency>
- <dependency>
- <groupId>org.freemarker</groupId>
- <artifactId>freemarker</artifactId>
- </dependency>
- <dependency>
- <groupId>junit</groupId>
- <artifactId>junit</artifactId>
- <scope>test</scope>
- </dependency>
- <dependency>
- <groupId>org.apache.bval</groupId>
- <artifactId>bval-core</artifactId>
- <version>${project.version}</version>
- <type>test-jar</type>
- <scope>test</scope>
- </dependency>
- <dependency>
- <groupId>org.apache.bval</groupId>
- <artifactId>bval-xstream</artifactId>
- <version>${project.version}</version>
- <type>test-jar</type>
- <scope>test</scope>
- </dependency>
- </dependencies>
-
-</project>
-
http://git-wip-us.apache.org/repos/asf/bval/blob/ed299e4f/bval-json/src/main/appended-resources/META-INF/NOTICE.vm
----------------------------------------------------------------------
diff --git a/bval-json/src/main/appended-resources/META-INF/NOTICE.vm b/bval-json/src/main/appended-resources/META-INF/NOTICE.vm
deleted file mode 100644
index 9a0c1ee..0000000
--- a/bval-json/src/main/appended-resources/META-INF/NOTICE.vm
+++ /dev/null
@@ -1,25 +0,0 @@
-##
-## 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 following copyright notice(s) were affixed to portions of this code
-with which this file is now or was at one time distributed.
-
-This product includes software developed by agimatec GmbH.
-Copyright 2007-2010 Agimatec GmbH. All rights reserved.
-
http://git-wip-us.apache.org/repos/asf/bval/blob/ed299e4f/bval-json/src/main/java/org/apache/bval/json/JSONGenerator.java
----------------------------------------------------------------------
diff --git a/bval-json/src/main/java/org/apache/bval/json/JSONGenerator.java b/bval-json/src/main/java/org/apache/bval/json/JSONGenerator.java
deleted file mode 100644
index 11c668b..0000000
--- a/bval-json/src/main/java/org/apache/bval/json/JSONGenerator.java
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * 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.json;
-
-import freemarker.template.Configuration;
-import freemarker.template.Template;
-import freemarker.template.TemplateException;
-import org.apache.bval.model.MetaBean;
-
-import java.io.IOException;
-import java.io.StringWriter;
-import java.io.Writer;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-/**
- * Description: Generate a JSON String for a collection of {@link MetaBean}s.
- * This implementation uses a freemarker template to generate the output.<br/>
- *
- * This is an optional module which requires the freemarker dependency
- * and template resource file "bean-infos-json.ftl" with it.
- */
-public class JSONGenerator {
- private final Template template;
-
- public JSONGenerator() throws IOException {
- this("bean-infos-json.ftl");
- }
-
- public JSONGenerator(String templateName) throws IOException {
- Configuration freemarker = new Configuration();
- freemarker.setNumberFormat("0.######"); // prevent locale-sensitive number format
- freemarker.setClassForTemplateLoading(getClass(), "");
- template = freemarker.getTemplate(templateName);
- }
-
- public JSONGenerator(Template template) {
- this.template = template;
- }
-
- public String toJSON(MetaBean metaBean) throws IOException, TemplateException {
- List<MetaBean> metaBeans = new ArrayList<MetaBean>(1);
- metaBeans.add(metaBean);
- return toJSON(metaBeans);
- }
-
- public String toJSON(Collection<MetaBean> metaBeans) throws IOException, TemplateException {
- final StringWriter out = new StringWriter();
- toJSON(metaBeans, out);
- return out.toString();
- }
-
- public void toJSON(Collection<MetaBean> metaBeans, Writer out) throws IOException, TemplateException {
- Map<String, Object> rootMap = new HashMap<String, Object>();
- rootMap.put("metaBeans", metaBeans);
- rootMap.put("generator", this);
- template.process(rootMap, out);
- }
-}
http://git-wip-us.apache.org/repos/asf/bval/blob/ed299e4f/bval-json/src/main/resources/org/apache/bval/json/bean-infos-json.ftl
----------------------------------------------------------------------
diff --git a/bval-json/src/main/resources/org/apache/bval/json/bean-infos-json.ftl b/bval-json/src/main/resources/org/apache/bval/json/bean-infos-json.ftl
deleted file mode 100644
index 63012ad..0000000
--- a/bval-json/src/main/resources/org/apache/bval/json/bean-infos-json.ftl
+++ /dev/null
@@ -1,85 +0,0 @@
-bval.namespace("bval.metadata");
-
-<#--
- 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.
--->
-
-
-(function(){
-<#assign var = 0>
-<#assign varrefs = {}>
-
-<#list metaBeans as metaBean>
-<#assign varrefs = varrefs + {metaBean.id : var}>
-var metaBean${var} = {
- "id" : "${metaBean.id}",
- <#if metaBean.beanClass??>"beanClass" : "${metaBean.beanClass.name}",</#if>
- <#if metaBean.name??>"name" : "${metaBean.name}",</#if>
- "features" :{<#rt/>
- <#list metaBean.features?keys as featureKey>
- <#assign value = metaBean.features[featureKey]>
- "${featureKey}" : <#if
- value?is_string>"${value}"<#elseif
- value?is_boolean>${value?string}<#elseif
- value?is_number>${value}<#elseif
- value?is_date>${value?string.full}<#elseif
- !(value??)>null<#elseif value?is_sequence>[<#list value as v>"${v}"<#if v_has_next>,</#if></#list>]<#elseif
- value?is_hash>{<#list value?keys as key>"${key}" : "${value[key]}"<#if key_has_next>,</#if></#list>}<#else
- >"?"</#if><#rt/><#if
- featureKey_has_next>,</#if>
- </#list>
- <#lt/>},
- "properties" :{
- <#list metaBean.properties as property>
- "${property.name}":{
- "name" : "${property.name}",
- <#if property.type??>"type" : "${property.type}",</#if>
- <#if property.typeClass??>"typeClass" : "${property.typeClass.name}",</#if>
- "features" : {<#if property.type?? &&
- property.type.enum!false>"enum" : {<#list property.type.enumConstants as enum>"${enum.name()}": "${enum.name()}"<#if enum_has_next>, </#if></#list>}<#if property.features?size > 0>,</#if></#if><#list
- property.features?keys as featureKey>
- <#assign value = property.features[featureKey]>
- "${featureKey}" : <#rt/><#if
- value?is_string>"${value}"<#elseif
- value?is_boolean>${value?string}<#elseif
- value?is_number>${value}<#elseif
- value?is_date>${value?string.full}<#elseif
- !(value??)>null<#elseif value?is_sequence>[<#list value as v>"${v}"<#if v_has_next>,</#if></#list>]<#elseif
- value?is_hash_ex>{<#list value?keys as key>"${key}" : "${value[key]}"<#if key_has_next>,</#if></#list>}<#else
- >"?"</#if><#rt/><#if featureKey_has_next>,</#if>
- </#list>
- }
- }<#if property_has_next>,</#if>
- </#list>
- }
-};
-<#assign var = var + 1>
-</#list>
-
-<#assign var = 0>
-<#list metaBeans as metaBean><#list
- metaBean.properties as property><#if
- property.metaBean?? && varrefs[property.metaBean.id]??>
-metaBean${var}.properties.${property.name}.metaBean = metaBean${varrefs[property.metaBean.id]};
-</#if></#list><#assign var = var + 1></#list><#assign var = 0>
-bval.metadata.metaBeans = {
-<#list metaBeans as metaBean>
- "${metaBean.id}" : metaBean${var}<#if metaBean_has_next>,</#if>
- <#assign var = var + 1>
-</#list>};
-})();
http://git-wip-us.apache.org/repos/asf/bval/blob/ed299e4f/bval-json/src/test/java/org/apache/bval/json/JSONGeneratorTest.java
----------------------------------------------------------------------
diff --git a/bval-json/src/test/java/org/apache/bval/json/JSONGeneratorTest.java b/bval-json/src/test/java/org/apache/bval/json/JSONGeneratorTest.java
deleted file mode 100644
index ab24d93..0000000
--- a/bval-json/src/test/java/org/apache/bval/json/JSONGeneratorTest.java
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- * 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.json;
-
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import org.apache.bval.example.BusinessEnum;
-import org.apache.bval.example.BusinessObject;
-import org.apache.bval.example.BusinessObjectAddress;
-import org.apache.bval.model.DynaTypeEnum;
-import org.apache.bval.model.MetaBean;
-import org.apache.bval.model.MetaProperty;
-import org.apache.bval.xml.XMLMetaBeanManager;
-import org.apache.bval.xml.XMLMetaBeanURLLoader;
-import org.junit.Before;
-import org.junit.Test;
-
-/**
- * Description: <br>
- * Author: roman.stumm<br>
- */
-public class JSONGeneratorTest {
- private XMLMetaBeanManager mbm;
-
- @Before
- public void setUp() throws Exception {
- mbm = new XMLMetaBeanManager();
- mbm.addLoader(new XMLMetaBeanURLLoader(BusinessObject.class.getResource("test-beanInfos.xml")));
- }
-
- @Test
- public void testBeanInfosCustomPatchGenerated() throws Exception {
- MetaBean mbean = mbm.findForClass(BusinessObject.class);
- MetaProperty mprop = mbean.getProperty("lastName");
- assertTrue(mprop.isMandatory());
-
- mbm.getCache().removeFromCache(mbean);
- mbm.addLoader(new XMLMetaBeanURLLoader(BusinessObject.class.getResource("test-beanInfos-custom.xml")));
- mbean = mbm.findForClass(BusinessObject.class);
- mprop = mbean.getProperty("lastName");
- assertTrue(!mprop.isMandatory());
-
- JSONGenerator converter = new JSONGenerator();
-
- List<MetaBean> metaBeans = new ArrayList<MetaBean>(2);
- metaBeans.add(mbean);
- MetaBean mbean2 = mbm.findForId("UnknownObject");
- metaBeans.add(mbean2);
- String json = converter.toJSON(metaBeans);
- assertNotNull(json);
- }
-
- @Test
- public void testJSON() throws Exception {
- MetaBean info = mbm.findForClass(BusinessObject.class);
- MetaBean info2 = info.getProperty("address").getMetaBean();
-
- // empty default bean without xml backup
- MetaBean info3 = mbm.findForClass(BusinessObjectAddress.class);
- JSONGenerator converter = new JSONGenerator();
-
- List<MetaBean> metaBeans = new ArrayList<MetaBean>(2);
- metaBeans.add(info);
- metaBeans.add(info2);
- metaBeans.add(info3);
- String json = converter.toJSON(metaBeans);
- assertNotNull(json);
- }
-
- @Test
- public void testJSON_dynaTypeEnum() throws Exception {
- MetaBean info = mbm.findForClass(BusinessObject.class);
- MetaProperty choice = info.getProperty("choice");
- choice.setType(new DynaTypeEnum(BusinessEnum.class, "CUSTOM_1", "CUSTOM_2"));
-
- JSONGenerator converter = new JSONGenerator();
-
- List<MetaBean> metaBeans = new ArrayList<MetaBean>(1);
- metaBeans.add(info);
- String json = converter.toJSON(metaBeans);
- assertNotNull(json);
- assertTrue(json.indexOf("CUSTOM_1") > 0);
- assertTrue(json.indexOf("CUSTOM_2") > 0);
- assertTrue(json.indexOf("VALUE1") < 0);
- }
-}