/*

  * 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.commons.beanutils.locale;

 import org.apache.commons.beanutils.BeanUtilsBean;

 import org.apache.commons.beanutils.ConvertUtils;

 import org.apache.commons.beanutils.ConvertUtilsBean;

 import org.apache.commons.beanutils.DynaBean;

 import org.apache.commons.beanutils.DynaClass;

 import org.apache.commons.beanutils.DynaProperty;

 import org.apache.commons.beanutils.MappedPropertyDescriptor;

 import org.apache.commons.beanutils.PropertyUtilsBean;

 import org.apache.commons.beanutils.ContextClassLoaderLocal;

 import org.apache.commons.beanutils.expression.Resolver;

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

 import java.beans.IndexedPropertyDescriptor;

 import java.beans.PropertyDescriptor;

 import java.lang.reflect.InvocationTargetException;

 import java.util.Locale;

 /**

  * <p>Utility methods for populating JavaBeans properties

  * via reflection in a locale-dependent manner.</p>

  *

  * @author Craig R. McClanahan

  * @author Ralph Schaer

  * @author Chris Audley

  * @author Rey Francois

  * @author Gregor Rayman

  * @author Yauheny Mikulski

  * @since 1.7

  */

 public class LocaleBeanUtilsBean extends BeanUtilsBean {

     /** 

      * Contains <code>LocaleBeanUtilsBean</code> instances indexed by context classloader.

      */

     private static final ContextClassLoaderLocal 

             LOCALE_BEANS_BY_CLASSLOADER = new ContextClassLoaderLocal() {

                         // Creates the default instance used when the context classloader is unavailable

                         protected Object initialValue() {

                             return new LocaleBeanUtilsBean();

                         }

                     };

      /**

       * Gets singleton instance

       *

       * @return the singleton instance

       */

      public static LocaleBeanUtilsBean getLocaleBeanUtilsInstance() {

         return (LocaleBeanUtilsBean)LOCALE_BEANS_BY_CLASSLOADER.get();

      }

     /** 

      * Sets the instance which provides the functionality for {@link LocaleBeanUtils}.

      * This is a pseudo-singleton - an single instance is provided per (thread) context classloader.

      * This mechanism provides isolation for web apps deployed in the same container.

      * 

      * @param newInstance a new singleton instance

      */

     public static void setInstance(LocaleBeanUtilsBean newInstance) {

         LOCALE_BEANS_BY_CLASSLOADER.set(newInstance);

     }

     /** All logging goes through this logger */

     private Log log = LogFactory.getLog(LocaleBeanUtilsBean.class);

     // ----------------------------------------------------- Instance Variables

     /** Convertor used by this class */

     private LocaleConvertUtilsBean localeConvertUtils;

     // --------------------------------------------------------- Constructors

     /** Construct instance with standard conversion bean */

     public LocaleBeanUtilsBean() {

         this.localeConvertUtils = new LocaleConvertUtilsBean();

     }

     /** 

      * Construct instance that uses given locale conversion

      *

      * @param localeConvertUtils use this <code>localeConvertUtils</code> to perform

      * conversions

      * @param convertUtilsBean use this for standard conversions

      * @param propertyUtilsBean use this for property conversions

      */

     public LocaleBeanUtilsBean(

                             LocaleConvertUtilsBean localeConvertUtils,

                             ConvertUtilsBean convertUtilsBean,

                             PropertyUtilsBean propertyUtilsBean) {

         super(convertUtilsBean, propertyUtilsBean);

         this.localeConvertUtils = localeConvertUtils;

     }

     /** 

      * Construct instance that uses given locale conversion

      *

      * @param localeConvertUtils use this <code>localeConvertUtils</code> to perform

      * conversions

      */

     public LocaleBeanUtilsBean(LocaleConvertUtilsBean localeConvertUtils) {

         this.localeConvertUtils = localeConvertUtils;

     }

     // --------------------------------------------------------- Public Methods

     /**

      * Gets the bean instance used for conversions

      *

      * @return the locale converter bean instance

      */

     public LocaleConvertUtilsBean getLocaleConvertUtils() {

         return localeConvertUtils;

     }

     /**

      * Gets the default Locale

      * @return the default locale

      */

     public Locale getDefaultLocale() {

         return getLocaleConvertUtils().getDefaultLocale();

     }

     /**

      * Sets the default Locale.

      *

      * @param locale the default locale

      */

     public void setDefaultLocale(Locale locale) {

         getLocaleConvertUtils().setDefaultLocale(locale);

     }

     /**

      * Is the pattern to be applied localized

      * (Indicate whether the pattern is localized or not)

      *

      * @return <code>true</code> if pattern is localized,

      * otherwise <code>false</code>

      */

     public boolean getApplyLocalized() {

         return getLocaleConvertUtils().getApplyLocalized();

     }

     /**

      * Sets whether the pattern is applied localized

      * (Indicate whether the pattern is localized or not)

      *

      * @param newApplyLocalized <code>true</code> if pattern is localized,

      * otherwise <code>false</code>

      */

     public void setApplyLocalized(boolean newApplyLocalized) {

         getLocaleConvertUtils().setApplyLocalized(newApplyLocalized);

     }

     // --------------------------------------------------------- Public Methods

     /**

      * Return the value of the specified locale-sensitive indexed property

      * of the specified bean, as a String. The zero-relative index of the

      * required value must be included (in square brackets) as a suffix to

      * the property name, or <code>IllegalArgumentException</code> will be

      * thrown.

      *

      * @param bean Bean whose property is to be extracted

      * @param name <code>propertyname[index]</code> of the property value

      *  to be extracted

      * @param pattern The conversion pattern

      * @return The indexed property's value, converted to a String

      *

      * @exception IllegalAccessException if the caller does not have

      *  access to the property accessor method

      * @exception InvocationTargetException if the property accessor method

      *  throws an exception

      * @exception NoSuchMethodException if an accessor method for this

      *  propety cannot be found

      */

     public String getIndexedProperty(

                                     Object bean, 

                                     String name, 

                                     String pattern)

                                         throws 

                                             IllegalAccessException, 

                                             InvocationTargetException,

                                             NoSuchMethodException {

         Object value = getPropertyUtils().getIndexedProperty(bean, name);

         return getLocaleConvertUtils().convert(value, pattern);

     }

     /**

      * Return the value of the specified locale-sensitive indexed property

      * of the specified bean, as a String using the default conversion pattern of

      * the corresponding {@link LocaleConverter}. The zero-relative index

      * of the required value must be included (in square brackets) as a suffix

      * to the property name, or <code>IllegalArgumentException</code> will be thrown.

      *

      * @param bean Bean whose property is to be extracted

      * @param name <code>propertyname[index]</code> of the property value

      *  to be extracted

      * @return The indexed property's value, converted to a String

      *

      * @exception IllegalAccessException if the caller does not have

      *  access to the property accessor method

      * @exception InvocationTargetException if the property accessor method

      *  throws an exception

      * @exception NoSuchMethodException if an accessor method for this

      *  propety cannot be found

      */

     public String getIndexedProperty(

                                     Object bean, 

                                     String name)

                                         throws 

                                             IllegalAccessException, 

                                             InvocationTargetException,

                                             NoSuchMethodException {

         return getIndexedProperty(bean, name, null);

     }

     /**

      * Return the value of the specified locale-sensetive indexed property

      * of the specified bean, as a String using the specified conversion pattern.

      * The index is specified as a method parameter and

      * must *not* be included in the property name expression

      *

      * @param bean Bean whose property is to be extracted

      * @param name Simple property name of the property value to be extracted

      * @param index Index of the property value to be extracted

      * @param pattern The conversion pattern

      * @return The indexed property's value, converted to a String

      *

      * @exception IllegalAccessException if the caller does not have

      *  access to the property accessor method

      * @exception InvocationTargetException if the property accessor method

      *  throws an exception

      * @exception NoSuchMethodException if an accessor method for this

      *  propety cannot be found

      */

     public String getIndexedProperty(Object bean,

                                             String name, int index, String pattern)

             throws IllegalAccessException, InvocationTargetException,

             NoSuchMethodException {

         Object value = getPropertyUtils().getIndexedProperty(bean, name, index);

         return getLocaleConvertUtils().convert(value, pattern);

     }

     /**

      * Return the value of the specified locale-sensetive indexed property

      * of the specified bean, as a String using the default conversion pattern of

      * the corresponding {@link LocaleConverter}.

      * The index is specified as a method parameter and

      * must *not* be included in the property name expression

      *

      * @param bean Bean whose property is to be extracted

      * @param name Simple property name of the property value to be extracted

      * @param index Index of the property value to be extracted

      * @return The indexed property's value, converted to a String

      *

      * @exception IllegalAccessException if the caller does not have

      *  access to the property accessor method

      * @exception InvocationTargetException if the property accessor method

      *  throws an exception

      * @exception NoSuchMethodException if an accessor method for this

      *  propety cannot be found

      */

     public String getIndexedProperty(Object bean,

                                             String name, int index)

             throws IllegalAccessException, InvocationTargetException,

             NoSuchMethodException {

         return getIndexedProperty(bean, name, index, null);

     }

     /**

      * Return the value of the specified simple locale-sensitive property

      * of the specified bean, converted to a String using the specified

      * conversion pattern.

      *

      * @param bean Bean whose property is to be extracted

      * @param name Name of the property to be extracted

      * @param pattern The conversion pattern

      * @return The property's value, converted to a String

      *

      * @exception IllegalAccessException if the caller does not have

      *  access to the property accessor method

      * @exception InvocationTargetException if the property accessor method

      *  throws an exception

      * @exception NoSuchMethodException if an accessor method for this

      *  propety cannot be found

      */

     public String getSimpleProperty(Object bean, String name, String pattern)

             throws IllegalAccessException, InvocationTargetException,

             NoSuchMethodException {

         Object value = getPropertyUtils().getSimpleProperty(bean, name);

         return getLocaleConvertUtils().convert(value, pattern);

     }

     /**

      * Return the value of the specified simple locale-sensitive property

      * of the specified bean, converted to a String using the default

      * conversion pattern of the corresponding {@link LocaleConverter}.

      *

      * @param bean Bean whose property is to be extracted

      * @param name Name of the property to be extracted

      * @return The property's value, converted to a String

      *

      * @exception IllegalAccessException if the caller does not have

      *  access to the property accessor method

      * @exception InvocationTargetException if the property accessor method

      *  throws an exception

      * @exception NoSuchMethodException if an accessor method for this

      *  propety cannot be found

      */

     public String getSimpleProperty(Object bean, String name)

             throws IllegalAccessException, InvocationTargetException,

             NoSuchMethodException {

         return getSimpleProperty(bean, name, null);

     }

     /**

      * Return the value of the specified mapped locale-sensitive property

      * of the specified bean, as a String using the specified conversion pattern.

      * The key is specified as a method parameter and must *not* be included in

      * the property name expression.

      *

      * @param bean Bean whose property is to be extracted

      * @param name Simple property name of the property value to be extracted

      * @param key Lookup key of the property value to be extracted

      * @param pattern The conversion pattern

      * @return The mapped property's value, converted to a String

      *

      * @exception IllegalAccessException if the caller does not have

      *  access to the property accessor method

      * @exception InvocationTargetException if the property accessor method

      *  throws an exception

      * @exception NoSuchMethodException if an accessor method for this

      *  propety cannot be found

      */

     public String getMappedProperty(

                                     Object bean,

                                     String name, 

                                     String key, 

                                     String pattern)

                                         throws 

                                             IllegalAccessException, 

                                             InvocationTargetException,

                                             NoSuchMethodException {

         Object value = getPropertyUtils().getMappedProperty(bean, name, key);

         return getLocaleConvertUtils().convert(value, pattern);

     }

     /**

      * Return the value of the specified mapped locale-sensitive property

      * of the specified bean, as a String

      * The key is specified as a method parameter and must *not* be included

      * in the property name expression

      *

      * @param bean Bean whose property is to be extracted

      * @param name Simple property name of the property value to be extracted

      * @param key Lookup key of the property value to be extracted

      * @return The mapped property's value, converted to a String

      *

      * @exception IllegalAccessException if the caller does not have

      *  access to the property accessor method

      * @exception InvocationTargetException if the property accessor method

      *  throws an exception

      * @exception NoSuchMethodException if an accessor method for this

      *  propety cannot be found

      */

     public String getMappedProperty(Object bean,

                                            String name, String key)

             throws IllegalAccessException, InvocationTargetException,

             NoSuchMethodException {

         return getMappedProperty(bean, name, key, null);

     }

     /**

      * Return the value of the specified locale-sensitive mapped property

      * of the specified bean, as a String using the specified pattern.

      * The String-valued key of the required value

      * must be included (in parentheses) as a suffix to

      * the property name, or <code>IllegalArgumentException</code> will be

      * thrown.

      *

      * @param bean Bean whose property is to be extracted

      * @param name <code>propertyname(index)</code> of the property value

      *  to be extracted

      * @param pattern The conversion pattern

      * @return The mapped property's value, converted to a String

      *

      * @exception IllegalAccessException if the caller does not have

      *  access to the property accessor method

      * @exception InvocationTargetException if the property accessor method

      *  throws an exception

      * @exception NoSuchMethodException if an accessor method for this

      *  propety cannot be found

      */

     public String getMappedPropertyLocale(

                                         Object bean, 

                                         String name, 

                                         String pattern)

                                             throws 

                                                 IllegalAccessException, 

                                                 InvocationTargetException,

                                                 NoSuchMethodException {

         Object value = getPropertyUtils().getMappedProperty(bean, name);

         return getLocaleConvertUtils().convert(value, pattern);

     }

     /**

      * Return the value of the specified locale-sensitive mapped property

      * of the specified bean, as a String using the default

      * conversion pattern of the corresponding {@link LocaleConverter}.

      * The String-valued key of the required value

      * must be included (in parentheses) as a suffix to

      * the property name, or <code>IllegalArgumentException</code> will be

      * thrown.

      *

      * @param bean Bean whose property is to be extracted

      * @param name <code>propertyname(index)</code> of the property value

      *  to be extracted

      * @return The mapped property's value, converted to a String

      *

      * @exception IllegalAccessException if the caller does not have

      *  access to the property accessor method

      * @exception InvocationTargetException if the property accessor method

      *  throws an exception

      * @exception NoSuchMethodException if an accessor method for this

      *  propety cannot be found

      */

     public String getMappedProperty(Object bean, String name)

                                     throws 

                                         IllegalAccessException, 

                                         InvocationTargetException,

                                         NoSuchMethodException {

         return getMappedPropertyLocale(bean, name, null);

     }

     /**

      * Return the value of the (possibly nested) locale-sensitive property

      * of the specified name, for the specified bean,

      * as a String using the specified pattern.

      *

      * @param bean Bean whose property is to be extracted

      * @param name Possibly nested name of the property to be extracted

      * @param pattern The conversion pattern

      * @return The nested property's value, converted to a String

      *

      * @exception IllegalAccessException if the caller does not have

      *  access to the property accessor method

      * @exception IllegalArgumentException if a nested reference to a

      *  property returns null

      * @exception InvocationTargetException if the property accessor method

      *  throws an exception

      * @exception NoSuchMethodException if an accessor method for this

      *  propety cannot be found

      */

     public String getNestedProperty(    

                                     Object bean, 

                                     String name, 

                                     String pattern)

                                         throws 

                                             IllegalAccessException, 

                                             InvocationTargetException,

                                             NoSuchMethodException {

         Object value = getPropertyUtils().getNestedProperty(bean, name);

         return getLocaleConvertUtils().convert(value, pattern);

     }

     /**

      * Return the value of the (possibly nested) locale-sensitive property

      * of the specified name, for the specified bean, as a String using the default

      * conversion pattern of the corresponding {@link LocaleConverter}.

      *

      * @param bean Bean whose property is to be extracted

      * @param name Possibly nested name of the property to be extracted

      * @return The nested property's value, converted to a String

      *

      * @exception IllegalAccessException if the caller does not have

      *  access to the property accessor method

      * @exception IllegalArgumentException if a nested reference to a

      *  property returns null

      * @exception InvocationTargetException if the property accessor method

      *  throws an exception

      * @exception NoSuchMethodException if an accessor method for this

      *  propety cannot be found

      */

     public String getNestedProperty(Object bean, String name)

                                     throws 

                                         IllegalAccessException, 

                                         InvocationTargetException,

                                         NoSuchMethodException {

         return getNestedProperty(bean, name, null);

     }

     /**

      * Return the value of the specified locale-sensitive property

      * of the specified bean, no matter which property reference

      * format is used, as a String using the specified conversion pattern.

      *

      * @param bean Bean whose property is to be extracted

      * @param name Possibly indexed and/or nested name of the property

      *  to be extracted

      * @param pattern The conversion pattern

      * @return The nested property's value, converted to a String

      *

      * @exception IllegalAccessException if the caller does not have

      *  access to the property accessor method

      * @exception InvocationTargetException if the property accessor method

      *  throws an exception

      * @exception NoSuchMethodException if an accessor method for this

      *  propety cannot be found

      */

     public String getProperty(Object bean, String name, String pattern)

                                 throws 

                                     IllegalAccessException, 

                                     InvocationTargetException,

                                     NoSuchMethodException {

         return getNestedProperty(bean, name, pattern);

     }

     /**

      * Return the value of the specified locale-sensitive property

      * of the specified bean, no matter which property reference

      * format is used, as a String using the default

      * conversion pattern of the corresponding {@link LocaleConverter}.

      *

      * @param bean Bean whose property is to be extracted

      * @param name Possibly indexed and/or nested name of the property

      *  to be extracted

      * @return The property's value, converted to a String

      *

      * @exception IllegalAccessException if the caller does not have

      *  access to the property accessor method

      * @exception InvocationTargetException if the property accessor method

      *  throws an exception

      * @exception NoSuchMethodException if an accessor method for this

      *  propety cannot be found

      */

     public String getProperty(Object bean, String name)

                                 throws 

                                     IllegalAccessException, 

                                     InvocationTargetException,

                                     NoSuchMethodException {

         return getNestedProperty(bean, name);

     }

     /**

      * Set the specified locale-sensitive property value, performing type

      * conversions as required to conform to the type of the destination property

      * using the default conversion pattern of the corresponding {@link LocaleConverter}.

      *

      * @param bean Bean on which setting is to be performed

      * @param name Property name (can be nested/indexed/mapped/combo)

      * @param value Value to be set

      *

      * @exception IllegalAccessException if the caller does not have

      *  access to the property accessor method

      * @exception InvocationTargetException if the property accessor method

      *  throws an exception

      */

     public void setProperty(Object bean, String name, Object value)

                                 throws 

                                     IllegalAccessException, 

                                     InvocationTargetException {

         setProperty(bean, name, value, null);

     }

     /**

      * Set the specified locale-sensitive property value, performing type

      * conversions as required to conform to the type of the destination

      * property using the specified conversion pattern.

      *

      * @param bean Bean on which setting is to be performed

      * @param name Property name (can be nested/indexed/mapped/combo)

      * @param value Value to be set

      * @param pattern The conversion pattern

      *

      * @exception IllegalAccessException if the caller does not have

      *  access to the property accessor method

      * @exception InvocationTargetException if the property accessor method

      *  throws an exception

      */

     public void setProperty(

                             Object bean, 

                             String name, 

                             Object value, 

                             String pattern)

                                 throws 

                                     IllegalAccessException, 

                                     InvocationTargetException {

         // Trace logging (if enabled)

         if (log.isTraceEnabled()) {

             StringBuffer sb = new StringBuffer("  setProperty(");

             sb.append(bean);

             sb.append(", ");

             sb.append(name);

             sb.append(", ");

             if (value == null) {

                 sb.append("<NULL>");

             }

             else if (value instanceof String) {

                 sb.append((String) value);

             }

             else if (value instanceof String[]) {

                 String[] values = (String[]) value;

                 sb.append('[');

                 for (int i = 0; i < values.length; i++) {

                     if (i > 0) {

                         sb.append(',');

                     }

                     sb.append(values[i]);

                 }

                 sb.append(']');

             }

             else {

                 sb.append(value.toString());

             }

             sb.append(')');

             log.trace(sb.toString());

         }

         // Resolve any nested expression to get the actual target bean

         Object target = bean;

         Resolver resolver = getPropertyUtils().getResolver();

         while (resolver.hasNested(name)) {

             try {

                 target = getPropertyUtils().getProperty(target, resolver.next(name));

                 name = resolver.remove(name);

             } catch (NoSuchMethodException e) {

                 return; // Skip this property setter

             }

         }

         if (log.isTraceEnabled()) {

             log.trace("    Target bean = " + target);

             log.trace("    Target name = " + name);

         }

         // Declare local variables we will require

         String propName = resolver.getProperty(name); // Simple name of target property

         int index  = resolver.getIndex(name);         // Indexed subscript value (if any)

         String key = resolver.getKey(name);           // Mapped key value (if any)

         Class type = definePropertyType(target, name, propName);

         if (type != null) {

             Object newValue = convert(type, index, value, pattern);

             invokeSetter(target, propName, key, index, newValue);

         }

     }

     /**

      * Calculate the property type.

      *

      * @param target The bean

      * @param name The property name

      * @param propName The Simple name of target property

      * @return The property's type

      *

      * @exception IllegalAccessException if the caller does not have

      *  access to the property accessor method

      * @exception InvocationTargetException if the property accessor method

      *  throws an exception

      */

     protected Class definePropertyType(Object target, String name, String propName)

             throws IllegalAccessException, InvocationTargetException {

         Class type = null;               // Java type of target property

         if (target instanceof DynaBean) {

             DynaClass dynaClass = ((DynaBean) target).getDynaClass();

             DynaProperty dynaProperty = dynaClass.getDynaProperty(propName);

             if (dynaProperty == null) {

                 return null; // Skip this property setter

             }

             type = dynaProperty.getType();

         }

         else {

             PropertyDescriptor descriptor = null;

             try {

                 descriptor =

                         getPropertyUtils().getPropertyDescriptor(target, name);

                 if (descriptor == null) {

                     return null; // Skip this property setter

                 }

             }

             catch (NoSuchMethodException e) {

                 return null; // Skip this property setter

             }

             if (descriptor instanceof MappedPropertyDescriptor) {

                 type = ((MappedPropertyDescriptor) descriptor).

                         getMappedPropertyType();

             }

             else if (descriptor instanceof IndexedPropertyDescriptor) {

                 type = ((IndexedPropertyDescriptor) descriptor).

                         getIndexedPropertyType();

             }

             else {

                 type = descriptor.getPropertyType();

             }

         }

         return type;

     }

     /**

      * Convert the specified value to the required type using the

      * specified conversion pattern.

      *

      * @param type The Java type of target property

      * @param index The indexed subscript value (if any)

      * @param value The value to be converted

      * @param pattern The conversion pattern

      * @return The converted value

      */

     protected Object convert(Class type, int index, Object value, String pattern) {

         if (log.isTraceEnabled()) {

             log.trace("Converting value '" + value + "' to type:" + type);

         }

         Object newValue = null;

         if (type.isArray() && (index < 0)) { // Scalar value into array

             if (value instanceof String) {

                 String[] values = new String[1];

                 values[0] = (String) value;

                 newValue = getLocaleConvertUtils().convert(values, type, pattern);

             }

             else if (value instanceof String[]) {

                 newValue = getLocaleConvertUtils().convert((String[]) value, type, pattern);

             }

             else {

                 newValue = value;

             }

         }

         else if (type.isArray()) {         // Indexed value into array

             if (value instanceof String) {

                 newValue = getLocaleConvertUtils().convert((String) value,

                         type.getComponentType(), pattern);

             }

             else if (value instanceof String[]) {

                 newValue = getLocaleConvertUtils().convert(((String[]) value)[0],

                         type.getComponentType(), pattern);

             }

             else {

                 newValue = value;

             }

         }

         else {                             // Value into scalar

             if (value instanceof String) {

                 newValue = getLocaleConvertUtils().convert((String) value, type, pattern);

             }

             else if (value instanceof String[]) {

                 newValue = getLocaleConvertUtils().convert(((String[]) value)[0],

                         type, pattern);

             }

             else {

                 newValue = value;

             }

         }

         return newValue;

     }

     /**

      *  Convert the specified value to the required type.

      *

      * @param type The Java type of target property

      * @param index The indexed subscript value (if any)

      * @param value The value to be converted

      * @return The converted value

      */

     protected Object convert(Class type, int index, Object value) {

         Object newValue = null;

         if (type.isArray() && (index < 0)) { // Scalar value into array

             if (value instanceof String) {

                 String[] values = new String[1];

                 values[0] = (String) value;

                 newValue = ConvertUtils.convert(values, type);

             }

             else if (value instanceof String[]) {

                 newValue = ConvertUtils.convert((String[]) value, type);

             }

             else {

                 newValue = value;

             }

         }

         else if (type.isArray()) {         // Indexed value into array

             if (value instanceof String) {

                 newValue = ConvertUtils.convert((String) value,

                         type.getComponentType());

             }

             else if (value instanceof String[]) {

                 newValue = ConvertUtils.convert(((String[]) value)[0],

                         type.getComponentType());

             }

             else {

                 newValue = value;

             }

         }

         else {                             // Value into scalar

             if (value instanceof String) {

                 newValue = ConvertUtils.convert((String) value, type);

             }

             else if (value instanceof String[]) {

                 newValue = ConvertUtils.convert(((String[]) value)[0],

                         type);

             }

             else {

                 newValue = value;

             }

         }

         return newValue;

     }

     /**

      * Invoke the setter method.

      *

      * @param target The bean

      * @param propName The Simple name of target property

      * @param key The Mapped key value (if any)

      * @param index The indexed subscript value (if any)

      * @param newValue The value to be set

      *

      * @exception IllegalAccessException if the caller does not have

      *  access to the property accessor method

      * @exception InvocationTargetException if the property accessor method

      *  throws an exception

      */

     protected void invokeSetter(Object target, String propName, String key, int index, Object newValue)

             throws IllegalAccessException, InvocationTargetException {

         try {

             if (index >= 0) {

                 getPropertyUtils().setIndexedProperty(target, propName,

                         index, newValue);

             }

             else if (key != null) {

                 getPropertyUtils().setMappedProperty(target, propName,

                         key, newValue);

             }

             else {

                 getPropertyUtils().setProperty(target, propName, newValue);

             }

         }

         catch (NoSuchMethodException e) {

             throw new InvocationTargetException

                     (e, "Cannot set " + propName);

         }

     }

     /**

      * Resolve any nested expression to get the actual target property.

      *

      * @param bean The bean

      * @param name The property name

      * @return The property's descriptor

      *

      * @exception IllegalAccessException if the caller does not have

      *  access to the property accessor method

      * @exception InvocationTargetException if the property accessor method

      *  throws an exception

      * @deprecated Property name expressions are now processed by

      * the configured {@link Resolver} implementation and this method

      * is no longer used by BeanUtils.

      */

     protected Descriptor calculate(Object bean, String name)

             throws IllegalAccessException, InvocationTargetException {

         // Resolve any nested expression to get the actual target bean

         Object target = bean;

         Resolver resolver = getPropertyUtils().getResolver();

         while (resolver.hasNested(name)) {

             try {

                 target = getPropertyUtils().getProperty(target, resolver.next(name));

                 name = resolver.remove(name);

             } catch (NoSuchMethodException e) {

                 return null; // Skip this property setter

             }

         }

         if (log.isTraceEnabled()) {

             log.trace("    Target bean = " + target);

             log.trace("    Target name = " + name);

         }

         // Declare local variables we will require

         String propName = resolver.getProperty(name); // Simple name of target property

         int index  = resolver.getIndex(name);         // Indexed subscript value (if any)

         String key = resolver.getKey(name);           // Mapped key value (if any)

         return new Descriptor(target, name, propName, key, index);

     }

     /**

      * @deprecated Property name expressions are now processed by

      * the configured {@link Resolver} implementation and this class

      * is no longer used by BeanUtils.

      */

     protected class Descriptor {

         private int index = -1;    // Indexed subscript value (if any)

         private String name;

         private String propName;   // Simple name of target property

         private String key;        // Mapped key value (if any)

         private Object target;

         /**

          * Construct a descriptor instance for the target bean and property.

          *

          * @param target The target bean

          * @param name The property name (includes indexed/mapped expr)

          * @param propName The property name

          * @param key The mapped property key (if any)

          * @param index The indexed property index (if any)

          */

         public Descriptor(Object target, String name, String propName, String key, int index) {

             setTarget(target);

             setName(name);

             setPropName(propName);

             setKey(key);

             setIndex(index);

         }

         /**

          * Return the target bean.

          *

          * @return The descriptors target bean

          */

         public Object getTarget() {

             return target;

         }

         /**

          * Set the target bean.

          *

          * @param target The target bean

          */

         public void setTarget(Object target) {

             this.target = target;

         }

         /**

          * Return the mapped property key.

          *

          * @return the mapped property key (if any)

          */

         public String getKey() {

             return key;

         }

         /**

          * Set the mapped property key.

          *

          * @param key The mapped property key (if any)

          */

         public void setKey(String key) {

             this.key = key;

         }

         /**

          * Return indexed property index.

          *

          * @return indexed property index (if any)

          */

         public int getIndex() {

             return index;

         }

         /**

          * Set the indexed property index.

          *

          * @param index The indexed property index (if any)

          */

         public void setIndex(int index) {

             this.index = index;

         }

         /**

          * Return property name (includes indexed/mapped expr).

          *

          * @return The property name (includes indexed/mapped expr)

          */

         public String getName() {

             return name;

         }

         /**

          * Set the property name (includes indexed/mapped expr).

          *

          * @param name The property name (includes indexed/mapped expr)

          */

         public void setName(String name) {

             this.name = name;

         }

         /**

          * Return the property name.

          *

          * @return The property name

          */

         public String getPropName() {

             return propName;

         }

         /**

          * Set the property name.

          *

          * @param propName The property name

          */

         public void setPropName(String propName) {

             this.propName = propName;

         }

     }

 }