Map>
- Class -> convert to class
- Map
- String -> property name
eg. Element_property, property etc.
- Object -> String to represent properties
eg. value part of
KeyProperty_property=id
-> TypeConverter to represent an Ognl TypeConverter
eg. value part of
property=foo.bar.MyConverter
-> Class to represent a class
eg. value part of
Element_property=foo.bar.MyObject

- String - classname as String
- TypeConverter - instance of TypeConverter

- String -> classname as String

 protected XWorkConverter() 
{

}

  void addConverterMapping(Map mapping,
    Class clazz) 
{
        try {
            String converterFilename = buildConverterFilename(clazz);
            InputStream is = FileManager.loadFile(converterFilename, clazz);
            if (is != null) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug("processing conversion file ["+converterFilename+"] [class="+clazz+"]");
                }
                Properties prop = new Properties();
                prop.load(is);
                Iterator it = prop.entrySet().iterator();
                while (it.hasNext()) {
                    Map.Entry entry = (Map.Entry) it.next();
                    String key = (String) entry.getKey();
                    if (mapping.containsKey(key)) {
                        break;
                    }
                    // for keyProperty of Set
                    if (key.startsWith(DefaultObjectTypeDeterminer.KEY_PROPERTY_PREFIX)
                            || key.startsWith(DefaultObjectTypeDeterminer.CREATE_IF_NULL_PREFIX)) {
                        if (LOG.isDebugEnabled()) {
                            LOG.debug("\t"+key + ":" + entry.getValue()+"[treated as String]");
                        }
                        mapping.put(key, entry.getValue());
                    }
                    //for properties of classes
                    else if (!(key.startsWith(DefaultObjectTypeDeterminer.ELEMENT_PREFIX) ||
                            key.startsWith(DefaultObjectTypeDeterminer.KEY_PREFIX) ||
                            key.startsWith(DefaultObjectTypeDeterminer.DEPRECATED_ELEMENT_PREFIX))
                            ) {
                        TypeConverter _typeConverter = createTypeConverter((String) entry.getValue());
                        if (LOG.isDebugEnabled()) {
                            LOG.debug("\t"+key + ":" + entry.getValue()+"[treated as TypeConverter "+_typeConverter+"]");
                        }
                        mapping.put(key, _typeConverter);
                    }
                    //for keys of Maps
                    else if (key.startsWith(DefaultObjectTypeDeterminer.KEY_PREFIX)) {
                        Class converterClass = Thread.currentThread().getContextClassLoader().loadClass((String) entry.getValue());
                        //check if the converter is a type converter if it is one
                        //then just put it in the map as is. Otherwise
                        //put a value in for the type converter of the class
                        if (converterClass.isAssignableFrom(TypeConverter.class)) {
                            TypeConverter _typeConverter = createTypeConverter((String) entry.getValue());
                            if (LOG.isDebugEnabled()) {
                                LOG.debug("\t"+key + ":" + entry.getValue()+"[treated as TypeConverter "+_typeConverter+"]");
                            }
                            mapping.put(key, _typeConverter);
                        } else {
                            if (LOG.isDebugEnabled()) {
                                LOG.debug("\t"+key + ":" + entry.getValue()+"[treated as Class "+converterClass+"]");
                            }
                            mapping.put(key, converterClass);
                        }
                    }
                    //elements(values) of maps / lists
                    else {
                        Class _c = Thread.currentThread().getContextClassLoader().loadClass((String) entry.getValue());
                        if (LOG.isDebugEnabled()) {
                            LOG.debug("\t"+key + ":" + entry.getValue()+"[treated as Class "+_c+"]");
                        }
                        mapping.put(key, _c);
                    }
                }
            }
        } catch (Exception ex) {
            LOG.error("Problem loading properties for " + clazz.getName(), ex);
        }
        // Process annotations
        Annotation[] annotations = clazz.getAnnotations();
        for (Annotation annotation : annotations) {
            if (annotation instanceof Conversion) {
                Conversion conversion = (Conversion) annotation;
                for (TypeConversion tc : conversion.conversions()) {
                    String key = tc.key();
                    if (mapping.containsKey(key)) {
                        break;
                    }
                    if (LOG.isDebugEnabled()) {
                        LOG.debug(key + ":" + key);
                    }
                    if (key != null) {
                        try {
                        	if (tc.type()  == ConversionType.APPLICATION) {
                                defaultMappings.put(key, createTypeConverter(tc.converter()));
                            } else {
                                if (tc.rule().toString().equals(ConversionRule.KEY_PROPERTY) || tc.rule().toString().equals(ConversionRule.CREATE_IF_NULL)) {
                                    mapping.put(key, tc.value());
                                }
                                //for properties of classes
                                else if (!(tc.rule().toString().equals(ConversionRule.ELEMENT.toString())) ||
                                        tc.rule().toString().equals(ConversionRule.KEY.toString()) ||
                                        tc.rule().toString().equals(ConversionRule.COLLECTION.toString())
                                        ) {
                                    mapping.put(key, createTypeConverter(tc.converter()));
                                }
                                //for keys of Maps
                                else if (tc.rule().toString().equals(ConversionRule.KEY.toString())) {
                                    Class converterClass = Thread.currentThread().getContextClassLoader().loadClass(tc.converter());
                                    if (LOG.isDebugEnabled()) {
                                        LOG.debug("Converter class: " + converterClass);
                                    }
                                    //check if the converter is a type converter if it is one
                                    //then just put it in the map as is. Otherwise
                                    //put a value in for the type converter of the class
                                    if (converterClass.isAssignableFrom(TypeConverter.class)) {
                                        mapping.put(key, createTypeConverter(tc.converter()));
                                    } else {
                                        mapping.put(key, converterClass);
                                        if (LOG.isDebugEnabled()) {
                                            LOG.debug("Object placed in mapping for key "
                                                    + key
                                                    + " is "
                                                    + mapping.get(key));
                                        }
                                    }
                                }
                                //elements(values) of maps / lists
                                else {
                                    mapping.put(key, Thread.currentThread().getContextClassLoader().loadClass(tc.converter()));
                                }
                            }
                        } catch (Exception e) {
                        }
                    }
                }
            }
        }
        Method[] methods = clazz.getMethods();
        for (Method method : methods) {
            annotations = method.getAnnotations();
            for (Annotation annotation : annotations) {
                if (annotation instanceof TypeConversion) {
                    TypeConversion tc = (TypeConversion) annotation;
                    String key = tc.key();
                    if (mapping.containsKey(key)) {
                        break;
                    }
                    // Default to the property name
                    if ( key != null && key.length() == 0) {
                        key = AnnotationUtils.resolvePropertyName(method);
                        LOG.debug("key from method name... " + key + " - " + method.getName());
                    }
                    if (LOG.isDebugEnabled()) {
                        LOG.debug(key + ":" + key);
                    }
                    if (key != null) {
                        try {
                        	if (tc.type() == ConversionType.APPLICATION) {
                                defaultMappings.put(key, createTypeConverter(tc.converter()));
                            } else {
                                if (tc.rule().toString().equals(ConversionRule.KEY_PROPERTY)) {
                                    mapping.put(key, tc.value());
                                }
                                //for properties of classes
                                else if (!(tc.rule().toString().equals(ConversionRule.ELEMENT.toString())) ||
                                        tc.rule().toString().equals(ConversionRule.KEY.toString()) ||
                                        tc.rule().toString().equals(ConversionRule.COLLECTION.toString())
                                        ) {
                                    mapping.put(key, createTypeConverter(tc.converter()));
                                }
                                //for keys of Maps
                                else if (tc.rule().toString().equals(ConversionRule.KEY.toString())) {
                                    Class converterClass = Thread.currentThread().getContextClassLoader().loadClass(tc.converter());
                                    if (LOG.isDebugEnabled()) {
                                        LOG.debug("Converter class: " + converterClass);
                                    }
                                    //check if the converter is a type converter if it is one
                                    //then just put it in the map as is. Otherwise
                                    //put a value in for the type converter of the class
                                    if (converterClass.isAssignableFrom(TypeConverter.class)) {
                                        mapping.put(key, createTypeConverter(tc.converter()));
                                    } else {
                                        mapping.put(key, converterClass);
                                        if (LOG.isDebugEnabled()) {
                                            LOG.debug("Object placed in mapping for key "
                                                    + key
                                                    + " is "
                                                    + mapping.get(key));
                                        }
                                    }
                                }
                                //elements(values) of maps / lists
                                else {
                                    mapping.put(key, Thread.currentThread().getContextClassLoader().loadClass(tc.converter()));
                                }
                            }
                        } catch (Exception e) {
                        }
                    }
                }
            }
        }
}

Looks for converter mappings for the specified class and adds it to an existing map. Only new converters are added. If a converter is defined on a key that already exists, the converter is ignored.

 public static String buildConverterFilename(Class clazz) 
{
        String className = clazz.getName();
        String resource = className.replace('.", '/") + "-conversion.properties";
        return resource;
}

 public Object convertValue(Map map,
    Object o,
    Class aClass) 
{
        return convertValue(map, null, null, null, o, aClass);
}

 public Object convertValue(Map context,
    Object target,
    Member member,
    String property,
    Object value,
    Class toClass) 
{
        //
        // Process the conversion using the default mappings, if one exists
        //
        TypeConverter tc = null;
        if ((value != null) && (toClass == value.getClass())) {
            return value;
        }
        // allow this method to be called without any context
        // i.e. it can be called with as little as "Object value" and "Class toClass"
        if (target != null) {
            Class clazz = target.getClass();
            Object[] classProp = null;
            // this is to handle weird issues with setValue with a different type
            if ((target instanceof CompoundRoot) && (context != null)) {
                classProp = getClassProperty(context);
            }
            if (classProp != null) {
                clazz = (Class) classProp[0];
                property = (String) classProp[1];
            }
            tc = (TypeConverter) getConverter(clazz, property);
            if (LOG.isDebugEnabled())
                LOG.debug("field-level type converter for property ["+property+"] = "+(tc==null?"none found":tc));
        }
        if (tc == null && context != null) {
            // ok, let's see if we can look it up by path as requested in XW-297
            Object lastPropertyPath = context.get(ReflectionContextState.CURRENT_PROPERTY_PATH);
            Class clazz = (Class) context.get(XWorkConverter.LAST_BEAN_CLASS_ACCESSED);
            if (lastPropertyPath != null && clazz != null) {
                String path = lastPropertyPath + "." + property;
                tc = (TypeConverter) getConverter(clazz, path);
            }
        }
        if (tc == null) {
            if (toClass.equals(String.class) && (value != null) && !(value.getClass().equals(String.class) || value.getClass().equals(String[].class)))
            {
                // when converting to a string, use the source target's class's converter
                tc = lookup(value.getClass());
            } else {
                // when converting from a string, use the toClass's converter
                tc = lookup(toClass);
            }
            if (LOG.isDebugEnabled())
                LOG.debug("global-level type converter for property ["+property+"] = "+(tc==null?"none found":tc));
        }
        if (tc != null) {
            try {
                return tc.convertValue(context, target, member, property, value, toClass);
            } catch (Exception e) {
                e.printStackTrace();
                handleConversionException(context, property, value, target);
                return TypeConverter.NO_CONVERSION_POSSIBLE;
            }
        }
        if (defaultTypeConverter != null) {
            try {
                if (LOG.isDebugEnabled())
                    LOG.debug("falling back to default type converter ["+defaultTypeConverter+"]");
                return defaultTypeConverter.convertValue(context, target, member, property, value, toClass);
            } catch (Exception e) {
                e.printStackTrace();
                handleConversionException(context, property, value, target);
                return TypeConverter.NO_CONVERSION_POSSIBLE;
            }
        } else {
            try {
                if (LOG.isDebugEnabled())
                    LOG.debug("falling back to Ognl's default type conversion");
                return super.convertValue(value, toClass);
            } catch (Exception e) {
                e.printStackTrace();
                handleConversionException(context, property, value, target);
                return TypeConverter.NO_CONVERSION_POSSIBLE;
            }
        }
}

Convert value from one form to another. Minimum requirement of arguments:
• supplying context, toClass and value
• supplying context, target and value.

 TypeConverter createTypeConverter(String className) throws Exception 
{
        // type converters are used across users
        Object obj = objectFactory.buildBean(className, null);
        if (obj instanceof TypeConverter) {
            return (TypeConverter) obj;
        // For backwards compatibility
        } else if (obj instanceof ognl.TypeConverter) {
            return new XWorkTypeConverterWrapper((ognl.TypeConverter)obj);
        } else {
            throw new IllegalArgumentException("Type converter class "+obj.getClass()+" doesn't implement com.opensymphony.xwork2.conversion.TypeConverter");
        }
}

 public static String getConversionErrorMessage(String propertyName,
    ValueStack stack) 
{
        String defaultMessage = LocalizedTextUtil.findDefaultText(XWorkMessages.DEFAULT_INVALID_FIELDVALUE,
                ActionContext.getContext().getLocale(),
                new Object[]{
                        propertyName
                });
        String getTextExpression = "getText('" + CONVERSION_ERROR_PROPERTY_PREFIX + propertyName + "','" + defaultMessage + "')";
        String message = (String) stack.findValue(getTextExpression);
        if (message == null) {
            message = defaultMessage;
        }
        return message;
}

 protected Object getConverter(Class clazz,
    String property) 
{
        if (LOG.isDebugEnabled()) {
            LOG.debug("Property: " + property);
            LOG.debug("Class: " + clazz.getName());
        }
        synchronized (clazz) {
            if ((property != null) && !noMapping.contains(clazz)) {
                try {
                    Map< String, Object > mapping = mappings.get(clazz);
                    if (mapping == null) {
                        mapping = buildConverterMapping(clazz);
                    } else {
                        mapping = conditionalReload(clazz, mapping);
                    }
                    Object converter = mapping.get(property);
                    if (LOG.isDebugEnabled() && converter == null) {
                        LOG.debug("converter is null for property " + property + ". Mapping size: " + mapping.size());
                        Iterator< String > iter = mapping.keySet().iterator();
                        while (iter.hasNext()) {
                            String next = iter.next();
                            LOG.debug(next + ":" + mapping.get(next));
                        }
                    }
                    return converter;
                } catch (Throwable t) {
                    noMapping.add(clazz);
                }
            }
        }
        return null;
}

 protected  void handleConversionException(Map context,
    String property,
    Object value,
    Object object) 
{
        if ((Boolean.TRUE.equals(context.get(REPORT_CONVERSION_ERRORS)))) {
            String realProperty = property;
            String fullName = (String) context.get(CONVERSION_PROPERTY_FULLNAME);
            if (fullName != null) {
                realProperty = fullName;
            }
            Map conversionErrors = (Map) context.get(ActionContext.CONVERSION_ERRORS);
            if (conversionErrors == null) {
                conversionErrors = new HashMap();
                context.put(ActionContext.CONVERSION_ERRORS, conversionErrors);
            }
            conversionErrors.put(realProperty, value);
        }
}

 public  void loadConversionProperties(String propsName) throws IOException 
{
        Iterator< URL > resources = ClassLoaderUtil.getResources(propsName, getClass(), true);
        while (resources.hasNext()) {
            URL url = resources.next();
        Properties props = new Properties();
            props.load(url.openStream());
        if (LOG.isDebugEnabled()) {
            LOG.debug("processing conversion file ["+propsName+"]");
        }
            for (Iterator iterator = props.entrySet().iterator(); iterator.hasNext();) {
            Map.Entry entry = (Map.Entry) iterator.next();
            String key = (String) entry.getKey();
            try {
                TypeConverter _typeConverter = createTypeConverter((String) entry.getValue());
                if (LOG.isDebugEnabled()) {
                    LOG.debug("\t"+key + ":" + entry.getValue()+" [treated as TypeConverter "+_typeConverter+"]");
                }
                defaultMappings.put(key, _typeConverter);
            } catch (Exception e) {
                LOG.error("Conversion registration error", e);
            }
        }
    }
}

 public TypeConverter lookup(String className) 
{
        if (unknownMappings.contains(className) && !defaultMappings.containsKey(className)) {
            return null;
        }
        TypeConverter result = (TypeConverter) defaultMappings.get(className);
        //Looks for super classes
        if (result == null) {
            Class clazz = null;
            try {
                clazz = Thread.currentThread().getContextClassLoader().loadClass(className);
            } catch (ClassNotFoundException cnfe) {
            }
            result = lookupSuper(clazz);
            if (result != null) {
                //Register now, the next lookup will be faster
                registerConverter(className, result);
            } else {
                // if it isn't found, never look again (also faster)
                registerConverterNotFound(className);
            }
        }
        return result;
}

Looks for a TypeConverter in the default mappings.

 public TypeConverter lookup(Class clazz) 
{
        return lookup(clazz.getName());
}

Looks for a TypeConverter in the default mappings.

 TypeConverter lookupSuper(Class clazz) 
{
        TypeConverter result = null;
        if (clazz != null) {
            result = (TypeConverter) defaultMappings.get(clazz.getName());
            if (result == null) {
                // Looks for direct interfaces (depth = 1 )
                Class[] interfaces = clazz.getInterfaces();
                for (int i = 0; i <  interfaces.length; i++) {
                    if (defaultMappings.containsKey(interfaces[i].getName())) {
                        result = (TypeConverter) defaultMappings.get(interfaces[i].getName());
                        break;
                    }
                }
                if (result == null) {
                    // Looks for the superclass
                    // If 'clazz' is the Object class, an interface, a primitive type or void then clazz.getSuperClass() returns null
                    result = lookupSuper(clazz.getSuperclass());
                }
            }
        }
        return result;
}

Recurses through a class' interfaces and class hierarchy looking for a TypeConverter in the default mapping that can handle the specified class.

 public synchronized  void registerConverter(String className,
    TypeConverter converter) 
{
        defaultMappings.put(className, converter);
        if ( unknownMappings.contains(className)) {
            unknownMappings.remove(className);
        }
}

 public synchronized  void registerConverterNotFound(String className) 
{
        unknownMappings.add(className);
}

 public  void setDefaultTypeConverter(XWorkBasicConverter conv) 
{
        this.defaultTypeConverter = conv;
}

 public  void setObjectFactory(ObjectFactory factory) 
{
        this.objectFactory = factory;
        try {
            // note: this file is deprecated
            loadConversionProperties("xwork-default-conversion.properties");
        } catch (Exception e) {
        }
        try {
            loadConversionProperties("xwork-conversion.properties");
        } catch (Exception e) {
        }
}