/*

  *  Copyright 2003-2004 The Apache Software Foundation

  *

  *  Licensed under the Apache License, Version 2.0 (the "License");

  *  you may not use this file except in compliance with the License.

  *  You may obtain a copy of the License at

  *

  *      http://www.apache.org/licenses/LICENSE-2.0

  *

  *  Unless required by applicable law or agreed to in writing, software

  *  distributed under the License is distributed on an "AS IS" BASIS,

  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  *  See the License for the specific language governing permissions and

  *  limitations under the License.

  */

 package org.apache.commons.convert1;

 import java.util.Iterator;

 import java.util.Map;

 import org.apache.commons.convert1.util.ClassMap;

 import org.apache.commons.convert1.util.Inheritor;

 /**

  * Stores Converters under a dual-key system of fromClass to toClass.

  * 

  * @author Henri Yandell

  * @version $Id: ConvertRegistry.java 155441 2005-02-26 13:19:22Z dirkv $

  * @since 0.1

  */

 public class ConvertRegistry {

     // ------------------------------------------------------- Class Methods

     // ------------------------------------------------------- Variables

     /**

      * A ClassMap of Class to ClassMap. This then contains 

      * a Class to {@link Converter} mapping.

      */

     private ClassMap converters = new ClassMap();

     // ------------------------------------------------------- Constructors

     // TODO: Allow the Inheritor's used by the ClassMap to be set by 

     //       the user so that different ways of looking up may be used

     public ConvertRegistry() {

     }

     // --------------------------------------------------------- Public Methods

     // ------------------------------------------------------ Static Properties

     /**

      * Convert the specified value into a String.  If the specified value

      * is an array, the first element (converted to a String) will be

      * returned.  The registered {@link Converter} for the

      * <code>java.lang.String</code> class will be used, which allows

      * applications to customize Object->String conversions (the default

      * implementation simply uses toString()).

      *

      * @param value Value to be converted (may be null)

      */

     /*

     // This whole method appears to be a waste of time. 

     // It's a way to plugin a StringConverter, but why treat Strings 

     // in a special way?

     public String convert(Object value) {

         if (value == null) {

             return ((String) null);

         } else if (value.getClass().isArray()) {

             //H? This seems bad. String[0] becomes null.

             //   Why not return String[]??

             if (Array.getLength(value) < 1) {

                 return (null);

             }

             value = Array.get(value, 0);

             if (value == null) {

                 return ((String) null);

             } else {

                 Converter converter = lookup(String.class);

                 return ((String) converter.convert(String.class, value));

             }

         } else {

             Converter converter = lookup(String.class);

             return ((String) converter.convert(String.class, value));

         }

     }

     */

     /**

      * Convert the specified value to an object of the specified class (if

      * possible).  Otherwise, return a String representation of the value.

      *

      * @param value Value to be converted (may be null)

      * @param clazz Java class to be converted to

      *

      * @exception ConversionException if thrown by an underlying Converter

      */

     public Object convert(Object value, Class toClass) {

         //H? If value == null, return null??

         if(value == null) {

             return null;

         }

         Class fromClass = value.getClass();

         Converter converter = lookup(value.getClass(), toClass);

         if (converter == null) {

             //H? If value.getClass() == toClass, do we auto-return?

             if(value.getClass() == toClass) {

                 return value;

             }

             Inheritor inh = converters.getInheritor();

             Iterator itr = inh.iterator();

             while( itr.hasNext() && converter == null ) {

                 converter = lookup( value.getClass(), toClass );

             }

             //H? Try to treat converter as a Collection concept

             //   Or should this be a converter of its own? 

             //   How would it be mapped? To every possible 

             //   collective type? primitve[], Object[], Collection, 

             //   Map?

             //   Yes, this should be a converter.

             //H? Throw exception?  return null? Treat as String? 

             //H? How about returning value? Should this be a user choice?

             if( converter == null ) {

                 converter = new IdentityConverter();

             }

         }

         //H? Should this check if the returned value is 

         //   the correct class?

         return converter.convert(toClass, value);

     }

     /**

      * Convert an array of specified values to an array of objects of the

      * specified class (if possible).  If the specified Java class is itself

      * an array class, this class will be the type of the returned value.

      * Otherwise, an array will be constructed whose component type is the

      * specified class.

      *

      * @param value Value to be converted (may be null)

      * @param clazz Java array or element class to be converted to

      *

      * @exception ConversionException if thrown by an underlying Converter

      */

      //H? This method is too specific. It needs to become convertCollective

      /*

     public Object convert(String values[], Class clazz) {

         Class type = clazz;

         if (clazz.isArray()) {

             type = clazz.getComponentType();

         }

         Converter converter = lookup(type);

         if (converter == null) {

             converter = lookup(String.class);

         }

         Object array = Array.newInstance(type, values.length);

         for (int i = 0; i < values.length; i++) {

             Array.set(array, i, converter.convert(type, values[i]));

         }

         return (array);

     }

     */

     /**

      * Remove all registered {@link Converter}s.

      */

     public void clear() {

                 converters.clear();

     }

     /**

      * Remove any registered {@link Converter} for the specified destination

      * <code>Class</code>.

      *

      * @param clazz Class for which to remove a registered Converter

      */

     public void deregister(Class fromClass, Class toClass) {

         Map map = (Map) converters.get(fromClass);

         map.remove(toClass);

     }

     public void fromClassDeregister(Class fromClass) {

         converters.remove(fromClass);

     }

     public void toClassDeregister(Class toClass) {

         // loop over every fromClass and remove

         // a dual indexed map will improve speed

         Iterator itr = converters.keySet().iterator();

         while( itr.hasNext() ) {

             Map map = (Map) itr.next();

             map.remove(toClass);

         }

     }

     /**

      * Look up and return any registered {@link Converter} for the specified

      * destination class; if there is no registered Converter, return

      * <code>null</code>.

      *

      * @param clazz Class for which to return a registered Converter

      */

     //H? Should this return an IdentityConverter?

     public Converter lookup(Class fromClass, Class toClass) {

         Map map = (Map) converters.get(fromClass);

         if(map == null) {

             return null;

         }

         Object obj = map.get(toClass);

         while( obj instanceof ConverterFactory ) {

             obj = ( (ConverterFactory) obj).create( fromClass, toClass );

         }

         //H? check obj is a Converter, or is ClassNotFound good enough?

         return (Converter) obj;

     }

     //H? What to do here? Return a registry with a default fromClass?

     //H? rename: lookupFromClassRegistry

     //H? add: lookupToClassRegistry

     /**

      * Register a custom {@link Converter} for the specified destination

      * <code>Class</code>, replacing any previously registered Converter.

      *

      * @param converter Converter to be registered

      * @param clazz Destination class for conversions performed by this

      *  Converter

      */

     public void register(Converter converter, Class fromClass, Class toClass) {

         Map map = (Map) converters.get(fromClass);

         if( map == null) {

             map = new ClassMap();

             converters.put( fromClass, map );

         }

         map.put(toClass, converter);

     }

     //H? refactor: registerForFromClass(ConverterRegistry, Class fromClass)

     //H? refactor: registerForToClass(ConverterRegistry, Class toClass)

 }