org.numenta.nupic.util.BeanUtil Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of htm.java Show documentation
The Java version of Numenta's HTM technology
There is a newer version: 0.6.13
/* ---------------------------------------------------------------------
 * Numenta Platform for Intelligent Computing (NuPIC)
 * Copyright (C) 2014, Numenta, Inc.  Unless you have an agreement
 * with Numenta, Inc., for a separate license for this software code, the
 * following terms and conditions apply:
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero Public License version 3 as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU Affero Public License for more details.
 *
 * You should have received a copy of the GNU Affero Public License
 * along with this program.  If not, see http://www.gnu.org/licenses.
 *
 * http://numenta.org/licenses/
 * ---------------------------------------------------------------------
 */

package org.numenta.nupic.util;

import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 *Singleton helper for reading/writing beans properties
 *@author Kirill Solovyev
 */
public class BeanUtil {
  //TODO introduce proper log in future
  //private static final Log LOG = LogFactory.getLog(BeanUtil.class);
  private final Map, PropertyInfo[]> properties = new ConcurrentHashMap, PropertyInfo[]>();
  private static final PropertyDescriptor[] EMPTY_PROPERTY_DESCRIPTOR = new PropertyDescriptor[0];
  private static BeanUtil INSTANCE = new BeanUtil();

  public static BeanUtil getInstance() {
    return INSTANCE;
  }

  private BeanUtil() {
  }

  /**
  * Write value to bean's property
  * @param bean
  * @param name
  * @param value
  * @return
  */
  public boolean setSimpleProperty(Object bean, String name, Object value) {
    PropertyInfo pi = getPropertyInfo(bean, name);
    if (pi != null) {
      setSimpleProperty(bean, pi, value);
      return true;
    } else {
      return false;
    }
  }

  public void setSimplePropertyRequired(Object bean, String name, Object value) {
    setSimpleProperty(bean, getPropertyInfoRequired(bean, name), value);
  }

    /**
     * Return bean's property value
     * @param bean
     * @param name
     * @return
     */
  public Object getSimpleProperty(Object bean, String name) {
    return getSimpleProperty(bean, getPropertyInfo(bean, name));
  }


  private Object getSimpleProperty(Object bean, PropertyInfo info) {
    if (info.getReadMethod() == null) {
      throw new IllegalArgumentException("Property '" + info.name + "' of bean " + bean.getClass().getName() +
                                         " does not have getter method");
    }
    return invokeMethod(info.getReadMethod(), bean);
  }

  private void setSimpleProperty(Object bean, PropertyInfo info, Object value) {
    if (info.getWriteMethod() == null) {
      throw new IllegalArgumentException("Property '" + info.name + "' of bean " + bean.getClass().getName() +
                                         " does not have setter method");
    }
    invokeMethod(info.getWriteMethod(), bean, value);
  }

  private Object invokeMethod(Method m, Object instance, Object... args) {
    if (instance == null) {
      throw new IllegalArgumentException("Can not invole Method '" + m + "' on null instance");
    }
    try {
      return m.invoke(instance, args);
    } catch (IllegalArgumentException e) {
      final String msg = "Cannot invoke " + m.getDeclaringClass().getName() + "." + m.getName() + " - " + e.getMessage();
      //LOG.error(msg, e);
      throw new IllegalArgumentException(msg, e);
    } catch (IllegalAccessException e) {
      final String msg = "Cannot invoke " + m.getDeclaringClass().getName() + "." + m.getName() + " - " + e.getMessage();
      //LOG.error(msg, e);
      throw new RuntimeException(msg, e);
    } catch (InvocationTargetException e) {
      Throwable te = e.getTargetException() == null ? e : e.getTargetException();
      final String msg = "Error invoking " + m.getDeclaringClass().getName() + "." + m.getName() + " - " + te.getMessage();
      //LOG.error(msg, e);
      throw new RuntimeException(msg, te);
    }
  }

  public PropertyInfo getPropertyInfo(Object bean, String name) {
    if (bean == null) {
      throw new IllegalArgumentException("Bean can not be null");
    }
    return getPropertyInfo(bean.getClass(), name);
  }

  public PropertyInfo getPropertyInfoRequired(Object bean, String name) {
    PropertyInfo result = getPropertyInfo(bean, name);
    if (result == null) {
      throw new IllegalArgumentException(
              "Bean " + bean.getClass().getName() + " does not have property '" + name + "'");
    }
    return result;
  }

  public PropertyInfo getPropertyInfo(Class beanClass, String name) {
    if (name == null) {
      throw new IllegalArgumentException("Property name is required and can not be null");
    }
    PropertyInfo infos[] = getPropertiesInfoForBean(beanClass);
    for (PropertyInfo info : infos) {
      if (name.equals(info.getName())) {
        return info;
      }
    }
    return null;
  }


  public PropertyInfo[] getPropertiesInfoForBean(Class beanClass) {
    if (beanClass == null) {
      throw new IllegalArgumentException("Bean class is required and can not be null");
    }

    PropertyInfo infos[] = properties.get(beanClass);
    if (infos != null) {
      return infos;
    }

    PropertyDescriptor descriptors[];
    try {
      descriptors = Introspector.getBeanInfo(beanClass).getPropertyDescriptors();
      if (descriptors == null) {
        descriptors = EMPTY_PROPERTY_DESCRIPTOR;
      }
    } catch (IntrospectionException e) {
      descriptors = EMPTY_PROPERTY_DESCRIPTOR;
    }
    infos = new PropertyInfo[descriptors.length];
    for (int i = 0; i < descriptors.length; i++) {
      infos[i] = createPropertyInfo(beanClass, descriptors[i]);
    }
    properties.put(beanClass, infos);
    return infos;
  }

  private PropertyInfo createPropertyInfo(Class beanClass, PropertyDescriptor d) {
    return new PropertyInfo(beanClass, d.getName(), d.getPropertyType(), d.getReadMethod(), d.getWriteMethod());
  }

  @SuppressWarnings("unused")
  private PropertyInfo createPropertyInfo(Class beanClass, String propertyName, Class propertyType) {
    return new PropertyInfo(beanClass, propertyName, propertyType, null, null);
  }

  public static class PropertyInfo {
    private final Class beanClass;
    private final String name;
    private final Class type;
    private final Method readMethod;
    private final Method writeMethod;

    PropertyInfo(Class beanClass, String name, Class type, Method readMethod, Method writeMethod) {
      this.beanClass = beanClass;
      this.name = name;
      this.type = type;
      this.readMethod = readMethod;
      this.writeMethod = writeMethod;
    }

    public Class getBeanClass() {
      return beanClass;
    }

    public String getName() {
      return name;
    }

    public Class getType() {
      return type;
    }

    public Method getReadMethod() {
      return readMethod;
    }

    public Method getWriteMethod() {
      return writeMethod;
    }


    public String toString() {
      return "PropertyInfo{" +
             "beanClass=" + beanClass +
             ", name='" + name + "'" +
             ", type=" + type +
             ", readMethod=" + readMethod +
             ", writeMethod=" + writeMethod +
             "}";
    }
  }


}