1 /*
   2  * Copyright (c) 1996, 2014, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package java.beans;
  27 
  28 import java.lang.ref.Reference;
  29 import java.lang.reflect.Method;
  30 
  31 /**
  32  * An IndexedPropertyDescriptor describes a property that acts like an
  33  * array and has an indexed read and/or indexed write method to access
  34  * specific elements of the array.
  35  * <p>
  36  * An indexed property may also provide simple non-indexed read and write
  37  * methods.  If these are present, they read and write arrays of the type
  38  * returned by the indexed read method.
  39  */
  40 
  41 public class IndexedPropertyDescriptor extends PropertyDescriptor {
  42 
  43     private Reference<? extends Class<?>> indexedPropertyTypeRef;
  44     private final MethodRef indexedReadMethodRef = new MethodRef();
  45     private final MethodRef indexedWriteMethodRef = new MethodRef();
  46 
  47     private String indexedReadMethodName;
  48     private String indexedWriteMethodName;
  49 
  50     /**
  51      * This constructor constructs an IndexedPropertyDescriptor for a property
  52      * that follows the standard Java conventions by having getFoo and setFoo
  53      * accessor methods, for both indexed access and array access.
  54      * <p>
  55      * Thus if the argument name is "fred", it will assume that there
  56      * is an indexed reader method "getFred", a non-indexed (array) reader
  57      * method also called "getFred", an indexed writer method "setFred",
  58      * and finally a non-indexed writer method "setFred".
  59      *
  60      * @param propertyName The programmatic name of the property.
  61      * @param beanClass The Class object for the target bean.
  62      * @exception IntrospectionException if an exception occurs during
  63      *              introspection.
  64      */
  65     public IndexedPropertyDescriptor(String propertyName, Class<?> beanClass)
  66                 throws IntrospectionException {
  67         this(propertyName, beanClass,
  68              Introspector.GET_PREFIX + NameGenerator.capitalize(propertyName),
  69              Introspector.SET_PREFIX + NameGenerator.capitalize(propertyName),
  70              Introspector.GET_PREFIX + NameGenerator.capitalize(propertyName),
  71              Introspector.SET_PREFIX + NameGenerator.capitalize(propertyName));
  72     }
  73 
  74     /**
  75      * This constructor takes the name of a simple property, and method
  76      * names for reading and writing the property, both indexed
  77      * and non-indexed.
  78      *
  79      * @param propertyName The programmatic name of the property.
  80      * @param beanClass  The Class object for the target bean.
  81      * @param readMethodName The name of the method used for reading the property
  82      *           values as an array.  May be null if the property is write-only
  83      *           or must be indexed.
  84      * @param writeMethodName The name of the method used for writing the property
  85      *           values as an array.  May be null if the property is read-only
  86      *           or must be indexed.
  87      * @param indexedReadMethodName The name of the method used for reading
  88      *          an indexed property value.
  89      *          May be null if the property is write-only.
  90      * @param indexedWriteMethodName The name of the method used for writing
  91      *          an indexed property value.
  92      *          May be null if the property is read-only.
  93      * @exception IntrospectionException if an exception occurs during
  94      *              introspection.
  95      */
  96     public IndexedPropertyDescriptor(String propertyName, Class<?> beanClass,
  97                 String readMethodName, String writeMethodName,
  98                 String indexedReadMethodName, String indexedWriteMethodName)
  99                 throws IntrospectionException {
 100         super(propertyName, beanClass, readMethodName, writeMethodName);
 101 
 102         this.indexedReadMethodName = indexedReadMethodName;
 103         if (indexedReadMethodName != null && getIndexedReadMethod() == null) {
 104             throw new IntrospectionException("Method not found: " + indexedReadMethodName);
 105         }
 106 
 107         this.indexedWriteMethodName = indexedWriteMethodName;
 108         if (indexedWriteMethodName != null && getIndexedWriteMethod() == null) {
 109             throw new IntrospectionException("Method not found: " + indexedWriteMethodName);
 110         }
 111         // Implemented only for type checking.
 112         findIndexedPropertyType(getIndexedReadMethod(), getIndexedWriteMethod());
 113     }
 114 
 115     /**
 116      * This constructor takes the name of a simple property, and Method
 117      * objects for reading and writing the property.
 118      *
 119      * @param propertyName The programmatic name of the property.
 120      * @param readMethod The method used for reading the property values as an array.
 121      *          May be null if the property is write-only or must be indexed.
 122      * @param writeMethod The method used for writing the property values as an array.
 123      *          May be null if the property is read-only or must be indexed.
 124      * @param indexedReadMethod The method used for reading an indexed property value.
 125      *          May be null if the property is write-only.
 126      * @param indexedWriteMethod The method used for writing an indexed property value.
 127      *          May be null if the property is read-only.
 128      * @exception IntrospectionException if an exception occurs during
 129      *              introspection.
 130      */
 131     public IndexedPropertyDescriptor(String propertyName, Method readMethod, Method writeMethod,
 132                                             Method indexedReadMethod, Method indexedWriteMethod)
 133                 throws IntrospectionException {
 134         super(propertyName, readMethod, writeMethod);
 135 
 136         setIndexedReadMethod0(indexedReadMethod);
 137         setIndexedWriteMethod0(indexedWriteMethod);
 138 
 139         // Type checking
 140         setIndexedPropertyType(findIndexedPropertyType(indexedReadMethod, indexedWriteMethod));
 141     }
 142 
 143     /**
 144      * Creates <code>PropertyDescriptor</code> for the specified bean
 145      * with the specified name and methods to read/write the property value.
 146      *
 147      * @param bean          the type of the target bean
 148      * @param base          the base name of the property (the rest of the method name)
 149      * @param read          the method used for reading the property value
 150      * @param write         the method used for writing the property value
 151      * @param readIndexed   the method used for reading an indexed property value
 152      * @param writeIndexed  the method used for writing an indexed property value
 153      * @exception IntrospectionException if an exception occurs during introspection
 154      *
 155      * @since 1.7
 156      */
 157     IndexedPropertyDescriptor(Class<?> bean, String base, Method read, Method write, Method readIndexed, Method writeIndexed) throws IntrospectionException {
 158         super(bean, base, read, write);
 159 
 160         setIndexedReadMethod0(readIndexed);
 161         setIndexedWriteMethod0(writeIndexed);
 162 
 163         // Type checking
 164         setIndexedPropertyType(findIndexedPropertyType(readIndexed, writeIndexed));
 165     }
 166 
 167     /**
 168      * Gets the method that should be used to read an indexed
 169      * property value.
 170      *
 171      * @return The method that should be used to read an indexed
 172      * property value.
 173      * May return null if the property isn't indexed or is write-only.
 174      */
 175     public synchronized Method getIndexedReadMethod() {
 176         Method indexedReadMethod = this.indexedReadMethodRef.get();
 177         if (indexedReadMethod == null) {
 178             Class<?> cls = getClass0();
 179             if (cls == null ||
 180                 (indexedReadMethodName == null && !this.indexedReadMethodRef.isSet())) {
 181                 // the Indexed readMethod was explicitly set to null.
 182                 return null;
 183             }
 184             String nextMethodName = Introspector.GET_PREFIX + getBaseName();
 185             if (indexedReadMethodName == null) {
 186                 Class<?> type = getIndexedPropertyType0();
 187                 if (type == boolean.class || type == null) {
 188                     indexedReadMethodName = Introspector.IS_PREFIX + getBaseName();
 189                 } else {
 190                     indexedReadMethodName = nextMethodName;
 191                 }
 192             }
 193 
 194             Class<?>[] args = { int.class };
 195             indexedReadMethod = Introspector.findMethod(cls, indexedReadMethodName, 1, args);
 196             if ((indexedReadMethod == null) && !indexedReadMethodName.equals(nextMethodName)) {
 197                 // no "is" method, so look for a "get" method.
 198                 indexedReadMethodName = nextMethodName;
 199                 indexedReadMethod = Introspector.findMethod(cls, indexedReadMethodName, 1, args);
 200             }
 201             setIndexedReadMethod0(indexedReadMethod);
 202         }
 203         return indexedReadMethod;
 204     }
 205 
 206     /**
 207      * Sets the method that should be used to read an indexed property value.
 208      *
 209      * @param readMethod The new indexed read method.
 210      * @throws IntrospectionException if an exception occurs during
 211      * introspection.
 212      */
 213     public synchronized void setIndexedReadMethod(Method readMethod)
 214         throws IntrospectionException {
 215 
 216         // the indexed property type is set by the reader.
 217         setIndexedPropertyType(findIndexedPropertyType(readMethod,
 218                                                        this.indexedWriteMethodRef.get()));
 219         setIndexedReadMethod0(readMethod);
 220     }
 221 
 222     private void setIndexedReadMethod0(Method readMethod) {
 223         this.indexedReadMethodRef.set(readMethod);
 224         if (readMethod == null) {
 225             indexedReadMethodName = null;
 226             return;
 227         }
 228         setClass0(readMethod.getDeclaringClass());
 229 
 230         indexedReadMethodName = readMethod.getName();
 231         setTransient(readMethod.getAnnotation(Transient.class));
 232     }
 233 
 234 
 235     /**
 236      * Gets the method that should be used to write an indexed property value.
 237      *
 238      * @return The method that should be used to write an indexed
 239      * property value.
 240      * May return null if the property isn't indexed or is read-only.
 241      */
 242     public synchronized Method getIndexedWriteMethod() {
 243         Method indexedWriteMethod = this.indexedWriteMethodRef.get();
 244         if (indexedWriteMethod == null) {
 245             Class<?> cls = getClass0();
 246             if (cls == null ||
 247                 (indexedWriteMethodName == null && !this.indexedWriteMethodRef.isSet())) {
 248                 // the Indexed writeMethod was explicitly set to null.
 249                 return null;
 250             }
 251 
 252             // We need the indexed type to ensure that we get the correct method.
 253             // Cannot use the getIndexedPropertyType method since that could
 254             // result in an infinite loop.
 255             Class<?> type = getIndexedPropertyType0();
 256             if (type == null) {
 257                 try {
 258                     type = findIndexedPropertyType(getIndexedReadMethod(), null);
 259                     setIndexedPropertyType(type);
 260                 } catch (IntrospectionException ex) {
 261                     // Set iprop type to be the classic type
 262                     Class<?> propType = getPropertyType();
 263                     if (propType.isArray()) {
 264                         type = propType.getComponentType();
 265                     }
 266                 }
 267             }
 268 
 269             if (indexedWriteMethodName == null) {
 270                 indexedWriteMethodName = Introspector.SET_PREFIX + getBaseName();
 271             }
 272 
 273             Class<?>[] args = (type == null) ? null : new Class<?>[] { int.class, type };
 274             indexedWriteMethod = Introspector.findMethod(cls, indexedWriteMethodName, 2, args);
 275             if (indexedWriteMethod != null) {
 276                 if (!indexedWriteMethod.getReturnType().equals(void.class)) {
 277                     indexedWriteMethod = null;
 278                 }
 279             }
 280             setIndexedWriteMethod0(indexedWriteMethod);
 281         }
 282         return indexedWriteMethod;
 283     }
 284 
 285     /**
 286      * Sets the method that should be used to write an indexed property value.
 287      *
 288      * @param writeMethod The new indexed write method.
 289      * @throws IntrospectionException if an exception occurs during
 290      * introspection.
 291      */
 292     public synchronized void setIndexedWriteMethod(Method writeMethod)
 293         throws IntrospectionException {
 294 
 295         // If the indexed property type has not been set, then set it.
 296         Class<?> type = findIndexedPropertyType(getIndexedReadMethod(),
 297                                              writeMethod);
 298         setIndexedPropertyType(type);
 299         setIndexedWriteMethod0(writeMethod);
 300     }
 301 
 302     private void setIndexedWriteMethod0(Method writeMethod) {
 303         this.indexedWriteMethodRef.set(writeMethod);
 304         if (writeMethod == null) {
 305             indexedWriteMethodName = null;
 306             return;
 307         }
 308         setClass0(writeMethod.getDeclaringClass());
 309 
 310         indexedWriteMethodName = writeMethod.getName();
 311         setTransient(writeMethod.getAnnotation(Transient.class));
 312     }
 313 
 314     /**
 315      * Returns the Java type info for the indexed property.
 316      * Note that the {@code Class} object may describe
 317      * primitive Java types such as {@code int}.
 318      * This type is returned by the indexed read method
 319      * or is used as the parameter type of the indexed write method.
 320      *
 321      * @return the {@code Class} object that represents the Java type info,
 322      *         or {@code null} if the type cannot be determined
 323      */
 324     public synchronized Class<?> getIndexedPropertyType() {
 325         Class<?> type = getIndexedPropertyType0();
 326         if (type == null) {
 327             try {
 328                 type = findIndexedPropertyType(getIndexedReadMethod(),
 329                                                getIndexedWriteMethod());
 330                 setIndexedPropertyType(type);
 331             } catch (IntrospectionException ex) {
 332                 // fall
 333             }
 334         }
 335         return type;
 336     }
 337 
 338     // Private methods which set get/set the Reference objects
 339 
 340     private void setIndexedPropertyType(Class<?> type) {
 341         this.indexedPropertyTypeRef = getWeakReference(type);
 342     }
 343 
 344     private Class<?> getIndexedPropertyType0() {
 345         return (this.indexedPropertyTypeRef != null)
 346                 ? this.indexedPropertyTypeRef.get()
 347                 : null;
 348     }
 349 
 350     private Class<?> findIndexedPropertyType(Method indexedReadMethod,
 351                                           Method indexedWriteMethod)
 352         throws IntrospectionException {
 353         Class<?> indexedPropertyType = null;
 354 
 355         if (indexedReadMethod != null) {
 356             Class<?>[] params = getParameterTypes(getClass0(), indexedReadMethod);
 357             if (params.length != 1) {
 358                 throw new IntrospectionException("bad indexed read method arg count");
 359             }
 360             if (params[0] != Integer.TYPE) {
 361                 throw new IntrospectionException("non int index to indexed read method");
 362             }
 363             indexedPropertyType = getReturnType(getClass0(), indexedReadMethod);
 364             if (indexedPropertyType == Void.TYPE) {
 365                 throw new IntrospectionException("indexed read method returns void");
 366             }
 367         }
 368         if (indexedWriteMethod != null) {
 369             Class<?>[] params = getParameterTypes(getClass0(), indexedWriteMethod);
 370             if (params.length != 2) {
 371                 throw new IntrospectionException("bad indexed write method arg count");
 372             }
 373             if (params[0] != Integer.TYPE) {
 374                 throw new IntrospectionException("non int index to indexed write method");
 375             }
 376             if (indexedPropertyType == null || params[1].isAssignableFrom(indexedPropertyType)) {
 377                 indexedPropertyType = params[1];
 378             } else if (!indexedPropertyType.isAssignableFrom(params[1])) {
 379                 throw new IntrospectionException(
 380                                                  "type mismatch between indexed read and indexed write methods: "
 381                                                  + getName());
 382             }
 383         }
 384         Class<?> propertyType = getPropertyType();
 385         if (propertyType != null && (!propertyType.isArray() ||
 386                                      propertyType.getComponentType() != indexedPropertyType)) {
 387             throw new IntrospectionException("type mismatch between indexed and non-indexed methods: "
 388                                              + getName());
 389         }
 390         return indexedPropertyType;
 391     }
 392 
 393     /**
 394      * Compares this <code>PropertyDescriptor</code> against the specified object.
 395      * Returns true if the objects are the same. Two <code>PropertyDescriptor</code>s
 396      * are the same if the read, write, property types, property editor and
 397      * flags  are equivalent.
 398      *
 399      * @since 1.4
 400      */
 401     public boolean equals(Object obj) {
 402         // Note: This would be identical to PropertyDescriptor but they don't
 403         // share the same fields.
 404         if (this == obj) {
 405             return true;
 406         }
 407 
 408         if (obj != null && obj instanceof IndexedPropertyDescriptor) {
 409             IndexedPropertyDescriptor other = (IndexedPropertyDescriptor)obj;
 410             Method otherIndexedReadMethod = other.getIndexedReadMethod();
 411             Method otherIndexedWriteMethod = other.getIndexedWriteMethod();
 412 
 413             if (!compareMethods(getIndexedReadMethod(), otherIndexedReadMethod)) {
 414                 return false;
 415             }
 416 
 417             if (!compareMethods(getIndexedWriteMethod(), otherIndexedWriteMethod)) {
 418                 return false;
 419             }
 420 
 421             if (getIndexedPropertyType() != other.getIndexedPropertyType()) {
 422                 return false;
 423             }
 424             return super.equals(obj);
 425         }
 426         return false;
 427     }
 428 
 429     /**
 430      * Package-private constructor.
 431      * Merge two property descriptors.  Where they conflict, give the
 432      * second argument (y) priority over the first argumnnt (x).
 433      *
 434      * @param x  The first (lower priority) PropertyDescriptor
 435      * @param y  The second (higher priority) PropertyDescriptor
 436      */
 437 
 438     IndexedPropertyDescriptor(PropertyDescriptor x, PropertyDescriptor y) {
 439         super(x,y);
 440         if (x instanceof IndexedPropertyDescriptor) {
 441             IndexedPropertyDescriptor ix = (IndexedPropertyDescriptor)x;
 442             try {
 443                 Method xr = ix.getIndexedReadMethod();
 444                 if (xr != null) {
 445                     setIndexedReadMethod(xr);
 446                 }
 447 
 448                 Method xw = ix.getIndexedWriteMethod();
 449                 if (xw != null) {
 450                     setIndexedWriteMethod(xw);
 451                 }
 452             } catch (IntrospectionException ex) {
 453                 // Should not happen
 454                 throw new AssertionError(ex);
 455             }
 456         }
 457         if (y instanceof IndexedPropertyDescriptor) {
 458             IndexedPropertyDescriptor iy = (IndexedPropertyDescriptor)y;
 459             try {
 460                 Method yr = iy.getIndexedReadMethod();
 461                 if (yr != null && yr.getDeclaringClass() == getClass0()) {
 462                     setIndexedReadMethod(yr);
 463                 }
 464 
 465                 Method yw = iy.getIndexedWriteMethod();
 466                 if (yw != null && yw.getDeclaringClass() == getClass0()) {
 467                     setIndexedWriteMethod(yw);
 468                 }
 469             } catch (IntrospectionException ex) {
 470                 // Should not happen
 471                 throw new AssertionError(ex);
 472             }
 473         }
 474     }
 475 
 476     /*
 477      * Package-private dup constructor
 478      * This must isolate the new object from any changes to the old object.
 479      */
 480     IndexedPropertyDescriptor(IndexedPropertyDescriptor old) {
 481         super(old);
 482         this.indexedReadMethodRef.set(old.indexedReadMethodRef.get());
 483         this.indexedWriteMethodRef.set(old.indexedWriteMethodRef.get());
 484         indexedPropertyTypeRef = old.indexedPropertyTypeRef;
 485         indexedWriteMethodName = old.indexedWriteMethodName;
 486         indexedReadMethodName = old.indexedReadMethodName;
 487     }
 488 
 489     void updateGenericsFor(Class<?> type) {
 490         super.updateGenericsFor(type);
 491         try {
 492             setIndexedPropertyType(findIndexedPropertyType(this.indexedReadMethodRef.get(), this.indexedWriteMethodRef.get()));
 493         }
 494         catch (IntrospectionException exception) {
 495             setIndexedPropertyType(null);
 496         }
 497     }
 498 
 499     /**
 500      * Returns a hash code value for the object.
 501      * See {@link java.lang.Object#hashCode} for a complete description.
 502      *
 503      * @return a hash code value for this object.
 504      * @since 1.5
 505      */
 506     public int hashCode() {
 507         int result = super.hashCode();
 508 
 509         result = 37 * result + ((indexedWriteMethodName == null) ? 0 :
 510                                 indexedWriteMethodName.hashCode());
 511         result = 37 * result + ((indexedReadMethodName == null) ? 0 :
 512                                 indexedReadMethodName.hashCode());
 513         result = 37 * result + ((getIndexedPropertyType() == null) ? 0 :
 514                                 getIndexedPropertyType().hashCode());
 515 
 516         return result;
 517     }
 518 
 519     void appendTo(StringBuilder sb) {
 520         super.appendTo(sb);
 521         appendTo(sb, "indexedPropertyType", this.indexedPropertyTypeRef);
 522         appendTo(sb, "indexedReadMethod", this.indexedReadMethodRef.get());
 523         appendTo(sb, "indexedWriteMethod", this.indexedWriteMethodRef.get());
 524     }
 525 }