Index: src/main/org/exolab/castor/mapping/loader/FieldHandlerImpl.java
===================================================================
RCS file: /cvs/castor/castor/src/main/org/exolab/castor/mapping/loader/FieldHandlerImpl.java,v
retrieving revision 1.2
diff -u -p -d -r1.2 FieldHandlerImpl.java
--- a/src/main/org/exolab/castor/mapping/loader/FieldHandlerImpl.java	16 Apr 2003 07:15:35 -0000	1.2
+++ b/src/main/org/exolab/castor/mapping/loader/FieldHandlerImpl.java	23 Oct 2004 11:36:41 -0000
@@ -49,17 +49,18 @@ package org.exolab.castor.mapping.loader
 
 import java.lang.reflect.Array;
 import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
-import java.lang.reflect.InvocationTargetException;
+import java.util.Vector;
+
 import org.exolab.castor.mapping.AbstractFieldHandler;
+import org.exolab.castor.mapping.CollectionHandler;
 import org.exolab.castor.mapping.ExtendedFieldHandler;
 import org.exolab.castor.mapping.FieldHandler;
-import org.exolab.castor.mapping.TypeConvertor;
-import org.exolab.castor.mapping.CollectionHandler;
 import org.exolab.castor.mapping.MappingException;
 import org.exolab.castor.mapping.MappingRuntimeException;
-import org.exolab.castor.mapping.ValidityException;
+import org.exolab.castor.mapping.TypeConvertor;
 import org.exolab.castor.util.Messages;
 
 
@@ -78,8 +79,6 @@ import org.exolab.castor.util.Messages;
 public final class FieldHandlerImpl
     extends AbstractFieldHandler
 {
-
-
     /**
      * The prefix for an "add" method
     **/
@@ -95,62 +94,62 @@ public final class FieldHandlerImpl
     /**
      * The Java field described and accessed through this descriptor.
      */
-    private final Field   _field;
+    private final Field	_field;
 
 
     /**
      * The sequence of methods used to obtain the nested field. May be null.
      */
-    private Method[]      _getSequence;
+    private Method[]	_getSequence;
 
 
     /**
      * The sequence of methods used to create the nested object. May be null.
      */
-    private Method[]      _setSequence;
+    private Method[]	_setSequence;
 
 
     /** 
       * The method used to "incrementally" set the value of this field.  
       * This is only used if the field is a collection 
       */ 
-    private Method        _addMethod; 
+    private Vector		_addMethods; 
 
 
     /**
      * The method used to obtain the value of this field. May be null.
      */
-    private Method        _getMethod;
+    private Method      _getMethod;
 
 
     /**
-     * The method used to set the value of this field. May be null.
+     * The available methods to be used to set the value of this field. May be null.
      */
-    private Method        _setMethod;
+    private Vector		_setMethods;
 
 
     /**
      * The method used to check if the value of this field exists. May be null.
      */
-    private Method  _hasMethod;
+    private Method		_hasMethod;
 
 
     /**
      * The method used to delete the value of this field. May be null.
      */
-    private Method  _deleteMethod;
+    private Method		_deleteMethod;
 
 
     /**
      * The method used to create a new instance of the field.
      */
-    private Method  _createMethod;
+    private Method		_createMethod;
 
 
     /**
      * The Java field name.
      */
-    private final String  _fieldName;
+    private final String _fieldName;
 
 
     /**
@@ -281,14 +280,14 @@ public final class FieldHandlerImpl
      *  must accept no parameters and have a return type castable to
      *  the field type
      * @param setMethod The method used to set the field value, must
-     *  accept a single paramater that is castable to the field type
+     *  accept a single parameter that is castable to the field type
      * @param typeInfo Type information
      * @throws MappingException If the get or set method are not public,
      *   are static, or do not specify the proper types
      *
      */
     public FieldHandlerImpl( String fieldName, Method[] getSequence, Method[] setSequence, 
-                             Method getMethod, Method setMethod, TypeInfo typeInfo )
+                             Method getMethod, Vector setMethods, TypeInfo typeInfo )
         throws MappingException
     {
         _handler = null;
@@ -303,18 +302,29 @@ public final class FieldHandlerImpl
         _getSequence = getSequence;
         _setSequence = setSequence;
 
-        if ( setMethod != null ) {
-            //-- might be an "add" method
-            if ( setMethod.getName().startsWith(ADD_PREFIX) ) {
-                Class pType = setMethod.getParameterTypes()[0];
-                if (pType != typeInfo.getFieldType() )
-                    setAddMethod (setMethod);
-                else 
-                    setWriteMethod(setMethod);
+        if (setMethods!=null && !setMethods.isEmpty()) {
+            //-- There might be "add" methods.
+            Vector addMethods = new Vector();
+
+            for(int i=0; i<setMethods.size(); ++i) {
+                Method method = (Method) setMethods.get(i);
+
+	            if (method.getName().startsWith(ADD_PREFIX)) {
+	                Class paraType = method.getParameterTypes()[0];
+
+	                if (paraType != typeInfo.getFieldType()) {
+	                    addMethods.add(setMethods.remove(i));
+	                    --i;
+	                }
+	            }
             }
-            else setWriteMethod( setMethod );
+
+            setWriteMethods(setMethods);
+
+            if (!addMethods.isEmpty())
+                setAddMethods(addMethods);
         }
-        
+
         if ( getMethod != null )
             setReadMethod(getMethod);
         
@@ -322,12 +332,18 @@ public final class FieldHandlerImpl
         _fieldName = fieldName + "(" + _fieldType.getName() + ")";
         _immutable = typeInfo.isImmutable();
         _required = typeInfo.isRequired();
+
         // If the field is of a primitive type or if it is required
         // we use the default value 
-        if ( setMethod != null && setMethod.getParameterTypes()[0].isPrimitive() )
-            _default = typeInfo.getDefaultValue();
-        else
-            _default = null;
+        Object def = null;
+        if ( setMethods != null )
+            for(int i=0; i<setMethods.size(); ++i)
+                if (((Method)setMethods.get(i)).getParameterTypes()[0].isPrimitive()) {
+                    def = typeInfo.getDefaultValue();
+        			break;
+    			}
+        _default = def;
+
         _convertTo = typeInfo.getConvertorTo();
         _convertFrom = typeInfo.getConvertorFrom();
         _convertParam = typeInfo.getConvertorParam();
@@ -407,7 +423,7 @@ public final class FieldHandlerImpl
 
     public void setValue( Object object, Object value )
     {
-        if ( _colHandler == null || _addMethod != null) {
+        if ( _colHandler == null || (_addMethods!=null && !_addMethods.isEmpty()) ) {
 
             // If there is a convertor, apply conversion here.
             if ( value != null && _convertTo != null ) {
@@ -570,8 +586,12 @@ public final class FieldHandlerImpl
                     //-- the new collection is not null
                     if (tmp != null) collect = tmp;
 
-                    if ( setCollection && (_setMethod != null))
-                        _setMethod.invoke( object, new Object[] { collect } );
+                    if ( setCollection ) {
+                        Method setter = selectMethod(_setMethods, collect);
+
+                        if (setter != null)
+                            setter.invoke( object, new Object[] { collect } );
+                    }
                 }                
             } catch ( IllegalAccessException except ) {
                 // This should never happen
@@ -580,7 +600,6 @@ public final class FieldHandlerImpl
                 // This should never happen
                 throw new MappingRuntimeException(except.getTargetException());
             }
-
         }
     }
 
@@ -594,7 +613,7 @@ public final class FieldHandlerImpl
                     _handler.resetValue( object );
                 else if ( _field != null )
                     _field.set( object, _default );
-                else if ( _setMethod != null ) {
+                else if ( _setMethods != null ) {
                     if ( _getSequence != null ) 
                         for ( int i = 0; i < _getSequence.length; i++ ) {
                             object = _getSequence[ i ].invoke( object, null );
@@ -604,8 +623,12 @@ public final class FieldHandlerImpl
                     if ( object != null ) {
                         if ( _deleteMethod != null )
                             _deleteMethod.invoke( object, null );
-                        else
-                            _setMethod.invoke( object, new Object[] { _default } );
+                        else {
+                            Method setter = selectMethod(_setMethods, _default);
+
+                            if (setter != null)
+                                setter.invoke( object, new Object[] { _default } );
+                        }
                     }
                 }
                 // If the field has no set method, ignore it.
@@ -641,8 +664,12 @@ public final class FieldHandlerImpl
                             object = _getSequence[ i ].invoke( object, null );
                     collect = _getMethod.invoke( object, null );
                     collect = _colHandler.clear( collect );
-                    if ( collect != null && _setMethod != null)
-                        _setMethod.invoke( object, new Object[] { collect } );
+                    if ( collect != null ) {
+                        Method setter = selectMethod(_setMethods, collect);
+
+                        if (setter != null)
+                            setter.invoke( object, new Object[] { collect } );
+                    }
                 }                
             } catch ( IllegalAccessException except ) {
                 // This should never happen
@@ -813,17 +840,22 @@ public final class FieldHandlerImpl
      * Please understand how this method is used before you start
      * playing with it! :-)
      */
-    public void setWriteMethod( Method method )
+    public void setWriteMethods( Vector methods )
         throws MappingException
     {
-        if ( ( method.getModifiers() & Modifier.PUBLIC ) == 0 ||
-             ( method.getModifiers() & Modifier.STATIC ) != 0 ) 
-            throw new MappingException( "mapping.accessorNotAccessible",
-                                        method, method.getDeclaringClass().getName() );
-        if ( method.getParameterTypes().length != 1 )
-            throw new MappingException( "mapping.writeMethodNoParam",
-                                        method, method.getDeclaringClass().getName() );
-        _setMethod = method;
+        for(int i=0; i<methods.size(); ++i) {
+            Method method = (Method) methods.get(i);
+
+	        if ( ( method.getModifiers() & Modifier.PUBLIC ) == 0 ||
+	             ( method.getModifiers() & Modifier.STATIC ) != 0 ) 
+	            throw new MappingException( "mapping.accessorNotAccessible",
+	                                        method, method.getDeclaringClass().getName() );
+	        if ( method.getParameterTypes().length != 1 )
+	            throw new MappingException( "mapping.writeMethodNoParam",
+	                                        method, method.getDeclaringClass().getName() );
+        }
+
+        _setMethods = methods;
     }
 
 
@@ -832,55 +864,89 @@ public final class FieldHandlerImpl
      * Please understand how this method is used before you start
      * playing with it! :-)
      */
-    public void setAddMethod( Method method ) 
+    public void setAddMethods( Vector methods ) 
         throws MappingException
     {
-        if ( ( method.getModifiers() & Modifier.PUBLIC ) == 0 ||
-             ( method.getModifiers() & Modifier.STATIC ) != 0 ) 
-            throw new MappingException( "mapping.accessorNotAccessible",
-                                        method, method.getDeclaringClass().getName() );
-        if ( method.getParameterTypes().length != 1 )
-            throw new MappingException( "mapping.writeMethodNoParam",
-                                        method, method.getDeclaringClass().getName() );
-        _addMethod = method;
-        
-        //-- make sure add method is not the same as the set method
-        if (_addMethod == _setMethod) _setMethod = null;
-        
+        for(int i=0; i<methods.size(); ++i) {
+            Method method = (Method) methods.get(i);
+
+	        if ( ( method.getModifiers() & Modifier.PUBLIC ) == 0 ||
+	             ( method.getModifiers() & Modifier.STATIC ) != 0 ) 
+	            throw new MappingException( "mapping.accessorNotAccessible",
+	                                        method, method.getDeclaringClass().getName() );
+	        if ( method.getParameterTypes().length != 1 )
+	            throw new MappingException( "mapping.writeMethodNoParam",
+	                                        method, method.getDeclaringClass().getName() );
+        }
+
+        _addMethods = methods;
+
+        //-- make sure the add methods are not the same as one of the set methods
+        if (_setMethods != null)
+            for(int j=0; j<_addMethods.size(); ++j)
+	            for(int i=0; i<_setMethods.size(); ++i)
+	                if (_addMethods.get(j) == _setMethods.get(i)) {
+	                    _setMethods.remove(i);
+	                    --i;
+	                }
     } //-- setAddMethod
     
     /** 
       * Selects the appropriate "write" method based on the 
-      * value. This is used when there is an "add" method 
-      * and a "set" method. 
+      * value. This is used to choose between the "set" and
+      * "add" methods based on the given value type. 
       * 
       * @return the selected write method 
-     **/ 
-     private Method selectWriteMethod( Object value ) { 
-          
-          
-         Method setter = null; 
-          
-         if (_setMethod != null) { 
-              
-             if (_addMethod == null) return _setMethod; 
-              
-             if (value == null) { 
-                 if (_default != null) value = _default; 
-                 else return _setMethod; 
-             } 
-              
-             //-- check value's class type 
-             Class paramType = _setMethod.getParameterTypes()[0]; 
-                                  
-             if (paramType.isAssignableFrom(value.getClass())) 
-                 return _setMethod; 
-         } 
-          
-         return _addMethod; 
-          
-     } //-- selectWriteMethod 
-  
+      */ 
+     private Method selectWriteMethod( Object value )
+     { 
+         if (_setMethods==null || _setMethods.isEmpty())
+             return selectMethod(_addMethods, value);
+
+          // use default value instead of null
+         if (value==null && _default!=null) 
+             value = _default; 
+
+          // search for the setter method based on the parameter type
+         Method setter = selectMethod(_setMethods, value);
+
+         if (setter != null)
+             return setter;
+
+         return selectMethod(_addMethods, value);
+	} //-- selectWriteMethod 
+
+    /**
+     * Selects the appropriate setter method based on the parameter type
+     * 
+     * @param methods vector of setter/adder methods 
+     * @param value value to assign 
+     * @return the selected setter method
+     */
+	private static Method selectMethod(Vector methods, Object value)
+	{
+	    Class valueType = value!=null? value.getClass(): null;
+
+        if (methods != null)
+	        for(int i=0; i<methods.size(); ++i) {
+	            Method method = (Method) methods.get(i);
+
+	            //-- check value's class type 
+                Class paramType = method.getParameterTypes()[0];
+
+            	// Setters with primitive types accept the corresponding class types.
+                if (paramType.isPrimitive())
+                    paramType = Types.typeFromPrimitive(paramType); 
+                else if (value == null)
+                    return method;	// null values can only be assigned to non-primitive setters.
+
+                if (paramType.isAssignableFrom(valueType))
+                    return method;	// found a matching method 
+	        }
+
+        return null;
+	}
+
     /**
      * Return true if the field is a collection.
      */
@@ -892,7 +958,4 @@ public final class FieldHandlerImpl
     {
         return _fieldName;
     }
-    
-
 }
-
Index: src/main/org/exolab/castor/mapping/loader/MappingLoader.java
===================================================================
RCS file: /cvs/castor/castor/src/main/org/exolab/castor/mapping/loader/MappingLoader.java,v
retrieving revision 1.8
diff -u -p -d -r1.8 MappingLoader.java
--- a/src/main/org/exolab/castor/mapping/loader/MappingLoader.java	1 Oct 2004 13:25:05 -0000	1.8
+++ b/src/main/org/exolab/castor/mapping/loader/MappingLoader.java	23 Oct 2004 11:36:41 -0000
@@ -997,17 +997,24 @@ public abstract class MappingLoader
             fieldName = fieldMap.getName(); // Not the same for nested fields
             if ( fieldName == null )
                 fieldName = ( getMethod == null ? setMethod.getName() : getMethod.getName() );
-                
+
             //-- create handler
+            Vector setMethods = null;
+
+            if (setMethod != null) {
+                setMethods = new Vector();
+                setMethods.add(setMethod);
+            }
+
             handler = new FieldHandlerImpl( fieldName, 
                                             getSequence, 
                                             setSequence, 
                                             getMethod, 
-                                            setMethod, 
+                                            setMethods, 
                                             typeInfoRef.typeInfo );
 
             if ((setMethod != null) && (setMethod.getName().startsWith(ADD_METHOD_PREFIX)))
-                handler.setAddMethod(setMethod);
+                handler.setAddMethods(setMethods);
         }
 
         // If there is a create method, add it to the field handler
Index: src/main/org/exolab/castor/xml/Introspector.java
===================================================================
RCS file: /cvs/castor/castor/src/main/org/exolab/castor/xml/Introspector.java,v
retrieving revision 1.16
diff -u -p -d -r1.16 Introspector.java
--- a/src/main/org/exolab/castor/xml/Introspector.java	1 Oct 2004 13:25:13 -0000	1.16
+++ b/src/main/org/exolab/castor/xml/Introspector.java	23 Oct 2004 11:36:43 -0000
@@ -50,7 +50,6 @@ import org.exolab.castor.xml.handlers.Co
 import org.exolab.castor.xml.handlers.DateFieldHandler;
 import org.exolab.castor.xml.handlers.DefaultFieldHandlerFactory;
 import org.exolab.castor.xml.util.ContainerElement;
-import org.exolab.castor.xml.util.DefaultNaming;
 import org.exolab.castor.xml.util.XMLClassDescriptorImpl;
 import org.exolab.castor.xml.util.XMLFieldDescriptorImpl;
 import org.exolab.castor.mapping.CollectionHandler;
@@ -66,9 +65,7 @@ import org.exolab.castor.util.Configurat
 import org.exolab.castor.util.LocalConfiguration;
 import org.exolab.castor.util.List;
 
-import java.io.IOException;
 import java.io.PrintWriter;
-import java.io.Serializable;
 import java.lang.reflect.*;
 import java.util.Enumeration;
 import java.util.Hashtable;
@@ -461,7 +458,7 @@ public final class Introspector {
                     methodSet = new MethodSet(fieldName);
                     methodSets.put(fieldName, methodSet);
                 }
-                methodSet.add = method;
+                methodSet.addMethods.add(method);
             }
             //-- write method (singleton or collection)
             else if (methodName.startsWith(SET)) {
@@ -478,7 +475,7 @@ public final class Introspector {
                     methodSet = new MethodSet(fieldName);
                     methodSets.put(fieldName, methodSet);
                 }
-                methodSet.set = method;
+                methodSet.setMethods.add(method);
             }
             else if (methodName.startsWith(CREATE)) {
                 if (method.getParameterTypes().length != 0) continue;
@@ -504,30 +501,32 @@ public final class Introspector {
         Enumeration enumeration = methodSets.elements();
         
         while (enumeration.hasMoreElements()) {
-            
+
             MethodSet methodSet = (MethodSet) enumeration.nextElement();
-            
+
             //-- create XMLFieldDescriptor
             String xmlName = _naming.toXMLName(methodSet.fieldName);
-                
+
             boolean isCollection = false;
-            
+
             //-- calculate class type
             //-- 1st check for add-method, then set or get method
             Class type = null;
-            if (methodSet.add != null) {
-                type = methodSet.add.getParameterTypes()[0];
+            if (!methodSet.addMethods.isEmpty()) {
+                type = ((Method)methodSet.addMethods.get(0)).	//TODO choose the best of the method types
+                			getParameterTypes()[0];
                 isCollection = true;
             }
-                        
+
             //-- if there was no add method, use get/set methods
             //-- to calculate type.
             if (type == null) {
                 if (methodSet.get != null) {
                     type = methodSet.get.getReturnType();
                 }
-                else if (methodSet.set != null) {
-                    type = methodSet.set.getParameterTypes()[0];
+                else if (!methodSet.setMethods.isEmpty()) {
+                    type = ((Method)methodSet.setMethods.get(0)).	//TODO choose the best of the method types
+                    			getParameterTypes()[0];
                 }
                 else {
                     //-- if we make it here, the only method found
@@ -535,7 +534,7 @@ public final class Introspector {
                     continue;
                 }
             }
-            
+
             //-- Handle Collections
             isCollection = (isCollection || isCollection(type));
             
@@ -544,8 +543,7 @@ public final class Introspector {
             
             //-- If the type is a collection and there is no add method, 
             //-- then we obtain a CollectionHandler
-            if (isCollection && (methodSet.add == null)) {
-                
+            if (isCollection && (methodSet.addMethods.isEmpty())) {
                 try {
                     colHandler = CollectionHandlers.getHandler(type);
                 }
@@ -569,7 +567,7 @@ public final class Introspector {
             
             //-- Create FieldHandler first, before the XMLFieldDescriptor
             //-- in case we need to use a custom handler
-                                                
+
             FieldHandler handler = null;
             boolean customHandler = false;
             try {
@@ -577,15 +575,15 @@ public final class Introspector {
                                                 null,
                                                 null,
                                                 methodSet.get,
-                                                methodSet.set, 
+                                                methodSet.setMethods, 
                                                 typeInfo);
                 //-- clean up
-                if (methodSet.add != null) 
-                    ((FieldHandlerImpl)handler).setAddMethod(methodSet.add);
-                                                
+                if (!methodSet.addMethods.isEmpty()) 
+                    ((FieldHandlerImpl)handler).setAddMethods(methodSet.addMethods);
+
                 if (methodSet.create != null) 
                     ((FieldHandlerImpl)handler).setCreateMethod(methodSet.create);
-                 
+
                 //-- handle Hashtable/Map 
                 if (isCollection && _saveMapKeys && isMapCollection(type)) {
                     ((FieldHandlerImpl)handler).setConvertFrom(new IdentityConvertor());
@@ -1317,23 +1315,23 @@ public final class Introspector {
         /**
          * A reference to the add method.
         **/
-        Method add    = null;
-        
+        Vector addMethods = new Vector();
+
         /**
          * A reference to the create method.
         **/
         Method create = null;
-        
+
         /**
          * A reference to the get method.
         **/
         Method get    = null;
-        
+
         /**
          * A reference to the set method.
         **/
-        Method set    = null;
-        
+        Vector setMethods = new Vector();
+
         /**
          * The fieldName for the field accessed by the methods in
          * this method set.