Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Logback: the reliable, generic, fast and flexible logging framework. Copyright (C) 1999-2011, QOS.ch. All rights reserved. This program and the accompanying materials are dual-licensed under either the terms of the Eclipse Public License v1.0 as published by the Eclipse Foundation or (per the licensee's choosing) under the terms of the GNU Lesser General Public License version 2.1 as published by the Free Software Foundation.
 
 // Contributors:  Georg Lundesgaard
 package ch.qos.logback.core.joran.util;
 
 
General purpose Object property setter. Clients repeatedly invokes setProperty(name,value) in order to invoke setters on the Object specified in the constructor. This class relies on the JavaBeans java.beans.Introspector to analyze the given Object Class using reflection.

Usage:

 PropertySetter ps = new PropertySetter(anObject);
 ps.set("name", "Joe");
 ps.set("age", "32");
 ps.set("isMale", "true");
 
will cause the invocations anObject.setName("Joe"), anObject.setAge(32), and setMale(true) if such methods exist with those signatures. Otherwise an java.beans.IntrospectionException are thrown.

Author(s):
Anders Kristensen
Ceki Gulcu
 
 public class PropertySetter extends ContextAwareBase {
 
   protected Object obj;
   protected Class objClass;
   protected MethodDescriptor[] methodDescriptors;

  
Create a new PropertySetter for the specified Object. This is done in preparation for invoking setProperty(java.lang.String,java.lang.String) one or more times.

Parameters:
obj the object for which to set properties
 
   public PropertySetter(Object obj) {
     this. = obj;
     this. = obj.getClass();
   }

  
Uses JavaBeans java.beans.Introspector to computer setters of object to be configured.
 
   protected void introspect() {
     try {
       BeanInfo bi = Introspector.getBeanInfo(.getClass());
     } catch (IntrospectionException ex) {
       addError("Failed to introspect " +  + ": " + ex.getMessage());
        = new PropertyDescriptor[0];
        = new MethodDescriptor[0];
     }
   }

  
Set a property on this PropertySetter's Object. If successful, this method will invoke a setter method on the underlying Object. The setter is the one for the specified property name and the value is determined partly from the setter argument type and partly from the value specified in the call to this method.

If the setter expects a String no conversion is necessary. If it expects an int, then an attempt is made to convert 'value' to an int using new Integer(value). If the setter expects a boolean, the conversion is by new Boolean(value).

Parameters:
name name of the property
value String value of the property
  public void setProperty(String nameString value) {
    if (value == null) {
      return;
    }
    name = Introspector.decapitalize(name);
    if (prop == null) {
      addWarn("No such property [" + name + "] in " + .getName() + ".");
    } else {
      try {
        setProperty(propnamevalue);
      } catch (PropertySetterException ex) {
        addWarn("Failed to set property [" + name + "] to value \"" + value
            + "\". "ex);
      }
    }
  }

  
Set the named property given a java.beans.PropertyDescriptor.

Parameters:
prop A PropertyDescriptor describing the characteristics of the property to set.
name The named of the property to set.
value The value of the property.
  public void setProperty(PropertyDescriptor propString nameString value)
      throws PropertySetterException {
    Method setter = prop.getWriteMethod();
    if (setter == null) {
      throw new PropertySetterException("No setter for property [" + name
          + "].");
    }
    Class[] paramTypes = setter.getParameterTypes();
    if (paramTypes.length != 1) {
      throw new PropertySetterException("#params for setter != 1");
    }
    Object arg;
    try {
      arg = StringToObjectConverter.convertArg(thisvalueparamTypes[0]);
    } catch (Throwable t) {
      throw new PropertySetterException("Conversion to type [" + paramTypes[0]
          + "] failed. "t);
    }
    if (arg == null) {
      throw new PropertySetterException("Conversion to type [" + paramTypes[0]
          + "] failed.");
    }
    try {
      setter.invoke(arg);
    } catch (Exception ex) {
      throw new PropertySetterException(ex);
    }
  }
    String cName = capitalizeFirstLetter(name);
    Method addMethod = findAdderMethod(cName);
    // if the
    if (addMethod != null) {
      AggregationType type = computeRawAggregationType(addMethod);
      switch (type) {
      case :
        return .;
      case :
      case :
      }
    }
    Method setterMethod = findSetterMethod(name);
    if (setterMethod != null) {
      return computeRawAggregationType(setterMethod);
    } else {
      // we have failed
      return .;
    }
  }
  private Method findAdderMethod(String name) {
    name = capitalizeFirstLetter(name);
    return getMethod("add" + name);
  }
  private Method findSetterMethod(String name) {
    String dName = Introspector.decapitalize(name);
    PropertyDescriptor propertyDescriptor = getPropertyDescriptor(dName);
    if (propertyDescriptor != null) {
      return propertyDescriptor.getWriteMethod();
    } else {
      return null;
    }
  }
  private Class<?> getParameterClassForMethod(Method method) {
    if (method == null) {
      return null;
    }
    Class[] classArray = method.getParameterTypes();
    if (classArray.length != 1) {
      return null;
    } else {
      return classArray[0];
    }
  }
    Class<?> parameterClass = getParameterClassForMethod(method);
    if (parameterClass == null) {
      return .;
    }
    if (StringToObjectConverter.canBeBuiltFromSimpleString(parameterClass)) {
    } else {
    }
  }

  
Can the given clazz instantiable with certainty?

Parameters:
clazz The class to test for instantiability
Returns:
true if clazz can be instantiated, and false otherwise.
  private boolean isUnequivocallyInstantiable(Class<?> clazz) {
    if (clazz.isInterface()) {
      return false;
    }
    // checking for constructors would be more elegant, but in
    // classes without any declared constructors, Class.getConstructor()
    // returns null.
    Object o;
    try {
      o = clazz.newInstance();
      if (o != null) {
        return true;
      } else {
        return false;
      }
    } catch (InstantiationException e) {
      return false;
    } catch (IllegalAccessException e) {
      return false;
    }
  }
  public Class getObjClass() {
    return ;
  }
  public void addComplexProperty(String nameObject complexProperty) {
    Method adderMethod = findAdderMethod(name);
    // first let us use the addXXX method
    if (adderMethod != null) {
      Class[] paramTypes = adderMethod.getParameterTypes();
      if (!isSanityCheckSuccessful(nameadderMethodparamTypes,
          complexProperty)) {
        return;
      }
      invokeMethodWithSingleParameterOnThisObject(adderMethodcomplexProperty);
    } else {
      addError("Could not find method [" + "add" + name + "] in class ["
          + .getName() + "].");
    }
  }
      Object parameter) {
    Class ccc = parameter.getClass();
    try {
      method.invoke(this.parameter);
    } catch (Exception e) {
      addError("Could not invoke method " + method.getName() + " in class "
          + .getClass().getName() + " with parameter of type "
          + ccc.getName(), e);
    }
  }
  public void addBasicProperty(String nameString strValue) {
    if (strValue == null) {
      return;
    }
    name = capitalizeFirstLetter(name);
    Method adderMethod = findAdderMethod(name);
    if (adderMethod == null) {
      addError("No adder for property [" + name + "].");
      return;
    }
    Class[] paramTypes = adderMethod.getParameterTypes();
    isSanityCheckSuccessful(nameadderMethodparamTypesstrValue);
    Object arg;
    try {
      arg = StringToObjectConverter.convertArg(thisstrValueparamTypes[0]);
    } catch (Throwable t) {
      addError("Conversion to type [" + paramTypes[0] + "] failed. "t);
      return;
    }
    if (arg != null) {
      invokeMethodWithSingleParameterOnThisObject(adderMethodstrValue);
    }
  }
  public void setComplexProperty(String nameObject complexProperty) {
    String dName = Introspector.decapitalize(name);
    PropertyDescriptor propertyDescriptor = getPropertyDescriptor(dName);
    if (propertyDescriptor == null) {
      addWarn("Could not find PropertyDescriptor for [" + name + "] in "
          + .getName());
      return;
    }
    Method setter = propertyDescriptor.getWriteMethod();
    if (setter == null) {
      addWarn("Not setter method for property [" + name + "] in "
          + .getClass().getName());
      return;
    }
    Class[] paramTypes = setter.getParameterTypes();
    if (!isSanityCheckSuccessful(namesetterparamTypescomplexProperty)) {
      return;
    }
    try {
      invokeMethodWithSingleParameterOnThisObject(settercomplexProperty);
    } catch (Exception e) {
      addError("Could not set component " +  + " for parent component "
          + e);
    }
  }
  private boolean isSanityCheckSuccessful(String nameMethod method,
      Class<?>[] paramsObject complexProperty) {
    Class ccc = complexProperty.getClass();
    if (params.length != 1) {
      addError("Wrong number of parameters in setter method for property ["
          + name + "] in " + .getClass().getName());
      return false;
    }
    if (!params[0].isAssignableFrom(complexProperty.getClass())) {
      addError("A \"" + ccc.getName() + "\" object is not assignable to a \""
          + params[0].getName() + "\" variable.");
      addError("The class \"" + params[0].getName() + "\" was loaded by ");
      addError("[" + params[0].getClassLoader() + "] whereas object of type ");
      addError("\"" + ccc.getName() + "\" was loaded by ["
          + ccc.getClassLoader() + "].");
      return false;
    }
    return true;
  }
  private String capitalizeFirstLetter(String name) {
    return name.substring(0, 1).toUpperCase() + name.substring(1);
  }
  protected Method getMethod(String methodName) {
    if ( == null) {
      introspect();
    }
    for (int i = 0; i < .i++) {
      if (methodName.equals([i].getName())) {
        return [i].getMethod();
      }
    }
    return null;
  }
    if ( == null) {
      introspect();
    }
    for (int i = 0; i < .i++) {
      // System.out.println("Comparing " + name + " against "
      // + propertyDescriptors[i].getName());
      if (name.equals([i].getName())) {
        // System.out.println("matched");
        return [i];
      }
    }
    return null;
  }
  public Object getObj() {
    return ;
  }
  Method getRelevantMethod(String nameAggregationType aggregationType) {
    String cName = capitalizeFirstLetter(name);
    Method relevantMethod;
    if (aggregationType == .) {
      relevantMethod = findAdderMethod(cName);
    } else if (aggregationType == .) {
      relevantMethod = findSetterMethod(cName);
    } else {
      throw new IllegalStateException(aggregationType + " not allowed here");
    }
    return relevantMethod;
  }
  <T extends Annotation> T getAnnotation(String nameClass<T> annonationClass,
      Method relevantMethod) {
    if (relevantMethod != null) {
      return relevantMethod.getAnnotation(annonationClass);
    } else {
      return null;
    }
  }
  Class getDefaultClassNameByAnnonation(String nameMethod relevantMethod) {
    DefaultClass defaultClassAnnon = getAnnotation(nameDefaultClass.class,
        relevantMethod);
    if (defaultClassAnnon != null) {
      return defaultClassAnnon.value();
    }
    return null;
  }
  Class getByConcreteType(String nameMethod relevantMethod) {
    Class<?> paramType = getParameterClassForMethod(relevantMethod);
    if (paramType == null) {
      return null;
    }
    boolean isUnequivocallyInstantiable = isUnequivocallyInstantiable(paramType);
    if (isUnequivocallyInstantiable) {
      return paramType;
    } else {
      return null;
    }
  }
      AggregationType aggregationTypeDefaultNestedComponentRegistry registry) {
    Class registryResult = registry.findDefaultComponentType(.getClass(),
        name);
    if (registryResult != null) {
      return registryResult;
    }
    // find the relevant method for the given property name and aggregationType
    Method relevantMethod = getRelevantMethod(nameaggregationType);
    if (relevantMethod == null) {
      return null;
    }
    Class byAnnotation = getDefaultClassNameByAnnonation(namerelevantMethod);
    if (byAnnotation != null) {
      return byAnnotation;
    }
    return getByConcreteType(namerelevantMethod);
  }
New to GrepCode? Check out our FAQ X