001    /* IndexedPropertyDescriptor.java --
002       Copyright (C) 1998, 2003 Free Software Foundation, Inc.
003    
004    This file is part of GNU Classpath.
005    
006    GNU Classpath is free software; you can redistribute it and/or modify
007    it under the terms of the GNU General Public License as published by
008    the Free Software Foundation; either version 2, or (at your option)
009    any later version.
010     
011    GNU Classpath is distributed in the hope that it will be useful, but
012    WITHOUT ANY WARRANTY; without even the implied warranty of
013    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
014    General Public License for more details.
015    
016    You should have received a copy of the GNU General Public License
017    along with GNU Classpath; see the file COPYING.  If not, write to the
018    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
019    02110-1301 USA.
020    
021    Linking this library statically or dynamically with other modules is
022    making a combined work based on this library.  Thus, the terms and
023    conditions of the GNU General Public License cover the whole
024    combination.
025    
026    As a special exception, the copyright holders of this library give you
027    permission to link this library with independent modules to produce an
028    executable, regardless of the license terms of these independent
029    modules, and to copy and distribute the resulting executable under
030    terms of your choice, provided that you also meet, for each linked
031    independent module, the terms and conditions of the license of that
032    module.  An independent module is a module which is not derived from
033    or based on this library.  If you modify this library, you may extend
034    this exception to your version of the library, but you are not
035    obligated to do so.  If you do not wish to do so, delete this
036    exception statement from your version. */
037    
038    
039    package java.beans;
040    
041    import java.lang.reflect.Array;
042    import java.lang.reflect.Method;
043    
044    /**
045     * IndexedPropertyDescriptor describes information about a JavaBean
046     * indexed property, by which we mean an array-like property that
047     * has been exposed via a pair of get and set methods and another
048     * pair that allows you to get to the property by an index.<P>
049     *
050     * An example property would have four methods like this:<P>
051     * <CODE>FooBar[] getFoo()</CODE><BR>
052     * <CODE>void setFoo(FooBar[])</CODE><BR>
053     * <CODE>FooBar getFoo(int)</CODE><BR>
054     * <CODE>void setFoo(int,FooBar)</CODE><P>
055     *
056     * The constraints put on get and set methods are:<P>
057     * <OL>
058     * <LI>There must be at least a get(int) or a set(int,...) method.
059     * Nothing else is required.  <B>Spec note:</B>One nice restriction
060     * would be that if there is a get() there must be a get(int), same
061     * with set, but that is not in the spec and is fairly harmless.)</LI>
062     * <LI>A get array method must have signature
063     *     <CODE>&lt;propertyType&gt;[] &lt;getMethodName&gt;()</CODE></LI>
064     * <LI>A set array method must have signature
065     *     <CODE>void &lt;setMethodName&gt;(&lt;propertyType&gt;[])</CODE></LI>
066     * <LI>A get index method must have signature
067     *     <CODE>&lt;propertyType&gt; &lt;getMethodName&gt;(int)</CODE></LI>
068     * <LI>A set index method must have signature
069     *     <CODE>void &lt;setMethodName&gt;(int,&lt;propertyType&gt;)</CODE></LI>
070     * <LI>All these methods may throw any exception.</LI>
071     * <LI>All these methods must be public.</LI>
072     * </OL>
073     *
074     * @author John Keiser
075     * @since JDK1.1
076     */
077    public class IndexedPropertyDescriptor extends PropertyDescriptor
078    {
079      private Class<?> indexedPropertyType;
080      private Method setIndex;
081      private Method getIndex;
082    
083      /**
084       * Create a new IndexedPropertyDescriptor by introspection.
085       * This form of constructor creates the PropertyDescriptor by
086       * looking for getter methods named <CODE>get&lt;name&gt;()</CODE>
087       * and setter methods named
088       * <CODE>set&lt;name&gt;()</CODE> in class
089       * <CODE>&lt;beanClass&gt;</CODE>, where &lt;name&gt; has its
090       * first letter capitalized by the constructor.<P>
091       *
092       * <B>Implementation note:</B> If there is a get(int) method,
093       * then the return type of that method is used to find the
094       * remaining methods.  If there is no get method, then the
095       * set(int) method is searched for exhaustively and that type
096       * is used to find the others.<P>
097       *
098       * <B>Spec note:</B>
099       * If there is no get(int) method and multiple set(int) methods with
100       * the same name and the correct parameters (different type of course),
101       * then an IntrospectionException is thrown.  While Sun's spec
102       * does not state this, it can make Bean behavior different on
103       * different systems (since method order is not guaranteed) and as
104       * such, can be treated as a bug in the spec.  I am not aware of
105       * whether Sun's implementation catches this.
106       *
107       * @param name the programmatic name of the property, usually
108       *             starting with a lowercase letter (e.g. fooManChu
109       *             instead of FooManChu).
110       * @param beanClass the class the get and set methods live in.
111       *
112       * @exception IntrospectionException if the methods are not found or
113       *            invalid.
114       */
115      public IndexedPropertyDescriptor(String name, Class<?> beanClass)
116        throws IntrospectionException
117      {
118        super(name);
119        String capitalized;
120        try
121          {
122            capitalized = Character.toUpperCase(name.charAt(0))
123              + name.substring(1);
124          }
125        catch(StringIndexOutOfBoundsException e)
126          {
127            capitalized = "";
128          }
129        findMethods(beanClass, "get" + capitalized, "set" + capitalized,
130                    "get" + capitalized, "set" + capitalized);
131      }
132    
133      /**
134       * Create a new IndexedPropertyDescriptor by introspection.
135       * This form of constructor allows you to specify the
136       * names of the get and set methods to search for.<P>
137       *
138       * <B>Implementation note:</B> If there is a get(int) method,
139       * then the return type of that method is used to find the
140       * remaining methods.  If there is no get method, then the
141       * set(int) method is searched for exhaustively and that type
142       * is used to find the others.<P>
143       *
144       * <B>Spec note:</B>
145       * If there is no get(int) method and multiple set(int) methods with
146       * the same name and the correct parameters (different type of course),
147       * then an IntrospectionException is thrown.  While Sun's spec
148       * does not state this, it can make Bean behavior different on
149       * different systems (since method order is not guaranteed) and as
150       * such, can be treated as a bug in the spec.  I am not aware of
151       * whether Sun's implementation catches this.
152       *
153       * @param name the programmatic name of the property, usually
154       *             starting with a lowercase letter (e.g. fooManChu
155       *             instead of FooManChu).
156       * @param beanClass the class the get and set methods live in.
157       * @param getMethodName the name of the get array method.
158       * @param setMethodName the name of the set array method.
159       * @param getIndexName the name of the get index method.
160       * @param setIndexName the name of the set index method.
161       *
162       * @exception IntrospectionException if the methods are not found or invalid.
163       */
164      public IndexedPropertyDescriptor(String name, Class<?> beanClass,
165                                       String getMethodName, String setMethodName,
166                                       String getIndexName, String setIndexName)
167        throws IntrospectionException
168      {
169        super(name);
170        findMethods(beanClass, getMethodName, setMethodName, getIndexName,
171                    setIndexName);
172      }
173    
174      /**
175       * Create a new PropertyDescriptor using explicit Methods.
176       * Note that the methods will be checked for conformance to standard
177       * Property method rules, as described above at the top of this class.
178       * 
179       * @param name the programmatic name of the property, usually
180       *             starting with a lowercase letter (e.g. fooManChu
181       *             instead of FooManChu).
182       * @param getMethod the get array method.
183       * @param setMethod the set array method.
184       * @param getIndex the get index method.
185       * @param setIndex the set index method.
186       *
187       * @exception IntrospectionException if the methods are not found or invalid.
188       */
189      public IndexedPropertyDescriptor(String name, Method getMethod,
190                                       Method setMethod, Method getIndex,
191                                       Method setIndex)
192        throws IntrospectionException
193      {
194        super(name);
195        if(getMethod != null && getMethod.getParameterTypes().length > 0)
196          throw new IntrospectionException("get method has parameters");
197        if(getMethod != null && setMethod.getParameterTypes().length != 1)
198          throw new IntrospectionException("set method does not have exactly one parameter");
199        if(getMethod != null && setMethod != null)
200          {
201            if(!getMethod.getReturnType().equals(setMethod.getParameterTypes()[0]))
202              {
203                throw new IntrospectionException("set and get methods do not "
204                                                 + "share the same type");
205              }
206            if(!getMethod.getDeclaringClass().isAssignableFrom
207               (setMethod.getDeclaringClass())
208               && !setMethod.getDeclaringClass().isAssignableFrom
209               (getMethod.getDeclaringClass()))
210              {
211                throw new IntrospectionException("set and get methods are not in "
212                                                 + "the same class.");
213              }
214          }
215    
216        if (getIndex != null
217            && (getIndex.getParameterTypes().length != 1
218             || !(getIndex.getParameterTypes()[0]).equals(java.lang.Integer.TYPE)))
219          {
220            throw new IntrospectionException("get index method has wrong "
221                                             + "parameters");
222          }
223        if (setIndex != null
224           && (setIndex.getParameterTypes().length != 2
225             || !(setIndex.getParameterTypes()[0]).equals(java.lang.Integer.TYPE)))
226          {
227            throw new IntrospectionException("set index method has wrong "
228                                             + "parameters");
229          }
230        if (getIndex != null && setIndex != null)
231          {
232            if(!getIndex.getReturnType().equals(setIndex.getParameterTypes()[1]))
233              {
234                throw new IntrospectionException("set index methods do not share "
235                                                 + "the same type");
236              }
237            if(!getIndex.getDeclaringClass().isAssignableFrom
238               (setIndex.getDeclaringClass())
239               && !setIndex.getDeclaringClass().isAssignableFrom
240               (getIndex.getDeclaringClass()))
241              {
242                throw new IntrospectionException("get and set index methods are "
243                                                 + "not in the same class.");
244              }
245          }
246    
247        if (getIndex != null && getMethod != null
248            && !getIndex.getDeclaringClass().isAssignableFrom
249            (getMethod.getDeclaringClass())
250            && !getMethod.getDeclaringClass().isAssignableFrom
251            (getIndex.getDeclaringClass()))
252          {
253            throw new IntrospectionException("methods are not in the same class.");
254          }
255    
256        if (getIndex != null && getMethod != null
257            && !Array.newInstance(getIndex.getReturnType(),0)
258            .getClass().equals(getMethod.getReturnType()))
259          {
260            throw new IntrospectionException("array methods do not match index "
261                                             + "methods.");
262          }
263    
264        this.getMethod = getMethod;
265        this.setMethod = setMethod;
266        this.getIndex = getIndex;
267        this.setIndex = setIndex;
268        this.indexedPropertyType = getIndex != null ? getIndex.getReturnType()
269                                                 : setIndex.getParameterTypes()[1];
270        this.propertyType = getMethod != null ? getMethod.getReturnType()
271          : (setMethod != null ? setMethod.getParameterTypes()[0]
272             : Array.newInstance(this.indexedPropertyType,0).getClass());
273      }
274    
275      public Class<?> getIndexedPropertyType()
276      {
277        return indexedPropertyType;
278      }
279    
280      public Method getIndexedReadMethod()
281      {
282        return getIndex;
283      }
284    
285      /**
286       * Sets the method that is used to read an indexed property.
287       *
288       * @param m the method to set
289       */
290      public void setIndexedReadMethod(Method m) throws IntrospectionException
291      {
292        getIndex = m;
293      }
294    
295      public Method getIndexedWriteMethod()
296      {
297        return setIndex;
298      }
299    
300      /**
301       * Sets the method that is used to write an indexed property.
302       *
303       * @param m the method to set
304       */
305      public void setIndexedWriteMethod(Method m) throws IntrospectionException
306      {
307        setIndex = m;
308      }
309    
310      private void findMethods(Class beanClass, String getMethodName,
311                               String setMethodName, String getIndexName,
312                               String setIndexName)
313        throws IntrospectionException
314      {
315        try
316          {
317            if(getIndexName != null)
318              {
319                try
320                  {
321                    Class[] getArgs = new Class[1];
322                    getArgs[0] = java.lang.Integer.TYPE;
323                    getIndex = beanClass.getMethod(getIndexName,getArgs);
324                    indexedPropertyType = getIndex.getReturnType();
325                  }
326                catch(NoSuchMethodException E)
327                  {
328                  }
329              }
330            if(getIndex != null)
331              {
332                if(setIndexName != null)
333                  {
334                    try
335                      {
336                        Class[] setArgs = new Class[2];
337                        setArgs[0] = java.lang.Integer.TYPE;
338                        setArgs[1] = indexedPropertyType;
339                        setIndex = beanClass.getMethod(setIndexName,setArgs);
340                        if(!setIndex.getReturnType().equals(java.lang.Void.TYPE))
341                          {
342                            throw new IntrospectionException(setIndexName
343                                                    + " has non-void return type");
344                          }
345                      }
346                    catch(NoSuchMethodException E)
347                      {
348                      }
349                  }
350              }
351            else if(setIndexName != null)
352              {
353                Method[] m = beanClass.getMethods();
354                for(int i=0;i<m.length;i++)
355                  {
356                    Method current = m[i];
357                    if(current.getName().equals(setIndexName)
358                       && current.getParameterTypes().length == 2
359                       && (current.getParameterTypes()[0])
360                       .equals(java.lang.Integer.TYPE)
361                       && current.getReturnType().equals(java.lang.Void.TYPE))
362                      {
363                        if(setIndex != null)
364                          {
365                            throw new IntrospectionException("Multiple, different "
366                                         + "set methods found that fit the bill!");
367                          }
368                        else
369                          {
370                            setIndex = current;
371                            indexedPropertyType = current.getParameterTypes()[1];
372                          }
373                      }
374                  }
375                if(setIndex == null)
376                  {
377                    throw new IntrospectionException("Cannot find get or set "
378                                                     + "methods.");
379                  }
380              }
381            else
382              {
383               throw new IntrospectionException("Cannot find get or set methods.");
384              }
385    
386            Class arrayType = Array.newInstance(indexedPropertyType,0).getClass();
387    
388            Class[] setArgs = new Class[1];
389            setArgs[0] = arrayType;
390            try
391              {
392                setMethod = beanClass.getMethod(setMethodName,setArgs);
393                if (!setMethod.getReturnType().equals(java.lang.Void.TYPE))
394                  {
395                    setMethod = null;
396                  }
397              }
398            catch(NoSuchMethodException E)
399              {
400              }
401    
402            Class[] getArgs = new Class[0];
403            try
404              {
405                getMethod = beanClass.getMethod(getMethodName,getArgs);
406                if (!getMethod.getReturnType().equals(arrayType))
407                  {
408                    getMethod = null;
409                  }
410              }
411            catch(NoSuchMethodException E)
412              {
413              }
414          }
415        catch(SecurityException E)
416          {
417            throw new IntrospectionException("SecurityException while trying to "
418                                             + "find methods.");
419          }
420      }
421    }