Java Examples for org.apache.commons.beanutils.ConvertUtils

/**
	 * @param value
	 * @param targetType
	 */
public static Object convert(Object value, Class<?> targetType) {
    try {
        Class<?> clazz = Thread.currentThread().getContextClassLoader().loadClass("org.apache.commons.beanutils.ConvertUtils");
        Method method = clazz.getMethod("convert", Object.class, Class.class);
        return method.invoke(null, value, targetType);
    } catch (Exception e) {
        throw new ActiveJpaException("Failed while converting the type", e);
    }
}

/**
     * @see Comparator#compare(Object, Object)
     */
public int compare(Object obj1, Object obj2) {
    double dbl1 = 0;
    if (obj1 instanceof Number) {
        dbl1 = ((Number) obj1).doubleValue();
    } else if (obj1 != null) {
        dbl1 = ((Number) ConvertUtils.convert(obj1.toString(), Number.class)).doubleValue();
    }
    double dbl2 = 0;
    if (obj2 instanceof Number) {
        dbl2 = ((Number) obj2).doubleValue();
    } else if (obj1 != null) {
        dbl2 = ((Number) ConvertUtils.convert(obj2.toString(), Number.class)).doubleValue();
    }
    return new Double(dbl1).compareTo(new Double(dbl2));
}

protected void setAttribute(Object pojo, AttributeMetaData attribute, Object value) {
    try {
        if (value != null) {
            PropertyUtils.setProperty(pojo, attribute.getName(), value);
        } else if (PropertyUtil.isPrimitive(attribute.getType())) {
            PropertyUtils.setProperty(pojo, attribute.getName(), ConvertUtils.convert(0, attribute.getType()));
        }
    } catch (Exception e) {
        throw new AutoPojoException(e);
    }
}

/**
         * Creates a new instance of {@link CoberturaPublisher} from a submitted form.
         */
@Override
public CoberturaPublisher newInstance(StaplerRequest req, JSONObject formData) throws FormException {
    CoberturaPublisher instance = req.bindParameters(CoberturaPublisher.class, "cobertura.");
    ConvertUtils.register(CoberturaPublisherTarget.CONVERTER, CoverageMetric.class);
    List<CoberturaPublisherTarget> targets = req.bindParametersToList(CoberturaPublisherTarget.class, "cobertura.target.");
    instance.setTargets(targets);
    return instance;
}

//ΪbeanUtils¿ò¼Ü×¢²áʵÏÖ½«×Ö·û´®×ª»»Îª¸´ÔÓÊý¾ÝÀàÐ͵Äת»»Æ÷£¬ÕâÀïÊǽ«½«×Ö·û´®×ª»¯ÎªÉúÈÕÈÕÆÚµÄת»»Æ÷
@Test
public void test3() throws Exception {
    String name = "aaa";
    String password = "123";
    String age = "24";
    String birthday = "1980-09-09";
    //ΪÁËÈÃÈÕÆÚ¸³µ½beanµÄbirthdayÊôÐÔÉÏ£¬ÎÒÃǸøbeanUtils×¢²áÒ»¸öÈÕÆÚת»»Æ÷£¬beanUtilsΪÁËÖ¸¶¨ÁËΪ¸´ÔÓÀàÐÍ×¢²áת»»Æ÷µÄ·½·¨ConvertUtils¹¤¾ßÀà
    ConvertUtils.register(new //ÔÚbeanUtilsת»»Ö®Ç°×¢²áµÄÕâ¸öת»¯¸´ÔÓÀàÐ͵Äת»¯Æ÷
    Converter() {

        public //Õâ¸öº¯ÊýÓÐbeanUtilsµ÷Ó㬽«value×Ö·û´®ÀàÐÍÊýֵת»¯Îª¸´ÔÓµÄtypeÀàÐÍ(ÕâÀïÊÇDateÀàÐÍ)
        Object convert(//Õâ¸öº¯ÊýÓÐbeanUtilsµ÷Ó㬽«value×Ö·û´®ÀàÐÍÊýֵת»¯Îª¸´ÔÓµÄtypeÀàÐÍ(ÕâÀïÊÇDateÀàÐÍ)
        Class type, //Õâ¸öº¯ÊýÓÐbeanUtilsµ÷Ó㬽«value×Ö·û´®ÀàÐÍÊýֵת»¯Îª¸´ÔÓµÄtypeÀàÐÍ(ÕâÀïÊÇDateÀàÐÍ)
        Object value) {
            //Ê×Ïȼì²éǰ̨´ø¹ýÀ´µÄ×Ö·û´®Êý¾ÝvalueÊÇ·ñΪ¿Õ£¬Îª¿Õ²»¸øÓÚת»¯
            if (value == null) {
                return null;
            }
            if (//ÅжÏbeanUtils´«µÝ½øÀ´µÄǰ̨Ҫת»¯Îª¸´ÔÓÀàÐ͵ÄÊý¾ÝÊDz»ÊÇStringÀàÐÍ
            !(value instanceof String)) {
                throw new RuntimeException("Ö§³ÖStringÀàÐ͵Äת»»");
            }
            //½«valueת»¯ÎªStringÀàÐÍ
            String str = (String) value;
            if (//·Àֹǰ̨´«µÝ¹ýÀ´µÄ×Ö·û´®ÊÇһϵÁеĿոñÈç  ¡°     ¡±
            str.trim().equals("")) {
                return null;
            }
            //˵Ã÷ÊÇ×Ö·û´®ÇÒÓÐÖµ
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
            try {
                return df.parse(str);
            } catch (ParseException e) {
                throw new RuntimeException(e);
            }
        }
    }, //ΪbeanUtils×¢²áÒ»¸öʵÏÖ½«×Ö·û´®×ª»¯Îªclazz±êʾµÄ¸´ÔÓÀàÐ͵Äת»»Æ÷
    Date.class);
    Person bean = new Person();
    //±íʾÉèÖÃÄĸöbeanµÄÄĸöÊôÐÔ£¬¾ÍΪÕâ¸öÊôÐÔ¸³ÖµÎªvalue
    BeanUtils.setProperty(bean, "name", name);
    //Ö»Ö§³Ö×Ö·û´®µ½8ÖÖ»ù±¾Êý¾ÝÀàÐÍ×Ô¶¯×ª»»
    BeanUtils.setProperty(bean, "password", password);
    BeanUtils.setProperty(bean, "age", age);
    BeanUtils.setProperty(bean, "birthday", birthday);
    System.out.println(//aaa
    bean.getName());
    System.out.println(//123
    bean.getPassword());
    //24£¬¿ÉÒÔ¿´µ½Ç°Ì¨´«µÝ¹ýµÄÊý¾Ý¶¼¶¼ÊÇ×Ö·û´®ÀàÐ͵ģ¬µ«ÊÇbean¶ÔÏóageÊôÐÔÊÇintÐÍ£¬Ò²¾ÍÊÇbeanUtils¿ò¼ÜÖ§³Ö½«Ç°Ì¨µÄ×Ö·û´®Êý¾Ý×Ô¶¯×ªÐÍΪ°ËÖÖ»ù±¾ÀàÐÍÊý¾Ý£¬µ«ÊǸ´ÔÓÀàÐÍ£¬¾Í²»¿ÉÒÔÁË£¬ÐèÒªÎÒÃÇΪ¸´ÔÓÀàÐÍ×¢²áÒ»¸öת»¯Æ÷¸æËßbeanUtilsÓÃÕâ¸öת»»Æ÷È¥½«Ç°Ì¨stringÀàÐÍת»¯Îªbean¶ÔÏóµÄ¸´ÔÓÀàÐÍÊôÐÔ£¬ÈçÉúÈÕÈÕÆÚ
    System.out.println(bean.getAge());
    //1980-9-9 0:00:00
    System.out.println(bean.getBirthday().toLocaleString());
}

/**
   * <p>A conversion utility that will properly convert enumeration types.  All other conversion are done with
   * org.apache.commons.beanutils.ConvertUtils.convert( Object, Class ).</p>
   *
   * @param value the value to convert.
   * @param type the target type for the value.
   * @return the converted type.
   */
public static Object convert(Object value, Class type) {
    if (Enum.class.isAssignableFrom(type)) {
        //System.out.println("The type "+type+" is assignable to Enum.");
        Object result = org.apache.commons.beanutils.ConvertUtils.convert(value, type);
        if (result == null) {
            return null;
        } else if (type.isAssignableFrom(result.getClass())) {
            return result;
        } else {
            return Enum.valueOf(type, result.toString());
        }
    } else {
        //System.out.println("The type "+type+" is not assignable to Enum.");
        return org.apache.commons.beanutils.ConvertUtils.convert(value, type);
    }
}

public static void autowire(Object obj, Map<String, String> attributes) {
    ProcessToolContext ctx = ProcessToolContext.Util.getThreadProcessToolContext();
    Class clazz = obj.getClass();
    for (Field f : Classes.getDeclaredFields(clazz)) {
        String autoName = null;
        AutoWiredProperty awp = f.getAnnotation(AutoWiredProperty.class);
        if (awp != null) {
            autoName = AutoWiredProperty.DEFAULT.equals(awp.name()) ? f.getName() : awp.name();
        }
        String v = nvl(attributes.get(autoName), ctx.getAutowiredProperty("autowire." + autoName));
        if (autoName != null && v != null) {
            try {
                logger.finer("Setting class " + clazz.getSimpleName() + " attribute " + autoName + " to " + v);
                Object value = ConvertUtils.convert(v, f.getType());
                Classes.setFieldValue(obj, f, value);
            } catch (Exception e) {
                logger.log(Level.SEVERE, e.getMessage(), e);
            }
        }
    }
}

private void setConfiguration(AccessibleObject ao, Configuration config, EnvVars envVars, VariableResolver<String> resolver) {
    Property p = ao.getAnnotation(Property.class);
    if (p == null)
        return;
    try {
        String v = ConvertUtils.convert(getPropertyValue(ao));
        if (v != null) {
            if (v != RemotePropertySet.PASSWORD) {
                v = expandVariable(envVars, resolver, v);
            }
            config.setProperty(p.value(), v);
        }
    } catch (Exception e) {
        IllegalAccessError x = new IllegalAccessError();
        x.initCause(e);
        throw x;
    }
}

/**
	 * Convert value into the specified type
	 * 
	 * @param <X>
	 *            Class to convert to
	 * @param value
	 *            Value to convert from
	 * @param targetType
	 *            Type to convert into
	 * @return The converted value
	 */
@SuppressWarnings("unchecked")
public static <X> X convert(Object value, Class<X> targetType) {
    LOGGER.trace("Attempting to convert " + value + " to class type " + targetType);
    if (value != null) {
        // it, just return as it is
        if (value.getClass() == targetType) {
            return (X) value;
        }
        if (value.getClass() == JSONObject.class || value.getClass() == JSONArray.class) {
            return (X) value;
        }
    }
    String strValue = String.valueOf(value);
    Object retval = ConvertUtils.convert(strValue, targetType);
    return (X) retval;
}

/**
   * Returns a {@link Converter} that can convert values to the target value
   * type. If the target entity type + property has a custom converter defined
   * in the GTFS entity schema, we will use that as instead.
   * 
   * @param targetEntityType the target entity type whose property will be
   *          updated.
   * @param targetPropertyName the target property name for the property that
   *          will be updated on the target entity.
   * @param targetValueType the target value type we wish to convert to
   */
public Converter resolveConverter(Class<?> targetEntityType, String targetPropertyName, Class<?> targetValueType) {
    SingleFieldMapping mapping = _schemaCache.getFieldMappingForCsvFieldName(targetEntityType, targetPropertyName);
    if (mapping == null) {
        mapping = _schemaCache.getFieldMappingForObjectFieldName(targetEntityType, targetPropertyName);
    }
    if (mapping != null) {
        if (mapping instanceof ConverterFactory) {
            ConverterFactory factory = (ConverterFactory) mapping;
            return factory.create(_reader.getContext());
        }
        if (mapping instanceof Converter) {
            return (Converter) mapping;
        }
    }
    return ConvertUtils.lookup(targetValueType);
}

/**
     *
     */
public List<DiskDetailInfo> listDiskInfo(String disk, String ownershipType) {
    List<DiskDetailInfo> disks = new ArrayList<DiskDetailInfo>();
    NaElement input = new NaElement("disk-list-info");
    if (StringUtils.isNotBlank(disk)) {
        input.addNewChild("disk", disk);
    }
    if (StringUtils.isNotBlank(ownershipType)) {
        input.addNewChild("ownership-type", ownershipType);
    }
    NaElement result = server.invoke(input);
    if (result != null) {
        NaElement diskDetails = result.getChildByName("disk-details");
        if (diskDetails != null) {
            for (NaElement diskDetailElem : (List<NaElement>) diskDetails.getChildren()) {
                if (diskDetailElem != null) {
                    DiskDetailInfo diskDetailInfo = new DiskDetailInfo();
                    diskDetailInfo.setAggregate(diskDetailElem.getChildContent("aggregate"));
                    diskDetailInfo.setDiskModel(diskDetailElem.getChildContent("disk-model"));
                    diskDetailInfo.setDiskType(diskDetailElem.getChildContent("disk-type"));
                    diskDetailInfo.setDiskUid(diskDetailElem.getChildContent("disk-uid"));
                    diskDetailInfo.setName(diskDetailElem.getChildContent("name"));
                    diskDetailInfo.setPool(diskDetailElem.getChildContent("pool"));
                    diskDetailInfo.setRaidGroup(diskDetailElem.getChildContent("raid-group"));
                    diskDetailInfo.setRaidState(diskDetailElem.getChildContent("raid-state"));
                    diskDetailInfo.setRaidType(diskDetailElem.getChildContent("raid-type"));
                    diskDetailInfo.setRpm((Integer) ConvertUtils.convert(diskDetailElem.getChildContent("rpm"), Integer.class));
                    diskDetailInfo.setPhysicalSpace((Long) ConvertUtils.convert(diskDetailElem.getChildContent("physical-space"), Long.class));
                    disks.add(diskDetailInfo);
                }
            }
        }
    }
    return disks;
}

/**
     * 从XML文件中读�数�
     * @param obj �存数�的对象
     * @param inputUrl 所�读�的XML文件对应的URL
     * @param rulesUrl XML文件读�规则对应的URL
     * @return 读�数��对应的对象，如果读�失败，则返回null
     */
public static Object parse(Object obj, URL inputUrl, URL rulesUrl) {
    // Digester 1.8 需�的关闭的日志
    Logger.getLogger("org.apache.commons.digester.Digester").setLevel(Level.OFF);
    Logger.getLogger("org.apache.commons.beanutils.BeanUtils").setLevel(Level.OFF);
    Logger.getLogger("org.apache.commons.beanutils.ConvertUtils").setLevel(Level.OFF);
    // Digester 2.0 新增的需�的关闭的日志
    Logger.getLogger("org.apache.commons.beanutils.converters").setLevel(Level.OFF);
    InputStream inputStream = null;
    try {
        inputStream = new FileInputStream(inputUrl.getFile());
        obj = parse(obj, inputStream, rulesUrl);
    } catch (Exception e) {
        RunLogger.warn("Failed to read XML", e);
    } finally {
        if (null != inputStream) {
            try {
                inputStream.close();
            } catch (IOException e) {
            }
        }
    }
    return obj;
}

/**
	 * Converts a string based Row Key to the Key Type as specified by the
	 * DataController (adaptee).
	 * 
	 * @param rowKey
	 *            string based Row Key
	 * @return the converted key
	 */
@SuppressWarnings("unchecked")
K convertToGetValueOfParameter(final String rowKey) {
    final Object parameterValue = ConvertUtils.convert(rowKey, getkeyofParameterType);
    if (parameterValue.getClass().equals(getkeyofParameterType)) {
        return (K) parameterValue;
    } else {
        throw new RuntimeException("Unable to convert String " + "based rowKey to " + getkeyofParameterType.getName());
    }
}

@SuppressWarnings({ "rawtypes", "unchecked" })
private static <T> void addElementToList(T bean, NameValuePair element, PropertyDescriptor descriptor) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
    List obj = (List) PropertyUtils.getProperty(bean, element.getName());
    if (obj == null) {
        obj = new ArrayList();
    }
    Class<?> clazz = getListGenericType(descriptor);
    obj.add(ConvertUtils.convert(element.getValue(), clazz));
    PropertyUtils.setProperty(bean, element.getName(), obj);
}

private int compareByProperty(Class propType, Object prop1, Object prop2) {
    int compareResult = 0;
    if (prop1 != null && prop2 != null && Comparable.class.isAssignableFrom(prop1.getClass())) {
        compareResult = ((Comparable<Object>) prop1).compareTo(prop2);
    } else if (prop1 != null && prop2 != null) {
        compareResult = ConvertUtils.convert(prop1).compareTo(ConvertUtils.convert(prop2));
    } else if (prop1 == null && prop2 != null) {
        compareResult = 1;
    } else if (prop1 != null && prop2 == null) {
        compareResult = -1;
    }
    return compareResult;
}

@SuppressWarnings({ "unchecked", "rawtypes" })
public static <T> T convertTo(String value, Class<T> type) {
    if (type.isEnum()) {
        return type.cast(Enum.valueOf((Class) type, value.toUpperCase()));
    }
    Class<T> clazz = type;
    if (type.isPrimitive()) {
        clazz = ClassUtils.primitiveToWrapper(type);
    }
    if (clazz.getName().equals(Boolean.class.getName())) {
        return clazz.cast(booleanConverter.convert(Boolean.class, value));
    }
    try {
        Constructor constructor = type.getConstructor(String.class);
        return (T) constructor.newInstance(value);
    } catch (Exception e) {
    }
    return clazz.cast(org.apache.commons.beanutils.ConvertUtils.convert(value, type));
}

/**
	 * Given a Class and an List, this method will
	 * populate the given List with all Field's for that Class and
	 * all of its parent Classes in the inheritance tree
	 * 
	 * @param fields
	 * @param type the Class to check
	 * @param stopAtClass, if the current class is equal to this, we go no further up the parent chains
	 * @param	annotationClass the class of the annotation which must be present in 
	 */
private void populateAllDeclaredFields(List<Field> fields, Class type, Class stopAtClass, Class<? extends Annotation> annotationClass) {
    for (Field field : type.getDeclaredFields()) {
        if (annotationClass != null) {
            if (field.isAnnotationPresent(annotationClass)) {
                fields.add(field);
            }
        } else {
            fields.add(field);
        }
        if (field.getType().isEnum()) {
            ConvertUtils.register(new GenericEnumConverter(), field.getType());
        }
    }
    // this is as far as we go...
    if (stopAtClass != null && stopAtClass == type) {
        return;
    }
    if (type.getSuperclass() != null) {
        populateAllDeclaredFields(fields, type.getSuperclass(), stopAtClass, annotationClass);
    }
}

public void parse(String[] args) throws CmdLineParseException {
    LinkedList<String> arglist = new LinkedList<String>();
    arglist.addAll(Arrays.asList(args));
    // Quick Help
    if (arglist.contains("--" + OPT_HELP)) {
        usage();
        return;
    }
    // Configuration File Option
    int idx = arglist.indexOf("--" + OPT_CONFIG);
    if (idx >= 0) {
        if (idx + 1 > arglist.size()) {
            throw new CmdLineParseException("Expected <File> parameter for option: --" + OPT_CONFIG);
        }
        String value = arglist.get(idx + 1);
        File file = (File) ConvertUtils.convert(value, File.class);
        this.configer.setPersistFile(file);
        arglist.remove(idx + 1);
        arglist.remove(idx);
    }
    // Save Options Option
    boolean saveOptions = false;
    idx = arglist.indexOf("--" + OPT_SAVE);
    if (idx >= 0) {
        saveOptions = true;
        arglist.remove(idx);
    }
    // Restore from persist first.
    try {
        configer.restore();
    } catch (IOException e) {
        throw new CmdLineParseException("Unable to load configuration: " + e.getMessage(), e);
    }
    // Set values from command line now.
    String value;
    ListIterator<String> iter = arglist.listIterator();
    while (iter.hasNext()) {
        String arg = iter.next();
        if (arg.startsWith("--")) {
            // Its an option.
            String optname = arg.substring(2);
            Configurable cfgrbl = configer.getConfigurable(optname);
            if (cfgrbl == null) {
                throw new CmdLineParseException("Invalid Option: " + arg);
            }
            if (!iter.hasNext()) {
                throw new CmdLineParseException("Expected <" + cfgrbl.getType() + "> parameter for option: " + arg);
            }
            value = iter.next();
            configer.setValue(optname, value);
            // process next arg
            continue;
        }
        // All others are considered args.
        addToRawArgs(arg);
    }
    // Save options (if specified)
    if (saveOptions) {
        try {
            configer.persist();
        } catch (IOException e) {
            throw new CmdLineParseException("Unable to save configuration: " + e.getMessage(), e);
        }
    }
}

public static Object convertGenericType(String fieldName, Object value, FieldType type) {
    if (FieldType.DATE == type) {
        return convertDate(fieldName, value);
    }
    if (type.getClasses().length == 0)
        return error(INVALID_FORMAT, fieldName);
    Class<?> clz = type.getClasses()[0];
    value = ConvertUtils.convert(value, clz);
    if (value == null || !clz.isAssignableFrom(value.getClass())) {
        return error(INVALID_FORMAT, fieldName);
    }
    return value;
}

@Override
protected void init() {
    super.init();
    ButtonResource.cleanUpFiles();
    BorderMaker.install("borders-engine");
    this.mountBookmarkablePage("/Quickstart", QuickStart.class);
    this.mountBookmarkablePage("/ButtonEditor", ButtonEditor.class);
    this.mountBookmarkablePage("/Download", Download.class);
    ConvertUtils.register(new ColorConverter(), Color.class);
}

public static void registerConverters() {
    ConvertUtils.register(new StringConverter(), String.class);
    //date 
    ConvertUtils.register(new DateConverter(null), java.util.Date.class);
    ConvertUtils.register(new SqlDateConverter(null), java.sql.Date.class);
    ConvertUtils.register(new SqlTimeConverter(null), Time.class);
    ConvertUtils.register(new SqlTimestampConverter(null), Timestamp.class);
    //number
    ConvertUtils.register(new BooleanConverter(null), Boolean.class);
    ConvertUtils.register(new ShortConverter(null), Short.class);
    ConvertUtils.register(new IntegerConverter(null), Integer.class);
    ConvertUtils.register(new LongConverter(null), Long.class);
    ConvertUtils.register(new FloatConverter(null), Float.class);
    ConvertUtils.register(new DoubleConverter(null), Double.class);
    ConvertUtils.register(new BigDecimalConverter(null), BigDecimal.class);
    ConvertUtils.register(new BigIntegerConverter(null), BigInteger.class);
}

/**
	 * 
	* @Title: testRegist 
	* @Description: 实现对�支�的类进行转�。 
	* @return:void   
	* @throws 
	* @author peace w_peace@163.com
	 */
@Test
public void testRegist() {
    // 注册日期类型转�器：1， 自定义的方�
    ConvertUtils.register(new Converter() {

        /**
			   * 转�函数，实现对date的转�。
			   */
        @Override
        public Object convert(Class type, Object value) {
            //判断是�为Date类型
            if (type != Date.class)
                return null;
            //判断是�为空
            if (value == null || "".equals(value.toString().trim()))
                return null;
            try {
                //转�方�
                SimpleDateFormat date = new SimpleDateFormat("yyyy-mm-dd");
                return date.parse(value.toString());
            } catch (ParseException e) {
                throw new RuntimeException(e);
            }
        }
    }, Date.class);
    //执行
    Admin admin = new Admin();
    Map<String, Object> map = new HashMap<>();
    map.put("userName", "peace2");
    map.put("age", 22);
    map.put("id", 002);
    map.put("pwd", 123456);
    map.put("birth", new Date(2015, 10, 9));
    try {
        BeanUtils.populate(admin, map);
        System.out.println(admin);
    } catch (IllegalAccessExceptionInvocationTargetException |  e) {
        e.printStackTrace();
    }
}

public String[] convertToString(Object[] objects) {
    String[] strings = new String[objects.length];
    int i = 0;
    for (Object object : objects) {
        if (object != null) {
            Converter converter = ConvertUtils.lookup(object.getClass());
            strings[i++] = converter.convert(object.getClass(), object).toString();
        } else {
            strings[i++] = "";
        }
    }
    return strings;
}

/**
     * Parse given string expression to expected type of value
     * 
     * @param expression String expression
     * @param type Target type
     * @return Object of value
     */
public static Object parse(String expression, String type) {
    if (expression == null || StringUtils.equalsIgnoreCase(NULL, expression)) {
        return null;
    }
    Class<?> c;
    try {
        c = ClassUtils.getClass(type);
    } catch (ClassNotFoundException e) {
        throw new IllegalArgumentException("Type " + type + " isn't valid", e);
    }
    if (c == String.class) {
        return expression;
    }
    if (StringUtils.isEmpty(expression)) {
        return null;
    }
    return ConvertUtils.convert(expression, c);
}

/**
     * Adds the type and value of a method parameter to the internal lists.
     * @param param The parameter object that holds the type and value information in a string manner.
     * @throws MethodParamException If the parameter type cannot be found or If the parameter string value cannot be converted into an object defined by the parameter type.
     */
public void add(MessageParam param) throws MethodParamException {
    try {
        Class type = null;
        try {
            type = Class.forName(param.getType(), true, Thread.currentThread().getContextClassLoader());
        } catch (ClassNotFoundException e) {
            type = Class.forName(String.class.getName(), true, Thread.currentThread().getContextClassLoader());
        }
        String stringValue = param.getValue() == null ? StringConstants.EMPTY : param.getValue();
        Object objectValue = ConvertUtils.convert(stringValue, type);
        if (objectValue == null || !type.isAssignableFrom(objectValue.getClass())) {
            throw new MethodParamException(//$NON-NLS-1$
            "Failed converting " + stringValue + " into an instance of " + type, //$NON-NLS-1$
            param);
        }
        m_types.add(type);
        m_objectValues.add(objectValue);
    } catch (ClassNotFoundException e) {
        throw new MethodParamException("Action parameter type not found: " + e, param);
    }
}

public void populateBean(String dataString, Map beans) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException, ClassNotFoundException {
    Object bean;
    if (beans.containsKey(beanKey)) {
        bean = beans.get(beanKey);
        Class dataType = getPropertyType(beans);
        Object value = null;
        if (!(nullAllowed && dataString == null)) {
            // set only if null is not allowed!
            value = ConvertUtils.convert(dataString, dataType);
        }
        PropertyUtils.setProperty(bean, propertyName, value);
    } else {
        if (log.isWarnEnabled()) {
            log.warn("Can't find bean under the key=" + beanKey);
        }
    }
}

public static void registerConverters() {
    ConvertUtils.register(new StringConverter(), String.class);
    //date 
    ConvertUtils.register(new DateConverter(null), java.util.Date.class);
    ConvertUtils.register(new SqlDateConverter(null), java.sql.Date.class);
    ConvertUtils.register(new SqlTimeConverter(null), Time.class);
    ConvertUtils.register(new SqlTimestampConverter(null), Timestamp.class);
    //number
    ConvertUtils.register(new BooleanConverter(null), Boolean.class);
    ConvertUtils.register(new ShortConverter(null), Short.class);
    ConvertUtils.register(new IntegerConverter(null), Integer.class);
    ConvertUtils.register(new LongConverter(null), Long.class);
    ConvertUtils.register(new FloatConverter(null), Float.class);
    ConvertUtils.register(new DoubleConverter(null), Double.class);
    ConvertUtils.register(new BigDecimalConverter(null), BigDecimal.class);
    ConvertUtils.register(new BigIntegerConverter(null), BigInteger.class);
}

public String[] convertToString(Object[] objects) {
    String[] strings = new String[objects.length];
    int i = 0;
    for (Object object : objects) {
        if (object != null) {
            Converter converter = ConvertUtils.lookup(object.getClass());
            strings[i++] = converter.convert(object.getClass(), object).toString();
        } else {
            strings[i++] = "";
        }
    }
    return strings;
}

@Override
@SuppressWarnings("unchecked")
public <T> T get(String path, Class<T> type) {
    DataObjectImplUtil.checkPath(path);
    Object o = get(path);
    T value = (T) ConvertUtils.convert(o, type);
    if (DataObject.class.equals(type) && !(value instanceof DataObject)) {
        // If the contained object requires directFieldsInsteadOfJavaBean, it won't work, as we are cheating here:
        return (T) new BeanWrapper(value);
    }
    return value;
}

public static Object generalAttributeConversion(Class expectedType, Object value) {
    if (value instanceof String) {
        if (expectedType.equals(Class.class)) {
            try {
                value = AttributeUtils.classValue(value);
            } catch (ClassNotFoundException e) {
                throw new WicketComponentBuilderException("Attribute conversion error.  Could not find class '" + value.toString() + "'", e);
            }
        }
        if (expectedType.equals(String.class) == false)
            value = ConvertUtils.convert((String) value, expectedType);
    }
    return value;
}

/**
     * @param <T> the type in which the provided value has to be converted
     * @param targetType the type in which the provided value has to be converted
     * @param sourceValue the value to convert
     * @return the converted value
     */
private <T> T convert(Class<T> targetType, Object sourceValue) {
    T result;
    // primitive type.
    try {
        result = (T) ConvertUtils.convert(sourceValue, targetType);
    } catch (ConversionException ex) {
        throw new org.xwiki.properties.converter.ConversionException("Error while performing type conversion", ex);
    }
    // that the returned value is compatible with the expected type and raise a ConversionException if not.
    if (!TypeUtils.isAssignable(targetType, result.getClass())) {
        throw new org.xwiki.properties.converter.ConversionException(String.format("Failed to find a Converter to convert from [%s] to [%s]", sourceValue.getClass().getName(), targetType.getName()));
    }
    return result;
}

/**
     * sets up the converters that this marshaller should use
     */
private static void configureConverters() {
    String pattern = "MM/dd/yy";
    Locale locale = Locale.getDefault();
    DateLocaleConverter converter = new DateLocaleConverter(locale, pattern);
    converter.setLenient(true);
    ConvertUtils.register(converter, java.util.Date.class);
    TypeEnumConverter enumConverter = new TypeEnumConverter();
    ConvertUtils.register(enumConverter, Question.Type.class);
    ConvertUtils.register(enumConverter, QuestionDto.QuestionType.class);
    ConvertUtils.register(enumConverter, AccessPoint.Status.class);
    ConvertUtils.register(enumConverter, AccessPoint.AccessPointType.class);
    ConvertUtils.register(enumConverter, UnitOfMeasure.UnitOfMeasureSystem.class);
    ConvertUtils.register(enumConverter, UnitOfMeasure.UnitOfMeasureType.class);
    ConvertUtils.register(enumConverter, QuestionHelpMedia.Type.class);
    ConvertUtils.register(enumConverter, QuestionHelpDto.Type.class);
    ConvertUtils.register(enumConverter, OGRFeatureDto.FeatureType.class);
    ConvertUtils.register(enumConverter, Survey.Status.class);
    ConvertUtils.register(enumConverter, Survey.Sector.class);
    ConvertUtils.register(enumConverter, SurveyGroup.ProjectType.class);
    ConvertUtils.register(enumConverter, SurveyGroup.PrivacyLevel.class);
    // Resetting default values from zero to null
    ConvertUtils.register(new DoubleConverter(null), Double.class);
    ConvertUtils.register(new LongConverter(null), Long.class);
    ConvertUtils.register(new IntegerConverter(null), Integer.class);
    DatastoreTextConverter textConverter = new DatastoreTextConverter();
    ConvertUtils.register(textConverter, Text.class);
    ConvertUtils.register(textConverter, String.class);
}

public static void registerConverter() {
    ConvertUtils.register(new SqlDateConverter(), java.sql.Date.class);
    ConvertUtils.register(new DateConverter(), java.util.Date.class);
    ConvertUtils.register(new BooleanConverter(null), Boolean.class);
    ConvertUtils.register(new IntegerConverter(null), Integer.class);
    ConvertUtils.register(new LongConverter(null), Long.class);
    ConvertUtils.register(new FloatConverter(null), Float.class);
    ConvertUtils.register(new DoubleConverter(null), Double.class);
}

//    private PropertyUtilsBean propertyUtilsBean = null;
public Object convertOmit(Object dest, Object src, String[] omit) throws IllegalAccessException, InvocationTargetException {
    // Validate existence of the specified beans
    if (dest == null) {
        throw new IllegalArgumentException("No destination bean specified");
    }
    if (src == null) {
        throw new IllegalArgumentException("No origin bean specified");
    }
    if (log.isDebugEnabled()) {
        log.debug("BeanUtils.copyProperties(" + dest + ", " + src + ")");
    }
    org.apache.commons.beanutils.Converter converter = ConvertUtils.lookup(java.util.Date.class);
    System.out.println("ConvertUtils.lookup( java.util.Date.class): " + converter);
    org.apache.commons.beanutils.Converter converter2 = ConvertUtils.lookup(java.lang.String.class);
    System.out.println("ConvertUtils.lookup( java.lang.String.class): " + converter2);
    // Copy the properties, converting as necessary
    if (src instanceof DynaBean) {
        copyDynaBean(dest, src);
    } else if (src instanceof Map) {
        copyMap(dest, src);
    } else /* if (src is a standard JavaBean) */
    {
        copyJavaBean(dest, src, omit);
    }
    return dest;
}

public void parse(final PrettyConfigBuilder builder, final InputStream resource) throws IOException, SAXException {
    if (builder == null) {
        throw new IllegalArgumentException("Builder must not be null.");
    }
    if (resource == null) {
        throw new IllegalArgumentException("Input stream must not be null.");
    }
    final Digester digester = configureDigester(new Digester());
    ConvertUtils.register(caseConverter, Case.class);
    ConvertUtils.register(trailingSlashConverter, TrailingSlash.class);
    ConvertUtils.register(phaseIdConverter, PhaseId.class);
    ConvertUtils.register(redirectConverter, Redirect.class);
    digester.push(builder);
    digester.parse(resource);
}

public static void exploringBeanUtils() {
    Person person = new Person();
    person.setAttribute("address1", "2930 Oak Shadow Drive");
    person.setAttribute("city", "Oak Hill");
    person.setAttribute("dateOfBirth", new java.util.Date());
/*		Convert ingWrapDynaBean bean = new ConvertingWrapDynaBean(person);
		System.out.println("Build a dyna bean using my person:");
		System.out.println(bean.get("address1"));
		System.out.println(bean.get("dateOfBirth"));
		
		System.out.println("Changing some of the values.");
		bean.set("givenName", "Odysseas");
		bean.set("familyName", "Pentakalos");
		System.out.println(bean.get("nationality.nationalityCd"));
		bean.set("nationality.nationalityCd", "150");
		System.out.println("Value " + bean.get("nationality.nationalityCd") + " is of type " + bean.get("nationality.nationalityCd").getClass());
		person = (Person) bean.getInstance();
		System.out.println(person);
		
		List<String> properties = ConvertUtil.extractProperties(person);
		for (String property : properties) {
			System.out.println("Property name is: " + property);
		}

//		DynaProperty[] properties = bean.getDynaClass().getDynaProperties();
//		for (DynaProperty property : properties) {
//			System.out.println("The map has the property: " + property.getName() + " which is mapped " + property.getType());
//			if (property.getType().getName().startsWith("org.openhie")) {
//				WrapDynaClass dynaClass = WrapDynaClass.createDynaClass(property.getType());
//				DynaProperty[] internalProperties = dynaClass.getDynaProperties();
//				for (DynaProperty internalProperty : internalProperties) {
//					System.out.println("The map has the property: " + property.getName() + "." + internalProperty.getName());
//				}
//			}
//		}
		
//		BeanMap beanMap = new BeanMap(person);
//		Set<String> properties = beanMap.keySet();
//		for (String key : properties) {
//			System.out.println("The map has the property: " + key);
//		}
		
		org.apache.commons.beanutils.converters.DateConverter converter = new org.apache.commons.beanutils.converters.DateConverter();
		converter.setPattern("yyyy.MM.dd HH:mm:ss z");
		String[] patterns = converter.getPatterns();
		for (String pattern : patterns) {
			System.out.println("Pattern is " + pattern);
		}
		Date now = new Date();
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss z");
		System.out.println(sdf.format(now));
		
		ConvertUtils.register(converter, java.util.Date.class);
		ConvertUtils convertUtils = new ConvertUtils();
		System.out.println(convertUtils.convert("2009.03.06 15:13:29 EST", java.util.Date.class));
		
		try {
			BeanUtils.setProperty(person, "dateOfBirth", "2009.03.06 15:13:29 EST");
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(bean.get("dateOfBirth"));
		
		System.out.println(bean.getDynaClass().getDynaProperty("dateOfBirth"));
		bean.set("dateOfBirth", "2009.03.06 15:13:29 EST");
		System.out.println(bean.get("dateOfBirth"));*/
}

protected void copyMapFieldsToEntity(ServiceContext context, AuditedBaseEntity entity, Map<String, String> map) {
    Map<String, String> entityFields = entity.getAsMap();
    Map<String, Method> methods = Maps.newHashMap();
    for (Method method : entity.getClass().getMethods()) {
        methods.put(method.getName(), method);
    }
    Iterator<Entry<String, String>> iterator = map.entrySet().iterator();
    while (iterator.hasNext()) {
        Entry<String, String> entry = iterator.next();
        String key = entry.getKey();
        String value = entry.getValue();
        if (entityFields.containsKey(key)) {
            try {
                String methodName = "set" + key.substring(0, 1).toUpperCase() + key.substring(1);
                if (methods.containsKey(methodName)) {
                    Method method = methods.get(methodName);
                    Class<?>[] parameters = method.getParameterTypes();
                    if (ArrayUtils.isNotEmpty(parameters) && parameters.length == 1) {
                        Object convertedValue;
                        if (value == null) {
                            convertedValue = null;
                        } else if (Number.class.isAssignableFrom(parameters[0]) && StringUtils.isEmpty(value)) {
                            convertedValue = null;
                        } else {
                            convertedValue = ConvertUtils.convert(value, parameters[0]);
                        }
                        method.invoke(entity, convertedValue);
                        iterator.remove();
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
                log.warn("Unable to copy map entry: {}, to member variable on entity: {}.", key, entity.getClass());
            }
        }
    }
}

/**
	 * 转�字符串类型到clazz的property类型的值.
	 * 
	 * @param value 待转�的字符串
	 * @param clazz æ??供类型信æ?¯çš„Class
	 * @param propertyName æ??供类型信æ?¯çš„Class的属性.
	 */
public static Object convertValue(Object value, Class<?> toType) {
    try {
        DateConverter dc = new DateConverter();
        dc.setUseLocaleFormat(true);
        dc.setPatterns(new String[] { "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss" });
        ConvertUtils.register(dc, Date.class);
        return ConvertUtils.convert(value, toType);
    } catch (Exception e) {
        throw convertToUncheckedException(e);
    }
}

public static void copyFromStringObject(final Object strObject, final Object dest) throws Exception {
    if (strObject == null || dest == null) {
        return;
    }
    final Map<String, String> map = mapProperties(strObject, dest);
    ConvertUtils.register(BIG_DECIMAL_CONVERTER, BigDecimal.class);
    ConvertUtils.register(DOUBLE_CONVERTER, Double.class);
    ConvertUtils.register(INTEGER_CONVERTER, Integer.class);
    ConvertUtils.register(LONG_CONVERTER, Long.class);
    ConvertUtils.register(SQL_DATE_CONVERTER, Date.class);
    ConvertUtils.register(SQL_TIME_CONVERTER, Time.class);
    ConvertUtils.register(TIME_CONVERTER, Time.class);
    BeanUtils.populate(dest, map);
}

private void setProperty(final MetaDataProvider instance, final String propertyName, final String propertyValue) throws MojoExecutionException {
    final Class<? extends MetaDataProvider> metaDataProviderClass = instance.getClass();
    try {
        final Field field = findField(metaDataProviderClass, propertyName);
        field.setAccessible(true);
        final Class<?> type = field.getType();
        final Object typedPropertyValue = ConvertUtils.convert(propertyValue, type);
        field.set(instance, typedPropertyValue);
    } catch (final Exception e) {
        throw new MojoExecutionException("Cannot set property '" + propertyName + "' to value '" + propertyValue + "' for the instance of class '" + metaDataProviderClass.getName() + "'.", e);
    }
}

public static Object convertStringToObject(String value, Class<?> toType) {
    try {
        DateConverter dc = new DateConverter();
        dc.setUseLocaleFormat(true);
        dc.setPatterns(new String[] { "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss" });
        ConvertUtils.register(dc, Date.class);
        return ConvertUtils.convert(value, toType);
    } catch (Exception e) {
        throw convertReflectionExceptionToUnchecked(e);
    }
}

public void set(String name, Object value) {
    DynaProperty property = getDynaProperty(name);
    if (property.getType() == null) {
        throw new NullPointerException("Unspecified property type for " + name);
    }
    if (value == null) {
        if (property.getType().isPrimitive()) {
            throw new NullPointerException("Property type for " + name + " is primitive");
        }
    } else if (!isDynaAssignable(property.getType(), value.getClass())) {
        try {
            value = ConvertUtils.convert(String.valueOf(value), value.getClass());
        } catch (Exception e) {
            throw new IllegalArgumentException("Unassignable property type for " + name);
        }
    }
    // log.debug( name + " = " + value );
    dynaValues.put(name, value);
}

/**
     *  Convert the specified value to the required type.
     *
     * @param type The Java type of target property
     * @param index The indexed subscript value (if any)
     * @param value The value to be converted
     * @return The converted value
     */
protected Object convert(Class type, int index, Object value) {
    Object newValue = null;
    if (type.isArray() && (index < 0)) {
        // Scalar value into array
        if (value instanceof String) {
            String[] values = new String[1];
            values[0] = (String) value;
            newValue = ConvertUtils.convert(values, type);
        } else if (value instanceof String[]) {
            newValue = ConvertUtils.convert((String[]) value, type);
        } else {
            newValue = value;
        }
    } else if (type.isArray()) {
        // Indexed value into array
        if (value instanceof String) {
            newValue = ConvertUtils.convert((String) value, type.getComponentType());
        } else if (value instanceof String[]) {
            newValue = ConvertUtils.convert(((String[]) value)[0], type.getComponentType());
        } else {
            newValue = value;
        }
    } else {
        // Value into scalar
        if (value instanceof String) {
            newValue = ConvertUtils.convert((String) value, type);
        } else if (value instanceof String[]) {
            newValue = ConvertUtils.convert(((String[]) value)[0], type);
        } else {
            newValue = value;
        }
    }
    return newValue;
}

/**
	 * 转�字符串类型到clazz的property类型的值.
	 * 
	 * @param value 待转�的字符串
	 * @param clazz æ??供类型信æ?¯çš„Class
	 * @param propertyName æ??供类型信æ?¯çš„Class的属性.
	 */
public static Object convertValue(Object value, Class<?> toType) {
    try {
        DateConverter dc = new DateConverter();
        dc.setUseLocaleFormat(true);
        dc.setPatterns(new String[] { "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss" });
        ConvertUtils.register(dc, Date.class);
        return ConvertUtils.convert(value, toType);
    } catch (Exception e) {
        throw convertToUncheckedException(e);
    }
}

/**
	 * 获得�数key值 例如： /admin/productAction.do?action=edit&productId=1721
	 * 缺�:productId为product的modelmapping.xml中key定义值
	 * 
	 * 对于如下调用： /admin/productAction.do?action=edit&userId=16
	 * userId�是modelmapping.xml中key定义值，则需�override本方法，
	 * 
	 * 
	 * @param actionMapping
	 * @param request
	 * @return �数key值
	 * @throws java.lang.Exception
	 */
public Object getParamKeyValue(HttpServletRequest request, ModelHandler modelHandler) {
    Object keyValue = null;
    try {
        ModelMapping modelMapping = modelHandler.getModelMapping();
        String keyName = modelMapping.getKeyName();
        Debug.logVerbose("[JdonFramework] the keyName is  " + keyName, module);
        String keyValueS = request.getParameter(keyName);
        Debug.logVerbose("[JdonFramework] got the keyValue is  " + keyValueS, module);
        if (keyValueS == null) {
            Debug.logVerbose("[JdonFramework]the keyValue is null", module);
        }
        Class keyClassType = modelMapping.getKeyClassType();
        if (keyClassType.isAssignableFrom(String.class)) {
            keyValue = keyValueS;
        } else {
            Debug.logVerbose("[JdonFramework] convert String keyValue to" + keyClassType.getName(), module);
            keyValue = ConvertUtils.convert(keyValueS, keyClassType);
        }
    } catch (Exception e) {
        Debug.logError("[JdonFramework] getParamKeyValue error: " + e);
    }
    return keyValue;
}

public void handle(Annotation fieldAnnotation, Object object, Field field, Map<String, Field> allFieldMap) throws Exception {
    Object maxValueObj = ReflectUtil.getAnnoValue(fieldAnnotation, "value", (Object) null);
    double maxValue = ((Double) ConvertUtils.convert(maxValueObj, Double.class)).doubleValue();
    Object valueObj = field.get(object);
    double value = ((Double) ConvertUtils.convert(valueObj, Double.class)).doubleValue();
    value = (value > maxValue ? maxValue : value);
    field.set(object, ConvertUtils.convert(value, field.getType()));
}

/**
	 * @param parameters
	 * @param request
	 * @param values
	 * @return
	 */
private static Object[] getActionParameterValues(List<ParameterMetaData> parameters, Map<String, Object> body, Map<String, Object> values) {
    if (body != null) {
        values.putAll(body);
    }
    Object[] params = new Object[parameters.size()];
    for (int i = 0; i < parameters.size(); i++) {
        ParameterMetaData param = parameters.get(i);
        Object value = values.get(param.getName());
        if (value != null && !value.getClass().equals(param.getType())) {
            value = ConvertUtils.convert(value, param.getType());
        }
        params[i] = value;
    }
    return params;
}

/*
     * Register shared converters, then msInspect converters
     * TODO: Should merge cpl and msInspect converters
     */
protected void register() {
    super.register();
    ConvertUtils.register(new MyBooleanConverter(), Boolean.TYPE);
    ConvertUtils.register(new NullSafeConverter(new MyBooleanConverter()), Boolean.class);
    ConvertUtils.register(new NullSafeConverter(new ByteArrayConverter()), byte[].class);
    ConvertUtils.register(new PercentWrapper(new DoubleConverter()), Double.TYPE);
    ConvertUtils.register(new NullSafeConverter(new PercentWrapper(new DoubleConverter())), Double.class);
    ConvertUtils.register(new PercentWrapper(new FloatConverter()), Float.TYPE);
    ConvertUtils.register(new NullSafeConverter(new PercentWrapper(new FloatConverter())), Float.class);
    ConvertUtils.register(new ChargeWrapper(new IntegerConverter()), Integer.TYPE);
    ConvertUtils.register(new NullSafeConverter(new ChargeWrapper(new IntegerConverter())), Integer.class);
    ConvertUtils.register(new NullSafeConverter(new DateFriendlyStringConverter()), String.class);
    ConvertUtils.register(new LenientTimestampConverter(), java.sql.Timestamp.class);
    ConvertUtils.register(new LenientDateConverter(), java.util.Date.class);
}

/**
     * 尽�能地调用最匹�的Setter方法进行赋值
     *
     * @param data
     * @param name
     * @param value
     * @throws Exception
     */
protected void handle(T data, String name, Object value) throws Exception {
    //忽略空值
    if (value == null)
        return;
    List<Setter> setterList = setters.get(name.toLowerCase());
    if (setterList == null || setterList.isEmpty())
        return;
    //唯一setter方法
    if (setterList.size() == 1) {
        Setter setter = setterList.get(0);
        if (value != null && !setter.type.isInstance(value)) {
            value = ConvertUtils.convert(value, setter.type);
        }
        setter.invoke(data, value);
        return;
    }
    //�数兼容的方法列表
    List<Setter> compatibleList = new ArrayList<Setter>();
    //数字�数的方法列表
    List<Setter> numericList = new ArrayList<Setter>();
    for (Setter setter : setterList) {
        Class<?> type = setter.type;
        //�数类型一致
        if (value != null && type == value.getClass()) {
            setter.invoke(data, value);
        }
        //�数类型兼容
        if (type.isInstance(value)) {
            compatibleList.add(setter);
        } else if (Number.class.isAssignableFrom(type) && value instanceof Number) {
            //数值型�数
            numericList.add(setter);
        }
    }
    if (compatibleList.size() == 1) {
        compatibleList.get(0).invoke(data, value);
        return;
    }
    if (compatibleList.isEmpty() && numericList.size() == 1) {
        value = ConvertUtils.convert(value, numericList.get(0).type);
        numericList.get(0).invoke(data, value);
        return;
    }
    if (compatibleList.size() > 0 || numericList.size() > 0) {
        throw new Exception("ambiguous setter methods to call");
    }
}

public static void main(String args[]) {
    Options options = new Options();
    options.addOption("Z", false, "Zabbix mode");
    options.addOption("U", false, "UPDATE mode");
    options.addOption("S", false, "SELECT mode");
    options.addOption("C", false, "Create Mode");
    options.addOption("P", false, "Show Platform");
    options.addOption("L", false, "Show Users");
    options.addOption("E", false, "Ecrypt UserPassword");
    options.addOption("I", false, "IaasGateway Mode");
    options.addOption("A", false, "PCC-API Genarate ID or Key Mode");
    options.addOption("W", false, "Decrypt UserPassword");
    options.addOption("username", true, "Create the username");
    options.addOption("password", true, "Create the password");
    options.addOption("firstname", true, "Create the firstname");
    options.addOption("familyname", true, "Create the familyname");
    options.addOption("userno", true, "Create the userno");
    options.addOption("dburl", "connectionurl", true, "PrimeCloud Controller database url");
    options.addOption("dbuser", "username", true, "PrimeCloud Controller database username");
    options.addOption("dbpass", "password", true, "PrimeCloud Controller database password");
    options.addOption("sql", true, "SQL");
    options.addOption("columnname", true, "columnName");
    options.addOption("columntype", true, "columnType");
    options.addOption("salt", true, "Salt");
    OptionBuilder.withLongOpt("prepared");
    OptionBuilder.hasArgs();
    OptionBuilder.withDescription("execute as PreparedStatement");
    OptionBuilder.withArgName("params");
    Option optionPrepared = OptionBuilder.create();
    options.addOption(optionPrepared);
    // for Zabbix
    options.addOption("enable", false, "enable");
    options.addOption("disable", false, "disable");
    options.addOption("get", false, "getUser from zabbix");
    options.addOption("check", false, "API setting check for zabbix");
    options.addOption("config", true, "Property can obtain from management-config.properties");
    options.addOption("platformkind", true, "Platform kind. e.g. ec2 and ec2_vpc or vmware");
    options.addOption("platformname", true, "Platform can obtain from auto-config.xml");
    options.addOption("platformno", true, "Platform can obtain from auto-config.xml");
    // for IaasGateway(AWS, Cloudstack)
    options.addOption("keyname", true, "import your key pair as keyName");
    options.addOption("publickey", true, "import your public key");
    // for PCC
    options.addOption("accessid", true, "accessid for PCC-API");
    options.addOption("secretkey", true, "secretkey for PCC-API");
    options.addOption("generatetype", true, "genarateType for PCC-API");
    options.addOption("h", "help", false, "help");
    CommandLineParser parser = new BasicParser();
    CommandLine commandLine;
    try {
        commandLine = parser.parse(options, args);
    } catch (ParseException e) {
        System.out.println("引数ã?®æŒ‡å®šã?Œé–“é?•ã?£ã?¦ã?„ã?¾ã?™ -hコマンドã?§ç¢ºèª?ã?—ã?¦ã??ã? ã?•ã?„。");
        return;
    }
    if (commandLine.hasOption("h")) {
        HelpFormatter f = new HelpFormatter();
        f.printHelp("PCC script ", options);
    }
    ConvertUtils.register(new DateConverter(null), Date.class);
    ManagementConfigLoader.init();
    //Zabbixユーザ作�モード
    if (commandLine.hasOption("Z")) {
        if (commandLine.hasOption("C")) {
            //Zabbixユーザ作�
            ZabbixMain.createExecute(commandLine);
        } else if (commandLine.hasOption("U")) {
            //Zabbixユーザ更新
            ZabbixMain.updateExecute(commandLine);
        } else if (commandLine.hasOption("disable")) {
            //Zabbixユーザ無効化
            ZabbixMain.disableExecute(commandLine);
        } else if (commandLine.hasOption("enable")) {
            //Zabbixユーザ有効化
            ZabbixMain.enableExecute(commandLine);
        } else if (commandLine.hasOption("get")) {
            //Zabbixユーザ�得
            ZabbixMain.getUser(commandLine);
        } else if (commandLine.hasOption("check")) {
            //Zabbix�ージョン�得
            ZabbixMain.checkApiVersion();
        }
    //PCCユーザ作�
    } else if (commandLine.hasOption("U")) {
        if (commandLine.hasOption("prepared")) {
            SQLMain.updateExecutePrepared(commandLine);
        } else {
            //Update文�実行
            SQLMain.updateExecute(commandLine);
        }
    } else if (commandLine.hasOption("S")) {
        //Select文�実行
        SQLMain.selectExecute(commandLine);
    } else if (commandLine.hasOption("P")) {
        //プラットフォーム�表示
        ConfigMain.showPlatforms();
    } else if (commandLine.hasOption("L")) {
        //PCCユーザ使用�能プラットフォーム表示
        UserService.showUserPlatform();
    } else if (commandLine.hasOption("config")) {
        //設定ファイル�ら値��得
        ConfigMain.getProperty(commandLine.getOptionValue("config"));
    } else if (commandLine.hasOption("platformname") && commandLine.hasOption("platformkind")) {
        //プラットフォームå??ã?‹ã‚‰ãƒ—ラットフォーム番å?·ã?®å?–å¾—
        ConfigMain.getPlatformNo(commandLine.getOptionValue("platformname"), commandLine.getOptionValue("platformkind"));
    } else if (commandLine.hasOption("E")) {
        //PCCユーザ暗�化パスワード�得
        UserService.encryptUserPassword(commandLine.getOptionValue("password"));
    } else if (commandLine.hasOption("I")) {
        //IaasGatewayをCall��AWS or Cloudstack��キーペアイン�ート
        IaasGatewayMain.importExecute(commandLine);
    } else if (commandLine.hasOption("A")) {
        PccApiGenerateService.genarate(commandLine);
    } else if (commandLine.hasOption("W")) {
        //PCCユーザ復�化パスワード�得
        UserService.decryptUserPassword(commandLine.getOptionValue("password"), commandLine.getOptionValue("salt"));
    }
}

private Object[] process(Serializable buffer, Serializable axis, final int[] dimensions, final int symmetryFolds) {
    double[] parentaxis = (double[]) ConvertUtils.convert(axis, double[].class);
    float[] parentdata = (float[]) ConvertUtils.convert(buffer, float[].class);
    int size = dimensions[dimensions.length - 1];
    double[] myaxis = new double[size];
    double[] mydata = new double[size];
    double[] cos2data = new double[size];
    double[] sin2data = new double[size];
    double[] sincosdata = new double[size];
    for (int i = 0; i < parentaxis.length; i++) {
        myaxis[i] = Math.toRadians(parentaxis[i]) * symmetryFolds;
        mydata[i] = parentdata[i];
        float cos2alpha = (float) Math.cos(2.0 * myaxis[i]);
        float sin2alpha = (float) Math.sin(2.0 * myaxis[i]);
        cos2data[i] = (1.0f + cos2alpha) * parentdata[i] / 2.0;
        sin2data[i] = (1.0f - cos2alpha) * parentdata[i] / 2.0;
        sincosdata[i] = sin2alpha * parentdata[i] / 2.0;
    }
    UnivariateInterpolator interpolator = new SplineInterpolator();
    UnivariateFunction function = interpolator.interpolate(myaxis, mydata);
    UnivariateFunction cos2Function = interpolator.interpolate(myaxis, cos2data);
    UnivariateFunction sin2Function = interpolator.interpolate(myaxis, sin2data);
    UnivariateFunction sincosFunction = interpolator.interpolate(myaxis, sincosdata);
    UnivariateIntegrator integrator = new IterativeLegendreGaussIntegrator(15, BaseAbstractUnivariateIntegrator.DEFAULT_RELATIVE_ACCURACY, BaseAbstractUnivariateIntegrator.DEFAULT_ABSOLUTE_ACCURACY);
    try {
        float cos2mean = (float) integrator.integrate(INTEGRATION_POINTS, cos2Function, myaxis[0], myaxis[myaxis.length - 1]);
        float sin2mean = (float) integrator.integrate(INTEGRATION_POINTS, sin2Function, myaxis[0], myaxis[myaxis.length - 1]);
        float sincosmean = (float) integrator.integrate(INTEGRATION_POINTS, sincosFunction, myaxis[0], myaxis[myaxis.length - 1]);
        float norm = (float) integrator.integrate(INTEGRATION_POINTS, function, myaxis[0], myaxis[myaxis.length - 1]);
        cos2mean /= norm;
        sin2mean /= norm;
        sincosmean /= norm;
        float result = (float) Math.sqrt(Math.pow(cos2mean - sin2mean, 2) - 4.0 * sincosmean * sincosmean);
        double angle = MathUtils.normalizeAngle(Math.atan2(2.0 * sincosmean, cos2mean - sin2mean) / 2.0, Math.PI);
        // Make sure that the angle makes sense according to the number of folds of symmetry
        switch(symmetryFolds) {
            case 1:
                if (angle >= Math.PI) {
                    angle -= Math.PI;
                }
                break;
            case 2:
                if (angle >= (1.5 * Math.PI)) {
                    angle -= (1.5 * Math.PI);
                } else if (angle >= Math.PI) {
                    angle -= Math.PI;
                } else if (angle >= (Math.PI / 2)) {
                    angle -= (Math.PI / 2);
                }
                break;
        }
        Object[] output = new Object[] { new float[] { result }, new float[] { (float) Math.toDegrees(angle) }, new float[] { (float) (result * Math.cos(angle)), (float) (result * Math.sin(angle)) } };
        return output;
    } catch (TooManyEvaluationsException e) {
        logger.warn("Too many evaluations:" + e);
        return new Object[] { new float[] { Float.NaN }, new float[] { Float.NaN }, new float[] { Float.NaN } };
    } catch (MaxCountExceededException e) {
        logger.warn("Max count exceeded:" + e);
        return new Object[] { new float[] { Float.NaN }, new float[] { Float.NaN }, new float[] { Float.NaN } };
    }
}

public void buildExcelDocument(Map<String, Object> model, HSSFWorkbook workbook, HttpServletRequest request, HttpServletResponse response) throws UnsupportedEncodingException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
    Assert.notEmpty(this.properties);
    HSSFSheet localHSSFSheet;
    if (StringUtils.isNotEmpty(this.sheetName))
        localHSSFSheet = workbook.createSheet(this.sheetName);
    else
        localHSSFSheet = workbook.createSheet();
    int i = 0;
    Object localObject1;
    Object localObject2;
    Object localObject3;
    Object localObject4;
    Object localObject5;
    if ((this.titles != null) && (this.titles.length > 0)) {
        localObject1 = localHSSFSheet.createRow(i);
        ((HSSFRow) localObject1).setHeight((short) 400);
        for (int j = 0; j < this.properties.length; j++) {
            localObject2 = ((HSSFRow) localObject1).createCell(j);
            HSSFCellStyle localHSSFCellStyle = workbook.createCellStyle();
            localHSSFCellStyle.setFillForegroundColor((short) 31);
            localHSSFCellStyle.setFillPattern((short) 1);
            localHSSFCellStyle.setAlignment((short) 2);
            localHSSFCellStyle.setVerticalAlignment((short) 1);
            localObject3 = workbook.createFont();
            ((HSSFFont) localObject3).setFontHeightInPoints((short) 11);
            ((HSSFFont) localObject3).setBoldweight((short) 700);
            localHSSFCellStyle.setFont((HSSFFont) localObject3);
            ((HSSFCell) localObject2).setCellStyle(localHSSFCellStyle);
            if (j == 0) {
                localObject4 = localHSSFSheet.createDrawingPatriarch();
                localObject5 = ((HSSFPatriarch) localObject4).createComment(new HSSFClientAnchor((short) 0, (short) 0, (short) 0, (short) 0, (short) 1, (short) 1, (short) 4, (short) 4));
                ((HSSFComment) localObject5).setString(new HSSFRichTextString("Powered By SHOP-HQ"));
                ((HSSFCell) localObject2).setCellComment((Comment) localObject5);
            }
            if ((this.titles.length > j) && (this.titles[j] != null))
                ((HSSFCell) localObject2).setCellValue(this.titles[j]);
            else
                ((HSSFCell) localObject2).setCellValue(this.properties[j]);
            if ((this.widths != null) && (this.widths.length > j) && (this.widths[j] != null))
                localHSSFSheet.setColumnWidth(j, this.widths[j].intValue());
            else
                localHSSFSheet.autoSizeColumn(j);
        }
        i++;
    }
    if (this.data != null) {
        Iterator<?> localIterator = this.data.iterator();
        while (localIterator.hasNext()) {
            localObject1 = localIterator.next();
            localObject2 = localHSSFSheet.createRow(i);
            for (int n = 0; n < this.properties.length; n++) {
                localObject3 = ((HSSFRow) localObject2).createCell(n);
                if ((this.converters != null) && (this.converters.length > n) && (this.converters[n] != null)) {
                    localObject4 = PropertyUtils.getPropertyType(localObject1, this.properties[n]);
                    ConvertUtils.register(this.converters[n], (Class<?>) localObject4);
                    ((HSSFCell) localObject3).setCellValue(BeanUtils.getProperty(localObject1, this.properties[n]));
                    ConvertUtils.deregister((Class<?>) localObject4);
                    if (localObject4.equals(Date.class)) {
                        localObject5 = new DateConverter();
                        ((DateConverter) localObject5).setPattern(DATE_PATTERN);
                        ConvertUtils.register((Converter) localObject5, Date.class);
                    }
                } else {
                    ((HSSFCell) localObject3).setCellValue(BeanUtils.getProperty(localObject1, this.properties[n]));
                }
                if ((i != 0) && (i != 1))
                    continue;
                if ((this.widths != null) && (this.widths.length > n) && (this.widths[n] != null))
                    localHSSFSheet.setColumnWidth(n, this.widths[n].intValue());
                else
                    localHSSFSheet.autoSizeColumn(n);
            }
            i++;
        }
    }
    if ((this.contents != null) && (this.contents.length > 0)) {
        i++;
        for (String localString : this.contents) {
            localObject3 = localHSSFSheet.createRow(i);
            localObject4 = ((HSSFRow) localObject3).createCell(0);
            localObject5 = workbook.createCellStyle();
            HSSFFont localHSSFFont = workbook.createFont();
            localHSSFFont.setColor((short) 23);
            ((HSSFCellStyle) localObject5).setFont(localHSSFFont);
            ((HSSFCell) localObject4).setCellStyle((HSSFCellStyle) localObject5);
            ((HSSFCell) localObject4).setCellValue(localString);
            i++;
        }
    }
    response.setContentType("application/force-download");
    if (StringUtils.isNotEmpty(this.filename))
        try {
            response.setHeader("Content-disposition", "attachment; filename=" + URLEncoder.encode(this.filename, "UTF-8"));
        } catch (Exception e) {
            e.printStackTrace();
        }
    else
        response.setHeader("Content-disposition", "attachment");
}

/**
     * Converts from string to many type.
     *
     * @param value the string to be converted
     * @param toClass the type to convert to
     * @param format the format of the string to be converted. This is required to convert to temporal types
     * @return the converted object
     */
@SuppressWarnings("unchecked")
public Object fromString(final String value, @SuppressWarnings("rawtypes") final Class toClass, final String format) {
    // FIXME Must refactor to relieve this horrible cyclomatic complexity
    checkArgument(!StringUtils.isEmpty(value), TypeConversionErrorMessages.ERROR_CONVERT_FROM_NULL_OR_EMPTY_STRING);
    // NOPMD
    Object converted = null;
    // URL
    if (toClass == URL.class) {
        try {
            // NOPMD
            converted = new URL(value);
        } catch (// NOPMD
        MalformedURLException // NOPMD
        malformedURLException) {
            throw new ConversionException(String.class, toClass);
        }
    // Locale
    } else if (toClass == Locale.class) {
        if (Arrays.asList(Locale.getISOLanguages()).contains(value)) {
            converted = new Locale(value);
        } else {
            throw new ConversionException(String.class, toClass);
        }
    // Temporal
    } else if (toClass == Date.class) {
        checkArgument(!StringUtils.isEmpty(format), TypeConversionErrorMessages.ERROR_MISSING_FORMAT);
        final DateConverter dateConverter = new DateConverter();
        dateConverter.setPattern(format);
        converted = dateConverter.convert(Date.class, value);
    } else if (toClass == TimeZone.class) {
        if (Arrays.asList(TimeZone.getAvailableIDs()).contains(value)) {
            converted = TimeZone.getTimeZone(value);
        } else {
            throw new ConversionException(String.class, toClass);
        }
    } else if (toClass == Period.class) {
        checkArgument(!StringUtils.isEmpty(format), TypeConversionErrorMessages.ERROR_MISSING_FORMAT);
        converted = new JodaConverter(value, format).toPeriod();
    // Enum
    } else if (toClass.isEnum()) {
        if (StringUtils.isNumeric(value)) {
            final EnumSet<?> enumValues = EnumSet.allOf(toClass);
            for (Enum<?> e : enumValues) {
                if (Integer.parseInt(value) == e.ordinal()) {
                    // NOPMD
                    converted = e;
                    break;
                }
            }
            if (converted == null) {
                throw new ConversionException(String.class, toClass);
            }
        } else {
            if (EnumUtils.isValidEnum(toClass, value)) {
                converted = EnumUtils.getEnum(toClass, value);
            } else {
                throw new ConversionException(String.class, toClass);
            }
        }
    // Other
    } else {
        try {
            // NOPMD
            converted = ConvertUtils.convert(value, toClass);
        } catch (// NOPMD
        org.apache.commons.beanutils.ConversionException // NOPMD
        conversionException) {
            throw new ConversionException(String.class, toClass);
        }
    }
    return converted;
}

public static RowMapperFactory getScalarMapper(final Type itemType, final int idx, boolean req) {
    if (itemType == String.class) {
        return new ScalarRMF() {

            public Object map(ResultSet rs) throws SQLException {
                return rs.getString(idx);
            }
        };
    }
    if (itemType == Integer.class || itemType == Integer.TYPE) {
        return new ScalarRMF() {

            public Object map(ResultSet rs) throws SQLException {
                return rs.getInt(idx);
            }
        };
    }
    if (itemType == URL.class) {
        return new ScalarRMF() {

            public Object map(ResultSet rs) throws SQLException {
                return rs.getURL(idx);
            }
        };
    }
    if (itemType == BigInteger.class) {
        return new ScalarRMF() {

            public Object map(ResultSet rs) throws SQLException {
                final BigDecimal res = rs.getBigDecimal(idx);
                return res == null ? null : res.toBigInteger();
            }
        };
    }
    if (itemType == BigDecimal.class) {
        return new ScalarRMF() {

            public Object map(ResultSet rs) throws SQLException {
                return rs.getBigDecimal(idx);
            }
        };
    }
    if (itemType == InputStream.class) {
        return new ScalarRMF() {

            public Object map(ResultSet rs) throws SQLException {
                return rs.getBinaryStream(idx);
            }
        };
    }
    if (itemType == Boolean.class || itemType == Boolean.TYPE) {
        return new ScalarRMF() {

            public Object map(ResultSet rs) throws SQLException {
                return rs.getBoolean(idx);
            }
        };
    }
    if (itemType == Blob.class) {
        return new ScalarRMF() {

            public Object map(ResultSet rs) throws SQLException {
                return rs.getBlob(idx);
            }
        };
    }
    if (itemType == java.sql.Date.class || itemType == java.util.Date.class) {
        return new ScalarRMF() {

            public Object map(ResultSet rs) throws SQLException {
                return rs.getTimestamp(idx);
            }
        };
    }
    if (itemType instanceof Class) {
        final Class itemClass = (Class) itemType;
        final ColumnMapper columnMapper = ColumnMapperRegistry.lookup(itemClass);
        if (columnMapper != null) {
            return new ScalarRMF() {

                public Object map(ResultSet rs) throws SQLException {
                    return columnMapper.map(rs, idx);
                }
            };
        }
        final Converter converter = ConvertUtils.lookup(itemClass);
        if (converter != null) {
            return new ScalarRMF() {

                public Object map(ResultSet rs) throws SQLException {
                    String s = rs.getString(idx);
                    if (s == null) {
                        return null;
                    }
                    return converter.convert(itemClass, s);
                }
            };
        }
        if (Enum.class.isAssignableFrom((Class<?>) itemType)) {
            return new ScalarRMF() {

                public Object map(ResultSet rs) throws SQLException {
                    String s = rs.getString(idx);
                    if (s == null) {
                        return null;
                    }
                    //noinspection unchecked
                    return Enum.valueOf((Class<Enum>) itemType, s);
                }
            };
        }
    }
    if (req) {
        throw new IllegalArgumentException("no mapping defined for " + itemType);
    }
    return null;
}

/**
     * Asks if the bean's properties are empty. boolean properties that are false and numbers
     * that are zero are considered empty. String values that are zero-length are considered empty.
     * All other property types must be null to be considered empty.
     *
     * @param bean bean to check
     * @return true if bean has no values
     */
public static boolean isBeanEmpty(Object bean) {
    if (bean == null) {
        return true;
    }
    WrapDynaBean wrapDynaBean = new WrapDynaBean(bean);
    DynaProperty[] properties = wrapDynaBean.getDynaClass().getDynaProperties();
    for (DynaProperty property : properties) {
        String propertyName = property.getName();
        Class propertyType = property.getType();
        Object value = wrapDynaBean.get(propertyName);
        if (propertyType.isPrimitive()) {
            if (value instanceof Number && !value.toString().equals("0")) {
                return false;
            } else if (value instanceof Boolean && !value.toString().equals("false")) {
                return false;
            } else if (!value.toString().isEmpty()) {
                return false;
            }
        } else if (value != null) {
            if (!(value instanceof Collection)) {
                String convertedStringValue = ConvertUtils.convert(value);
                if (!StringUtil.isEmpty(convertedStringValue)) {
                    return false;
                }
            }
        }
    }
    return true;
}

/**
     * <p>Initialize other global characteristics of the controller
     * servlet.</p>
     *
     * @throws ServletException if we cannot initialize these resources
     */
protected void initOther() throws ServletException {
    String value;
    value = getServletConfig().getInitParameter("config");
    if (value != null) {
        //QB-RM add *.xml
        if (value.trim().length() > 0 && value.indexOf("*.xml") > -1) {
            //
            String finalValue = "";
            String[] aValue = value.trim().split(",");
            for (int j = 0; j < aValue.length; j++) {
                String path = aValue[j];
                if (path.trim().length() == 0) {
                    continue;
                }
                //判断当�这行是�*.xml
                if (path.trim().endsWith("*.xml")) {
                    File fWarDirStr = RmPathHelper.getWarDir();
                    File fPath = new File(fWarDirStr + File.separator + (path.substring(0, path.length() - "*.xml".length())));
                    for (int i = 0; i < fPath.listFiles().length; i++) {
                        File fPathXml = fPath.listFiles()[i];
                        if (fPathXml.isFile() && fPathXml.toString().toLowerCase().endsWith(".xml")) {
                            String newPath = fPathXml.getAbsolutePath().substring((int) fWarDirStr.getAbsoluteFile().toString().length()).replaceAll("\\\\", "/");
                            finalValue += newPath + ",";
                        }
                    }
                } else {
                    finalValue += path + ",";
                }
            }
            if (finalValue.endsWith(",")) {
                finalValue = finalValue.substring(0, finalValue.length() - ",".length());
            }
            config = finalValue;
        } else {
            config = value;
        }
    }
    // Backwards compatibility for form beans of Java wrapper classes
    // Set to true for strict Struts 1.0 compatibility
    value = getServletConfig().getInitParameter("convertNull");
    if ("true".equalsIgnoreCase(value) || "yes".equalsIgnoreCase(value) || "on".equalsIgnoreCase(value) || "y".equalsIgnoreCase(value) || "1".equalsIgnoreCase(value)) {
        convertNull = true;
    }
    if (convertNull) {
        ConvertUtils.deregister();
        ConvertUtils.register(new BigDecimalConverter(null), BigDecimal.class);
        ConvertUtils.register(new BigIntegerConverter(null), BigInteger.class);
        ConvertUtils.register(new BooleanConverter(null), Boolean.class);
        ConvertUtils.register(new ByteConverter(null), Byte.class);
        ConvertUtils.register(new CharacterConverter(null), Character.class);
        ConvertUtils.register(new DoubleConverter(null), Double.class);
        ConvertUtils.register(new FloatConverter(null), Float.class);
        ConvertUtils.register(new IntegerConverter(null), Integer.class);
        ConvertUtils.register(new LongConverter(null), Long.class);
        ConvertUtils.register(new ShortConverter(null), Short.class);
    }
}

/**
     * <p>Initialize other global characteristics of the controller
     * servlet.</p>
     *
     * @throws ServletException if we cannot initialize these resources
     */
protected void initOther() throws ServletException {
    String value;
    value = getServletConfig().getInitParameter("config");
    if (value != null) {
        //QB-RM add *.xml
        if (value.trim().length() > 0 && value.indexOf("*.xml") > -1) {
            //
            String finalValue = "";
            String[] aValue = value.trim().split(",");
            for (int j = 0; j < aValue.length; j++) {
                String path = aValue[j];
                if (path.trim().length() == 0) {
                    continue;
                }
                //判断当�这行是�*.xml
                if (path.trim().endsWith("*.xml")) {
                    File fWarDirStr = RmPathHelper.getWarDir();
                    File fPath = new File(fWarDirStr + File.separator + (path.substring(0, path.length() - "*.xml".length())));
                    for (int i = 0; i < fPath.listFiles().length; i++) {
                        File fPathXml = fPath.listFiles()[i];
                        if (fPathXml.isFile() && fPathXml.toString().toLowerCase().endsWith(".xml")) {
                            String newPath = fPathXml.getAbsolutePath().substring((int) fWarDirStr.getAbsoluteFile().toString().length()).replaceAll("\\\\", "/");
                            finalValue += newPath + ",";
                        }
                    }
                } else {
                    finalValue += path + ",";
                }
            }
            if (finalValue.endsWith(",")) {
                finalValue = finalValue.substring(0, finalValue.length() - ",".length());
            }
            config = finalValue;
        } else {
            config = value;
        }
    }
    // Backwards compatibility for form beans of Java wrapper classes
    // Set to true for strict Struts 1.0 compatibility
    value = getServletConfig().getInitParameter("convertNull");
    if ("true".equalsIgnoreCase(value) || "yes".equalsIgnoreCase(value) || "on".equalsIgnoreCase(value) || "y".equalsIgnoreCase(value) || "1".equalsIgnoreCase(value)) {
        convertNull = true;
    }
    if (convertNull) {
        ConvertUtils.deregister();
        ConvertUtils.register(new BigDecimalConverter(null), BigDecimal.class);
        ConvertUtils.register(new BigIntegerConverter(null), BigInteger.class);
        ConvertUtils.register(new BooleanConverter(null), Boolean.class);
        ConvertUtils.register(new ByteConverter(null), Byte.class);
        ConvertUtils.register(new CharacterConverter(null), Character.class);
        ConvertUtils.register(new DoubleConverter(null), Double.class);
        ConvertUtils.register(new FloatConverter(null), Float.class);
        ConvertUtils.register(new IntegerConverter(null), Integer.class);
        ConvertUtils.register(new LongConverter(null), Long.class);
        ConvertUtils.register(new ShortConverter(null), Short.class);
    }
}

protected Object convertNodeDataStringToObject(String valueStr) {
    if (contains(valueStr, ':')) {
        final String type = StringUtils.substringBefore(valueStr, ":");
        final String value = StringUtils.substringAfter(valueStr, ":");
        // there is no beanUtils converter for Calendar
        if (type.equalsIgnoreCase("date")) {
            return ISO8601.parse(value);
        } else if (type.equalsIgnoreCase("binary")) {
            return new ByteArrayInputStream(value.getBytes());
        } else {
            try {
                final Class<?> typeCl;
                if (type.equals("int")) {
                    typeCl = Integer.class;
                } else {
                    typeCl = Class.forName("java.lang." + StringUtils.capitalize(type));
                }
                return ConvertUtils.convert(value, typeCl);
            } catch (ClassNotFoundException e) {
                return valueStr;
            }
        }
    }
    // no type specified, we assume it's a string, no conversion
    return valueStr;
}

/**
   * 
   */
@Override
public XlsContentProvider setValue(final ExportCell cell, final Object value, final String property) {
    final Cell poiCell = cell.getPoiCell();
    final Object customizedValue = getCustomizedValue(value);
    if (customizedValue != null) {
        if (customizedValue instanceof Calendar) {
            poiCell.setCellValue((Calendar) customizedValue);
        } else if (customizedValue instanceof Date) {
            poiCell.setCellValue((Date) customizedValue);
        } else if (customizedValue instanceof String) {
            poiCell.setCellValue((String) customizedValue);
        } else {
            poiCell.setCellValue(String.valueOf(customizedValue));
        }
    } else if (value instanceof Date) {
        // Attention: Time zone is not given!
        poiCell.setCellValue((Date) value);
    } else if (value instanceof Calendar) {
        poiCell.setCellValue((Calendar) value);
    } else if (value instanceof Boolean) {
        poiCell.setCellValue(((Boolean) value).booleanValue());
    } else if (value instanceof Number) {
        poiCell.setCellValue(((Number) value).doubleValue());
    } else if (value instanceof Formula) {
        poiCell.setCellFormula(((Formula) value).getExpr());
    } else {
        poiCell.setCellValue(ConvertUtils.convert(value));
    }
    CellFormat cellFormat = getCellFormat(cell, value, property, formatMap);
    if (cellFormat == null) {
        cellFormat = getCellFormat(cell, value, property, defaultFormatMap);
    }
    if (cellFormat == null) {
        cellFormat = new CellFormat();
        cellFormat.setAlignment(CellStyle.ALIGN_LEFT);
        cellFormat.setDataFormat("@");
        cellFormat.setWrapText(true);
    }
    cell.setCellFormat(cellFormat);
    return this;
}

/**
     * <p>Initialize other global characteristics of the controller
     * servlet.</p>
     *
     * @throws ServletException if we cannot initialize these resources
     */
protected void initOther() throws ServletException {
    String value;
    value = getServletConfig().getInitParameter("config");
    if (value != null) {
        //QB-RM add *.xml
        if (value.trim().length() > 0 && value.indexOf("*.xml") > -1) {
            //
            String finalValue = "";
            String[] aValue = value.trim().split(",");
            for (int j = 0; j < aValue.length; j++) {
                String path = aValue[j];
                if (path.trim().length() == 0) {
                    continue;
                }
                //判断当�这行是�*.xml
                if (path.trim().endsWith("*.xml")) {
                    File fWarDirStr = RmPathHelper.getWarDir();
                    File fPath = new File(fWarDirStr + File.separator + (path.substring(0, path.length() - "*.xml".length())));
                    for (int i = 0; i < fPath.listFiles().length; i++) {
                        File fPathXml = fPath.listFiles()[i];
                        if (fPathXml.isFile() && fPathXml.toString().toLowerCase().endsWith(".xml")) {
                            String newPath = fPathXml.getAbsolutePath().substring((int) fWarDirStr.getAbsoluteFile().toString().length()).replaceAll("\\\\", "/");
                            finalValue += newPath + ",";
                        }
                    }
                } else {
                    finalValue += path + ",";
                }
            }
            if (finalValue.endsWith(",")) {
                finalValue = finalValue.substring(0, finalValue.length() - ",".length());
            }
            config = finalValue;
        } else {
            config = value;
        }
    }
    // Backwards compatibility for form beans of Java wrapper classes
    // Set to true for strict Struts 1.0 compatibility
    value = getServletConfig().getInitParameter("convertNull");
    if ("true".equalsIgnoreCase(value) || "yes".equalsIgnoreCase(value) || "on".equalsIgnoreCase(value) || "y".equalsIgnoreCase(value) || "1".equalsIgnoreCase(value)) {
        convertNull = true;
    }
    if (convertNull) {
        ConvertUtils.deregister();
        ConvertUtils.register(new BigDecimalConverter(null), BigDecimal.class);
        ConvertUtils.register(new BigIntegerConverter(null), BigInteger.class);
        ConvertUtils.register(new BooleanConverter(null), Boolean.class);
        ConvertUtils.register(new ByteConverter(null), Byte.class);
        ConvertUtils.register(new CharacterConverter(null), Character.class);
        ConvertUtils.register(new DoubleConverter(null), Double.class);
        ConvertUtils.register(new FloatConverter(null), Float.class);
        ConvertUtils.register(new IntegerConverter(null), Integer.class);
        ConvertUtils.register(new LongConverter(null), Long.class);
        ConvertUtils.register(new ShortConverter(null), Short.class);
    }
}

/**
     * <p>Initialize other global characteristics of the controller
     * servlet.</p>
     *
     * @throws ServletException if we cannot initialize these resources
     */
protected void initOther() throws ServletException {
    String value;
    value = getServletConfig().getInitParameter("config");
    if (value != null) {
        config = value;
    }
    // Backwards compatibility for form beans of Java wrapper classes
    // Set to true for strict Struts 1.0 compatibility
    value = getServletConfig().getInitParameter("convertNull");
    if ("true".equalsIgnoreCase(value) || "yes".equalsIgnoreCase(value) || "on".equalsIgnoreCase(value) || "y".equalsIgnoreCase(value) || "1".equalsIgnoreCase(value)) {
        convertNull = true;
    }
    if (convertNull) {
        ConvertUtils.deregister();
        ConvertUtils.register(new BigDecimalConverter(null), BigDecimal.class);
        ConvertUtils.register(new BigIntegerConverter(null), BigInteger.class);
        ConvertUtils.register(new BooleanConverter(null), Boolean.class);
        ConvertUtils.register(new ByteConverter(null), Byte.class);
        ConvertUtils.register(new CharacterConverter(null), Character.class);
        ConvertUtils.register(new DoubleConverter(null), Double.class);
        ConvertUtils.register(new FloatConverter(null), Float.class);
        ConvertUtils.register(new IntegerConverter(null), Integer.class);
        ConvertUtils.register(new LongConverter(null), Long.class);
        ConvertUtils.register(new ShortConverter(null), Short.class);
    }
}

/**
     * <p>Initialize other global characteristics of the controller
     * servlet.</p>
     *
     * @throws ServletException if we cannot initialize these resources
     */
protected void initOther() throws ServletException {
    String value;
    value = getServletConfig().getInitParameter("config");
    if (value != null) {
        config = value;
    }
    // Backwards compatibility for form beans of Java wrapper classes
    // Set to true for strict Struts 1.0 compatibility
    value = getServletConfig().getInitParameter("convertNull");
    if ("true".equalsIgnoreCase(value) || "yes".equalsIgnoreCase(value) || "on".equalsIgnoreCase(value) || "y".equalsIgnoreCase(value) || "1".equalsIgnoreCase(value)) {
        convertNull = true;
    }
    if (convertNull) {
        ConvertUtils.deregister();
        ConvertUtils.register(new BigDecimalConverter(null), BigDecimal.class);
        ConvertUtils.register(new BigIntegerConverter(null), BigInteger.class);
        ConvertUtils.register(new BooleanConverter(null), Boolean.class);
        ConvertUtils.register(new ByteConverter(null), Byte.class);
        ConvertUtils.register(new CharacterConverter(null), Character.class);
        ConvertUtils.register(new DoubleConverter(null), Double.class);
        ConvertUtils.register(new FloatConverter(null), Float.class);
        ConvertUtils.register(new IntegerConverter(null), Integer.class);
        ConvertUtils.register(new LongConverter(null), Long.class);
        ConvertUtils.register(new ShortConverter(null), Short.class);
    }
}

/**
     * <p>Initialize other global characteristics of the controller
     * servlet.</p>
     *
     * @throws ServletException if we cannot initialize these resources
     */
protected void initOther() throws ServletException {
    String value;
    value = getServletConfig().getInitParameter("config");
    if (value != null) {
        config = value;
    }
    // Backwards compatibility for form beans of Java wrapper classes
    // Set to true for strict Struts 1.0 compatibility
    value = getServletConfig().getInitParameter("convertNull");
    if ("true".equalsIgnoreCase(value) || "yes".equalsIgnoreCase(value) || "on".equalsIgnoreCase(value) || "y".equalsIgnoreCase(value) || "1".equalsIgnoreCase(value)) {
        convertNull = true;
    }
    if (convertNull) {
        ConvertUtils.deregister();
        ConvertUtils.register(new BigDecimalConverter(null), BigDecimal.class);
        ConvertUtils.register(new BigIntegerConverter(null), BigInteger.class);
        ConvertUtils.register(new BooleanConverter(null), Boolean.class);
        ConvertUtils.register(new ByteConverter(null), Byte.class);
        ConvertUtils.register(new CharacterConverter(null), Character.class);
        ConvertUtils.register(new DoubleConverter(null), Double.class);
        ConvertUtils.register(new FloatConverter(null), Float.class);
        ConvertUtils.register(new IntegerConverter(null), Integer.class);
        ConvertUtils.register(new LongConverter(null), Long.class);
        ConvertUtils.register(new ShortConverter(null), Short.class);
    }
}

/**
     * Returns true if it can convert the supplied
     * object to the specified class.
     * @param object to check
     * @param toType prospective destination class
     * @return boolean
     */
public boolean canConvert(Object object, final Class toType) {
    if (object == null) {
        return true;
    }
    final Class useType = TypeUtils.wrapPrimitive(toType);
    Class fromType = object.getClass();
    if (useType.isAssignableFrom(fromType)) {
        return true;
    }
    if (useType == String.class) {
        return true;
    }
    if (object instanceof Boolean && (Number.class.isAssignableFrom(useType) || "java.util.concurrent.atomic.AtomicBoolean".equals(useType.getName()))) {
        return true;
    }
    if (object instanceof Number && (Number.class.isAssignableFrom(useType) || useType == Boolean.class)) {
        return true;
    }
    if (object instanceof String && (useType == Boolean.class || useType == Character.class || useType == Byte.class || useType == Short.class || useType == Integer.class || useType == Long.class || useType == Float.class || useType == Double.class)) {
        return true;
    }
    if (fromType.isArray()) {
        // Collection -> array
        if (useType.isArray()) {
            Class cType = useType.getComponentType();
            int length = Array.getLength(object);
            for (int i = 0; i < length; i++) {
                Object value = Array.get(object, i);
                if (!canConvert(value, cType)) {
                    return false;
                }
            }
            return true;
        }
        if (Collection.class.isAssignableFrom(useType)) {
            return canCreateCollection(useType);
        }
        if (Array.getLength(object) > 0) {
            Object value = Array.get(object, 0);
            return canConvert(value, useType);
        }
        return canConvert("", useType);
    }
    if (object instanceof Collection) {
        // Collection -> array
        if (useType.isArray()) {
            Class cType = useType.getComponentType();
            Iterator it = ((Collection) object).iterator();
            while (it.hasNext()) {
                Object value = it.next();
                if (!canConvert(value, cType)) {
                    return false;
                }
            }
            return true;
        }
        if (Collection.class.isAssignableFrom(useType)) {
            return canCreateCollection(useType);
        }
        if (((Collection) object).size() > 0) {
            Object value;
            if (object instanceof List) {
                value = ((List) object).get(0);
            } else {
                Iterator it = ((Collection) object).iterator();
                value = it.next();
            }
            return canConvert(value, useType);
        }
        return canConvert("", useType);
    }
    if (object instanceof NodeSet) {
        return canConvert(((NodeSet) object).getValues(), useType);
    }
    if (object instanceof Pointer) {
        return canConvert(((Pointer) object).getValue(), useType);
    }
    return ConvertUtils.lookup(useType) != null;
}

protected Object getValue(Object component, AnnotatedElement target, Class type) throws MultiException {
    // look for the name in the list of parameters passed.
    Param param = target.getAnnotation(Param.class);
    if (param.primary()) {
        // this is the primary parameter for the command
        String value = parameters.getProperty("DEFAULT");
        if (value != null) {
            return value;
        }
    }
    return ConvertUtils.convert((String) parameters.get(getParamName(param, target)), type);
}

/**
	 * 转�字符串类型到clazz的property类型的值.
	 * 
	 * @param value 待转�的字符串
	 * @param clazz æ??供类型信æ?¯çš„Class
	 * @param propertyName æ??供类型信æ?¯çš„Class的属性.
	 */
public static Object convertValue(Object value, Class<?> toType) {
    try {
        DateConverter dc = new DateConverter();
        dc.setUseLocaleFormat(true);
        dc.setPatterns(new String[] { "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss" });
        ConvertUtils.register(dc, Date.class);
        return ConvertUtils.convert(value, toType);
    } catch (Exception e) {
        throw convertReflectionExceptionToUnchecked(e);
    }
}

private static Object parsePropertyToValue(Object valueObject, Class<?> propertyType) {
    Object value = null;
    //TODO: add cache of enum converters
    boolean isEnum = propertyType.isEnum();
    if (isEnum) {
        ConvertUtils.register(new EnumConverter(), propertyType);
    }
    if (valueObject != null && valueObject.getClass().equals(String.class)) {
        value = ConvertUtils.convert((String) valueObject, propertyType);
    } else {
        value = valueObject;
    }
    return value;
}

/**
     * オブジェクトを<code>T</code>型�変��る。
     * <p>
     * <ul>
     *  <li><code>allowsNull</code>�<code>false</code>��
     *        <code>obj</code>�<code>null</code> - 例外をスロー。
     *  <li><code>allowsNull</code>�<code>true</code>��
     *        <code>obj</code>�<code>null</code> - <code>null</code>を返�。
     *  <li><code>obj</code>ã?Œ<code>clazz</code>åž‹ - ã??ã?®ã?¾ã?¾è¿”å?´ã€‚
     *  <li><code>obj</code>�<code>clazz</code>型����
     *        - <code>ConvertUtils</code>を使用���切�型�変���返�。
     * </ul>
     * </p>
     * 
     * @param <T> 変�後�型。
     * @param obj オブジェクト。
     * @param clazz 変�後�型。
     * @param allowsNull 引数<code>obj</code>�<code>null</code>�
     *      場�を許容�る����。
     * @return 変�後�オブジェクト。
     * @throws IllegalArgumentException 引数<code>clazz</code>�
     *      <code>null</code>�場�。
     *      引数<code>allowsNull</code>�<code>false</code>��
     *        引数<code>obj</code>�<code>null</code>�場�。
     *      変��失敗��場�。
     */
@SuppressWarnings("unchecked")
public static <T> T convert(Object obj, Class<T> clazz, boolean allowsNull) throws IllegalArgumentException {
    if (clazz == null) {
        throw new IllegalArgumentException("Argument 'clazz' (" + Object.class.getName() + ") is null");
    }
    if (obj == null) {
        if (!allowsNull) {
            String message = "Unable to cast 'null' to '" + clazz.getName() + "'";
            throw new IllegalArgumentException(message, new ClassCastException(message));
        }
        return null;
    }
    if (clazz.isAssignableFrom(obj.getClass())) {
        return (T) obj;
    }
    Object result = null;
    try {
        result = ConvertUtils.convert(obj.toString(), clazz);
    } catch (ConversionException e) {
        throw new IllegalArgumentException(e);
    }
    return (T) result;
}

/**
         * Creates a new instance of {@link CoberturaPublisher} from a submitted form.
         */
@Override
public CoberturaPublisher newInstance(StaplerRequest req, JSONObject formData) throws FormException {
    // Null check because findbugs insists, despite the API guaranteeing this is never null.
    if (req == null) {
        throw new FormException("req cannot be null", "");
    }
    CoberturaPublisher instance = req.bindJSON(CoberturaPublisher.class, formData);
    ConvertUtils.register(CoberturaPublisherTarget.CONVERTER, CoverageMetric.class);
    List<CoberturaPublisherTarget> targets = req.bindParametersToList(CoberturaPublisherTarget.class, "cobertura.target.");
    instance.setTargets(targets);
    return instance;
}

/**
     * オブジェクトを指定��クラス�インスタンス�変���返���。
     * 変æ?›ã?®å¿…è¦?ã?Œç„¡ã?„å ´å?ˆã?¯ã??ã?®ã?¾ã?¾è¿”ã?—ã?¾ã?™ã€‚
     *
     * @param expectedClass 戻り型���期待�るクラス
     * @param value 変��る値
     * @return 変�後�値 (expectedClass�インスタンス)
     */
public static Object convert(Class expectedClass, Object value) {
    if (Object.class.equals(expectedClass) || (value != null && expectedClass.isAssignableFrom(value.getClass()))) {
        return value;
    }
    if (String.class.equals(expectedClass)) {
        return (value != null) ? value.toString() : null;
    }
    if (Boolean.class.equals(expectedClass) || Boolean.TYPE.equals(expectedClass)) {
        if (value instanceof Boolean) {
            return value;
        }
        return Boolean.valueOf(ObjectUtil.booleanValue(value, false));
    }
    Converter converter = ConvertUtils.lookup(expectedClass);
    if (converter != null) {
        if (value != null) {
            return converter.convert(expectedClass, value);
        }
        if (expectedClass.isPrimitive() || Number.class.isAssignableFrom(expectedClass)) {
            if (BigInteger.class.isAssignableFrom(expectedClass)) {
                return BigInteger.ZERO;
            } else if (BigDecimal.class.isAssignableFrom(expectedClass)) {
                return BigDecimal.valueOf(0);
            }
            return converter.convert(expectedClass, value);
        }
    }
    return value;
}

private void setFildValue(String value, Field field, Object instance) {
    Class<?> type = field.getType();
    Object convertedObject = ConvertUtils.convert(value, type);
    try {
        field.setAccessible(true);
        field.set(instance, convertedObject);
        logger.debug("field '{}' updated", field.getName());
    } catch (IllegalArgumentException e) {
        throw new RuntimeException(e);
    } catch (IllegalAccessException e) {
        throw new RuntimeException(e);
    }
}

/**
     * creates the panel programmically according to the definitions in the bean blass T.
     *
     * @throws IllegalAccessException
     * @throws NoSuchMethodException
     * @throws InvocationTargetException
     */
void initPanel() throws IllegalAccessException, NoSuchMethodException, InvocationTargetException {
    // fields means the fields of the BeanClass which defines the bahavior of the editor
    Field[] fields = data.getClass().getDeclaredFields();
    // I have to count them first.
    // makes sure, that we only care about fields which are meant for this editor.
    int numfields = 0;
    for (final Field field : fields) {
        if (field.isAnnotationPresent(EditorComponent.class)) {
            numfields++;
        }
    }
    // create a simple formlayout which is extendable
    setLayout(new FormLayout("5dlu, default, $lcgap, 162dlu:grow, $lcgap, 5dlu", "5dlu, " + (numfields + (saveMode == SAVE_MODE_IMMEDIATE ? 0 : 1) + "*(default, $lgap), default, 5dlu")));
    int row = 1;
    // deal with every single field
    for (final Field field : fields) {
        if (field.isAnnotationPresent(EditorComponent.class)) {
            // we only care about EditorComponents
            EditorComponent editorComponent = field.getAnnotation(EditorComponent.class);
            JLabel lblName = new JLabel(SYSTools.xx(editorComponent.label()));
            lblName.setFont(new Font("Arial", Font.BOLD, 14));
            JComponent comp = null;
            // this section handles every single type of editor component
            if (editorComponent.component()[0].equalsIgnoreCase("textfield")) {
                JPanel innerPanel = new JPanel();
                innerPanel.setLayout(new BoxLayout(innerPanel, BoxLayout.LINE_AXIS));
                final JLabel lblOK = new JLabel(SYSConst.icon16apply);
                final JTextField txt;
                if (field.isAnnotationPresent(Size.class)) {
                    Size sizeConstraint = field.getAnnotation(Size.class);
                    txt = new BoundedTextField(sizeConstraint.min(), sizeConstraint.max());
                } else {
                    txt = new JTextField();
                }
                // the data object sets the contents of the textfield
                txt.setText(PropertyUtils.getProperty(data, field.getName()).toString());
                txt.addFocusListener(new FocusAdapter() {

                    @Override
                    public void focusGained(FocusEvent e) {
                        ((JTextField) e.getSource()).selectAll();
                    }
                });
                // changes to the textfield are handled by a document listener
                txt.getDocument().addDocumentListener(new RelaxedDocumentListener( de -> {
                    if (ignoreListener)
                        return;
                    if (saveMode == SAVE_MODE_IMMEDIATE)
                        reload();
                    try {
                        String text = de.getDocument().getText(0, de.getDocument().getLength());
                        Object value = text;
                        if (!editorComponent.parserClass().isEmpty()) {
                            String p = editorComponent.parserClass();
                            logger.debug(String.format("Parserclass for Field %s: %s", field.getName(), p));
                            Class parserClazz = Class.forName(p);
                            value = parserClazz.getMethod("parse", String.class).invoke(parserClazz.newInstance(), text);
                            logger.debug(String.format("Parsed value: %s", value.toString()));
                        }
                        PropertyUtils.setProperty(data, field.getName(), ConvertUtils.convert(value, field.getType()));
                        if (saveMode == SAVE_MODE_IMMEDIATE) {
                            broadcast();
                        }
                        OPDE.getDisplayManager().clearSubMessages();
                        lblOK.setIcon(SYSConst.icon16apply);
                        lblOK.setToolTipText(null);
                        GUITools.flashBackground(txt, SYSConst.darkolivegreen1, Color.white, 2);
                    } catch (BadLocationException e1) {
                        OPDE.error(logger, e1);
                        lblOK.setIcon(SYSConst.icon16cancel);
                        lblOK.setToolTipText(SYSTools.toHTMLForScreen(SYSConst.html_bold(e1.getMessage())));
                    } catch (IllegalAccessException e1) {
                        OPDE.error(logger, e1);
                        lblOK.setToolTipText(SYSTools.toHTMLForScreen(SYSConst.html_bold(e1.getMessage())));
                    } catch (InvocationTargetException ite) {
                        if (ite.getTargetException() instanceof ParseException) {
                            OPDE.getDisplayManager().addSubMessage(new DisplayMessage(ite.getTargetException().getMessage(), DisplayMessage.WARNING));
                        } else {
                            OPDE.error(logger, ite);
                        }
                        lblOK.setIcon(SYSConst.icon16cancel);
                        lblOK.setToolTipText(SYSTools.toHTMLForScreen(SYSConst.html_bold(ite.getMessage())));
                    } catch (NoSuchMethodException e) {
                        OPDE.error(logger, e);
                        lblOK.setIcon(SYSConst.icon16cancel);
                        lblOK.setToolTipText(SYSTools.toHTMLForScreen(SYSConst.html_bold(e.getMessage())));
                    } catch (ConstraintViolationException cve) {
                        logger.debug("Constraint violation!!");
                        if (saveMode == SAVE_MODE_IMMEDIATE) {
                            OPDE.getDisplayManager().addSubMessage(new DisplayMessage(cve));
                        }
                        String message = "";
                        for (ConstraintViolation cv : cve.getConstraintViolations()) {
                            logger.debug(cv.getPropertyPath().toString());
                            logger.debug(field.getName());
                            if (cv.getPropertyPath().toString().equals(field.getName())) {
                                message = cv.getMessage();
                                break;
                            }
                        }
                        if (message.isEmpty()) {
                            OPDE.getDisplayManager().clearSubMessages();
                            lblOK.setIcon(SYSConst.icon16apply);
                            lblOK.setToolTipText(null);
                            GUITools.flashBackground(txt, SYSConst.darkolivegreen1, Color.white, 2);
                        } else {
                            lblOK.setIcon(SYSConst.icon16cancel);
                            lblOK.setToolTipText(SYSTools.toHTMLForScreen(SYSConst.html_paragraph(message)));
                            GUITools.flashBackground(txt, SYSConst.orangered, Color.white, 2);
                        }
                    } catch (ClassNotFoundException e) {
                        OPDE.error(logger, e);
                        lblOK.setIcon(SYSConst.icon16cancel);
                        lblOK.setToolTipText(SYSTools.toHTMLForScreen(SYSConst.html_bold(e.getMessage())));
                    } catch (InstantiationException e) {
                        OPDE.error(logger, e);
                        lblOK.setIcon(SYSConst.icon16cancel);
                        lblOK.setToolTipText(SYSTools.toHTMLForScreen(SYSConst.html_bold(e.getMessage())));
                    } catch (SQLIntegrityConstraintViolationException e) {
                        OPDE.warn(logger, e);
                        lblOK.setIcon(SYSConst.icon16cancel);
                        lblOK.setToolTipText(SYSTools.toHTMLForScreen("error.sql.integrity"));
                        GUITools.flashBackground(txt, SYSConst.orangered, Color.white, 2);
                    }
                }));
                innerPanel.add(txt);
                innerPanel.add(lblOK);
                innerPanel.setOpaque(false);
                comp = innerPanel;
                comp.setName("innerPanel");
                txt.setName(field.getName());
            } else if (editorComponent.component()[0].equalsIgnoreCase("combobox")) {
                // this is the default ItemListener, if there is no renderer defined
                ItemListener il =  e -> {
                    if (ignoreListener)
                        return;
                    if (e.getStateChange() == ItemEvent.SELECTED) {
                        if (saveMode == SAVE_MODE_IMMEDIATE)
                            reload();
                        try {
                            PropertyUtils.setProperty(data, field.getName(), field.getType().cast(((JComboBox) e.getSource()).getSelectedIndex()));
                            if (saveMode == SAVE_MODE_IMMEDIATE)
                                broadcast();
                        } catch (Exception e1) {
                            logger.debug(e1);
                        }
                    }
                };
                ListCellRenderer<T> renderer = null;
                DefaultComboBoxModel dcbm = new DefaultComboBoxModel<>(ArrayUtils.subarray(editorComponent.component(), 1, editorComponent.component().length - 1));
                try {
                    if (!editorComponent.renderer().isEmpty()) {
                        String r = editorComponent.renderer();
                        Class rendererClazz = Class.forName(r);
                        renderer = (ListCellRenderer) rendererClazz.newInstance();
                        String m = editorComponent.model();
                        Class modelClazz = Class.forName(m);
                        dcbm = (DefaultComboBoxModel) modelClazz.newInstance();
                        // if there is a renderer weg got for the object itself, rather than the selected index
                        il =  e -> {
                            if (e.getStateChange() == ItemEvent.SELECTED) {
                                if (ignoreListener)
                                    return;
                                if (saveMode == SAVE_MODE_IMMEDIATE)
                                    reload();
                                try {
                                    PropertyUtils.setProperty(data, field.getName(), field.getType().cast(((JComboBox) e.getSource()).getSelectedItem()));
                                    if (saveMode == SAVE_MODE_IMMEDIATE)
                                        broadcast();
                                } catch (Exception e1) {
                                    logger.debug(e1);
                                }
                            }
                        };
                    }
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                } catch (InstantiationException e) {
                    e.printStackTrace();
                }
                JComboBox combobox = new JComboBox(dcbm);
                if (renderer != null) {
                    combobox.setSelectedItem(PropertyUtils.getProperty(data, field.getName()));
                } else {
                    // https://github.com/tloehr/Offene-Pflege.de/issues/29
                    combobox.setSelectedIndex(Integer.parseInt(PropertyUtils.getProperty(data, field.getName()).toString()));
                }
                combobox.addItemListener(il);
                if (renderer != null)
                    combobox.setRenderer(renderer);
                comp = combobox;
                comp.setName(field.getName());
            } else if (editorComponent.component()[0].equalsIgnoreCase("onoffswitch")) {
                String yesText = "misc.msg.yes";
                String noText = "misc.msg.no";
                if (editorComponent.component().length == 3) {
                    yesText = editorComponent.component()[1];
                    noText = editorComponent.component()[2];
                }
                comp = new YesNoToggleButton(yesText, noText, (boolean) PropertyUtils.getProperty(data, field.getName()));
                comp.setName(field.getName());
                ((YesNoToggleButton) comp).addItemListener( e -> {
                    if (ignoreListener)
                        return;
                    if (saveMode == SAVE_MODE_IMMEDIATE)
                        reload();
                    try {
                        PropertyUtils.setProperty(data, field.getName(), new Boolean(e.getStateChange() == ItemEvent.SELECTED));
                        if (saveMode == SAVE_MODE_IMMEDIATE)
                            broadcast();
                    } catch (Exception e1) {
                        logger.debug(e1);
                    }
                });
            } else if (editorComponent.component()[0].equalsIgnoreCase("colorset")) {
                JColorChooser clr = new JColorChooser(GUITools.getColor(PropertyUtils.getProperty(data, field.getName()).toString()));
                clr.getSelectionModel().addChangeListener( e -> {
                    if (saveMode == SAVE_MODE_IMMEDIATE)
                        reload();
                    try {
                        PropertyUtils.setProperty(data, field.getName(), GUITools.getHTMLColor(((ColorSelectionModel) e.getSource()).getSelectedColor()));
                        DataChangeEvent<T> dce = new DataChangeEvent(thisPanel, data);
                        dce.setTriggersReload(true);
                        if (saveMode == SAVE_MODE_IMMEDIATE)
                            broadcast();
                    } catch (Exception e1) {
                        logger.debug(e1);
                    }
                });
                CollapsiblePane cp = new CollapsiblePane(SYSTools.xx(editorComponent.label()));
                cp.setStyle(CollapsiblePane.PLAIN_STYLE);
                cp.setIcon(SYSConst.icon22colorset);
                try {
                    cp.setCollapsed(true);
                } catch (PropertyVetoException e) {
                }
                cp.setOpaque(false);
                cp.setContentPane(clr);
                comp = cp;
                comp.setName(field.getName());
            } else {
                OPDE.fatal(logger, new IllegalStateException("invalid component name in EditorComponent Annotation"));
            }
            if (comp instanceof CollapsiblePane) {
                add(comp, CC.xyw(2, row + 1, 4, CC.FILL, CC.DEFAULT));
            } else if (editorComponent.filled().equals("false")) {
                add(lblName, CC.xy(2, row + 1, CC.LEFT, CC.TOP));
                add(comp, CC.xy(4, row + 1, CC.LEFT, CC.TOP));
            } else {
                add(lblName, CC.xy(2, row + 1, CC.LEFT, CC.TOP));
                add(comp, CC.xy(4, row + 1));
            }
            SYSTools.setXEnabled(comp, editorComponent.readonly().equals("false"));
            //                comp.setEnabled();
            comp.setToolTipText(editorComponent.tooltip().isEmpty() ? null : SYSTools.xx(editorComponent.tooltip()));
            componentSet.add(comp);
            row += 2;
        }
    }
}

/**
     * Process the end of this element.<p>
     * 
     * @param namespace the namespace URI of the matching element, or an empty string if the parser is not namespace 
     *                  aware or the element has no namespace
     * @param name the local name if the parser is namespace aware, or just the element name otherwise
     * @throws Exception if something goes wrong
     */
@Override
public void end(String namespace, String name) throws Exception {
    // Determine the target object for the method call: the parent object
    Object parent = digester.peek(1);
    Object child = digester.peek(0);
    // Retrieve or construct the parameter values array
    Object[] parameters = null;
    if (m_paramCount > 0) {
        parameters = (Object[]) digester.popParams();
        if (LOG.isTraceEnabled()) {
            for (int i = 0, size = parameters.length; i < size; i++) {
                LOG.trace("[SetNextRuleWithParams](" + i + ")" + parameters[i]);
            }
        }
        // parameter, but it always has been so we can't change it now.
        if ((m_paramCount == 1) && (parameters[0] == null)) {
            return;
        }
    } else if (m_paramTypes.length != 0) {
        // so skip the method call
        if (m_bodyText == null) {
            return;
        }
        parameters = new Object[1];
        parameters[0] = m_bodyText;
        if (m_paramTypes.length == 0) {
            m_paramTypes = new Class[1];
            m_paramTypes[0] = String.class;
        }
    } else {
        // When paramCount is zero and paramTypes.length is zero it
        // means that we truly are calling a method with no parameters.
        // Nothing special needs to be done here.
        parameters = new Object[0];
    }
    // Construct the parameter values array we will need
    // We only do the conversion if the param value is a String and
    // the specified paramType is not String. 
    Object[] paramValues = new Object[m_paramTypes.length];
    Class<?> propertyClass = child.getClass();
    for (int i = 0; i < m_paramTypes.length; i++) {
        if (m_paramTypes[i] == propertyClass) {
            // implant the original child to set if Class matches: 
            paramValues[i] = child;
        } else if ((parameters[i] == null) || ((parameters[i] instanceof String) && !String.class.isAssignableFrom(m_paramTypes[i]))) {
            // for non-stringy param types
            if (parameters[i] == null) {
                paramValues[i] = null;
            } else {
                paramValues[i] = ConvertUtils.convert((String) parameters[i], m_paramTypes[i]);
            }
        } else {
            paramValues[i] = parameters[i];
        }
    }
    if (parent == null) {
        StringBuffer sb = new StringBuffer();
        sb.append("[SetNextRuleWithParams]{");
        sb.append(digester.getMatch());
        sb.append("} Call target is null (");
        sb.append("targetOffset=");
        sb.append(m_targetOffset);
        sb.append(",stackdepth=");
        sb.append(digester.getCount());
        sb.append(")");
        throw new org.xml.sax.SAXException(sb.toString());
    }
    // Invoke the required method on the top object
    if (LOG.isDebugEnabled()) {
        StringBuffer sb = new StringBuffer("[SetNextRuleWithParams]{");
        sb.append(digester.getMatch());
        sb.append("} Call ");
        sb.append(parent.getClass().getName());
        sb.append(".");
        sb.append(m_methodName);
        sb.append("(");
        for (int i = 0; i < paramValues.length; i++) {
            if (i > 0) {
                sb.append(",");
            }
            if (paramValues[i] == null) {
                sb.append("null");
            } else {
                sb.append(paramValues[i].toString());
            }
            sb.append("/");
            if (m_paramTypes[i] == null) {
                sb.append("null");
            } else {
                sb.append(m_paramTypes[i].getName());
            }
        }
        sb.append(")");
        LOG.debug(sb.toString());
    }
    Object result = null;
    if (m_useExactMatch) {
        // invoke using exact match
        result = MethodUtils.invokeExactMethod(parent, m_methodName, paramValues, m_paramTypes);
    } else {
        // invoke using fuzzier match
        result = MethodUtils.invokeMethod(parent, m_methodName, paramValues, m_paramTypes);
    }
    processMethodCallResult(result);
}

/**
     * Process the end of this element.<p>
     * 
     * @param namespace the namespace URI of the matching element, or an empty string if the parser is not namespace 
     *                  aware or the element has no namespace
     * @param name the local name if the parser is namespace aware, or just the element name otherwise
     * @throws Exception if something goes wrong
     */
@Override
public void end(String namespace, String name) throws Exception {
    // Determine the target object for the method call: the parent object
    Object parent = digester.peek(1);
    Object child = digester.peek(0);
    // Retrieve or construct the parameter values array
    Object[] parameters = null;
    if (m_paramCount > 0) {
        parameters = (Object[]) digester.popParams();
        if (LOG.isTraceEnabled()) {
            for (int i = 0, size = parameters.length; i < size; i++) {
                LOG.trace("[SetNextRuleWithParams](" + i + ")" + parameters[i]);
            }
        }
        // parameter, but it always has been so we can't change it now.
        if ((m_paramCount == 1) && (parameters[0] == null)) {
            return;
        }
    } else if (m_paramTypes.length != 0) {
        // so skip the method call
        if (m_bodyText == null) {
            return;
        }
        parameters = new Object[1];
        parameters[0] = m_bodyText;
        if (m_paramTypes.length == 0) {
            m_paramTypes = new Class[1];
            m_paramTypes[0] = String.class;
        }
    } else {
        // When paramCount is zero and paramTypes.length is zero it
        // means that we truly are calling a method with no parameters.
        // Nothing special needs to be done here.
        parameters = new Object[0];
    }
    // Construct the parameter values array we will need
    // We only do the conversion if the param value is a String and
    // the specified paramType is not String. 
    Object[] paramValues = new Object[m_paramTypes.length];
    Class<?> propertyClass = child.getClass();
    for (int i = 0; i < m_paramTypes.length; i++) {
        if (m_paramTypes[i] == propertyClass) {
            // implant the original child to set if Class matches: 
            paramValues[i] = child;
        } else if ((parameters[i] == null) || ((parameters[i] instanceof String) && !String.class.isAssignableFrom(m_paramTypes[i]))) {
            // for non-stringy param types
            if (parameters[i] == null) {
                paramValues[i] = null;
            } else {
                paramValues[i] = ConvertUtils.convert((String) parameters[i], m_paramTypes[i]);
            }
        } else {
            paramValues[i] = parameters[i];
        }
    }
    if (parent == null) {
        StringBuffer sb = new StringBuffer();
        sb.append("[SetNextRuleWithParams]{");
        sb.append(digester.getMatch());
        sb.append("} Call target is null (");
        sb.append("targetOffset=");
        sb.append(m_targetOffset);
        sb.append(",stackdepth=");
        sb.append(digester.getCount());
        sb.append(")");
        throw new org.xml.sax.SAXException(sb.toString());
    }
    // Invoke the required method on the top object
    if (LOG.isDebugEnabled()) {
        StringBuffer sb = new StringBuffer("[SetNextRuleWithParams]{");
        sb.append(digester.getMatch());
        sb.append("} Call ");
        sb.append(parent.getClass().getName());
        sb.append(".");
        sb.append(m_methodName);
        sb.append("(");
        for (int i = 0; i < paramValues.length; i++) {
            if (i > 0) {
                sb.append(",");
            }
            if (paramValues[i] == null) {
                sb.append("null");
            } else {
                sb.append(paramValues[i].toString());
            }
            sb.append("/");
            if (m_paramTypes[i] == null) {
                sb.append("null");
            } else {
                sb.append(m_paramTypes[i].getName());
            }
        }
        sb.append(")");
        LOG.debug(sb.toString());
    }
    Object result = null;
    if (m_useExactMatch) {
        // invoke using exact match
        result = MethodUtils.invokeExactMethod(parent, m_methodName, paramValues, m_paramTypes);
    } else {
        // invoke using fuzzier match
        result = MethodUtils.invokeMethod(parent, m_methodName, paramValues, m_paramTypes);
    }
    processMethodCallResult(result);
}

/**
	 * Coerce object type.
	 * 
	 * @param <T>
	 *            the expected type
	 * @param from
	 *            from object
	 * @param expectedType
	 *            to object type
	 * @return the to object
	 */
public static <T> T coerceType(Object from, Class<? extends T> expectedType) {
    if (from == null) {
        return null;
    }
    Object targetValue = null;
    if (expectedType.isInstance(from)) {
        targetValue = from;
    } else if (expectedType.isEnum()) {
        for (Object e : expectedType.getEnumConstants()) {
            if (from.toString().equalsIgnoreCase(e.toString())) {
                targetValue = e;
                break;
            }
        }
        if (targetValue == null) {
            throw new PaxmlRuntimeException("No enum named '" + from + "' is defined in class: " + expectedType);
        }
    } else if (List.class.equals(expectedType)) {
        targetValue = new ArrayList();
        collect(from, (Collection) targetValue, true);
    } else if (Set.class.equals(expectedType)) {
        targetValue = new LinkedHashSet();
        collect(from, (Collection) targetValue, true);
    } else if (isImplementingClass(expectedType, Collection.class, false)) {
        try {
            targetValue = expectedType.newInstance();
        } catch (Exception e) {
            throw new PaxmlRuntimeException(e);
        }
        collect(from, (Collection) targetValue, true);
    } else if (Iterator.class.equals(expectedType)) {
        List list = new ArrayList();
        collect(from, list, true);
        targetValue = list.iterator();
    } else if (isImplementingClass(expectedType, Coerceable.class, false)) {
        try {
            Constructor c = expectedType.getConstructor(Object.class);
            targetValue = c.newInstance(from);
        } catch (Exception e) {
            throw new PaxmlRuntimeException(e);
        }
    } else if (from instanceof Map) {
        return mapToBean((Map) from, expectedType);
    } else {
        targetValue = ConvertUtils.convert(from.toString(), expectedType);
    }
    return (T) targetValue;
}

/**
	 * 
	 * @param value.  Convert from this value
	 * @param clazz. Convert to this clazz type.
	 * @return object of type clazz.
	 * @throws FieldParseException
	 */
private Object _convert(Object value, Class clazz, FieldContext context) throws FieldParseException {
    try {
        if (value instanceof String) {
            Object result = null;
            if (context == null)
                result = ConvertUtils.convert((String) value, clazz);
            else {
                Converter contextConverter = null;
                HashMap<Class, Converter> contextMap = contextMaps.get(context);
                if (contextMap != null)
                    contextConverter = contextMap.get(clazz);
                if (contextConverter != null) {
                    contextConverter.convert(clazz, value);
                } else {
                    System.out.println("no context converter found ");
                    result = ConvertUtils.convert((String) value, clazz);
                }
            }
            //			}
            if (result == null) {
                throw new FieldParseException("Invalid type");
            }
            return result;
        }
        // Because of stupidity of beanutils which assumes type string, I implement this by hand
        Converter converter = ConvertUtils.lookup(clazz);
        if (converter == null) {
            System.out.println("converter is null for class " + clazz + " instance " + instance.hashCode() + " resetting");
            instance = new FieldConverter();
            converter = ConvertUtils.lookup(String.class);
        }
        return converter.convert(clazz, value);
    } catch (ConversionException conversionException) {
        throw new FieldParseException(conversionException);
    }
}

public static void concatPropertyList(Object bean, String propertyList, StringBuffer result, boolean quoted) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
    if (bean == null || propertyList == null || result == null) {
        return;
    }
    StringTokenizer st = new StringTokenizer(propertyList, ",");
    while (st.hasMoreTokens()) {
        String name = st.nextToken();
        Object value = PropertyUtils.getProperty(bean, name);
        if (value instanceof String && value != null) {
            result.append(" ");
            if (quoted)
                result.append("\"");
            result.append(value);
            if (quoted)
                result.append("\"");
        } else if (value instanceof Collection && value != null) {
            Iterator valIter = ((Collection) value).iterator();
            while (valIter.hasNext()) {
                concatPropertyList(valIter.next(), "displayName", result, quoted);
            // result.append(" " + ConvertUtils.convert(valIter.next()));
            }
        } else if (value != null) {
            result.append(" ");
            if (quoted)
                result.append("\"");
            result.append(ConvertUtils.convert(value));
            if (quoted)
                result.append("\"");
        }
    }
}

public static void main(String[] args) {
    log.debug("Hermes Browser " + Hermes.VERSION + " starting...");
    log.debug("working directory: " + new File(".").getAbsolutePath());
    Hermes.events.addConnectionListener(new ConnectionListener() {

        public void onConnectionOpen(Hermes hermes) {
            log.debug("Connection " + hermes.getId() + " opened");
        }

        public void onConnectionClosed(Hermes hermes) {
            log.debug("Connection " + hermes.getId() + " closed");
        }
    });
    //
    // Need to bootstrap objects into the singleton manager... hack for now.
    JVMUtils.forceInit(SingletonManager.class);
    JVMUtils.forceInit(ThreadPool.class);
    JVMUtils.forceInit(SimpleClassLoaderManager.class);
    //
    // Commented out as this is for debug use only.
    // RepaintManager.setCurrentManager(new ThreadCheckingRepaintManager());
    //
    // Note this is the license for the JIDE Framework, it is licenced
    // to Colin Crist and the Hermes project and should not be used for any
    // other purpose
    //
    Lm.verifyLicense("Colin Crist", "Hermes", "9vkNAfxF1lvVyW7uZXYjpxFskycSGLw1");
    //
    // See http://www.jidesoft.com for licensing terms.
    //
    // Register a converter from a String to a File with PropertyUtils.
    ConvertUtils.register(new Converter() {

        public Object convert(Class arg0, Object filename) {
            return new File((String) filename);
        }
    }, File.class);
    SplashScreen.create(IconCache.getIcon("hermes.splash"));
    SplashScreen.show();
    SwingUtilities.invokeLater(new Runnable() {

        public void run() {
            try {
                ui = new HermesBrowser(HERMES_TITLE);
                ui.initJIDE();
                try {
                    ui.loadConfig();
                } catch (NamingException ex) {
                    log.fatal("cannot initialise hermes: " + ex.getMessage(), ex);
                    System.exit(1);
                } catch (HeadlessException ex) {
                    log.fatal("cannot initialise hermes browser, no head: " + ex.getMessage(), ex);
                    System.exit(1);
                }
                ui.initUI();
                ui.init();
                ui.getLayoutPersistence().setProfileKey(ui.getUserProfileName());
                ui.getLayoutPersistence().loadLayoutData();
                // This must be done after the layout has been set otherwise
                // the
                // frames are hidden.
                final ArrayList<WatchConfig> tmpList = new ArrayList<WatchConfig>(ui.getConfig().getWatch());
                ui.getLoader().getConfig().getWatch().clear();
                for (WatchConfig wConfig : tmpList) {
                    ui.createWatch(wConfig);
                }
                ui.firstLoad = false;
            } catch (Exception ex) {
                log.fatal("cannot initialise hermes browser: " + ex.getMessage(), ex);
            }
        }
    });
}

/**
     * Adds rules to the digester to parse the a plan XML.
     * 
     * @param digester
     *            the digester
     * @throws ParserConfigurationException
     *             if an error occurred
     */
private static void addRules(Digester digester) throws ParserConfigurationException {
    ConvertUtils.register(new EnumConverter<EvaluationScope>(EvaluationScope.class), EvaluationScope.class);
    // start with a new file
    digester.addObjectCreate("*/plan", Plan.class);
    digester.addSetProperties("*/plan");
    digester.addSetRoot("*/plan", "setProject");
    digester.addFactoryCreate("*/changelog", ChangeLogFactory.class);
    digester.addSetNext("*/changelog", "setChangeLog");
    digester.addObjectCreate("*/plan/properties", PlanProperties.class);
    digester.addSetProperties("*/plan/properties");
    digester.addSetNext("*/plan/properties", "setPlanProperties");
    digester.addCallMethod("*/plan/properties/description", "setDescription", 0);
    digester.addCallMethod("*/plan/properties/owner", "setOwner", 0);
    digester.addFactoryCreate("*/plan/properties/state", PlanStateFactory.class);
    digester.addSetNext("*/plan/properties/state", "setState");
    PlanParser.addCreateUpload(digester, "*/plan/properties/report", "setReportUpload", DigitalObject.class);
    digester.addObjectCreate("*/plan/basis", ProjectBasis.class);
    digester.addSetProperties("*/plan/basis");
    digester.addSetNext("*/plan/basis", "setProjectBasis");
    digester.addCallMethod("*/plan/basis/applyingPolicies", "setApplyingPolicies", 0);
    digester.addCallMethod("*/plan/basis/designatedCommunity", "setDesignatedCommunity", 0);
    digester.addCallMethod("*/plan/basis/mandate", "setMandate", 0);
    digester.addCallMethod("*/plan/basis/documentTypes", "setDocumentTypes", 0);
    digester.addCallMethod("*/plan/basis/identificationCode", "setIdentificationCode", 0);
    digester.addCallMethod("*/plan/basis/organisationalProcedures", "setOrganisationalProcedures", 0);
    digester.addCallMethod("*/plan/basis/planningPurpose", "setPlanningPurpose", 0);
    digester.addCallMethod("*/plan/basis/planRelations", "setPlanRelations", 0);
    digester.addCallMethod("*/plan/basis/preservationRights", "setPreservationRights", 0);
    digester.addCallMethod("*/plan/basis/referenceToAgreements", "setReferenceToAgreements", 0);
    // define common rule for triggers, for all */triggers/...!
    // also used for PlanDefinition
    digester.addObjectCreate("*/triggers", TriggerDefinition.class);
    digester.addSetNext("*/triggers", "setTriggers");
    // every time a */triggers/trigger is encountered:
    digester.addFactoryCreate("*/triggers/trigger", TriggerFactory.class);
    digester.addSetNext("*/triggers/trigger", "setTrigger");
    //
    // Policy Tree
    //
    digester.addObjectCreate("*/plan/basis/policyTree", PolicyTree.class);
    digester.addSetProperties("*/plan/basis/policyTree");
    digester.addSetNext("*/plan/basis/policyTree", "setPolicyTree");
    digester.addObjectCreate("*/plan/basis/policyTree/policyNode", PolicyNode.class);
    digester.addSetProperties("*/plan/basis/policyTree/policyNode");
    digester.addSetNext("*/plan/basis/policyTree/policyNode", "setRoot");
    digester.addObjectCreate("*/policyNode/policyNode", PolicyNode.class);
    digester.addSetProperties("*/policyNode/policyNode");
    digester.addSetNext("*/policyNode/policyNode", "addChild");
    digester.addObjectCreate("*/policyNode/policy", Policy.class);
    digester.addSetProperties("*/policyNode/policy");
    digester.addSetNext("*/policyNode/policy", "addChild");
    //
    // Sample Records
    //
    digester.addObjectCreate("*/plan/sampleRecords", SampleRecordsDefinition.class);
    digester.addSetProperties("*/plan/sampleRecords");
    digester.addSetNext("*/plan/sampleRecords", "setSampleRecordsDefinition");
    digester.addCallMethod("*/plan/sampleRecords/samplesDescription", "setSamplesDescription", 0);
    // - records
    digester.addObjectCreate("*/record", SampleObject.class);
    digester.addSetProperties("*/record");
    digester.addSetNext("*/record", "addRecord");
    digester.addCallMethod("*/record/description", "setDescription", 0);
    digester.addCallMethod("*/record/originalTechnicalEnvironment", "setOriginalTechnicalEnvironment", 0);
    digester.addObjectCreate("*/record/data", BinaryDataWrapper.class);
    digester.addSetTop("*/record/data", "setData");
    digester.addCallMethod("*/record/data", "setFromBase64Encoded", 0);
    // set up an general rule for all jhove strings!
    digester.addObjectCreate("*/jhoveXML", BinaryDataWrapper.class);
    digester.addSetTop("*/jhoveXML", "setString");
    digester.addCallMethod("*/jhoveXML", "setFromBase64Encoded", 0);
    digester.addCallMethod("*/jhoveXML", "setMethodName", 1, new String[] { "java.lang.String" });
    digester.addObjectParam("*/jhoveXML", 0, "setJhoveXMLString");
    // set up general rule for all fitsXMLs
    digester.addObjectCreate("*/fitsXML", BinaryDataWrapper.class);
    digester.addSetTop("*/fitsXML", "setString");
    digester.addCallMethod("*/fitsXML", "setFromBase64Encoded", 0);
    digester.addCallMethod("*/fitsXML", "setMethodName", 1, new String[] { "java.lang.String" });
    digester.addObjectParam("*/fitsXML", 0, "setFitsXMLString");
    digester.addObjectCreate("*/formatInfo", FormatInfo.class);
    digester.addSetProperties("*/formatInfo");
    digester.addSetNext("*/formatInfo", "setFormatInfo");
    PlanParser.addCreateUpload(digester, "*/record/xcdlDescription", "setXcdlDescription", XcdlDescription.class);
    // - collection profile
    digester.addObjectCreate("*/plan/sampleRecords/collectionProfile", CollectionProfile.class);
    digester.addSetProperties("*/plan/sampleRecords/collectionProfile");
    digester.addSetNext("*/plan/sampleRecords/collectionProfile", "setCollectionProfile");
    digester.addCallMethod("*/plan/sampleRecords/collectionProfile/collectionID", "setCollectionID", 0);
    digester.addCallMethod("*/plan/sampleRecords/collectionProfile/description", "setDescription", 0);
    digester.addCallMethod("*/plan/sampleRecords/collectionProfile/numberOfObjects", "setNumberOfObjects", 0);
    digester.addCallMethod("*/plan/sampleRecords/collectionProfile/typeOfObjects", "setTypeOfObjects", 0);
    digester.addCallMethod("*/plan/sampleRecords/collectionProfile/expectedGrowthRate", "setExpectedGrowthRate", 0);
    digester.addCallMethod("*/plan/sampleRecords/collectionProfile/retentionPeriod", "setRetentionPeriod", 0);
    PlanParser.addCreateUpload(digester, "*/plan/sampleRecords/collectionProfile/profile", "setProfile", DigitalObject.class);
    // requirements definition
    digester.addObjectCreate("*/plan/requirementsDefinition", RequirementsDefinition.class);
    digester.addSetProperties("*/plan/requirementsDefinition");
    digester.addSetNext("*/plan/requirementsDefinition", "setRequirementsDefinition");
    digester.addCallMethod("*/plan/requirementsDefinition/description", "setDescription", 0);
    // - uploads
    digester.addObjectCreate("*/plan/requirementsDefinition/uploads", ArrayList.class);
    digester.addSetNext("*/plan/requirementsDefinition/uploads", "setUploads");
    PlanParser.addCreateUpload(digester, "*/plan/requirementsDefinition/uploads/upload", "add", DigitalObject.class);
    // alternatives
    digester.addObjectCreate("*/plan/alternatives", AlternativesDefinition.class);
    digester.addSetProperties("*/plan/alternatives");
    digester.addCallMethod("*/plan/alternatives/description", "setDescription", 0);
    digester.addSetNext("*/plan/alternatives", "setAlternativesDefinition");
    digester.addObjectCreate("*/plan/alternatives/alternative", Alternative.class);
    digester.addSetProperties("*/plan/alternatives/alternative");
    digester.addSetNext("*/plan/alternatives/alternative", "addAlternative");
    // - action
    digester.addObjectCreate("*/plan/alternatives/alternative/action", PreservationActionDefinition.class);
    digester.addSetProperties("*/plan/alternatives/alternative/action");
    digester.addBeanPropertySetter("*/plan/alternatives/alternative/action/descriptor");
    digester.addBeanPropertySetter("*/plan/alternatives/alternative/action/parameterInfo");
    digester.addSetNext("*/plan/alternatives/alternative/action", "setAction");
    digester.addCallMethod("*/plan/alternatives/alternative/description", "setDescription", 0);
    // - - params
    digester.addObjectCreate("*/plan/alternatives/alternative/action/params", LinkedList.class);
    digester.addSetNext("*/plan/alternatives/alternative/action/params", "setParams");
    digester.addObjectCreate("*/plan/alternatives/alternative/action/params/param", Parameter.class);
    digester.addSetProperties("*/plan/alternatives/alternative/action/params/param");
    digester.addSetNext("*/plan/alternatives/alternative/action/params/param", "add");
    // - resource description
    digester.addObjectCreate("*/resourceDescription", ResourceDescription.class);
    digester.addSetProperties("*/resourceDescription");
    digester.addSetNext("*/resourceDescription", "setResourceDescription");
    digester.addCallMethod("*/resourceDescription/configSettings", "setConfigSettings", 0);
    digester.addCallMethod("*/resourceDescription/necessaryResources", "setNecessaryResources", 0);
    digester.addCallMethod("*/resourceDescription/reasonForConsidering", "setReasonForConsidering", 0);
    // - experiment
    digester.addObjectCreate("*/experiment", ExperimentWrapper.class);
    digester.addSetProperties("*/experiment");
    digester.addSetNext("*/experiment", "setExperiment");
    digester.addCallMethod("*/experiment/description", "setDescription", 0);
    digester.addCallMethod("*/experiment/settings", "setSettings", 0);
    PlanParser.addCreateUpload(digester, "*/experiment/workflow", "setWorkflow", DigitalObject.class);
    PlanParser.addCreateUpload(digester, "*/experiment/results/result", null, DigitalObject.class);
    PlanParser.addCreateUpload(digester, "*/result/xcdlDescription", "setXcdlDescription", XcdlDescription.class);
    // call function addUpload of ExperimentWrapper
    // method
    CallMethodRule r = new CallMethodRule(1, "addResult", 2);
    // with
    // two
    // params
    // every time */experiment/uploads/upload is encountered
    digester.addRule("*/experiment/results/result", r);
    // use attribute "key" as first param
    digester.addCallParam("*/experiment/results/result", 0, "key");
    // and the object on stack (DigitalObject) as the second
    digester.addCallParam("*/experiment/results/result", 1, true);
    // addCreateUpload(digester,
    // "*/experiment/xcdlDescriptions/xcdlDescription", null,
    // XcdlDescription.class);
    // // call function addXcdlDescription of ExperimentWrapper
    // r = new CallMethodRule(1, "addXcdlDescription", 2); //method with
    // two
    // params
    // // every time */experiment/xcdlDescriptions/xcdlDescription is
    // encountered
    // digester.addRule("*/experiment/xcdlDescriptions/xcdlDescription",
    // r);
    // // use attribute "key" as first param
    // digester.addCallParam("*/experiment/xcdlDescriptions/xcdlDescription",
    // 0 , "key");http://fue.onb.ac.at/abo/data
    // // and the object on stack (DigitalObject) as the second
    // digester.addCallParam("*/experiment/xcdlDescriptions/xcdlDescription",1,true);
    digester.addObjectCreate("*/experiment/detailedInfos/detailedInfo", DetailedExperimentInfo.class);
    digester.addSetProperties("*/experiment/detailedInfos/detailedInfo");
    digester.addBeanPropertySetter("*/experiment/detailedInfos/detailedInfo/programOutput");
    digester.addBeanPropertySetter("*/experiment/detailedInfos/detailedInfo/cpr");
    // call function "addDetailedInfo" of ExperimentWrapper
    // method with two
    r = new CallMethodRule(1, "addDetailedInfo", 2);
    // params
    // every time */experiment/detailedInfos/detailedInfo is encountered
    digester.addRule("*/experiment/detailedInfos/detailedInfo", r);
    // use attribute "key" as first param
    digester.addCallParam("*/experiment/detailedInfos/detailedInfo", 0, "key");
    // and the object on stack as second parameter
    digester.addCallParam("*/experiment/detailedInfos/detailedInfo", 1, true);
    // read contained measurements:
    digester.addObjectCreate("*/detailedInfo/measurements/measurement", Measurement.class);
    digester.addSetProperties("*/detailedInfo/measurements/measurement");
    digester.addSetNext("*/detailedInfo/measurements/measurement", "put");
    // values are defined with wild-cards, and therefore set
    // automatically
    /*
         * for each value type a set of rules because of FreeStringValue we need
         * to store the value as XML-element instead of an attribute naming them
         * "ResultValues" wasn't nice too
         */
    PlanParser.addCreateValue(digester, BooleanValue.class, "setValue");
    PlanParser.addCreateValue(digester, FloatRangeValue.class, "setValue");
    PlanParser.addCreateValue(digester, IntegerValue.class, "setValue");
    PlanParser.addCreateValue(digester, IntRangeValue.class, "setValue");
    PlanParser.addCreateValue(digester, OrdinalValue.class, "setValue");
    PlanParser.addCreateValue(digester, PositiveFloatValue.class, "setValue");
    PlanParser.addCreateValue(digester, PositiveIntegerValue.class, "setValue");
    PlanParser.addCreateValue(digester, YanValue.class, "setValue");
    PlanParser.addCreateValue(digester, FreeStringValue.class, "setValue");
    // go no go decision
    digester.addObjectCreate("*/plan/decision", Decision.class);
    digester.addSetProperties("*/plan/decision");
    digester.addSetNext("*/plan/decision", "setDecision");
    digester.addCallMethod("*/plan/decision/actionNeeded", "setActionNeeded", 0);
    digester.addCallMethod("*/plan/decision/reason", "setReason", 0);
    digester.addFactoryCreate("*/plan/decision/goDecision", GoDecisionFactory.class);
    digester.addSetNext("*/plan/decision/goDecision", "setDecision");
    // evaluation
    digester.addObjectCreate("*/plan/evaluation", Evaluation.class);
    digester.addSetProperties("*/plan/evaluation");
    digester.addSetNext("*/plan/evaluation", "setEvaluation");
    digester.addCallMethod("*/plan/evaluation/comment", "setComment", 0);
    // importance weighting
    digester.addObjectCreate("*/plan/importanceWeighting", ImportanceWeighting.class);
    digester.addSetProperties("*/plan/importanceWeighting");
    digester.addSetNext("*/plan/importanceWeighting", "setImportanceWeighting");
    digester.addCallMethod("*/plan/importanceWeighting/comment", "setComment", 0);
    // recommendation
    digester.addObjectCreate("*/plan/recommendation", RecommendationWrapper.class);
    digester.addSetProperties("*/plan/recommendation");
    digester.addSetNext("*/plan/recommendation", "setRecommendation");
    digester.addCallMethod("*/plan/recommendation/reasoning", "setReasoning", 0);
    digester.addCallMethod("*/plan/recommendation/effects", "setEffects", 0);
    // transformation
    digester.addObjectCreate("*/plan/transformation", Transformation.class);
    digester.addSetProperties("*/plan/transformation");
    digester.addSetNext("*/plan/transformation", "setTransformation");
    digester.addCallMethod("*/plan/transformation/comment", "setComment", 0);
    // Tree
    /*
         * Some rules for tree parsing are necessary for importing templates
         * too, that's why they are added by this static method.
         */
    PlanParser.addTreeParsingRulesToDigester(digester);
    digester.addObjectCreate("*/leaf/evaluation", HashMap.class);
    digester.addSetNext("*/leaf/evaluation", "setValueMap");
    /*
         * The valueMap has an entry for each (considered) alternative ... and
         * for each alternative there is a list of values, one per SampleObject.
         * Note: The digester uses a stack, therefore the rule to put the list
         * of values to the valueMap must be added after the rule for adding the
         * values to the list.
         */
    /*
         * 2. and for each alternative there is a list of values, one per
         * SampleObject
         */
    digester.addObjectCreate("*/leaf/evaluation/alternative", Values.class);
    digester.addCallMethod("*/leaf/evaluation/alternative/comment", "setComment", 0);
    /*
         * for each result-type a set of rules they are added to the valueMap by
         * the rules above
         */
    PlanParser.addCreateResultValue(digester, BooleanValue.class);
    PlanParser.addCreateResultValue(digester, FloatValue.class);
    PlanParser.addCreateResultValue(digester, FloatRangeValue.class);
    PlanParser.addCreateResultValue(digester, IntegerValue.class);
    PlanParser.addCreateResultValue(digester, IntRangeValue.class);
    PlanParser.addCreateResultValue(digester, OrdinalValue.class);
    PlanParser.addCreateResultValue(digester, PositiveFloatValue.class);
    PlanParser.addCreateResultValue(digester, PositiveIntegerValue.class);
    PlanParser.addCreateResultValue(digester, YanValue.class);
    PlanParser.addCreateResultValue(digester, FreeStringValue.class);
    /*
         * 1. The valueMap has an entry for each (considered) alternative ...
         */
    // call put of the ValueMap (HashMap)
    r = new CallMethodRule(1, "put", 2);
    digester.addRule("*/leaf/evaluation/alternative", r);
    digester.addCallParam("*/leaf/evaluation/alternative", 0, "key");
    digester.addCallParam("*/leaf/evaluation/alternative", 1, true);
    // digester.addObjectCreate("*/plan/executablePlan/planWorkflow",
    // ExecutablePlanContentWrapper.class);
    // digester.addSetProperties("*/plan/executablePlan/planWorkflow");
    // digester.addSetNext("*/plan/executablePlan/planWorkflow",
    // "setRecommendation");
    // Executable plan definition
    digester.addObjectCreate("*/plan/executablePlan", ExecutablePlanDefinition.class);
    digester.addSetProperties("*/plan/executablePlan");
    digester.addCallMethod("*/plan/executablePlan/objectPath", "setObjectPath", 0);
    digester.addCallMethod("*/plan/executablePlan/toolParameters", "setToolParameters", 0);
    digester.addCallMethod("*/plan/executablePlan/triggersConditions", "setTriggersConditions", 0);
    digester.addCallMethod("*/plan/executablePlan/validateQA", "setValidateQA", 0);
    PlanParser.addCreateUpload(digester, "*/plan/executablePlan/workflow", "setT2flowExecutablePlan", DigitalObject.class);
    digester.addSetNext("*/plan/executablePlan", "setExecutablePlanDefinition");
    // Preservation action plan
    digester.addObjectCreate("*/plan/preservationActionPlan", DigitalObject.class);
    digester.addSetNext("*/plan/preservationActionPlan", "setPreservationActionPlan");
    digester.addCallMethod("*/plan/preservationActionPlan", "setContentType", 1);
    digester.addObjectParam("*/plan/preservationActionPlan", 0, "application/xml");
    digester.addCallMethod("*/plan/preservationActionPlan", "setFullname", 1);
    digester.addObjectParam("*/plan/preservationActionPlan", 0, PreservationActionPlanGenerator.FULL_NAME);
    digester.addSetNext("*/plan/preservationActionPlan", "setPreservationActionPlan");
    PlanParser.addCreateXMLData(digester, "*/plan/preservationActionPlan", "setData", "setChangeLog");
    //
    // Import Planets executable plan if present
    //
    // object-create rules are called at the beginning element-tags, in
    // the
    // same order as defined
    // first create the wrapper
    // digester.addObjectCreate("*/plan/executablePlan/planWorkflow",
    // NodeContentWrapper.class);
    // // then an element for workflowConf
    // digester.addRule("*/plan/executablePlan/planWorkflow/workflowConf",
    // new NodeCreateRule());
    //
    // // CallMethod and SetNext rules are called at closing element-tags,
    // // (last
    // // in - first out!)
    //
    // CallMethodRule rr = new CallMethodRule(1, "setNodeContent", 2);
    // digester.addRule("*/plan/executablePlan/planWorkflow/workflowConf",
    // rr);
    // // right below the wrapper is an instance of
    // // ExecutablePlanDefinition
    // digester.addCallParam("*/plan/executablePlan/planWorkflow/workflowConf",
    // 0, 1);
    // // provide the name of the setter method
    // digester.addObjectParam("*/plan/executablePlan/planWorkflow/workflowConf",
    // 1, "setExecutablePlan");
    //
    // // the generated node is not accessible as CallParam (why?!?), but
    // // available for addSetNext
    // digester.addSetNext("*/plan/executablePlan/planWorkflow/workflowConf",
    // "setNode");
    //
    // //
    // // Import EPrints executable plan if present
    // //
    // digester.addObjectCreate("*/plan/executablePlan/eprintsPlan",
    // NodeContentWrapper.class);
    // // then an element for workflowConf
    // digester.addRule("*/plan/executablePlan/eprintsPlan", new
    // NodeCreateRule());
    //
    // CallMethodRule rr2 = new CallMethodRule(1,
    // "setNodeContentEPrintsPlan", 2);
    // digester.addRule("*/plan/executablePlan/eprintsPlan", rr2);
    // // right below the wrapper is an instance of
    // // ExecutablePlanDefinition
    // digester.addCallParam("*/plan/executablePlan/eprintsPlan", 0, 1);
    // // provide the name of the setter method
    // digester.addObjectParam("*/plan/executablePlan/eprintsPlan", 1,
    // "setEprintsExecutablePlan");
    // digester.addSetNext("*/plan/executablePlan/eprintsPlan", "setNode");
    // Plan definition
    digester.addObjectCreate("*/plan/planDefinition", PlanDefinition.class);
    digester.addSetProperties("*/plan/planDefinition");
    digester.addSetNext("*/plan/planDefinition", "setPlanDefinition");
    digester.addCallMethod("*/plan/planDefinition/costsIG", "setCostsIG", 0);
    digester.addCallMethod("*/plan/planDefinition/costsPA", "setCostsPA", 0);
    digester.addCallMethod("*/plan/planDefinition/costsPE", "setCostsPE", 0);
    digester.addCallMethod("*/plan/planDefinition/costsQA", "setCostsQA", 0);
    digester.addCallMethod("*/plan/planDefinition/costsREI", "setCostsREI", 0);
    digester.addCallMethod("*/plan/planDefinition/costsRemarks", "setCostsRemarks", 0);
    digester.addCallMethod("*/plan/planDefinition/costsRM", "setCostsRM", 0);
    digester.addCallMethod("*/plan/planDefinition/costsTCO", "setCostsTCO", 0);
    digester.addCallMethod("*/plan/planDefinition/responsibleExecution", "setResponsibleExecution", 0);
    digester.addCallMethod("*/plan/planDefinition/responsibleMonitoring", "setResponsibleMonitoring", 0);
    digester.addObjectCreate("*/plan/planDefinition/triggers", TriggerDefinition.class);
    digester.addSetNext("*/plan/planDefinition/triggers", "setTriggers");
    // every time a */plan/basis/triggers/trigger is encountered:
    digester.addFactoryCreate("*/plan/planDefinition/triggers/trigger", TriggerFactory.class);
    digester.addSetNext("*/plan/planDefinition/triggers/trigger", "setTrigger");
}

@Override
public String convert(Object value) {
    return ConvertUtils.convert(value);
}

@Override
public String convert(Object value) {
    return ConvertUtils.convert(value);
}

/**
     * convert element String to Object.
     * 
     * @param value
     *            String
     * @param toType
     *            Class
     * @return Object
     */
public static Object convertStringToObject(String value, Class<?> toType) {
    return org.apache.commons.beanutils.ConvertUtils.convert(value, toType);
}

/**
	 * 转�字符串到相应类型.
	 * 
	 * @param value 待转�的字符串.
	 * @param toType 转�目标类型.
	 */
public static Object convertStringToObject(String value, Class<?> toType) {
    try {
        return org.apache.commons.beanutils.ConvertUtils.convert(value, toType);
    } catch (Exception e) {
        throw ReflectionUtils.convertReflectionExceptionToUnchecked(e);
    }
}

/**
	 * 转�字符串到相应类型.
	 * 
	 * @param value 待转�的字符串.
	 * @param toType 转�目标类型.
	 */
public static Object convertStringToObject(String value, Class<?> toType) {
    try {
        return org.apache.commons.beanutils.ConvertUtils.convert(value, toType);
    } catch (Exception e) {
        throw ReflectionUtils.convertReflectionExceptionToUnchecked(e);
    }
}

public static <V> V getValue(Object target, String name, Class<V> type) {
    return type.cast(ConvertUtils.convert(getValue(target, name), type));
}

public static void SetupDateConverters() {
    DateTimeConverter dtConverter = new DateConverter(null);
    dtConverter.setPatterns(new String[] { "yyyy-MM-dd", "yyyy-MM-dd hh:mm:ss" });
    ConvertUtils.register(dtConverter, Date.class);
}

protected Object instantiateValueForField(FieldProperty property) {
    for (Generator generator : generators) {
        if (generator.canGenerate(property)) {
            return ConvertUtils.convert(generator.generate(property), property.getType());
        }
    }
    return null;
}

/**
	 * Delegates to {@link ConvertUtils#lookup(java.lang.Class)} to create a 
	 * converter instance.
	 * 
	 * @see ConverterFactory#createConverter(Class, Class, Hints). 
	 */
public Converter createConverter(Class source, Class target, Hints hints) {
    //only do strings
    if (source.equals(String.class)) {
        org.apache.commons.beanutils.Converter converter = ConvertUtils.lookup(target);
        if (converter != null) {
            return new CommonsConverterWrapper(converter);
        }
    }
    return null;
}

@Override
public Object convert(IFormulaContext context, ASTBaseNode[] nodes, int pos) {
    if (pos >= nodes.length) {
        // get the default value as specified by the converters
        return ConvertUtils.convert((String) null, paramType);
    }
    IGenericValue value = nodes[pos].eval(context);
    return GenericValueUtils.convert(value, paramType);
}

@Override
public String getString(int columnIndex) throws SQLException {
    //		return (String) getObject(columnIndex);
    return ConvertUtils.convert(getObject(columnIndex));
}