1 /*
   2  * Copyright (c) 2010, 2018, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package com.sun.javafx.fxml;
  27 
  28 import java.lang.reflect.InvocationTargetException;
  29 import java.lang.reflect.Method;
  30 import java.lang.reflect.Modifier;
  31 import java.lang.reflect.ParameterizedType;
  32 import java.lang.reflect.Type;
  33 import java.lang.reflect.TypeVariable;
  34 import java.math.BigDecimal;
  35 import java.math.BigInteger;
  36 import java.util.*;
  37 
  38 import java.lang.reflect.*;
  39 import java.security.AccessController;
  40 import java.security.PrivilegedAction;
  41 
  42 import javafx.beans.value.ObservableValue;
  43 import com.sun.javafx.reflect.FieldUtil;
  44 import com.sun.javafx.reflect.MethodUtil;
  45 import com.sun.javafx.reflect.ReflectUtil;
  46 
  47 /**
  48  * Exposes Java Bean properties of an object via the {@link Map} interface.
  49  * A call to {@link Map#get(Object)} invokes the getter for the corresponding
  50  * property, and a call to {@link Map#put(Object, Object)} invokes the
  51  * property's setter. Appending a "Property" suffix to the key returns the
  52  * corresponding property model.
  53  */
  54 public class BeanAdapter extends AbstractMap<String, Object> {
  55     private final Object bean;
  56 
  57     private static class MethodCache {
  58         private final Map<String, List<Method>> methods;
  59         private final MethodCache nextClassCache;
  60 
  61         private MethodCache(Map<String, List<Method>> methods, MethodCache nextClassCache) {
  62             this.methods = methods;
  63             this.nextClassCache = nextClassCache;
  64         }
  65 
  66         private Method getMethod(String name, Class<?>... parameterTypes) {
  67             List<Method> namedMethods = methods.get(name);
  68             if (namedMethods != null) {
  69                 for (int i = 0; i < namedMethods.size(); i++) {
  70                     Method namedMethod = namedMethods.get(i);
  71                     if (namedMethod.getName().equals(name)
  72                             && Arrays.equals(namedMethod.getParameterTypes(), parameterTypes)) {
  73                         return namedMethod;
  74                     }
  75                 }
  76             }
  77 
  78             return nextClassCache != null ? nextClassCache.getMethod(name, parameterTypes) : null;
  79         }
  80 
  81     }
  82 
  83     private static final HashMap<Class<?>, MethodCache> globalMethodCache =
  84         new HashMap<>();
  85 
  86     private final MethodCache localCache;
  87 
  88     public static final String GET_PREFIX = "get";
  89     public static final String IS_PREFIX = "is";
  90     public static final String SET_PREFIX = "set";
  91     public static final String PROPERTY_SUFFIX = "Property";
  92 
  93     public static final String VALUE_OF_METHOD_NAME = "valueOf";
  94 
  95     /**
  96      * Creates a new Bean adapter.
  97      *
  98      * @param bean
  99      * The Bean object to wrap.
 100      */
 101     public BeanAdapter(Object bean) {
 102         this.bean = bean;
 103 
 104         localCache = getClassMethodCache(bean.getClass());
 105     }
 106 
 107     private static MethodCache getClassMethodCache(final Class<?> type) {
 108         if (type == Object.class) {
 109             return null;
 110         }
 111         MethodCache classMethodCache;
 112         synchronized (globalMethodCache) {
 113             if ((classMethodCache = globalMethodCache.get(type)) != null) {
 114                 return classMethodCache;
 115             }
 116             Map<String, List<Method>> classMethods = new HashMap<>();
 117 
 118             ReflectUtil.checkPackageAccess(type);
 119             if (Modifier.isPublic(type.getModifiers())) {
 120                 // only interested in public methods in public classes in
 121                 // non-restricted packages
 122                 final Method[] declaredMethods =
 123                         AccessController.doPrivileged(
 124                                 new PrivilegedAction<Method[]>() {
 125                                     @Override
 126                                     public Method[] run() {
 127                                         return type.getDeclaredMethods();
 128                                     }
 129                                 });
 130                 for (int i = 0; i < declaredMethods.length; i++) {
 131                     Method method = declaredMethods[i];
 132                     int modifiers = method.getModifiers();
 133 
 134                     if (Modifier.isPublic(modifiers) && !Modifier.isStatic(modifiers)) {
 135                         String name = method.getName();
 136                         List<Method> namedMethods = classMethods.get(name);
 137 
 138                         if (namedMethods == null) {
 139                             namedMethods = new ArrayList<>();
 140                             classMethods.put(name, namedMethods);
 141                         }
 142 
 143                         namedMethods.add(method);
 144                     }
 145                 }
 146             }
 147             MethodCache cache = new MethodCache(classMethods, getClassMethodCache(type.getSuperclass()));
 148             globalMethodCache.put(type, cache);
 149             return cache;
 150         }
 151     }
 152 
 153     /**
 154      * Returns the Bean object this adapter wraps.
 155      *
 156      * @return
 157      * The Bean object, or <tt>null</tt> if no Bean has been set.
 158      */
 159     public Object getBean() {
 160         return bean;
 161     }
 162 
 163     private Method getGetterMethod(String key) {
 164         Method getterMethod = localCache.getMethod(getMethodName(GET_PREFIX, key));
 165 
 166         if (getterMethod == null) {
 167             getterMethod = localCache.getMethod(getMethodName(IS_PREFIX, key));
 168         }
 169 
 170         return getterMethod;
 171     }
 172 
 173     private Method getSetterMethod(String key) {
 174         Class<?> type = getType(key);
 175 
 176         if (type == null) {
 177             throw new UnsupportedOperationException("Cannot determine type for property.");
 178         }
 179 
 180         return localCache.getMethod(getMethodName(SET_PREFIX, key), type);
 181     }
 182 
 183     private static String getMethodName(String prefix, String key) {
 184         return prefix + Character.toUpperCase(key.charAt(0)) + key.substring(1);
 185     }
 186 
 187     /**
 188      * Invokes the getter method for the given property.
 189      *
 190      * @param key
 191      * The property name.
 192      *
 193      * @return
 194      * The value returned by the method, or <tt>null</tt> if no such method
 195      * exists.
 196      */
 197     @Override
 198     public Object get(Object key) {
 199         if (key == null) {
 200             throw new NullPointerException();
 201         }
 202 
 203         return get(key.toString());
 204     }
 205 
 206     private Object get(String key) {
 207         Method getterMethod = key.endsWith(PROPERTY_SUFFIX) ? localCache.getMethod(key) : getGetterMethod(key);
 208 
 209         Object value;
 210         if (getterMethod != null) {
 211             try {
 212                 value = ModuleHelper.invoke(getterMethod, bean, (Object[]) null);
 213             } catch (IllegalAccessException exception) {
 214                 throw new RuntimeException(exception);
 215             } catch (InvocationTargetException exception) {
 216                 throw new RuntimeException(exception);
 217             }
 218         } else {
 219             value = null;
 220         }
 221 
 222         return value;
 223     }
 224 
 225     /**
 226      * Invokes a setter method for the given property. The
 227      * {@link #coerce(Object, Class)} method is used as needed to attempt to
 228      * convert a given value to the property type, as defined by the return
 229      * value of the getter method.
 230      *
 231      * @param key
 232      * The property name.
 233      *
 234      * @param value
 235      * The new property value.
 236      *
 237      * @return
 238      * Returns <tt>null</tt>, since returning the previous value would require
 239      * an unnecessary call to the getter method.
 240      *
 241      * @throws PropertyNotFoundException
 242      * If the given property does not exist or is read-only.
 243      */
 244     @Override
 245     public Object put(String key, Object value) {
 246         if (key == null) {
 247             throw new NullPointerException();
 248         }
 249 
 250         Method setterMethod = getSetterMethod(key);
 251 
 252         if (setterMethod == null) {
 253             throw new PropertyNotFoundException("Property \"" + key + "\" does not exist"
 254                 + " or is read-only.");
 255         }
 256 
 257         try {
 258             ModuleHelper.invoke(setterMethod, bean, new Object[] { coerce(value, getType(key)) });
 259         } catch (IllegalAccessException exception) {
 260             throw new RuntimeException(exception);
 261         } catch (InvocationTargetException exception) {
 262             throw new RuntimeException(exception);
 263         }
 264 
 265         return null;
 266     }
 267 
 268     /**
 269      * Verifies the existence of a property.
 270      *
 271      * @param key
 272      * The property name.
 273      *
 274      * @return
 275      * <tt>true</tt> if the property exists; <tt>false</tt>, otherwise.
 276      */
 277     @Override
 278     public boolean containsKey(Object key) {
 279         if (key == null) {
 280             throw new NullPointerException();
 281         }
 282 
 283         return getType(key.toString()) != null;
 284     }
 285 
 286     @Override
 287     public Set<Entry<String, Object>> entrySet() {
 288         throw new UnsupportedOperationException();
 289     }
 290 
 291     /**
 292      * Tests the mutability of a property.
 293      *
 294      * @param key
 295      * The property name.
 296      *
 297      * @return
 298      * <tt>true</tt> if the property is read-only; <tt>false</tt>, otherwise.
 299      */
 300     public boolean isReadOnly(String key) {
 301         if (key == null) {
 302             throw new NullPointerException();
 303         }
 304 
 305         return getSetterMethod(key) == null;
 306     }
 307 
 308     /**
 309      * Returns the property model for the given property.
 310      *
 311      * @param key
 312      * The property name.
 313      *
 314      * @return
 315      * The named property model, or <tt>null</tt> if no such property exists.
 316      */
 317     @SuppressWarnings("unchecked")
 318     public <T> ObservableValue<T> getPropertyModel(String key) {
 319         if (key == null) {
 320             throw new NullPointerException();
 321         }
 322 
 323         return (ObservableValue<T>)get(key + BeanAdapter.PROPERTY_SUFFIX);
 324     }
 325 
 326     /**
 327      * Returns the type of a property.
 328      *
 329      * @param key
 330      * The property name.
 331      */
 332     public Class<?> getType(String key) {
 333         if (key == null) {
 334             throw new NullPointerException();
 335         }
 336 
 337         Method getterMethod = getGetterMethod(key);
 338 
 339         return (getterMethod == null) ? null : getterMethod.getReturnType();
 340     }
 341 
 342     /**
 343      * Returns the generic type of a property.
 344      *
 345      * @param key
 346      * The property name.
 347      */
 348     public Type getGenericType(String key) {
 349         if (key == null) {
 350             throw new NullPointerException();
 351         }
 352 
 353         Method getterMethod = getGetterMethod(key);
 354 
 355         return (getterMethod == null) ? null : getterMethod.getGenericReturnType();
 356     }
 357 
 358     @Override
 359     public boolean equals(Object object) {
 360         boolean equals = false;
 361 
 362         if (object instanceof BeanAdapter) {
 363             BeanAdapter beanAdapter = (BeanAdapter)object;
 364             equals = (bean == beanAdapter.bean);
 365         }
 366 
 367         return equals;
 368     }
 369 
 370     @Override
 371     public int hashCode() {
 372         return (bean == null) ? -1 : bean.hashCode();
 373     }
 374 
 375     /**
 376      * Coerces a value to a given type.
 377      *
 378      * @param value
 379      * @param type
 380      *
 381      * @return
 382      * The coerced value.
 383      */
 384     @SuppressWarnings("unchecked")
 385     public static <T> T coerce(Object value, Class<? extends T> type) {
 386         if (type == null) {
 387             throw new NullPointerException();
 388         }
 389 
 390         Object coercedValue = null;
 391 
 392         if (value == null) {
 393             // Null values can only be coerced to null
 394             coercedValue = null;
 395         } else if (type.isAssignableFrom(value.getClass())) {
 396             // Value doesn't require coercion
 397             coercedValue = value;
 398         } else if (type == Boolean.class
 399             || type == Boolean.TYPE) {
 400             coercedValue = Boolean.valueOf(value.toString());
 401         } else if (type == Character.class
 402             || type == Character.TYPE) {
 403             coercedValue = value.toString().charAt(0);
 404         } else if (type == Byte.class
 405             || type == Byte.TYPE) {
 406             if (value instanceof Number) {
 407                 coercedValue = ((Number)value).byteValue();
 408             } else {
 409                 coercedValue = Byte.valueOf(value.toString());
 410             }
 411         } else if (type == Short.class
 412             || type == Short.TYPE) {
 413             if (value instanceof Number) {
 414                 coercedValue = ((Number)value).shortValue();
 415             } else {
 416                 coercedValue = Short.valueOf(value.toString());
 417             }
 418         } else if (type == Integer.class
 419             || type == Integer.TYPE) {
 420             if (value instanceof Number) {
 421                 coercedValue = ((Number)value).intValue();
 422             } else {
 423                 coercedValue = Integer.valueOf(value.toString());
 424             }
 425         } else if (type == Long.class
 426             || type == Long.TYPE) {
 427             if (value instanceof Number) {
 428                 coercedValue = ((Number)value).longValue();
 429             } else {
 430                 coercedValue = Long.valueOf(value.toString());
 431             }
 432         } else if (type == BigInteger.class) {
 433             if (value instanceof Number) {
 434                 coercedValue = BigInteger.valueOf(((Number)value).longValue());
 435             } else {
 436                 coercedValue = new BigInteger(value.toString());
 437             }
 438         } else if (type == Float.class
 439             || type == Float.TYPE) {
 440             if (value instanceof Number) {
 441                 coercedValue = ((Number)value).floatValue();
 442             } else {
 443                 coercedValue = Float.valueOf(value.toString());
 444             }
 445         } else if (type == Double.class
 446             || type == Double.TYPE) {
 447             if (value instanceof Number) {
 448                 coercedValue = ((Number)value).doubleValue();
 449             } else {
 450                 coercedValue = Double.valueOf(value.toString());
 451             }
 452         } else if (type == Number.class) {
 453             String number = value.toString();
 454             if (number.contains(".")) {
 455                 coercedValue = Double.valueOf(number);
 456             } else {
 457                 coercedValue = Long.valueOf(number);
 458             }
 459         } else if (type == BigDecimal.class) {
 460             if (value instanceof Number) {
 461                 coercedValue = BigDecimal.valueOf(((Number)value).doubleValue());
 462             } else {
 463                 coercedValue = new BigDecimal(value.toString());
 464             }
 465         } else if (type == Class.class) {
 466             try {
 467                 final String className = value.toString();
 468                 ReflectUtil.checkPackageAccess(className);
 469                 final ClassLoader cl = Thread.currentThread().getContextClassLoader();
 470                 coercedValue = Class.forName(
 471                         className,
 472                         false,
 473                         cl);
 474             } catch (ClassNotFoundException exception) {
 475                 throw new IllegalArgumentException(exception);
 476             }
 477         } else {
 478             Class<?> valueType = value.getClass();
 479             Method valueOfMethod = null;
 480 
 481             while (valueOfMethod == null
 482                 && valueType != null) {
 483                 try {
 484                     ReflectUtil.checkPackageAccess(type);
 485                     valueOfMethod = type.getDeclaredMethod(VALUE_OF_METHOD_NAME, valueType);
 486                 } catch (NoSuchMethodException exception) {
 487                     // No-op
 488                 }
 489 
 490                 if (valueOfMethod == null) {
 491                     valueType = valueType.getSuperclass();
 492                 }
 493             }
 494 
 495             if (valueOfMethod == null) {
 496                 throw new IllegalArgumentException("Unable to coerce " + value + " to " + type + ".");
 497             }
 498 
 499             if (type.isEnum()
 500                 && value instanceof String
 501                 && Character.isLowerCase(((String)value).charAt(0))) {
 502                 value = toAllCaps((String)value);
 503             }
 504 
 505             try {
 506                 coercedValue = ModuleHelper.invoke(valueOfMethod, null, new Object[] { value });
 507             } catch (IllegalAccessException exception) {
 508                 throw new RuntimeException(exception);
 509             } catch (InvocationTargetException exception) {
 510                 throw new RuntimeException(exception);
 511             } catch (SecurityException exception) {
 512                 throw new RuntimeException(exception);
 513             }
 514         }
 515 
 516         return (T)coercedValue;
 517     }
 518 
 519     /**
 520      * Invokes the static getter method for the given property.
 521      *
 522      * @param target
 523      * The object to which the property is attached.
 524      *
 525      * @param sourceType
 526      * The class that defines the property.
 527      *
 528      * @param key
 529      * The property name.
 530      *
 531      * @return
 532      * The value returned by the method, or <tt>null</tt> if no such method
 533      * exists.
 534      */
 535     @SuppressWarnings("unchecked")
 536     public static <T> T get(Object target, Class<?> sourceType, String key) {
 537         T value = null;
 538 
 539         Class<?> targetType = target.getClass();
 540         Method getterMethod = getStaticGetterMethod(sourceType, key, targetType);
 541 
 542         if (getterMethod != null) {
 543             try {
 544                 value = (T) ModuleHelper.invoke(getterMethod, null, new Object[] { target } );
 545             } catch (InvocationTargetException exception) {
 546                 throw new RuntimeException(exception);
 547             } catch (IllegalAccessException exception) {
 548                 throw new RuntimeException(exception);
 549             }
 550         }
 551 
 552         return value;
 553     }
 554 
 555     /**
 556      * Invokes a static setter method for the given property. If the value is
 557      * <tt>null</tt> or there is no explicit setter for a given type, the
 558      * {@link #coerce(Object, Class)} method is used to attempt to convert the
 559      * value to the actual property type (defined by the return value of the
 560      * getter method).
 561      *
 562      * @param target
 563      * The object to which the property is or will be attached.
 564      *
 565      * @param sourceType
 566      * The class that defines the property.
 567      *
 568      * @param key
 569      * The property name.
 570      *
 571      * @param value
 572      * The new property value.
 573      *
 574      * @throws PropertyNotFoundException
 575      * If the given static property does not exist or is read-only.
 576      */
 577     public static void put(Object target, Class<?> sourceType, String key, Object value) {
 578         Class<?> targetType = target.getClass();
 579 
 580         Method setterMethod = null;
 581         if (value != null) {
 582             setterMethod = getStaticSetterMethod(sourceType, key, value.getClass(), targetType);
 583         }
 584 
 585         if (setterMethod == null) {
 586             // Get the property type and attempt to coerce the value to it
 587             Class<?> propertyType = getType(sourceType, key, targetType);
 588 
 589             if (propertyType != null) {
 590                 setterMethod = getStaticSetterMethod(sourceType, key, propertyType, targetType);
 591                 value = coerce(value, propertyType);
 592             }
 593         }
 594 
 595         if (setterMethod == null) {
 596             throw new PropertyNotFoundException("Static property \"" + key + "\" does not exist"
 597                 + " or is read-only.");
 598         }
 599 
 600         // Invoke the setter
 601         try {
 602             ModuleHelper.invoke(setterMethod, null, new Object[] { target, value });
 603         } catch (InvocationTargetException exception) {
 604             throw new RuntimeException(exception);
 605         } catch (IllegalAccessException exception) {
 606             throw new RuntimeException(exception);
 607         }
 608     }
 609 
 610     /**
 611      * Tests the existence of a static property.
 612      *
 613      * @param sourceType
 614      * The class that defines the property.
 615      *
 616      * @param key
 617      * The property name.
 618      *
 619      * @param targetType
 620      * The type of the object to which the property applies.
 621      *
 622      * @return
 623      * <tt>true</tt> if the property exists; <tt>false</tt>, otherwise.
 624      */
 625     public static boolean isDefined(Class<?> sourceType, String key, Class<?> targetType) {
 626         return (getStaticGetterMethod(sourceType, key, targetType) != null);
 627     }
 628 
 629     /**
 630      * Returns the type of a static property.
 631      *
 632      * @param sourceType
 633      * The class that defines the property.
 634      *
 635      * @param key
 636      * The property name.
 637      *
 638      * @param targetType
 639      * The type of the object to which the property applies.
 640      */
 641     public static Class<?> getType(Class<?> sourceType, String key, Class<?> targetType) {
 642         Method getterMethod = getStaticGetterMethod(sourceType, key, targetType);
 643         return (getterMethod == null) ? null : getterMethod.getReturnType();
 644     }
 645 
 646     /**
 647      * Returns the generic type of a static property.
 648      *
 649      * @param sourceType
 650      * The class that defines the property.
 651      *
 652      * @param key
 653      * The property name.
 654      *
 655      * @param targetType
 656      * The type of the object to which the property applies.
 657      */
 658     public static Type getGenericType(Class<?> sourceType, String key, Class<?> targetType) {
 659         Method getterMethod = getStaticGetterMethod(sourceType, key, targetType);
 660         return (getterMethod == null) ? null : getterMethod.getGenericReturnType();
 661     }
 662 
 663     /**
 664      * Determines the type of a list item.
 665      *
 666      * @param listType
 667      */
 668     public static Class<?> getListItemType(Type listType) {
 669         Type itemType = getGenericListItemType(listType);
 670 
 671         if (itemType instanceof ParameterizedType) {
 672             itemType = ((ParameterizedType)itemType).getRawType();
 673         }
 674 
 675         return (Class<?>)itemType;
 676     }
 677 
 678     /**
 679      * Determines the type of a map value.
 680      *
 681      * @param mapType
 682      */
 683     public static Class<?> getMapValueType(Type mapType) {
 684         Type valueType = getGenericMapValueType(mapType);
 685 
 686         if (valueType instanceof ParameterizedType) {
 687             valueType = ((ParameterizedType)valueType).getRawType();
 688         }
 689 
 690         return (Class<?>)valueType;
 691     }
 692 
 693     /**
 694      * Determines the type of a list item.
 695      *
 696      * @param listType
 697      */
 698     public static Type getGenericListItemType(Type listType) {
 699         Type itemType = null;
 700 
 701         Type parentType = listType;
 702         while (parentType != null) {
 703             if (parentType instanceof ParameterizedType) {
 704                 ParameterizedType parameterizedType = (ParameterizedType)parentType;
 705                 Class<?> rawType = (Class<?>)parameterizedType.getRawType();
 706 
 707                 if (List.class.isAssignableFrom(rawType)) {
 708                     itemType = parameterizedType.getActualTypeArguments()[0];
 709                 }
 710 
 711                 break;
 712             }
 713 
 714             Class<?> classType = (Class<?>)parentType;
 715             Type[] genericInterfaces = classType.getGenericInterfaces();
 716 
 717             for (int i = 0; i < genericInterfaces.length; i++) {
 718                 Type genericInterface = genericInterfaces[i];
 719 
 720                 if (genericInterface instanceof ParameterizedType) {
 721                     ParameterizedType parameterizedType = (ParameterizedType)genericInterface;
 722                     Class<?> interfaceType = (Class<?>)parameterizedType.getRawType();
 723 
 724                     if (List.class.isAssignableFrom(interfaceType)) {
 725                         itemType = parameterizedType.getActualTypeArguments()[0];
 726                         break;
 727                     }
 728                 }
 729             }
 730 
 731             if (itemType != null) {
 732                 break;
 733             }
 734 
 735             parentType = classType.getGenericSuperclass();
 736         }
 737 
 738         if (itemType != null && itemType instanceof TypeVariable<?>) {
 739             itemType = Object.class;
 740         }
 741 
 742         return itemType;
 743     }
 744 
 745     /**
 746      * Determines the type of a map value.
 747      *
 748      * @param mapType
 749      */
 750     public static Type getGenericMapValueType(Type mapType) {
 751         Type valueType = null;
 752 
 753         Type parentType = mapType;
 754         while (parentType != null) {
 755             if (parentType instanceof ParameterizedType) {
 756                 ParameterizedType parameterizedType = (ParameterizedType)parentType;
 757                 Class<?> rawType = (Class<?>)parameterizedType.getRawType();
 758 
 759                 if (Map.class.isAssignableFrom(rawType)) {
 760                     valueType = parameterizedType.getActualTypeArguments()[1];
 761                 }
 762 
 763                 break;
 764             }
 765 
 766             Class<?> classType = (Class<?>)parentType;
 767             Type[] genericInterfaces = classType.getGenericInterfaces();
 768 
 769             for (int i = 0; i < genericInterfaces.length; i++) {
 770                 Type genericInterface = genericInterfaces[i];
 771 
 772                 if (genericInterface instanceof ParameterizedType) {
 773                     ParameterizedType parameterizedType = (ParameterizedType)genericInterface;
 774                     Class<?> interfaceType = (Class<?>)parameterizedType.getRawType();
 775 
 776                     if (Map.class.isAssignableFrom(interfaceType)) {
 777                         valueType = parameterizedType.getActualTypeArguments()[1];
 778                         break;
 779                     }
 780                 }
 781             }
 782 
 783             if (valueType != null) {
 784                 break;
 785             }
 786 
 787             parentType = classType.getGenericSuperclass();
 788         }
 789 
 790         if (valueType != null && valueType instanceof TypeVariable<?>) {
 791             valueType = Object.class;
 792         }
 793 
 794         return valueType;
 795     }
 796 
 797     /**
 798      * Returns the value of a named constant.
 799      *
 800      * @param type
 801      * The type that defines the constant.
 802      *
 803      * @param name
 804      * The name of the constant.
 805      */
 806     public static Object getConstantValue(Class<?> type, String name) {
 807         if (type == null) {
 808             throw new IllegalArgumentException();
 809         }
 810 
 811         if (name == null) {
 812             throw new IllegalArgumentException();
 813         }
 814 
 815         Field field;
 816         try {
 817             field = FieldUtil.getField(type, name);
 818         } catch (NoSuchFieldException exception) {
 819             throw new IllegalArgumentException(exception);
 820         }
 821 
 822         int fieldModifiers = field.getModifiers();
 823         if ((fieldModifiers & Modifier.STATIC) == 0
 824             || (fieldModifiers & Modifier.FINAL) == 0) {
 825             throw new IllegalArgumentException("Field is not a constant.");
 826         }
 827 
 828         Object value;
 829         try {
 830             value = field.get(null);
 831         } catch (IllegalAccessException exception) {
 832             throw new IllegalArgumentException(exception);
 833         }
 834 
 835         return value;
 836     }
 837 
 838     private static Method getStaticGetterMethod(Class<?> sourceType, String key,
 839         Class<?> targetType) {
 840         if (sourceType == null) {
 841             throw new NullPointerException();
 842         }
 843 
 844         if (key == null) {
 845             throw new NullPointerException();
 846         }
 847 
 848         Method method = null;
 849 
 850         if (targetType != null) {
 851             key = Character.toUpperCase(key.charAt(0)) + key.substring(1);
 852 
 853             String getMethodName = GET_PREFIX + key;
 854             String isMethodName = IS_PREFIX + key;
 855 
 856             try {
 857                 method = MethodUtil.getMethod(sourceType, getMethodName, new Class[] { targetType });
 858             } catch (NoSuchMethodException exception) {
 859                 // No-op
 860             }
 861 
 862             if (method == null) {
 863                 try {
 864                     method = MethodUtil.getMethod(sourceType, isMethodName, new Class[] { targetType });
 865                 } catch (NoSuchMethodException exception) {
 866                     // No-op
 867                 }
 868             }
 869 
 870             // Check for interfaces
 871             if (method == null) {
 872                 Class<?>[] interfaces = targetType.getInterfaces();
 873                 for (int i = 0; i < interfaces.length; i++) {
 874                     try {
 875                         method = MethodUtil.getMethod(sourceType, getMethodName, new Class[] { interfaces[i] });
 876                     } catch (NoSuchMethodException exception) {
 877                         // No-op
 878                     }
 879 
 880                     if (method == null) {
 881                         try {
 882                             method = MethodUtil.getMethod(sourceType, isMethodName, new Class[] { interfaces[i] });
 883                         } catch (NoSuchMethodException exception) {
 884                             // No-op
 885                         }
 886                     }
 887 
 888                     if (method != null) {
 889                         break;
 890                     }
 891                 }
 892             }
 893 
 894             if (method == null) {
 895                 method = getStaticGetterMethod(sourceType, key, targetType.getSuperclass());
 896             }
 897         }
 898 
 899         return method;
 900     }
 901 
 902     private static Method getStaticSetterMethod(Class<?> sourceType, String key,
 903         Class<?> valueType, Class<?> targetType) {
 904         if (sourceType == null) {
 905             throw new NullPointerException();
 906         }
 907 
 908         if (key == null) {
 909             throw new NullPointerException();
 910         }
 911 
 912         if (valueType == null) {
 913             throw new NullPointerException();
 914         }
 915 
 916         Method method = null;
 917 
 918         if (targetType != null) {
 919             key = Character.toUpperCase(key.charAt(0)) + key.substring(1);
 920 
 921             String setMethodName = SET_PREFIX + key;
 922             try {
 923                 method = MethodUtil.getMethod(sourceType, setMethodName, new Class[] { targetType, valueType });
 924             } catch (NoSuchMethodException exception) {
 925                 // No-op
 926             }
 927 
 928             // Check for interfaces
 929             if (method == null) {
 930                 Class<?>[] interfaces = targetType.getInterfaces();
 931                 for (int i = 0; i < interfaces.length; i++) {
 932                     try {
 933                         method = MethodUtil.getMethod(sourceType, setMethodName, new Class[] { interfaces[i], valueType });
 934                     } catch (NoSuchMethodException exception) {
 935                         // No-op
 936                     }
 937 
 938                     if (method != null) {
 939                         break;
 940                     }
 941                 }
 942             }
 943 
 944             if (method == null) {
 945                 method = getStaticSetterMethod(sourceType, key, valueType, targetType.getSuperclass());
 946             }
 947         }
 948 
 949         return method;
 950     }
 951 
 952     private static String toAllCaps(String value) {
 953         if (value == null) {
 954             throw new NullPointerException();
 955         }
 956 
 957         StringBuilder allCapsBuilder = new StringBuilder();
 958 
 959         for (int i = 0, n = value.length(); i < n; i++) {
 960             char c = value.charAt(i);
 961 
 962             if (Character.isUpperCase(c)) {
 963                 allCapsBuilder.append('_');
 964             }
 965 
 966             allCapsBuilder.append(Character.toUpperCase(c));
 967         }
 968 
 969         return allCapsBuilder.toString();
 970     }
 971 }