001/* IndexedPropertyDescriptor.java --
002   Copyright (C) 1998, 2003 Free Software Foundation, Inc.
003
004This file is part of GNU Classpath.
005
006GNU Classpath is free software; you can redistribute it and/or modify
007it under the terms of the GNU General Public License as published by
008the Free Software Foundation; either version 2, or (at your option)
009any later version.
010
011GNU Classpath is distributed in the hope that it will be useful, but
012WITHOUT ANY WARRANTY; without even the implied warranty of
013MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
014General Public License for more details.
015
016You should have received a copy of the GNU General Public License
017along with GNU Classpath; see the file COPYING.  If not, write to the
018Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
01902110-1301 USA.
020
021Linking this library statically or dynamically with other modules is
022making a combined work based on this library.  Thus, the terms and
023conditions of the GNU General Public License cover the whole
024combination.
025
026As a special exception, the copyright holders of this library give you
027permission to link this library with independent modules to produce an
028executable, regardless of the license terms of these independent
029modules, and to copy and distribute the resulting executable under
030terms of your choice, provided that you also meet, for each linked
031independent module, the terms and conditions of the license of that
032module.  An independent module is a module which is not derived from
033or based on this library.  If you modify this library, you may extend
034this exception to your version of the library, but you are not
035obligated to do so.  If you do not wish to do so, delete this
036exception statement from your version. */
037
038
039package java.beans;
040
041import java.lang.reflect.Array;
042import 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 */
077public 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}