/*

  * 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.mapper;

 import java.util.ArrayList;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 import org.apache.commons.mapper.util.ObjectFactory;

 /**

  * <code>MapperFactory</code> is responsible for creating mappers based on 

  * domain class names or any other String name.  This allows a domain class to 

  * be a value bean and delegate data storage responsibility to a specific 

  * <code>Mapper</code> subclass.

  * <p>

  * <code>MapperFactory.getMapper()</code> method uses caching to prevent 

  * creating mappers multiple times.  This means that a Mapper returned from 

  * <code>getMapper()</code> will not be a new instance which could cause 

  * problems in a multi-threaded environment (the servlet container environment 

  * is multi-threaded).  Mappers returned by the <code>MapperFactory</code> 

  * should not use instance variables to maintain state, rather, they should 

  * use local method variables so they are thread-safe.

  * <p>

  * Note that you do not need to subclass <code>MapperFactory</code> to specify 

  * the specific <code>Mapper</code> implementation classes to return from 

  * <code>getMapper()</code>.  Because <code>Mapper</code> implementation 

  * classes are defined in a <code>Map</code>, you can have any combination of 

  * <code>Mapper</code> types in use at the same time.  For example, you could 

  * have EjbPersonMapper using an EJB to persist Person objects and a 

  * JdbcOrderMapper using JDBC calls to persist Order objects.  You can register 

  * <code>MapperFactoryListener</code> implementations with the factory to 

  * initialize the various types of Mappers when they are created.

  * 

  * @see Mapper

  * @see MapperFactoryListener

  */

 public class MapperFactory {

     /** 

      * This factory actually creates the mappers. 

      */

     protected ObjectFactory factory = null;

     /** 

      * Holds mapper instances that have already been created.   The key is a 

      * String name which is often a domain class' name and the value is a 

      * <code>Mapper</code> instance.

      */

     private Map mapperCache = new HashMap();

     /**

      * The List of listeners to notify when a Mapper is created.

      */

     private List listeners = new ArrayList();

     /**

      * Create a new MapperFactory with the mappings contained in the given Map.

      * @param map Any map containing logical names (often domain class names) 

      * as the keys and mapper class names as the values.

      * @throws IllegalArgumentException if there is a problem finding the 

      * mapped classes.  

      */

     public MapperFactory(Map map) {

         super();

         this.factory = new ObjectFactory(map);

     }

     /**

      * Factory method for getting the mapper associated with the given class.

      * @param mappedClass The class whose mapper should be returned

      * @return Mapper the mapper associated with the given class

      * @throws IllegalArgumentException if the given Class was not found in 

      * the map or there was an error creating an instance of the Mapper.  This 

      * is usually caused by a missing public no-arg constructor.

      */

     public Mapper getMapper(Class mappedClass) {

         return this.getMapper(mappedClass.getName());

     }

     /**

      * Factory method for getting the mapper associated with the given class.

      * @param name The name of the mapper to be returned.

      * @return Mapper the mapper associated with the given name.

      * @throws IllegalArgumentException if the given name was not found in 

      * the map or there was an error creating an instance of the Mapper.  This 

      * is usually caused by a missing public no-arg constructor.

      */

     public Mapper getMapper(String name) {

         synchronized (this.mapperCache) {

             Mapper m = (Mapper) this.mapperCache.get(name);

             if (m == null) {

                 m = (Mapper) this.factory.create(name);

                 this.fireMapperCreated(m);

                 this.mapperCache.put(name, m);

             }

             return m;

         }

     }

     /**

      * Register a listener with this MapperFactory to receive notifications 

      * of events.

      * @param listener

      */

     public void addMapperFactoryListener(MapperFactoryListener listener) {

         synchronized (this.listeners) {

             this.listeners.add(listener);

         }

     }

     /**

      * Unregister a listener from this MapperFactory.

      * @param listener

      */

     public void removeMapperFactoryListener(MapperFactoryListener listener) {

         synchronized (this.listeners) {

             this.listeners.remove(listener);

         }

     }

     /**

      * Call the mapperCreated() method of all registered listeners.

      * @param created The Mapper that was just created and should be passed to

      * the listeners for initialization.

      */

     private void fireMapperCreated(Mapper created) {

         MapperFactoryEvent event = new MapperFactoryEvent(this, created);

         synchronized (this.listeners) {

             Iterator iter = this.listeners.iterator();

             while (iter.hasNext()) {

                 MapperFactoryListener listener = (MapperFactoryListener) iter.next();

                 listener.mapperCreated(event);

             }

         }

     }

 }