View Javadoc

1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  
18  
19  package org.apache.commons.beanutils;
20  
21  import java.beans.PropertyDescriptor;
22  import java.lang.reflect.InvocationTargetException;
23  import java.lang.reflect.Method;
24  import java.util.Map;
25  
26  import org.apache.commons.collections.FastHashMap;
27  
28  
29  /***
30   * <p>Utility methods for using Java Reflection APIs to facilitate generic
31   * property getter and setter operations on Java objects.</p>
32   *
33   * <p>The implementations for these methods are provided by <code>PropertyUtilsBean</code>.
34   * For more details see {@link PropertyUtilsBean}.</p>
35   *
36   * @author Craig R. McClanahan
37   * @author Ralph Schaer
38   * @author Chris Audley
39   * @author Rey Francois
40   * @author Gregor Rayman
41   * @author Jan Sorensen
42   * @author Scott Sanders
43   * @version $Revision: 555845 $ $Date: 2007-07-13 03:52:05 +0100 (Fri, 13 Jul 2007) $
44   * @see PropertyUtilsBean
45   * @see org.apache.commons.beanutils.expression.Resolver
46   */
47  
48  public class PropertyUtils {
49  
50  
51      // ----------------------------------------------------- Manifest Constants
52  
53  
54      /***
55       * The delimiter that preceeds the zero-relative subscript for an
56       * indexed reference.
57       *
58       * @deprecated The notation used for property name expressions is now
59       * dependant on the {@link org.apache.commons.beanutils.expression.Resolver}
60       * implementation being used.
61       */
62      public static final char INDEXED_DELIM = '[';
63  
64  
65      /***
66       * The delimiter that follows the zero-relative subscript for an
67       * indexed reference.
68       *
69       * @deprecated The notation used for property name expressions is now
70       * dependant on the {@link org.apache.commons.beanutils.expression.Resolver}
71       * implementation being used.
72       */
73      public static final char INDEXED_DELIM2 = ']';
74  
75  
76      /***
77       * The delimiter that preceeds the key of a mapped property.
78       *
79       * @deprecated The notation used for property name expressions is now
80       * dependant on the {@link org.apache.commons.beanutils.expression.Resolver}
81       * implementation being used.
82       */
83      public static final char MAPPED_DELIM = '(';
84  
85  
86      /***
87       * The delimiter that follows the key of a mapped property.
88       *
89       * @deprecated The notation used for property name expressions is now
90       * dependant on the {@link org.apache.commons.beanutils.expression.Resolver}
91       * implementation being used.
92       */
93      public static final char MAPPED_DELIM2 = ')';
94  
95  
96      /***
97       * The delimiter that separates the components of a nested reference.
98       *
99       * @deprecated The notation used for property name expressions is now
100      * dependant on the {@link org.apache.commons.beanutils.expression.Resolver}
101      * implementation being used.
102      */
103     public static final char NESTED_DELIM = '.';
104 
105 
106     // ------------------------------------------------------- Static Variables
107 
108 
109     /***
110      * The debugging detail level for this component.
111      * 
112      * Note that this static variable will have unexpected side-effects if
113      * this class is deployed in a shared classloader within a container.
114      * However as it is actually completely ignored by this class due to its
115      * deprecated status, it doesn't do any actual harm.
116      *
117      * @deprecated The <code>debug</code> static property is no longer used
118      */
119     private static int debug = 0;
120 
121     /***
122      * The <code>debug</code> static property is no longer used
123      * @return debug property
124      * @deprecated The <code>debug</code> static property is no longer used
125      */
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     public static void setDebug(int newDebug) {
136         debug = newDebug;
137     }
138 
139     // --------------------------------------------------------- Public Methods
140 
141 
142     /***
143      * Clear any cached property descriptors information for all classes
144      * loaded by any class loaders.  This is useful in cases where class
145      * loaders are thrown away to implement class reloading.
146      *
147      * <p>For more details see <code>PropertyUtilsBean</code>.</p>
148      *
149      * @see PropertyUtilsBean#clearDescriptors  
150      */
151     public static void clearDescriptors() {
152 
153         PropertyUtilsBean.getInstance().clearDescriptors();
154 
155     }
156 
157 
158     /***
159      * <p>Copy property values from the "origin" bean to the "destination" bean
160      * for all cases where the property names are the same (even though the
161      * actual getter and setter methods might have been customized via
162      * <code>BeanInfo</code> classes).</p>
163      *
164      * <p>For more details see <code>PropertyUtilsBean</code>.</p>
165      *
166      * @param dest Destination bean whose properties are modified
167      * @param orig Origin bean whose properties are retrieved
168      *
169      * @exception IllegalAccessException if the caller does not have
170      *  access to the property accessor method
171      * @exception IllegalArgumentException if the <code>dest</code> or
172      *  <code>orig</code> argument is null
173      * @exception InvocationTargetException if the property accessor method
174      *  throws an exception
175      * @exception NoSuchMethodException if an accessor method for this
176      *  propety cannot be found
177      * @see PropertyUtilsBean#copyProperties  
178      */
179     public static void copyProperties(Object dest, Object orig)
180             throws IllegalAccessException, InvocationTargetException,
181             NoSuchMethodException {
182 
183         PropertyUtilsBean.getInstance().copyProperties(dest, orig);
184     }
185 
186 
187     /***
188      * <p>Return the entire set of properties for which the specified bean
189      * provides a read method.</p>
190      *
191      * <p>For more details see <code>PropertyUtilsBean</code>.</p>
192      *
193      * @param bean Bean whose properties are to be extracted
194      * @return The set of properties for the bean
195      *
196      * @exception IllegalAccessException if the caller does not have
197      *  access to the property accessor method
198      * @exception IllegalArgumentException if <code>bean</code> is null
199      * @exception InvocationTargetException if the property accessor method
200      *  throws an exception
201      * @exception NoSuchMethodException if an accessor method for this
202      *  propety cannot be found
203      * @see PropertyUtilsBean#describe  
204      */
205     public static Map describe(Object bean)
206             throws IllegalAccessException, InvocationTargetException,
207             NoSuchMethodException {
208 
209         return (PropertyUtilsBean.getInstance().describe(bean));
210 
211     }
212 
213 
214     /***
215      * <p>Return the value of the specified indexed property of the specified
216      * bean, with no type conversions.</p>
217      *
218      * <p>For more details see <code>PropertyUtilsBean</code>.</p>
219      *
220      * @param bean Bean whose property is to be extracted
221      * @param name <code>propertyname[index]</code> of the property value
222      *  to be extracted
223      * @return the indexed property value
224      *
225      * @exception IndexOutOfBoundsException if the specified index
226      *  is outside the valid range for the underlying property
227      * @exception IllegalAccessException if the caller does not have
228      *  access to the property accessor method
229      * @exception IllegalArgumentException if <code>bean</code> or
230      *  <code>name</code> is null
231      * @exception InvocationTargetException if the property accessor method
232      *  throws an exception
233      * @exception NoSuchMethodException if an accessor method for this
234      *  propety cannot be found
235      * @see PropertyUtilsBean#getIndexedProperty(Object,String)  
236      */
237     public static Object getIndexedProperty(Object bean, String name)
238             throws IllegalAccessException, InvocationTargetException,
239             NoSuchMethodException {
240 
241         return (PropertyUtilsBean.getInstance().getIndexedProperty(bean, name));
242 
243     }
244 
245 
246     /***
247      * <p>Return the value of the specified indexed property of the specified
248      * bean, with no type conversions.</p>
249      *
250      * <p>For more details see <code>PropertyUtilsBean</code>.</p>
251      *
252      * @param bean Bean whose property is to be extracted
253      * @param name Simple property name of the property value to be extracted
254      * @param index Index of the property value to be extracted
255      * @return the indexed property value
256      *
257      * @exception IndexOutOfBoundsException if the specified index
258      *  is outside the valid range for the underlying property
259      * @exception IllegalAccessException if the caller does not have
260      *  access to the property accessor method
261      * @exception IllegalArgumentException if <code>bean</code> or
262      *  <code>name</code> is null
263      * @exception InvocationTargetException if the property accessor method
264      *  throws an exception
265      * @exception NoSuchMethodException if an accessor method for this
266      *  propety cannot be found
267      * @see PropertyUtilsBean#getIndexedProperty(Object,String, int)  
268      */
269     public static Object getIndexedProperty(Object bean,
270                                             String name, int index)
271             throws IllegalAccessException, InvocationTargetException,
272             NoSuchMethodException {
273 
274         return (PropertyUtilsBean.getInstance().getIndexedProperty(bean, name, index));
275     }
276 
277 
278     /***
279      * <p>Return the value of the specified mapped property of the
280      * specified bean, with no type conversions.</p>
281      *
282      * <p>For more details see <code>PropertyUtilsBean</code>.</p>
283      *
284      * @param bean Bean whose property is to be extracted
285      * @param name <code>propertyname(key)</code> of the property value
286      *  to be extracted
287      * @return the mapped property value
288      *
289      * @exception IllegalAccessException if the caller does not have
290      *  access to the property accessor method
291      * @exception InvocationTargetException if the property accessor method
292      *  throws an exception
293      * @exception NoSuchMethodException if an accessor method for this
294      *  propety cannot be found
295      * @see PropertyUtilsBean#getMappedProperty(Object,String)  
296      */
297     public static Object getMappedProperty(Object bean, String name)
298             throws IllegalAccessException, InvocationTargetException,
299             NoSuchMethodException {
300 
301         return (PropertyUtilsBean.getInstance().getMappedProperty(bean, name));
302 
303     }
304 
305 
306     /***
307      * <p>Return the value of the specified mapped property of the specified
308      * bean, with no type conversions.</p>
309      *
310      * <p>For more details see <code>PropertyUtilsBean</code>.</p>
311      *
312      * @param bean Bean whose property is to be extracted
313      * @param name Mapped property name of the property value to be extracted
314      * @param key Key of the property value to be extracted
315      * @return the mapped property value
316      *
317      * @exception IllegalAccessException if the caller does not have
318      *  access to the property accessor method
319      * @exception InvocationTargetException if the property accessor method
320      *  throws an exception
321      * @exception NoSuchMethodException if an accessor method for this
322      *  propety cannot be found
323      * @see PropertyUtilsBean#getMappedProperty(Object,String, String)  
324      */
325     public static Object getMappedProperty(Object bean,
326                                            String name, String key)
327             throws IllegalAccessException, InvocationTargetException,
328             NoSuchMethodException {
329 
330         return PropertyUtilsBean.getInstance().getMappedProperty(bean, name, key);
331 
332     }
333 
334 
335     /***
336      * <p>Return the mapped property descriptors for this bean class.</p>
337      *
338      * <p>For more details see <code>PropertyUtilsBean</code>.</p>
339      *
340      * @param beanClass Bean class to be introspected
341      * @return the mapped property descriptors
342      * @see PropertyUtilsBean#getMappedPropertyDescriptors(Class)
343      * @deprecated This method should not be exposed
344      */
345     public static FastHashMap getMappedPropertyDescriptors(Class beanClass) {
346 
347         return PropertyUtilsBean.getInstance().getMappedPropertyDescriptors(beanClass);
348 
349     }
350 
351 
352     /***
353      * <p>Return the mapped property descriptors for this bean.</p>
354      *
355      * <p>For more details see <code>PropertyUtilsBean</code>.</p>
356      *
357      * @param bean Bean to be introspected
358      * @return the mapped property descriptors
359      * @see PropertyUtilsBean#getMappedPropertyDescriptors(Object)
360      * @deprecated This method should not be exposed
361      */
362     public static FastHashMap getMappedPropertyDescriptors(Object bean) {
363 
364         return PropertyUtilsBean.getInstance().getMappedPropertyDescriptors(bean);
365 
366     }
367 
368 
369     /***
370      * <p>Return the value of the (possibly nested) property of the specified
371      * name, for the specified bean, with no type conversions.</p>
372      *
373      * <p>For more details see <code>PropertyUtilsBean</code>.</p>
374      *
375      * @param bean Bean whose property is to be extracted
376      * @param name Possibly nested name of the property to be extracted
377      * @return the nested property value
378      *
379      * @exception IllegalAccessException if the caller does not have
380      *  access to the property accessor method
381      * @exception IllegalArgumentException if <code>bean</code> or
382      *  <code>name</code> is null
383      * @exception NestedNullException if a nested reference to a
384      *  property returns null
385      * @exception InvocationTargetException 
386      * if the property accessor method throws an exception
387      * @exception NoSuchMethodException if an accessor method for this
388      *  propety cannot be found
389      * @see PropertyUtilsBean#getNestedProperty
390      */
391     public static Object getNestedProperty(Object bean, String name)
392             throws IllegalAccessException, InvocationTargetException,
393             NoSuchMethodException {
394 
395         return PropertyUtilsBean.getInstance().getNestedProperty(bean, name);
396         
397     }
398 
399 
400     /***
401      * <p>Return the value of the specified property of the specified bean,
402      * no matter which property reference format is used, with no
403      * type conversions.</p>
404      *
405      * <p>For more details see <code>PropertyUtilsBean</code>.</p>
406      *
407      * @param bean Bean whose property is to be extracted
408      * @param name Possibly indexed and/or nested name of the property
409      *  to be extracted
410      * @return the property value
411      *
412      * @exception IllegalAccessException if the caller does not have
413      *  access to the property accessor method
414      * @exception IllegalArgumentException if <code>bean</code> or
415      *  <code>name</code> is null
416      * @exception InvocationTargetException if the property accessor method
417      *  throws an exception
418      * @exception NoSuchMethodException if an accessor method for this
419      *  propety cannot be found
420      * @see PropertyUtilsBean#getProperty
421      */
422     public static Object getProperty(Object bean, String name)
423             throws IllegalAccessException, InvocationTargetException,
424             NoSuchMethodException {
425 
426         return (PropertyUtilsBean.getInstance().getProperty(bean, name));
427 
428     }
429 
430 
431     /***
432      * <p>Retrieve the property descriptor for the specified property of the
433      * specified bean, or return <code>null</code> if there is no such
434      * descriptor.</p>
435      *
436      * <p>For more details see <code>PropertyUtilsBean</code>.</p>
437      *
438      * @param bean Bean for which a property descriptor is requested
439      * @param name Possibly indexed and/or nested name of the property for
440      *  which a property descriptor is requested
441      * @return the property descriptor
442      *
443      * @exception IllegalAccessException if the caller does not have
444      *  access to the property accessor method
445      * @exception IllegalArgumentException if <code>bean</code> or
446      *  <code>name</code> is null
447      * @exception IllegalArgumentException if a nested reference to a
448      *  property returns null
449      * @exception InvocationTargetException if the property accessor method
450      *  throws an exception
451      * @exception NoSuchMethodException if an accessor method for this
452      *  propety cannot be found
453      * @see PropertyUtilsBean#getPropertyDescriptor
454      */
455     public static PropertyDescriptor getPropertyDescriptor(Object bean,
456                                                            String name)
457             throws IllegalAccessException, InvocationTargetException,
458             NoSuchMethodException {
459 
460         return PropertyUtilsBean.getInstance().getPropertyDescriptor(bean, name);
461 
462     }
463 
464 
465     /***
466      * <p>Retrieve the property descriptors for the specified class,
467      * introspecting and caching them the first time a particular bean class
468      * is encountered.</p>
469      *
470      * <p>For more details see <code>PropertyUtilsBean</code>.</p>
471      *
472      * @param beanClass Bean class for which property descriptors are requested
473      * @return the property descriptors
474      * @exception IllegalArgumentException if <code>beanClass</code> is null
475      * @see PropertyUtilsBean#getPropertyDescriptors(Class)
476      */
477     public static PropertyDescriptor[]
478             getPropertyDescriptors(Class beanClass) {
479 
480         return PropertyUtilsBean.getInstance().getPropertyDescriptors(beanClass);
481 
482     }
483 
484 
485     /***
486      * <p>Retrieve the property descriptors for the specified bean,
487      * introspecting and caching them the first time a particular bean class
488      * is encountered.</p>
489      *
490      * <p>For more details see <code>PropertyUtilsBean</code>.</p>
491      *
492      * @param bean Bean for which property descriptors are requested
493      * @return the property descriptors
494      * @exception IllegalArgumentException if <code>bean</code> is null
495      * @see PropertyUtilsBean#getPropertyDescriptors(Object)
496      */
497     public static PropertyDescriptor[] getPropertyDescriptors(Object bean) {
498 
499         return PropertyUtilsBean.getInstance().getPropertyDescriptors(bean);
500 
501     }
502 
503 
504     /***
505      * <p>Return the Java Class repesenting the property editor class that has
506      * been registered for this property (if any).</p>
507      *
508      * <p>For more details see <code>PropertyUtilsBean</code>.</p>
509      *
510      * @param bean Bean for which a property descriptor is requested
511      * @param name Possibly indexed and/or nested name of the property for
512      *  which a property descriptor is requested
513      * @return the property editor class
514      *
515      * @exception IllegalAccessException if the caller does not have
516      *  access to the property accessor method
517      * @exception IllegalArgumentException if <code>bean</code> or
518      *  <code>name</code> is null
519      * @exception IllegalArgumentException if a nested reference to a
520      *  property returns null
521      * @exception InvocationTargetException if the property accessor method
522      *  throws an exception
523      * @exception NoSuchMethodException if an accessor method for this
524      *  propety cannot be found
525      * @see PropertyUtilsBean#getPropertyEditorClass(Object,String)
526      */
527     public static Class getPropertyEditorClass(Object bean, String name)
528             throws IllegalAccessException, InvocationTargetException,
529             NoSuchMethodException {
530 
531         return PropertyUtilsBean.getInstance().getPropertyEditorClass(bean, name);
532 
533     }
534 
535 
536     /***
537      * <p>Return the Java Class representing the property type of the specified
538      * property, or <code>null</code> if there is no such property for the
539      * specified bean.</p>
540      *
541      * <p>For more details see <code>PropertyUtilsBean</code>.</p>
542      *
543      * @param bean Bean for which a property descriptor is requested
544      * @param name Possibly indexed and/or nested name of the property for
545      *  which a property descriptor is requested
546      * @return The property type
547      *
548      * @exception IllegalAccessException if the caller does not have
549      *  access to the property accessor method
550      * @exception IllegalArgumentException if <code>bean</code> or
551      *  <code>name</code> is null
552      * @exception IllegalArgumentException if a nested reference to a
553      *  property returns null
554      * @exception InvocationTargetException if the property accessor method
555      *  throws an exception
556      * @exception NoSuchMethodException if an accessor method for this
557      *  propety cannot be found
558      * @see PropertyUtilsBean#getPropertyType(Object, String)
559      */
560     public static Class getPropertyType(Object bean, String name)
561             throws IllegalAccessException, InvocationTargetException,
562             NoSuchMethodException {
563 
564         return PropertyUtilsBean.getInstance().getPropertyType(bean, name);
565     }
566 
567 
568     /***
569      * <p>Return an accessible property getter method for this property,
570      * if there is one; otherwise return <code>null</code>.</p>
571      *
572      * <p>For more details see <code>PropertyUtilsBean</code>.</p>
573      *
574      * @param descriptor Property descriptor to return a getter for
575      * @return The read method
576      * @see PropertyUtilsBean#getReadMethod
577      */
578     public static Method getReadMethod(PropertyDescriptor descriptor) {
579 
580         return (PropertyUtilsBean.getInstance().getReadMethod(descriptor));
581 
582     }
583 
584 
585     /***
586      * <p>Return the value of the specified simple property of the specified
587      * bean, with no type conversions.</p>
588      *
589      * <p>For more details see <code>PropertyUtilsBean</code>.</p>
590      *
591      * @param bean Bean whose property is to be extracted
592      * @param name Name of the property to be extracted
593      * @return The property value
594      *
595      * @exception IllegalAccessException if the caller does not have
596      *  access to the property accessor method
597      * @exception IllegalArgumentException if <code>bean</code> or
598      *  <code>name</code> is null
599      * @exception IllegalArgumentException if the property name
600      *  is nested or indexed
601      * @exception InvocationTargetException if the property accessor method
602      *  throws an exception
603      * @exception NoSuchMethodException if an accessor method for this
604      *  propety cannot be found
605      * @see PropertyUtilsBean#getSimpleProperty
606      */
607     public static Object getSimpleProperty(Object bean, String name)
608             throws IllegalAccessException, InvocationTargetException,
609             NoSuchMethodException {
610 
611         return PropertyUtilsBean.getInstance().getSimpleProperty(bean, name);
612         
613     }
614 
615 
616     /***
617      * <p>Return an accessible property setter method for this property,
618      * if there is one; otherwise return <code>null</code>.</p>
619      *
620      * <p>For more details see <code>PropertyUtilsBean</code>.</p>
621      *
622      * @param descriptor Property descriptor to return a setter for
623      * @return The write method
624      * @see PropertyUtilsBean#getWriteMethod
625      */
626     public static Method getWriteMethod(PropertyDescriptor descriptor) {
627 
628         return PropertyUtilsBean.getInstance().getWriteMethod(descriptor);
629 
630     }
631 
632 
633     /***
634      * <p>Return <code>true</code> if the specified property name identifies
635      * a readable property on the specified bean; otherwise, return
636      * <code>false</code>.</p>
637      *
638      * <p>For more details see <code>PropertyUtilsBean</code>.</p>
639      *
640      * @param bean Bean to be examined (may be a {@link DynaBean}
641      * @param name Property name to be evaluated
642      * @return <code>true</code> if the property is readable,
643      * otherwise <code>false</code>
644      *
645      * @exception IllegalArgumentException if <code>bean</code>
646      *  or <code>name</code> is <code>null</code>
647      * @see PropertyUtilsBean#isReadable
648      * @since BeanUtils 1.6
649      */
650     public static boolean isReadable(Object bean, String name) {
651 
652         return PropertyUtilsBean.getInstance().isReadable(bean, name);
653     }
654 
655 
656     /***
657      * <p>Return <code>true</code> if the specified property name identifies
658      * a writeable property on the specified bean; otherwise, return
659      * <code>false</code>.</p>
660      *
661      * <p>For more details see <code>PropertyUtilsBean</code>.</p>
662      *
663      * @param bean Bean to be examined (may be a {@link DynaBean}
664      * @param name Property name to be evaluated
665      * @return <code>true</code> if the property is writeable,
666      * otherwise <code>false</code>
667      *
668      * @exception IllegalArgumentException if <code>bean</code>
669      *  or <code>name</code> is <code>null</code>
670      * @see PropertyUtilsBean#isWriteable
671      * @since BeanUtils 1.6
672      */
673     public static boolean isWriteable(Object bean, String name) {
674 
675         return PropertyUtilsBean.getInstance().isWriteable(bean, name);
676     }
677 
678 
679     /***
680      * <p>Sets the value of the specified indexed property of the specified
681      * bean, with no type conversions.</p>
682      *
683      * <p>For more details see <code>PropertyUtilsBean</code>.</p>
684      *
685      * @param bean Bean whose property is to be modified
686      * @param name <code>propertyname[index]</code> of the property value
687      *  to be modified
688      * @param value Value to which the specified property element
689      *  should be set
690      *
691      * @exception IndexOutOfBoundsException if the specified index
692      *  is outside the valid range for the underlying property
693      * @exception IllegalAccessException if the caller does not have
694      *  access to the property accessor method
695      * @exception IllegalArgumentException if <code>bean</code> or
696      *  <code>name</code> is null
697      * @exception InvocationTargetException if the property accessor method
698      *  throws an exception
699      * @exception NoSuchMethodException if an accessor method for this
700      *  propety cannot be found
701      * @see PropertyUtilsBean#setIndexedProperty(Object, String, Object)
702      */
703     public static void setIndexedProperty(Object bean, String name,
704                                           Object value)
705             throws IllegalAccessException, InvocationTargetException,
706             NoSuchMethodException {
707 
708         PropertyUtilsBean.getInstance().setIndexedProperty(bean, name, value);
709 
710     }
711 
712 
713     /***
714      * <p>Sets the value of the specified indexed property of the specified
715      * bean, with no type conversions.</p>
716      *
717      * <p>For more details see <code>PropertyUtilsBean</code>.</p>
718      *
719      * @param bean Bean whose property is to be set
720      * @param name Simple property name of the property value to be set
721      * @param index Index of the property value to be set
722      * @param value Value to which the indexed property element is to be set
723      *
724      * @exception IndexOutOfBoundsException if the specified index
725      *  is outside the valid range for the underlying property
726      * @exception IllegalAccessException if the caller does not have
727      *  access to the property accessor method
728      * @exception IllegalArgumentException if <code>bean</code> or
729      *  <code>name</code> is null
730      * @exception InvocationTargetException if the property accessor method
731      *  throws an exception
732      * @exception NoSuchMethodException if an accessor method for this
733      *  propety cannot be found
734      * @see PropertyUtilsBean#setIndexedProperty(Object, String, Object)
735      */
736     public static void setIndexedProperty(Object bean, String name,
737                                           int index, Object value)
738             throws IllegalAccessException, InvocationTargetException,
739             NoSuchMethodException {
740 
741         PropertyUtilsBean.getInstance().setIndexedProperty(bean, name, index, value);
742     }
743 
744 
745     /***
746      * <p>Sets the value of the specified mapped property of the
747      * specified bean, with no type conversions.</p>
748      *
749      * <p>For more details see <code>PropertyUtilsBean</code>.</p>
750      *
751      * @param bean Bean whose property is to be set
752      * @param name <code>propertyname(key)</code> of the property value
753      *  to be set
754      * @param value The property value to be set
755      *
756      * @exception IllegalAccessException if the caller does not have
757      *  access to the property accessor method
758      * @exception InvocationTargetException if the property accessor method
759      *  throws an exception
760      * @exception NoSuchMethodException if an accessor method for this
761      *  propety cannot be found
762      * @see PropertyUtilsBean#setMappedProperty(Object, String, Object)
763      */
764     public static void setMappedProperty(Object bean, String name,
765                                          Object value)
766             throws IllegalAccessException, InvocationTargetException,
767             NoSuchMethodException {
768 
769         PropertyUtilsBean.getInstance().setMappedProperty(bean, name, value);
770     }
771 
772 
773     /***
774      * <p>Sets the value of the specified mapped property of the specified
775      * bean, with no type conversions.</p>
776      *
777      * <p>For more details see <code>PropertyUtilsBean</code>.</p>
778      *
779      * @param bean Bean whose property is to be set
780      * @param name Mapped property name of the property value to be set
781      * @param key Key of the property value to be set
782      * @param value The property value to be set
783      *
784      * @exception IllegalAccessException if the caller does not have
785      *  access to the property accessor method
786      * @exception InvocationTargetException if the property accessor method
787      *  throws an exception
788      * @exception NoSuchMethodException if an accessor method for this
789      *  propety cannot be found
790      * @see PropertyUtilsBean#setMappedProperty(Object, String, String, Object)
791      */
792     public static void setMappedProperty(Object bean, String name,
793                                          String key, Object value)
794             throws IllegalAccessException, InvocationTargetException,
795             NoSuchMethodException {
796 
797         PropertyUtilsBean.getInstance().setMappedProperty(bean, name, key, value);
798     }
799 
800 
801     /***
802      * <p>Sets the value of the (possibly nested) property of the specified
803      * name, for the specified bean, with no type conversions.</p>
804      *
805      * <p>For more details see <code>PropertyUtilsBean</code>.</p>
806      *
807      * @param bean Bean whose property is to be modified
808      * @param name Possibly nested name of the property to be modified
809      * @param value Value to which the property is to be set
810      *
811      * @exception IllegalAccessException if the caller does not have
812      *  access to the property accessor method
813      * @exception IllegalArgumentException if <code>bean</code> or
814      *  <code>name</code> is null
815      * @exception IllegalArgumentException if a nested reference to a
816      *  property returns null
817      * @exception InvocationTargetException if the property accessor method
818      *  throws an exception
819      * @exception NoSuchMethodException if an accessor method for this
820      *  propety cannot be found
821      * @see PropertyUtilsBean#setNestedProperty
822      */
823     public static void setNestedProperty(Object bean,
824                                          String name, Object value)
825             throws IllegalAccessException, InvocationTargetException,
826             NoSuchMethodException {
827 
828         PropertyUtilsBean.getInstance().setNestedProperty(bean, name, value);
829     }
830 
831 
832     /***
833      * <p>Set the value of the specified property of the specified bean,
834      * no matter which property reference format is used, with no
835      * type conversions.</p>
836      *
837      * <p>For more details see <code>PropertyUtilsBean</code>.</p>
838      *
839      * @param bean Bean whose property is to be modified
840      * @param name Possibly indexed and/or nested name of the property
841      *  to be modified
842      * @param value Value to which this property is to be set
843      *
844      * @exception IllegalAccessException if the caller does not have
845      *  access to the property accessor method
846      * @exception IllegalArgumentException if <code>bean</code> or
847      *  <code>name</code> is null
848      * @exception InvocationTargetException if the property accessor method
849      *  throws an exception
850      * @exception NoSuchMethodException if an accessor method for this
851      *  propety cannot be found
852      * @see PropertyUtilsBean#setProperty
853      */
854     public static void setProperty(Object bean, String name, Object value)
855             throws IllegalAccessException, InvocationTargetException,
856             NoSuchMethodException {
857 
858         PropertyUtilsBean.getInstance().setProperty(bean, name, value);
859 
860     }
861 
862 
863     /***
864      * <p>Set the value of the specified simple property of the specified bean,
865      * with no type conversions.</p>
866      *
867      * <p>For more details see <code>PropertyUtilsBean</code>.</p>
868      *
869      * @param bean Bean whose property is to be modified
870      * @param name Name of the property to be modified
871      * @param value Value to which the property should be set
872      *
873      * @exception IllegalAccessException if the caller does not have
874      *  access to the property accessor method
875      * @exception IllegalArgumentException if <code>bean</code> or
876      *  <code>name</code> is null
877      * @exception IllegalArgumentException if the property name is
878      *  nested or indexed
879      * @exception InvocationTargetException if the property accessor method
880      *  throws an exception
881      * @exception NoSuchMethodException if an accessor method for this
882      *  propety cannot be found
883      * @see PropertyUtilsBean#setSimpleProperty
884      */
885     public static void setSimpleProperty(Object bean,
886                                          String name, Object value)
887             throws IllegalAccessException, InvocationTargetException,
888             NoSuchMethodException {
889 
890         PropertyUtilsBean.getInstance().setSimpleProperty(bean, name, value);
891     }
892 
893 
894 }