Java Reflection Assignable isAssignable(Class lhsType, Class rhsType)

Description

Check if the right-hand side type may be assigned to the left-hand side type, assuming setting by reflection.

License

Open Source License

Parameter

Parameter	Description
lhsType	the target type
rhsType	the value type that should be assigned to the target type

Return

if the target type is assignable from the value type

Declaration

public static boolean isAssignable(Class<?> lhsType, Class<?> rhsType) 

Method Source Code

//package com.java2s;
//License from project: Open Source License 

import java.util.HashMap;
import java.util.Map;

public class Main {
    /**/*w  w w  .  j a  v a2 s .  c o  m*/
     * Map with primitive wrapper type as key and corresponding primitive type
     * as value, for example: Integer.class -> int.class.
     */
    private static final Map<Class<?>, Class<?>> primitiveWrapperTypeMap = new HashMap<Class<?>, Class<?>>(8);
    /**
     * Map with primitive type as key and corresponding wrapper type as value,
     * for example: int.class -> Integer.class.
     */
    private static final Map<Class<?>, Class<?>> primitiveTypeToWrapperMap = new HashMap<Class<?>, Class<?>>(8);

    /**
     * Check if the right-hand side type may be assigned to the left-hand side
     * type, assuming setting by reflection. Considers primitive wrapper classes
     * as assignable to the corresponding primitive types.
     * 
     * @author Spring Framework
     * 
     * @param lhsType
     *            the target type
     * @param rhsType
     *            the value type that should be assigned to the target type
     * @return if the target type is assignable from the value type
     */
    public static boolean isAssignable(Class<?> lhsType, Class<?> rhsType) {
        if (lhsType.isAssignableFrom(rhsType)) {
            return true;
        }
        if (lhsType.isPrimitive()) {
            Class<?> resolvedPrimitive = primitiveWrapperTypeMap.get(rhsType);
            if (lhsType == resolvedPrimitive) {
                return true;
            }
        } else {
            Class<?> resolvedWrapper = primitiveTypeToWrapperMap.get(rhsType);
            if (resolvedWrapper != null && lhsType.isAssignableFrom(resolvedWrapper)) {
                return true;
            }
        }
        return false;
    }
}

Related

1. isAssignable(Class clazz, Class toClass)
2. isAssignable(Class lhsType, Class rhsType)
3. isAssignable(Class cls, final Class toClass)
4. isAssignable(Class lhsType, Class rhsType)
5. isAssignable(Class lhsType, Class rhsType)
6. isAssignable(final Class from, final Class to)
7. isAssignableFrom(Class class1, Class class2)