Save This Page
Home » openjdk-7 » java » beans » [javadoc | source]
    1   /*
    2    * Copyright (c) 1996, 2010, 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   import java.lang.reflect.Constructor;
   31   
   32   /**
   33    * A PropertyDescriptor describes one property that a Java Bean
   34    * exports via a pair of accessor methods.
   35    */
   36   public class PropertyDescriptor extends FeatureDescriptor {
   37   
   38       private Reference<Class> propertyTypeRef;
   39       private Reference<Method> readMethodRef;
   40       private Reference<Method> writeMethodRef;
   41       private Reference<Class> propertyEditorClassRef;
   42   
   43       private boolean bound;
   44       private boolean constrained;
   45   
   46       // The base name of the method name which will be prefixed with the
   47       // read and write method. If name == "foo" then the baseName is "Foo"
   48       private String baseName;
   49   
   50       private String writeMethodName;
   51       private String readMethodName;
   52   
   53       /**
   54        * Constructs a PropertyDescriptor for a property that follows
   55        * the standard Java convention by having getFoo and setFoo
   56        * accessor methods.  Thus if the argument name is "fred", it will
   57        * assume that the writer method is "setFred" and the reader method
   58        * is "getFred" (or "isFred" for a boolean property).  Note that the
   59        * property name should start with a lower case character, which will
   60        * be capitalized in the method names.
   61        *
   62        * @param propertyName The programmatic name of the property.
   63        * @param beanClass The Class object for the target bean.  For
   64        *          example sun.beans.OurButton.class.
   65        * @exception IntrospectionException if an exception occurs during
   66        *              introspection.
   67        */
   68       public PropertyDescriptor(String propertyName, Class<?> beanClass)
   69                   throws IntrospectionException {
   70           this(propertyName, beanClass,
   71                Introspector.IS_PREFIX + NameGenerator.capitalize(propertyName),
   72                Introspector.SET_PREFIX + NameGenerator.capitalize(propertyName));
   73       }
   74   
   75       /**
   76        * This constructor takes the name of a simple property, and method
   77        * names for reading and writing the property.
   78        *
   79        * @param propertyName The programmatic name of the property.
   80        * @param beanClass The Class object for the target bean.  For
   81        *          example sun.beans.OurButton.class.
   82        * @param readMethodName The name of the method used for reading the property
   83        *           value.  May be null if the property is write-only.
   84        * @param writeMethodName The name of the method used for writing the property
   85        *           value.  May be null if the property is read-only.
   86        * @exception IntrospectionException if an exception occurs during
   87        *              introspection.
   88        */
   89       public PropertyDescriptor(String propertyName, Class<?> beanClass,
   90                   String readMethodName, String writeMethodName)
   91                   throws IntrospectionException {
   92           if (beanClass == null) {
   93               throw new IntrospectionException("Target Bean class is null");
   94           }
   95           if (propertyName == null || propertyName.length() == 0) {
   96               throw new IntrospectionException("bad property name");
   97           }
   98           if ("".equals(readMethodName) || "".equals(writeMethodName)) {
   99               throw new IntrospectionException("read or write method name should not be the empty string");
  100           }
  101           setName(propertyName);
  102           setClass0(beanClass);
  103   
  104           this.readMethodName = readMethodName;
  105           if (readMethodName != null && getReadMethod() == null) {
  106               throw new IntrospectionException("Method not found: " + readMethodName);
  107           }
  108           this.writeMethodName = writeMethodName;
  109           if (writeMethodName != null && getWriteMethod() == null) {
  110               throw new IntrospectionException("Method not found: " + writeMethodName);
  111           }
  112           // If this class or one of its base classes allow PropertyChangeListener,
  113           // then we assume that any properties we discover are "bound".
  114           // See Introspector.getTargetPropertyInfo() method.
  115           Class[] args = { PropertyChangeListener.class };
  116           this.bound = null != Introspector.findMethod(beanClass, "addPropertyChangeListener", args.length, args);
  117       }
  118   
  119       /**
  120        * This constructor takes the name of a simple property, and Method
  121        * objects for reading and writing the property.
  122        *
  123        * @param propertyName The programmatic name of the property.
  124        * @param readMethod The method used for reading the property value.
  125        *          May be null if the property is write-only.
  126        * @param writeMethod The method used for writing the 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 PropertyDescriptor(String propertyName, Method readMethod, Method writeMethod)
  132                   throws IntrospectionException {
  133           if (propertyName == null || propertyName.length() == 0) {
  134               throw new IntrospectionException("bad property name");
  135           }
  136           setName(propertyName);
  137           setReadMethod(readMethod);
  138           setWriteMethod(writeMethod);
  139       }
  140   
  141       /**
  142        * Creates <code>PropertyDescriptor</code> for the specified bean
  143        * with the specified name and methods to read/write the property value.
  144        *
  145        * @param bean   the type of the target bean
  146        * @param base   the base name of the property (the rest of the method name)
  147        * @param read   the method used for reading the property value
  148        * @param write  the method used for writing the property value
  149        * @exception IntrospectionException if an exception occurs during introspection
  150        *
  151        * @since 1.7
  152        */
  153       PropertyDescriptor(Class<?> bean, String base, Method read, Method write) throws IntrospectionException {
  154           if (bean == null) {
  155               throw new IntrospectionException("Target Bean class is null");
  156           }
  157           setClass0(bean);
  158           setName(Introspector.decapitalize(base));
  159           setReadMethod(read);
  160           setWriteMethod(write);
  161           this.baseName = base;
  162       }
  163   
  164       /**
  165        * Returns the Java type info for the property.
  166        * Note that the {@code Class} object may describe
  167        * primitive Java types such as {@code int}.
  168        * This type is returned by the read method
  169        * or is used as the parameter type of the write method.
  170        * Returns {@code null} if the type is an indexed property
  171        * that does not support non-indexed access.
  172        *
  173        * @return the {@code Class} object that represents the Java type info,
  174        *         or {@code null} if the type cannot be determined
  175        */
  176       public synchronized Class<?> getPropertyType() {
  177           Class type = getPropertyType0();
  178           if (type  == null) {
  179               try {
  180                   type = findPropertyType(getReadMethod(), getWriteMethod());
  181                   setPropertyType(type);
  182               } catch (IntrospectionException ex) {
  183                   // Fall
  184               }
  185           }
  186           return type;
  187       }
  188   
  189       private void setPropertyType(Class type) {
  190           this.propertyTypeRef = getWeakReference(type);
  191       }
  192   
  193       private Class getPropertyType0() {
  194           return (this.propertyTypeRef != null)
  195                   ? this.propertyTypeRef.get()
  196                   : null;
  197       }
  198   
  199       /**
  200        * Gets the method that should be used to read the property value.
  201        *
  202        * @return The method that should be used to read the property value.
  203        * May return null if the property can't be read.
  204        */
  205       public synchronized Method getReadMethod() {
  206           Method readMethod = getReadMethod0();
  207           if (readMethod == null) {
  208               Class cls = getClass0();
  209               if (cls == null || (readMethodName == null && readMethodRef == null)) {
  210                   // The read method was explicitly set to null.
  211                   return null;
  212               }
  213               if (readMethodName == null) {
  214                   Class type = getPropertyType0();
  215                   if (type == boolean.class || type == null) {
  216                       readMethodName = Introspector.IS_PREFIX + getBaseName();
  217                   } else {
  218                       readMethodName = Introspector.GET_PREFIX + getBaseName();
  219                   }
  220               }
  221   
  222               // Since there can be multiple write methods but only one getter
  223               // method, find the getter method first so that you know what the
  224               // property type is.  For booleans, there can be "is" and "get"
  225               // methods.  If an "is" method exists, this is the official
  226               // reader method so look for this one first.
  227               readMethod = Introspector.findMethod(cls, readMethodName, 0);
  228               if (readMethod == null) {
  229                   readMethodName = Introspector.GET_PREFIX + getBaseName();
  230                   readMethod = Introspector.findMethod(cls, readMethodName, 0);
  231               }
  232               try {
  233                   setReadMethod(readMethod);
  234               } catch (IntrospectionException ex) {
  235                   // fall
  236               }
  237           }
  238           return readMethod;
  239       }
  240   
  241       /**
  242        * Sets the method that should be used to read the property value.
  243        *
  244        * @param readMethod The new read method.
  245        */
  246       public synchronized void setReadMethod(Method readMethod)
  247                                   throws IntrospectionException {
  248           if (readMethod == null) {
  249               readMethodName = null;
  250               readMethodRef = null;
  251               return;
  252           }
  253           // The property type is determined by the read method.
  254           setPropertyType(findPropertyType(readMethod, getWriteMethod0()));
  255           setClass0(readMethod.getDeclaringClass());
  256   
  257           readMethodName = readMethod.getName();
  258           this.readMethodRef = getSoftReference(readMethod);
  259           setTransient(readMethod.getAnnotation(Transient.class));
  260       }
  261   
  262       /**
  263        * Gets the method that should be used to write the property value.
  264        *
  265        * @return The method that should be used to write the property value.
  266        * May return null if the property can't be written.
  267        */
  268       public synchronized Method getWriteMethod() {
  269           Method writeMethod = getWriteMethod0();
  270           if (writeMethod == null) {
  271               Class cls = getClass0();
  272               if (cls == null || (writeMethodName == null && writeMethodRef == null)) {
  273                   // The write method was explicitly set to null.
  274                   return null;
  275               }
  276   
  277               // We need the type to fetch the correct method.
  278               Class type = getPropertyType0();
  279               if (type == null) {
  280                   try {
  281                       // Can't use getPropertyType since it will lead to recursive loop.
  282                       type = findPropertyType(getReadMethod(), null);
  283                       setPropertyType(type);
  284                   } catch (IntrospectionException ex) {
  285                       // Without the correct property type we can't be guaranteed
  286                       // to find the correct method.
  287                       return null;
  288                   }
  289               }
  290   
  291               if (writeMethodName == null) {
  292                   writeMethodName = Introspector.SET_PREFIX + getBaseName();
  293               }
  294   
  295               Class[] args = (type == null) ? null : new Class[] { type };
  296               writeMethod = Introspector.findMethod(cls, writeMethodName, 1, args);
  297               if (writeMethod != null) {
  298                   if (!writeMethod.getReturnType().equals(void.class)) {
  299                       writeMethod = null;
  300                   }
  301               }
  302               try {
  303                   setWriteMethod(writeMethod);
  304               } catch (IntrospectionException ex) {
  305                   // fall through
  306               }
  307           }
  308           return writeMethod;
  309       }
  310   
  311       /**
  312        * Sets the method that should be used to write the property value.
  313        *
  314        * @param writeMethod The new write method.
  315        */
  316       public synchronized void setWriteMethod(Method writeMethod)
  317                                   throws IntrospectionException {
  318           if (writeMethod == null) {
  319               writeMethodName = null;
  320               writeMethodRef = null;
  321               return;
  322           }
  323           // Set the property type - which validates the method
  324           setPropertyType(findPropertyType(getReadMethod(), writeMethod));
  325           setClass0(writeMethod.getDeclaringClass());
  326   
  327           writeMethodName = writeMethod.getName();
  328           this.writeMethodRef = getSoftReference(writeMethod);
  329           setTransient(writeMethod.getAnnotation(Transient.class));
  330       }
  331   
  332       private Method getReadMethod0() {
  333           return (this.readMethodRef != null)
  334                   ? this.readMethodRef.get()
  335                   : null;
  336       }
  337   
  338       private Method getWriteMethod0() {
  339           return (this.writeMethodRef != null)
  340                   ? this.writeMethodRef.get()
  341                   : null;
  342       }
  343   
  344       /**
  345        * Overridden to ensure that a super class doesn't take precedent
  346        */
  347       void setClass0(Class clz) {
  348           if (getClass0() != null && clz.isAssignableFrom(getClass0())) {
  349               // dont replace a subclass with a superclass
  350               return;
  351           }
  352           super.setClass0(clz);
  353       }
  354   
  355       /**
  356        * Updates to "bound" properties will cause a "PropertyChange" event to
  357        * get fired when the property is changed.
  358        *
  359        * @return True if this is a bound property.
  360        */
  361       public boolean isBound() {
  362           return bound;
  363       }
  364   
  365       /**
  366        * Updates to "bound" properties will cause a "PropertyChange" event to
  367        * get fired when the property is changed.
  368        *
  369        * @param bound True if this is a bound property.
  370        */
  371       public void setBound(boolean bound) {
  372           this.bound = bound;
  373       }
  374   
  375       /**
  376        * Attempted updates to "Constrained" properties will cause a "VetoableChange"
  377        * event to get fired when the property is changed.
  378        *
  379        * @return True if this is a constrained property.
  380        */
  381       public boolean isConstrained() {
  382           return constrained;
  383       }
  384   
  385       /**
  386        * Attempted updates to "Constrained" properties will cause a "VetoableChange"
  387        * event to get fired when the property is changed.
  388        *
  389        * @param constrained True if this is a constrained property.
  390        */
  391       public void setConstrained(boolean constrained) {
  392           this.constrained = constrained;
  393       }
  394   
  395   
  396       /**
  397        * Normally PropertyEditors will be found using the PropertyEditorManager.
  398        * However if for some reason you want to associate a particular
  399        * PropertyEditor with a given property, then you can do it with
  400        * this method.
  401        *
  402        * @param propertyEditorClass  The Class for the desired PropertyEditor.
  403        */
  404       public void setPropertyEditorClass(Class<?> propertyEditorClass) {
  405           this.propertyEditorClassRef = getWeakReference((Class)propertyEditorClass);
  406       }
  407   
  408       /**
  409        * Gets any explicit PropertyEditor Class that has been registered
  410        * for this property.
  411        *
  412        * @return Any explicit PropertyEditor Class that has been registered
  413        *          for this property.  Normally this will return "null",
  414        *          indicating that no special editor has been registered,
  415        *          so the PropertyEditorManager should be used to locate
  416        *          a suitable PropertyEditor.
  417        */
  418       public Class<?> getPropertyEditorClass() {
  419           return (this.propertyEditorClassRef != null)
  420                   ? this.propertyEditorClassRef.get()
  421                   : null;
  422       }
  423   
  424       /**
  425        * Constructs an instance of a property editor using the current
  426        * property editor class.
  427        * <p>
  428        * If the property editor class has a public constructor that takes an
  429        * Object argument then it will be invoked using the bean parameter
  430        * as the argument. Otherwise, the default constructor will be invoked.
  431        *
  432        * @param bean the source object
  433        * @return a property editor instance or null if a property editor has
  434        *         not been defined or cannot be created
  435        * @since 1.5
  436        */
  437       public PropertyEditor createPropertyEditor(Object bean) {
  438           Object editor = null;
  439   
  440           Class cls = getPropertyEditorClass();
  441           if (cls != null) {
  442               Constructor ctor = null;
  443               if (bean != null) {
  444                   try {
  445                       ctor = cls.getConstructor(new Class[] { Object.class });
  446                   } catch (Exception ex) {
  447                       // Fall through
  448                   }
  449               }
  450               try {
  451                   if (ctor == null) {
  452                       editor = cls.newInstance();
  453                   } else {
  454                       editor = ctor.newInstance(new Object[] { bean });
  455                   }
  456               } catch (Exception ex) {
  457                   // A serious error has occured.
  458                   // Proably due to an invalid property editor.
  459                   throw new RuntimeException("PropertyEditor not instantiated",
  460                                              ex);
  461               }
  462           }
  463           return (PropertyEditor)editor;
  464       }
  465   
  466   
  467       /**
  468        * Compares this <code>PropertyDescriptor</code> against the specified object.
  469        * Returns true if the objects are the same. Two <code>PropertyDescriptor</code>s
  470        * are the same if the read, write, property types, property editor and
  471        * flags  are equivalent.
  472        *
  473        * @since 1.4
  474        */
  475       public boolean equals(Object obj) {
  476           if (this == obj) {
  477               return true;
  478           }
  479           if (obj != null && obj instanceof PropertyDescriptor) {
  480               PropertyDescriptor other = (PropertyDescriptor)obj;
  481               Method otherReadMethod = other.getReadMethod();
  482               Method otherWriteMethod = other.getWriteMethod();
  483   
  484               if (!compareMethods(getReadMethod(), otherReadMethod)) {
  485                   return false;
  486               }
  487   
  488               if (!compareMethods(getWriteMethod(), otherWriteMethod)) {
  489                   return false;
  490               }
  491   
  492               if (getPropertyType() == other.getPropertyType() &&
  493                   getPropertyEditorClass() == other.getPropertyEditorClass() &&
  494                   bound == other.isBound() && constrained == other.isConstrained() &&
  495                   writeMethodName == other.writeMethodName &&
  496                   readMethodName == other.readMethodName) {
  497                   return true;
  498               }
  499           }
  500           return false;
  501       }
  502   
  503       /**
  504        * Package private helper method for Descriptor .equals methods.
  505        *
  506        * @param a first method to compare
  507        * @param b second method to compare
  508        * @return boolean to indicate that the methods are equivalent
  509        */
  510       boolean compareMethods(Method a, Method b) {
  511           // Note: perhaps this should be a protected method in FeatureDescriptor
  512           if ((a == null) != (b == null)) {
  513               return false;
  514           }
  515   
  516           if (a != null && b != null) {
  517               if (!a.equals(b)) {
  518                   return false;
  519               }
  520           }
  521           return true;
  522       }
  523   
  524       /**
  525        * Package-private constructor.
  526        * Merge two property descriptors.  Where they conflict, give the
  527        * second argument (y) priority over the first argument (x).
  528        *
  529        * @param x  The first (lower priority) PropertyDescriptor
  530        * @param y  The second (higher priority) PropertyDescriptor
  531        */
  532       PropertyDescriptor(PropertyDescriptor x, PropertyDescriptor y) {
  533           super(x,y);
  534   
  535           if (y.baseName != null) {
  536               baseName = y.baseName;
  537           } else {
  538               baseName = x.baseName;
  539           }
  540   
  541           if (y.readMethodName != null) {
  542               readMethodName = y.readMethodName;
  543           } else {
  544               readMethodName = x.readMethodName;
  545           }
  546   
  547           if (y.writeMethodName != null) {
  548               writeMethodName = y.writeMethodName;
  549           } else {
  550               writeMethodName = x.writeMethodName;
  551           }
  552   
  553           if (y.propertyTypeRef != null) {
  554               propertyTypeRef = y.propertyTypeRef;
  555           } else {
  556               propertyTypeRef = x.propertyTypeRef;
  557           }
  558   
  559           // Figure out the merged read method.
  560           Method xr = x.getReadMethod();
  561           Method yr = y.getReadMethod();
  562   
  563           // Normally give priority to y's readMethod.
  564           try {
  565               if (yr != null && yr.getDeclaringClass() == getClass0()) {
  566                   setReadMethod(yr);
  567               } else {
  568                   setReadMethod(xr);
  569               }
  570           } catch (IntrospectionException ex) {
  571               // fall through
  572           }
  573   
  574           // However, if both x and y reference read methods in the same class,
  575           // give priority to a boolean "is" method over a boolean "get" method.
  576           if (xr != null && yr != null &&
  577                      xr.getDeclaringClass() == yr.getDeclaringClass() &&
  578                      getReturnType(getClass0(), xr) == boolean.class &&
  579                      getReturnType(getClass0(), yr) == boolean.class &&
  580                      xr.getName().indexOf(Introspector.IS_PREFIX) == 0 &&
  581                      yr.getName().indexOf(Introspector.GET_PREFIX) == 0) {
  582               try {
  583                   setReadMethod(xr);
  584               } catch (IntrospectionException ex) {
  585                   // fall through
  586               }
  587           }
  588   
  589           Method xw = x.getWriteMethod();
  590           Method yw = y.getWriteMethod();
  591   
  592           try {
  593               if (yw != null && yw.getDeclaringClass() == getClass0()) {
  594                   setWriteMethod(yw);
  595               } else {
  596                   setWriteMethod(xw);
  597               }
  598           } catch (IntrospectionException ex) {
  599               // Fall through
  600           }
  601   
  602           if (y.getPropertyEditorClass() != null) {
  603               setPropertyEditorClass(y.getPropertyEditorClass());
  604           } else {
  605               setPropertyEditorClass(x.getPropertyEditorClass());
  606           }
  607   
  608   
  609           bound = x.bound | y.bound;
  610           constrained = x.constrained | y.constrained;
  611       }
  612   
  613       /*
  614        * Package-private dup constructor.
  615        * This must isolate the new object from any changes to the old object.
  616        */
  617       PropertyDescriptor(PropertyDescriptor old) {
  618           super(old);
  619           propertyTypeRef = old.propertyTypeRef;
  620           readMethodRef = old.readMethodRef;
  621           writeMethodRef = old.writeMethodRef;
  622           propertyEditorClassRef = old.propertyEditorClassRef;
  623   
  624           writeMethodName = old.writeMethodName;
  625           readMethodName = old.readMethodName;
  626           baseName = old.baseName;
  627   
  628           bound = old.bound;
  629           constrained = old.constrained;
  630       }
  631   
  632       /**
  633        * Returns the property type that corresponds to the read and write method.
  634        * The type precedence is given to the readMethod.
  635        *
  636        * @return the type of the property descriptor or null if both
  637        *         read and write methods are null.
  638        * @throws IntrospectionException if the read or write method is invalid
  639        */
  640       private Class findPropertyType(Method readMethod, Method writeMethod)
  641           throws IntrospectionException {
  642           Class propertyType = null;
  643           try {
  644               if (readMethod != null) {
  645                   Class[] params = getParameterTypes(getClass0(), readMethod);
  646                   if (params.length != 0) {
  647                       throw new IntrospectionException("bad read method arg count: "
  648                                                        + readMethod);
  649                   }
  650                   propertyType = getReturnType(getClass0(), readMethod);
  651                   if (propertyType == Void.TYPE) {
  652                       throw new IntrospectionException("read method " +
  653                                           readMethod.getName() + " returns void");
  654                   }
  655               }
  656               if (writeMethod != null) {
  657                   Class params[] = getParameterTypes(getClass0(), writeMethod);
  658                   if (params.length != 1) {
  659                       throw new IntrospectionException("bad write method arg count: "
  660                                                        + writeMethod);
  661                   }
  662                   if (propertyType != null && propertyType != params[0]) {
  663                       throw new IntrospectionException("type mismatch between read and write methods");
  664                   }
  665                   propertyType = params[0];
  666               }
  667           } catch (IntrospectionException ex) {
  668               throw ex;
  669           }
  670           return propertyType;
  671       }
  672   
  673   
  674       /**
  675        * Returns a hash code value for the object.
  676        * See {@link java.lang.Object#hashCode} for a complete description.
  677        *
  678        * @return a hash code value for this object.
  679        * @since 1.5
  680        */
  681       public int hashCode() {
  682           int result = 7;
  683   
  684           result = 37 * result + ((getPropertyType() == null) ? 0 :
  685                                   getPropertyType().hashCode());
  686           result = 37 * result + ((getReadMethod() == null) ? 0 :
  687                                   getReadMethod().hashCode());
  688           result = 37 * result + ((getWriteMethod() == null) ? 0 :
  689                                   getWriteMethod().hashCode());
  690           result = 37 * result + ((getPropertyEditorClass() == null) ? 0 :
  691                                   getPropertyEditorClass().hashCode());
  692           result = 37 * result + ((writeMethodName == null) ? 0 :
  693                                   writeMethodName.hashCode());
  694           result = 37 * result + ((readMethodName == null) ? 0 :
  695                                   readMethodName.hashCode());
  696           result = 37 * result + getName().hashCode();
  697           result = 37 * result + ((bound == false) ? 0 : 1);
  698           result = 37 * result + ((constrained == false) ? 0 : 1);
  699   
  700           return result;
  701       }
  702   
  703       // Calculate once since capitalize() is expensive.
  704       String getBaseName() {
  705           if (baseName == null) {
  706               baseName = NameGenerator.capitalize(getName());
  707           }
  708           return baseName;
  709       }
  710   
  711       void appendTo(StringBuilder sb) {
  712           appendTo(sb, "bound", this.bound);
  713           appendTo(sb, "constrained", this.constrained);
  714           appendTo(sb, "propertyEditorClass", this.propertyEditorClassRef);
  715           appendTo(sb, "propertyType", this.propertyTypeRef);
  716           appendTo(sb, "readMethod", this.readMethodRef);
  717           appendTo(sb, "writeMethod", this.writeMethodRef);
  718       }
  719   }

Save This Page
Home » openjdk-7 » java » beans » [javadoc | source]