1 /*
   2  * Copyright (c) 2010, 2018, 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 com.sun.javafx.property;
  27 
  28 import static java.security.AccessController.doPrivileged;
  29 
  30 import java.lang.reflect.Method;
  31 import java.lang.reflect.Modifier;
  32 import java.security.PrivilegedAction;
  33 
  34 import javafx.beans.property.ReadOnlyProperty;
  35 
  36 import com.sun.javafx.reflect.ReflectUtil;
  37 
  38 /**
  39  * A handle to a specific property defined on some {@link Bean}.
  40  */
  41 public final class PropertyReference<T> {
  42     private String name;
  43     private Method getter;
  44     private Method setter;
  45     private Method propertyGetter;
  46     private Class<?> clazz;
  47     private Class<?> type;
  48     private boolean reflected = false;
  49 
  50     // uses reflection to implement the get / set methods
  51     /**
  52      * Creates a new {@code PropertyReference} for a property of a bean.
  53      *
  54      * @param clazz
  55      *            The class of the {@link Bean} that contains the property
  56      * @param name
  57      *            The name of the property
  58      * @throws NullPointerException
  59      *             if {@code clazz} or {@code name} are null
  60      * @throws IllegalArgumentException
  61      *             if {@code name} is an empty {@code String}
  62      */
  63     public PropertyReference(Class<?> clazz, String name) {
  64         if (name == null)
  65             throw new NullPointerException("Name must be specified");
  66         if (name.trim().length() == 0)
  67             throw new IllegalArgumentException("Name must be specified");
  68         if (clazz == null)
  69             throw new NullPointerException("Class must be specified");
  70         ReflectUtil.checkPackageAccess(clazz);
  71         this.name = name;
  72         this.clazz = clazz;
  73     }
  74 
  75     /**
  76      * Can be used to determine if a property can be set.
  77      *
  78      * @return {@code true}, if the property can be set, {@code false} otherwise
  79      */
  80     public boolean isWritable() {
  81         reflect();
  82         return setter != null;
  83     }
  84 
  85     /**
  86      * Can be used to determine if a property can be get.
  87      *
  88      * @return {@code true}, if the property can be get, {@code false} otherwise
  89      */
  90     public boolean isReadable() {
  91         reflect();
  92         return getter != null;
  93     }
  94 
  95     /**
  96      * Can be used to determine if a property provides an implementation of
  97      * {@link javafx.beans.value.ObservableValue}.
  98      *
  99      * @return
 100      */
 101     public boolean hasProperty() {
 102         reflect();
 103         return propertyGetter != null;
 104     }
 105 
 106     /**
 107      * Returns the name of the property.
 108      *
 109      * @return name of the propery
 110      */
 111     public String getName() {
 112         return name;
 113     }
 114 
 115     /**
 116      * Returns the class of the {@link Bean} that contains the property.
 117      *
 118      * @return the class of the {@link Bean}
 119      */
 120     public Class<?> getContainingClass() {
 121         return clazz;
 122     }
 123 
 124     /**
 125      * Returns the type of the property. This type is only evaluated correctly
 126      * if a getter or a setter was found.
 127      *
 128      * @return the type of the property
 129      */
 130     public Class<?> getType() {
 131         reflect();
 132         return type;
 133     }
 134 
 135     /**
 136      * Set the property to a new value.
 137      *
 138      * @param bean
 139      *            The {@link Bean} instance for which the property should be set
 140      * @param value
 141      *            The new value
 142      * @throws IllegalStateException
 143      *             if the property is not writable
 144      */
 145     public void set(Object bean, T value) {
 146         if (!isWritable())
 147             throw new IllegalStateException(
 148                     "Cannot write to readonly property " + name);
 149         assert setter != null;
 150         try {
 151             MethodHelper.invoke(setter, bean, new Object[] {value});
 152         } catch (Exception ex) {
 153             throw new RuntimeException(ex);
 154         }
 155     }
 156 
 157     /**
 158      * Get the value of the property.
 159      *
 160      * @param bean
 161      *            The {@code Bean} instance for which the property should be
 162      *            read
 163      * @return The value of the property
 164      * @throws IllegalStateException
 165      *             if the property is not readable
 166      */
 167     @SuppressWarnings("unchecked")
 168     public T get(Object bean) {
 169         if (!isReadable())
 170             throw new IllegalStateException(
 171                     "Cannot read from unreadable property " + name);
 172         assert getter != null;
 173         try {
 174             return (T)MethodHelper.invoke(getter, bean, (Object[])null);
 175         } catch (Exception ex) {
 176             throw new RuntimeException(ex);
 177         }
 178     }
 179 
 180     /**
 181      * Get the {@link javafx.beans.value.ObservableValue} implementation of the
 182      * property.
 183      *
 184      * @param bean
 185      *            The {@code Bean} instance for which the property should be
 186      *            read
 187      * @return The {@code ObservableValue} of the property
 188      * @throws IllegalStateException
 189      *             if the property does not provide an implementation
 190      */
 191     @SuppressWarnings("unchecked")
 192     public ReadOnlyProperty<T> getProperty(Object bean) {
 193         if (!hasProperty())
 194             throw new IllegalStateException("Cannot get property " + name);
 195         assert propertyGetter != null;
 196         try {
 197             return (ReadOnlyProperty<T>)MethodHelper.invoke(propertyGetter, bean, (Object[])null);
 198         } catch (Exception ex) {
 199             throw new RuntimeException(ex);
 200         }
 201     }
 202 
 203     /**
 204      * {@inheritDoc}
 205      */
 206     @Override
 207     public String toString() {
 208         return name;
 209     }
 210 
 211     private void reflect() {
 212         // If both the getter and setter are null then we have not reflected
 213         // on this property before
 214         if (!reflected) {
 215             reflected = true;
 216             try {
 217                 // Since we use it in several places, construct the
 218                 // first-letter-capitalized version of name
 219                 final String properName = name.length() == 1 ?
 220                         name.substring(0, 1).toUpperCase() :
 221                         Character.toUpperCase(name.charAt(0))
 222                         + name.substring(1);
 223 
 224                 // Now look for the getter. It will be named either
 225                 // "get" + name with the first letter of name
 226                 // capitalized, or it will be named "is" + name with
 227                 // the first letter of the name capitalized. However it
 228                 // is only named with "is" as a prefix if the type is
 229                 // boolean.
 230                 type = null;
 231                 // first we check for getXXX
 232                 String getterName = "get" + properName;
 233                 try {
 234                     final Method m = clazz.getMethod(getterName);
 235                     if (Modifier.isPublic(m.getModifiers())) {
 236                         getter = m;
 237                     }
 238                 } catch (NoSuchMethodException ex) {
 239                     // This is a legitimate error
 240                 }
 241 
 242                 // Then if it wasn't found we look for isXXX
 243                 if (getter == null) {
 244                     getterName = "is" + properName;
 245                     try {
 246                         final Method m = clazz.getMethod(getterName);
 247                         if (Modifier.isPublic(m.getModifiers())) {
 248                             getter = m;
 249                         }
 250                     } catch (NoSuchMethodException ex) {
 251                         // This is a legitimate error
 252                     }
 253                 }
 254 
 255                 // Now attempt to look for the setter. It is simply
 256                 // "set" + name with the first letter of name
 257                 // capitalized.
 258                 final String setterName = "set" + properName;
 259 
 260                 // If we found the getter, we can get the type
 261                 // and the setter easily.
 262                 if (getter != null) {
 263                     type = getter.getReturnType();
 264                     try {
 265                         final Method m = clazz.getMethod(setterName, type);
 266                         if (Modifier.isPublic(m.getModifiers())) {
 267                             setter = m;
 268                         }
 269                     } catch (NoSuchMethodException ex) {
 270                         // This is a legitimate error
 271                     }
 272                 } else { // no getter found
 273                     final Method[] methods = clazz.getMethods();
 274                     for (final Method m : methods) {
 275                         final Class<?>[] parameters = m.getParameterTypes();
 276                         if (setterName.equals(m.getName())
 277                                 && (parameters.length == 1)
 278                                 && Modifier.isPublic(m.getModifiers()))
 279                         {
 280                             setter = m;
 281                             type = parameters[0];
 282                             break;
 283                         }
 284                     }
 285                 }
 286 
 287                 // Now attempt to look for the property-getter.
 288                 final String propertyGetterName = name + "Property";
 289                 try {
 290                     final Method m = clazz.getMethod(propertyGetterName);
 291                     if (Modifier.isPublic(m.getModifiers())) {
 292                         propertyGetter = m;
 293                     } else
 294                         propertyGetter = null;
 295                 } catch (NoSuchMethodException ex) {
 296                     // This is a legitimate error
 297                 }
 298             } catch (RuntimeException e) {
 299                 System.err.println("Failed to introspect property " + name);
 300             }
 301         }
 302     }
 303 
 304     /**
 305      * {@inheritDoc}
 306      */
 307     @Override
 308     public boolean equals(Object obj) {
 309         if (this == obj) {
 310             return true;
 311         }
 312         if (!(obj instanceof PropertyReference)) {
 313             return false;
 314         }
 315         final PropertyReference<?> other = (PropertyReference<?>) obj;
 316         if (this.name != other.name
 317                 && (this.name == null || !this.name.equals(other.name))) {
 318             return false;
 319         }
 320         if (this.clazz != other.clazz
 321                 && (this.clazz == null || !this.clazz.equals(other.clazz))) {
 322             return false;
 323         }
 324         return true;
 325     }
 326 
 327     /**
 328      * {@inheritDoc}
 329      */
 330     @Override
 331     public int hashCode() {
 332         int hash = 5;
 333         hash = 97 * hash + (this.name != null ? this.name.hashCode() : 0);
 334         hash = 97 * hash + (this.clazz != null ? this.clazz.hashCode() : 0);
 335         return hash;
 336     }
 337 }
--- EOF ---