001/*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements.  See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License.  You may obtain a copy of the License at
008 *
009 *      http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017
018
019package org.apache.commons.beanutils;
020
021import java.beans.PropertyDescriptor;
022import java.lang.reflect.InvocationTargetException;
023import java.lang.reflect.Method;
024import java.util.Map;
025
026import org.apache.commons.collections.FastHashMap;
027
028
029/**
030 * <p>Utility methods for using Java Reflection APIs to facilitate generic
031 * property getter and setter operations on Java objects.</p>
032 *
033 * <p>The implementations for these methods are provided by <code>PropertyUtilsBean</code>.
034 * For more details see {@link PropertyUtilsBean}.</p>
035 *
036 * @version $Id: PropertyUtils.java 1547898 2013-12-04 20:33:06Z oheger $
037 * @see PropertyUtilsBean
038 * @see org.apache.commons.beanutils.expression.Resolver
039 */
040
041public class PropertyUtils {
042
043
044    // ----------------------------------------------------- Manifest Constants
045
046
047    /**
048     * The delimiter that preceeds the zero-relative subscript for an
049     * indexed reference.
050     *
051     * @deprecated The notation used for property name expressions is now
052     * dependant on the {@link org.apache.commons.beanutils.expression.Resolver}
053     * implementation being used.
054     */
055    @Deprecated
056    public static final char INDEXED_DELIM = '[';
057
058
059    /**
060     * The delimiter that follows the zero-relative subscript for an
061     * indexed reference.
062     *
063     * @deprecated The notation used for property name expressions is now
064     * dependant on the {@link org.apache.commons.beanutils.expression.Resolver}
065     * implementation being used.
066     */
067    @Deprecated
068    public static final char INDEXED_DELIM2 = ']';
069
070
071    /**
072     * The delimiter that preceeds the key of a mapped property.
073     *
074     * @deprecated The notation used for property name expressions is now
075     * dependant on the {@link org.apache.commons.beanutils.expression.Resolver}
076     * implementation being used.
077     */
078    @Deprecated
079    public static final char MAPPED_DELIM = '(';
080
081
082    /**
083     * The delimiter that follows the key of a mapped property.
084     *
085     * @deprecated The notation used for property name expressions is now
086     * dependant on the {@link org.apache.commons.beanutils.expression.Resolver}
087     * implementation being used.
088     */
089    @Deprecated
090    public static final char MAPPED_DELIM2 = ')';
091
092
093    /**
094     * The delimiter that separates the components of a nested reference.
095     *
096     * @deprecated The notation used for property name expressions is now
097     * dependant on the {@link org.apache.commons.beanutils.expression.Resolver}
098     * implementation being used.
099     */
100    @Deprecated
101    public static final char NESTED_DELIM = '.';
102
103
104    // ------------------------------------------------------- Static Variables
105
106
107    /**
108     * The debugging detail level for this component.
109     *
110     * Note that this static variable will have unexpected side-effects if
111     * this class is deployed in a shared classloader within a container.
112     * However as it is actually completely ignored by this class due to its
113     * deprecated status, it doesn't do any actual harm.
114     *
115     * @deprecated The <code>debug</code> static property is no longer used
116     */
117    @Deprecated
118    private static int debug = 0;
119
120    /**
121     * The <code>debug</code> static property is no longer used
122     * @return debug property
123     * @deprecated The <code>debug</code> static property is no longer used
124     */
125    @Deprecated
126    public static int getDebug() {
127        return (debug);
128    }
129
130    /**
131     * The <code>debug</code> static property is no longer used
132     * @param newDebug debug property
133     * @deprecated The <code>debug</code> static property is no longer used
134     */
135    @Deprecated
136    public static void setDebug(int newDebug) {
137        debug = newDebug;
138    }
139
140    // --------------------------------------------------------- Public Methods
141
142
143    /**
144     * Clear any cached property descriptors information for all classes
145     * loaded by any class loaders.  This is useful in cases where class
146     * loaders are thrown away to implement class reloading.
147     *
148     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
149     *
150     * @see PropertyUtilsBean#clearDescriptors
151     */
152    public static void clearDescriptors() {
153
154        PropertyUtilsBean.getInstance().clearDescriptors();
155
156    }
157
158    /**
159     * Resets the registered {@link BeanIntrospector} objects to the initial default
160     * state.
161     *
162     * @since 1.9
163     */
164    public static void resetBeanIntrospectors() {
165        PropertyUtilsBean.getInstance().resetBeanIntrospectors();
166    }
167
168    /**
169     * Adds a <code>BeanIntrospector</code>. This object is invoked when the
170     * property descriptors of a class need to be obtained.
171     *
172     * @param introspector the <code>BeanIntrospector</code> to be added (must
173     *        not be <b>null</b>
174     * @throws IllegalArgumentException if the argument is <b>null</b>
175     * @since 1.9
176     */
177    public static void addBeanIntrospector(BeanIntrospector introspector) {
178        PropertyUtilsBean.getInstance().addBeanIntrospector(introspector);
179    }
180
181    /**
182     * Removes the specified <code>BeanIntrospector</code>.
183     *
184     * @param introspector the <code>BeanIntrospector</code> to be removed
185     * @return <b>true</b> if the <code>BeanIntrospector</code> existed and
186     *         could be removed, <b>false</b> otherwise
187     * @since 1.9
188     */
189    public static boolean removeBeanIntrospector(BeanIntrospector introspector) {
190        return PropertyUtilsBean.getInstance().removeBeanIntrospector(
191                introspector);
192    }
193
194    /**
195     * <p>Copy property values from the "origin" bean to the "destination" bean
196     * for all cases where the property names are the same (even though the
197     * actual getter and setter methods might have been customized via
198     * <code>BeanInfo</code> classes).</p>
199     *
200     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
201     *
202     * @param dest Destination bean whose properties are modified
203     * @param orig Origin bean whose properties are retrieved
204     *
205     * @exception IllegalAccessException if the caller does not have
206     *  access to the property accessor method
207     * @exception IllegalArgumentException if the <code>dest</code> or
208     *  <code>orig</code> argument is null
209     * @exception InvocationTargetException if the property accessor method
210     *  throws an exception
211     * @exception NoSuchMethodException if an accessor method for this
212     *  propety cannot be found
213     * @see PropertyUtilsBean#copyProperties
214     */
215    public static void copyProperties(Object dest, Object orig)
216            throws IllegalAccessException, InvocationTargetException,
217            NoSuchMethodException {
218
219        PropertyUtilsBean.getInstance().copyProperties(dest, orig);
220    }
221
222
223    /**
224     * <p>Return the entire set of properties for which the specified bean
225     * provides a read method.</p>
226     *
227     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
228     *
229     * @param bean Bean whose properties are to be extracted
230     * @return The set of properties for the bean
231     *
232     * @exception IllegalAccessException if the caller does not have
233     *  access to the property accessor method
234     * @exception IllegalArgumentException if <code>bean</code> is null
235     * @exception InvocationTargetException if the property accessor method
236     *  throws an exception
237     * @exception NoSuchMethodException if an accessor method for this
238     *  propety cannot be found
239     * @see PropertyUtilsBean#describe
240     */
241    public static Map<String, Object> describe(Object bean)
242            throws IllegalAccessException, InvocationTargetException,
243            NoSuchMethodException {
244
245        return (PropertyUtilsBean.getInstance().describe(bean));
246
247    }
248
249
250    /**
251     * <p>Return the value of the specified indexed property of the specified
252     * bean, with no type conversions.</p>
253     *
254     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
255     *
256     * @param bean Bean whose property is to be extracted
257     * @param name <code>propertyname[index]</code> of the property value
258     *  to be extracted
259     * @return the indexed property value
260     *
261     * @exception IndexOutOfBoundsException if the specified index
262     *  is outside the valid range for the underlying property
263     * @exception IllegalAccessException if the caller does not have
264     *  access to the property accessor method
265     * @exception IllegalArgumentException if <code>bean</code> or
266     *  <code>name</code> is null
267     * @exception InvocationTargetException if the property accessor method
268     *  throws an exception
269     * @exception NoSuchMethodException if an accessor method for this
270     *  propety cannot be found
271     * @see PropertyUtilsBean#getIndexedProperty(Object,String)
272     */
273    public static Object getIndexedProperty(Object bean, String name)
274            throws IllegalAccessException, InvocationTargetException,
275            NoSuchMethodException {
276
277        return (PropertyUtilsBean.getInstance().getIndexedProperty(bean, name));
278
279    }
280
281
282    /**
283     * <p>Return the value of the specified indexed property of the specified
284     * bean, with no type conversions.</p>
285     *
286     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
287     *
288     * @param bean Bean whose property is to be extracted
289     * @param name Simple property name of the property value to be extracted
290     * @param index Index of the property value to be extracted
291     * @return the indexed property value
292     *
293     * @exception IndexOutOfBoundsException if the specified index
294     *  is outside the valid range for the underlying property
295     * @exception IllegalAccessException if the caller does not have
296     *  access to the property accessor method
297     * @exception IllegalArgumentException if <code>bean</code> or
298     *  <code>name</code> is null
299     * @exception InvocationTargetException if the property accessor method
300     *  throws an exception
301     * @exception NoSuchMethodException if an accessor method for this
302     *  propety cannot be found
303     * @see PropertyUtilsBean#getIndexedProperty(Object,String, int)
304     */
305    public static Object getIndexedProperty(Object bean,
306                                            String name, int index)
307            throws IllegalAccessException, InvocationTargetException,
308            NoSuchMethodException {
309
310        return (PropertyUtilsBean.getInstance().getIndexedProperty(bean, name, index));
311    }
312
313
314    /**
315     * <p>Return the value of the specified mapped property of the
316     * specified bean, with no type conversions.</p>
317     *
318     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
319     *
320     * @param bean Bean whose property is to be extracted
321     * @param name <code>propertyname(key)</code> of the property value
322     *  to be extracted
323     * @return the mapped property value
324     *
325     * @exception IllegalAccessException if the caller does not have
326     *  access to the property accessor method
327     * @exception InvocationTargetException if the property accessor method
328     *  throws an exception
329     * @exception NoSuchMethodException if an accessor method for this
330     *  propety cannot be found
331     * @see PropertyUtilsBean#getMappedProperty(Object,String)
332     */
333    public static Object getMappedProperty(Object bean, String name)
334            throws IllegalAccessException, InvocationTargetException,
335            NoSuchMethodException {
336
337        return (PropertyUtilsBean.getInstance().getMappedProperty(bean, name));
338
339    }
340
341
342    /**
343     * <p>Return the value of the specified mapped property of the specified
344     * bean, with no type conversions.</p>
345     *
346     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
347     *
348     * @param bean Bean whose property is to be extracted
349     * @param name Mapped property name of the property value to be extracted
350     * @param key Key of the property value to be extracted
351     * @return the mapped property value
352     *
353     * @exception IllegalAccessException if the caller does not have
354     *  access to the property accessor method
355     * @exception InvocationTargetException if the property accessor method
356     *  throws an exception
357     * @exception NoSuchMethodException if an accessor method for this
358     *  propety cannot be found
359     * @see PropertyUtilsBean#getMappedProperty(Object,String, String)
360     */
361    public static Object getMappedProperty(Object bean,
362                                           String name, String key)
363            throws IllegalAccessException, InvocationTargetException,
364            NoSuchMethodException {
365
366        return PropertyUtilsBean.getInstance().getMappedProperty(bean, name, key);
367
368    }
369
370
371    /**
372     * <p>Return the mapped property descriptors for this bean class.</p>
373     *
374     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
375     *
376     * @param beanClass Bean class to be introspected
377     * @return the mapped property descriptors
378     * @see PropertyUtilsBean#getMappedPropertyDescriptors(Class)
379     * @deprecated This method should not be exposed
380     */
381    @Deprecated
382    public static FastHashMap getMappedPropertyDescriptors(Class<?> beanClass) {
383
384        return PropertyUtilsBean.getInstance().getMappedPropertyDescriptors(beanClass);
385
386    }
387
388
389    /**
390     * <p>Return the mapped property descriptors for this bean.</p>
391     *
392     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
393     *
394     * @param bean Bean to be introspected
395     * @return the mapped property descriptors
396     * @see PropertyUtilsBean#getMappedPropertyDescriptors(Object)
397     * @deprecated This method should not be exposed
398     */
399    @Deprecated
400    public static FastHashMap getMappedPropertyDescriptors(Object bean) {
401
402        return PropertyUtilsBean.getInstance().getMappedPropertyDescriptors(bean);
403
404    }
405
406
407    /**
408     * <p>Return the value of the (possibly nested) property of the specified
409     * name, for the specified bean, with no type conversions.</p>
410     *
411     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
412     *
413     * @param bean Bean whose property is to be extracted
414     * @param name Possibly nested name of the property to be extracted
415     * @return the nested property value
416     *
417     * @exception IllegalAccessException if the caller does not have
418     *  access to the property accessor method
419     * @exception IllegalArgumentException if <code>bean</code> or
420     *  <code>name</code> is null
421     * @exception NestedNullException if a nested reference to a
422     *  property returns null
423     * @exception InvocationTargetException
424     * if the property accessor method throws an exception
425     * @exception NoSuchMethodException if an accessor method for this
426     *  propety cannot be found
427     * @see PropertyUtilsBean#getNestedProperty
428     */
429    public static Object getNestedProperty(Object bean, String name)
430            throws IllegalAccessException, InvocationTargetException,
431            NoSuchMethodException {
432
433        return PropertyUtilsBean.getInstance().getNestedProperty(bean, name);
434
435    }
436
437
438    /**
439     * <p>Return the value of the specified property of the specified bean,
440     * no matter which property reference format is used, with no
441     * type conversions.</p>
442     *
443     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
444     *
445     * @param bean Bean whose property is to be extracted
446     * @param name Possibly indexed and/or nested name of the property
447     *  to be extracted
448     * @return the property value
449     *
450     * @exception IllegalAccessException if the caller does not have
451     *  access to the property accessor method
452     * @exception IllegalArgumentException if <code>bean</code> or
453     *  <code>name</code> is null
454     * @exception InvocationTargetException if the property accessor method
455     *  throws an exception
456     * @exception NoSuchMethodException if an accessor method for this
457     *  propety cannot be found
458     * @see PropertyUtilsBean#getProperty
459     */
460    public static Object getProperty(Object bean, String name)
461            throws IllegalAccessException, InvocationTargetException,
462            NoSuchMethodException {
463
464        return (PropertyUtilsBean.getInstance().getProperty(bean, name));
465
466    }
467
468
469    /**
470     * <p>Retrieve the property descriptor for the specified property of the
471     * specified bean, or return <code>null</code> if there is no such
472     * descriptor.</p>
473     *
474     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
475     *
476     * @param bean Bean for which a property descriptor is requested
477     * @param name Possibly indexed and/or nested name of the property for
478     *  which a property descriptor is requested
479     * @return the property descriptor
480     *
481     * @exception IllegalAccessException if the caller does not have
482     *  access to the property accessor method
483     * @exception IllegalArgumentException if <code>bean</code> or
484     *  <code>name</code> is null
485     * @exception IllegalArgumentException if a nested reference to a
486     *  property returns null
487     * @exception InvocationTargetException if the property accessor method
488     *  throws an exception
489     * @exception NoSuchMethodException if an accessor method for this
490     *  propety cannot be found
491     * @see PropertyUtilsBean#getPropertyDescriptor
492     */
493    public static PropertyDescriptor getPropertyDescriptor(Object bean,
494                                                           String name)
495            throws IllegalAccessException, InvocationTargetException,
496            NoSuchMethodException {
497
498        return PropertyUtilsBean.getInstance().getPropertyDescriptor(bean, name);
499
500    }
501
502
503    /**
504     * <p>Retrieve the property descriptors for the specified class,
505     * introspecting and caching them the first time a particular bean class
506     * is encountered.</p>
507     *
508     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
509     *
510     * @param beanClass Bean class for which property descriptors are requested
511     * @return the property descriptors
512     * @exception IllegalArgumentException if <code>beanClass</code> is null
513     * @see PropertyUtilsBean#getPropertyDescriptors(Class)
514     */
515    public static PropertyDescriptor[]
516            getPropertyDescriptors(Class<?> beanClass) {
517
518        return PropertyUtilsBean.getInstance().getPropertyDescriptors(beanClass);
519
520    }
521
522
523    /**
524     * <p>Retrieve the property descriptors for the specified bean,
525     * introspecting and caching them the first time a particular bean class
526     * is encountered.</p>
527     *
528     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
529     *
530     * @param bean Bean for which property descriptors are requested
531     * @return the property descriptors
532     * @exception IllegalArgumentException if <code>bean</code> is null
533     * @see PropertyUtilsBean#getPropertyDescriptors(Object)
534     */
535    public static PropertyDescriptor[] getPropertyDescriptors(Object bean) {
536
537        return PropertyUtilsBean.getInstance().getPropertyDescriptors(bean);
538
539    }
540
541
542    /**
543     * <p>Return the Java Class repesenting the property editor class that has
544     * been registered for this property (if any).</p>
545     *
546     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
547     *
548     * @param bean Bean for which a property descriptor is requested
549     * @param name Possibly indexed and/or nested name of the property for
550     *  which a property descriptor is requested
551     * @return the property editor class
552     *
553     * @exception IllegalAccessException if the caller does not have
554     *  access to the property accessor method
555     * @exception IllegalArgumentException if <code>bean</code> or
556     *  <code>name</code> is null
557     * @exception IllegalArgumentException if a nested reference to a
558     *  property returns null
559     * @exception InvocationTargetException if the property accessor method
560     *  throws an exception
561     * @exception NoSuchMethodException if an accessor method for this
562     *  propety cannot be found
563     * @see PropertyUtilsBean#getPropertyEditorClass(Object,String)
564     */
565    public static Class<?> getPropertyEditorClass(Object bean, String name)
566            throws IllegalAccessException, InvocationTargetException,
567            NoSuchMethodException {
568
569        return PropertyUtilsBean.getInstance().getPropertyEditorClass(bean, name);
570
571    }
572
573
574    /**
575     * <p>Return the Java Class representing the property type of the specified
576     * property, or <code>null</code> if there is no such property for the
577     * specified bean.</p>
578     *
579     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
580     *
581     * @param bean Bean for which a property descriptor is requested
582     * @param name Possibly indexed and/or nested name of the property for
583     *  which a property descriptor is requested
584     * @return The property type
585     *
586     * @exception IllegalAccessException if the caller does not have
587     *  access to the property accessor method
588     * @exception IllegalArgumentException if <code>bean</code> or
589     *  <code>name</code> is null
590     * @exception IllegalArgumentException if a nested reference to a
591     *  property returns null
592     * @exception InvocationTargetException if the property accessor method
593     *  throws an exception
594     * @exception NoSuchMethodException if an accessor method for this
595     *  propety cannot be found
596     * @see PropertyUtilsBean#getPropertyType(Object, String)
597     */
598    public static Class<?> getPropertyType(Object bean, String name)
599            throws IllegalAccessException, InvocationTargetException,
600            NoSuchMethodException {
601
602        return PropertyUtilsBean.getInstance().getPropertyType(bean, name);
603    }
604
605
606    /**
607     * <p>Return an accessible property getter method for this property,
608     * if there is one; otherwise return <code>null</code>.</p>
609     *
610     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
611     *
612     * @param descriptor Property descriptor to return a getter for
613     * @return The read method
614     * @see PropertyUtilsBean#getReadMethod(PropertyDescriptor)
615     */
616    public static Method getReadMethod(PropertyDescriptor descriptor) {
617
618        return (PropertyUtilsBean.getInstance().getReadMethod(descriptor));
619
620    }
621
622
623    /**
624     * <p>Return the value of the specified simple property of the specified
625     * bean, with no type conversions.</p>
626     *
627     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
628     *
629     * @param bean Bean whose property is to be extracted
630     * @param name Name of the property to be extracted
631     * @return The property value
632     *
633     * @exception IllegalAccessException if the caller does not have
634     *  access to the property accessor method
635     * @exception IllegalArgumentException if <code>bean</code> or
636     *  <code>name</code> is null
637     * @exception IllegalArgumentException if the property name
638     *  is nested or indexed
639     * @exception InvocationTargetException if the property accessor method
640     *  throws an exception
641     * @exception NoSuchMethodException if an accessor method for this
642     *  propety cannot be found
643     * @see PropertyUtilsBean#getSimpleProperty
644     */
645    public static Object getSimpleProperty(Object bean, String name)
646            throws IllegalAccessException, InvocationTargetException,
647            NoSuchMethodException {
648
649        return PropertyUtilsBean.getInstance().getSimpleProperty(bean, name);
650
651    }
652
653
654    /**
655     * <p>Return an accessible property setter method for this property,
656     * if there is one; otherwise return <code>null</code>.</p>
657     *
658     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
659     *
660     * @param descriptor Property descriptor to return a setter for
661     * @return The write method
662     * @see PropertyUtilsBean#getWriteMethod(PropertyDescriptor)
663     */
664    public static Method getWriteMethod(PropertyDescriptor descriptor) {
665
666        return PropertyUtilsBean.getInstance().getWriteMethod(descriptor);
667
668    }
669
670
671    /**
672     * <p>Return <code>true</code> if the specified property name identifies
673     * a readable property on the specified bean; otherwise, return
674     * <code>false</code>.</p>
675     *
676     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
677     *
678     * @param bean Bean to be examined (may be a {@link DynaBean}
679     * @param name Property name to be evaluated
680     * @return <code>true</code> if the property is readable,
681     * otherwise <code>false</code>
682     *
683     * @exception IllegalArgumentException if <code>bean</code>
684     *  or <code>name</code> is <code>null</code>
685     * @see PropertyUtilsBean#isReadable
686     * @since BeanUtils 1.6
687     */
688    public static boolean isReadable(Object bean, String name) {
689
690        return PropertyUtilsBean.getInstance().isReadable(bean, name);
691    }
692
693
694    /**
695     * <p>Return <code>true</code> if the specified property name identifies
696     * a writeable property on the specified bean; otherwise, return
697     * <code>false</code>.</p>
698     *
699     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
700     *
701     * @param bean Bean to be examined (may be a {@link DynaBean}
702     * @param name Property name to be evaluated
703     * @return <code>true</code> if the property is writeable,
704     * otherwise <code>false</code>
705     *
706     * @exception IllegalArgumentException if <code>bean</code>
707     *  or <code>name</code> is <code>null</code>
708     * @see PropertyUtilsBean#isWriteable
709     * @since BeanUtils 1.6
710     */
711    public static boolean isWriteable(Object bean, String name) {
712
713        return PropertyUtilsBean.getInstance().isWriteable(bean, name);
714    }
715
716
717    /**
718     * <p>Sets the value of the specified indexed property of the specified
719     * bean, with no type conversions.</p>
720     *
721     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
722     *
723     * @param bean Bean whose property is to be modified
724     * @param name <code>propertyname[index]</code> of the property value
725     *  to be modified
726     * @param value Value to which the specified property element
727     *  should be set
728     *
729     * @exception IndexOutOfBoundsException if the specified index
730     *  is outside the valid range for the underlying property
731     * @exception IllegalAccessException if the caller does not have
732     *  access to the property accessor method
733     * @exception IllegalArgumentException if <code>bean</code> or
734     *  <code>name</code> is null
735     * @exception InvocationTargetException if the property accessor method
736     *  throws an exception
737     * @exception NoSuchMethodException if an accessor method for this
738     *  propety cannot be found
739     * @see PropertyUtilsBean#setIndexedProperty(Object, String, Object)
740     */
741    public static void setIndexedProperty(Object bean, String name,
742                                          Object value)
743            throws IllegalAccessException, InvocationTargetException,
744            NoSuchMethodException {
745
746        PropertyUtilsBean.getInstance().setIndexedProperty(bean, name, value);
747
748    }
749
750
751    /**
752     * <p>Sets the value of the specified indexed property of the specified
753     * bean, with no type conversions.</p>
754     *
755     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
756     *
757     * @param bean Bean whose property is to be set
758     * @param name Simple property name of the property value to be set
759     * @param index Index of the property value to be set
760     * @param value Value to which the indexed property element is to be set
761     *
762     * @exception IndexOutOfBoundsException if the specified index
763     *  is outside the valid range for the underlying property
764     * @exception IllegalAccessException if the caller does not have
765     *  access to the property accessor method
766     * @exception IllegalArgumentException if <code>bean</code> or
767     *  <code>name</code> is null
768     * @exception InvocationTargetException if the property accessor method
769     *  throws an exception
770     * @exception NoSuchMethodException if an accessor method for this
771     *  propety cannot be found
772     * @see PropertyUtilsBean#setIndexedProperty(Object, String, Object)
773     */
774    public static void setIndexedProperty(Object bean, String name,
775                                          int index, Object value)
776            throws IllegalAccessException, InvocationTargetException,
777            NoSuchMethodException {
778
779        PropertyUtilsBean.getInstance().setIndexedProperty(bean, name, index, value);
780    }
781
782
783    /**
784     * <p>Sets the value of the specified mapped property of the
785     * specified bean, with no type conversions.</p>
786     *
787     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
788     *
789     * @param bean Bean whose property is to be set
790     * @param name <code>propertyname(key)</code> of the property value
791     *  to be set
792     * @param value The property value to be set
793     *
794     * @exception IllegalAccessException if the caller does not have
795     *  access to the property accessor method
796     * @exception InvocationTargetException if the property accessor method
797     *  throws an exception
798     * @exception NoSuchMethodException if an accessor method for this
799     *  propety cannot be found
800     * @see PropertyUtilsBean#setMappedProperty(Object, String, Object)
801     */
802    public static void setMappedProperty(Object bean, String name,
803                                         Object value)
804            throws IllegalAccessException, InvocationTargetException,
805            NoSuchMethodException {
806
807        PropertyUtilsBean.getInstance().setMappedProperty(bean, name, value);
808    }
809
810
811    /**
812     * <p>Sets the value of the specified mapped property of the specified
813     * bean, with no type conversions.</p>
814     *
815     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
816     *
817     * @param bean Bean whose property is to be set
818     * @param name Mapped property name of the property value to be set
819     * @param key Key of the property value to be set
820     * @param value The property value to be set
821     *
822     * @exception IllegalAccessException if the caller does not have
823     *  access to the property accessor method
824     * @exception InvocationTargetException if the property accessor method
825     *  throws an exception
826     * @exception NoSuchMethodException if an accessor method for this
827     *  propety cannot be found
828     * @see PropertyUtilsBean#setMappedProperty(Object, String, String, Object)
829     */
830    public static void setMappedProperty(Object bean, String name,
831                                         String key, Object value)
832            throws IllegalAccessException, InvocationTargetException,
833            NoSuchMethodException {
834
835        PropertyUtilsBean.getInstance().setMappedProperty(bean, name, key, value);
836    }
837
838
839    /**
840     * <p>Sets the value of the (possibly nested) property of the specified
841     * name, for the specified bean, with no type conversions.</p>
842     *
843     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
844     *
845     * @param bean Bean whose property is to be modified
846     * @param name Possibly nested name of the property to be modified
847     * @param value Value to which the property is to be set
848     *
849     * @exception IllegalAccessException if the caller does not have
850     *  access to the property accessor method
851     * @exception IllegalArgumentException if <code>bean</code> or
852     *  <code>name</code> is null
853     * @exception IllegalArgumentException if a nested reference to a
854     *  property returns null
855     * @exception InvocationTargetException if the property accessor method
856     *  throws an exception
857     * @exception NoSuchMethodException if an accessor method for this
858     *  propety cannot be found
859     * @see PropertyUtilsBean#setNestedProperty
860     */
861    public static void setNestedProperty(Object bean,
862                                         String name, Object value)
863            throws IllegalAccessException, InvocationTargetException,
864            NoSuchMethodException {
865
866        PropertyUtilsBean.getInstance().setNestedProperty(bean, name, value);
867    }
868
869
870    /**
871     * <p>Set the value of the specified property of the specified bean,
872     * no matter which property reference format is used, with no
873     * type conversions.</p>
874     *
875     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
876     *
877     * @param bean Bean whose property is to be modified
878     * @param name Possibly indexed and/or nested name of the property
879     *  to be modified
880     * @param value Value to which this property is to be set
881     *
882     * @exception IllegalAccessException if the caller does not have
883     *  access to the property accessor method
884     * @exception IllegalArgumentException if <code>bean</code> or
885     *  <code>name</code> is null
886     * @exception InvocationTargetException if the property accessor method
887     *  throws an exception
888     * @exception NoSuchMethodException if an accessor method for this
889     *  propety cannot be found
890     * @see PropertyUtilsBean#setProperty
891     */
892    public static void setProperty(Object bean, String name, Object value)
893            throws IllegalAccessException, InvocationTargetException,
894            NoSuchMethodException {
895
896        PropertyUtilsBean.getInstance().setProperty(bean, name, value);
897
898    }
899
900
901    /**
902     * <p>Set the value of the specified simple property of the specified bean,
903     * with no type conversions.</p>
904     *
905     * <p>For more details see <code>PropertyUtilsBean</code>.</p>
906     *
907     * @param bean Bean whose property is to be modified
908     * @param name Name of the property to be modified
909     * @param value Value to which the property should be set
910     *
911     * @exception IllegalAccessException if the caller does not have
912     *  access to the property accessor method
913     * @exception IllegalArgumentException if <code>bean</code> or
914     *  <code>name</code> is null
915     * @exception IllegalArgumentException if the property name is
916     *  nested or indexed
917     * @exception InvocationTargetException if the property accessor method
918     *  throws an exception
919     * @exception NoSuchMethodException if an accessor method for this
920     *  propety cannot be found
921     * @see PropertyUtilsBean#setSimpleProperty
922     */
923    public static void setSimpleProperty(Object bean,
924                                         String name, Object value)
925            throws IllegalAccessException, InvocationTargetException,
926            NoSuchMethodException {
927
928        PropertyUtilsBean.getInstance().setSimpleProperty(bean, name, value);
929    }
930
931
932}