/*
   
       stax  Stack API for XML.
       Copyright (c) 2001-2006 held jointly by the individual authors.
   
       This library is free software; you can redistribute it and/or modify it
       under the terms of the GNU Lesser General Public License as published
       by the Free Software Foundation; either version 2.1 of the License, or (at
       your option) any later version.
  
      This library is distributed in the hope that it will be useful, but WITHOUT
      ANY WARRANTY; with out even the implied warranty of MERCHANTABILITY or
      FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
      License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with this library;  if not, write to the Free Software Foundation,
      Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA.
  
      > http://www.gnu.org/copyleft/lesser.html
      > http://www.opensource.org/licenses/lgpl-license.php
  
  */
  package net.sf.stax;
  
  import java.util.Map;
  import java.util.Set;
  import java.util.List;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.ArrayList;
  
  import org.xml.sax.SAXException;
  
  /***
   * Default implementation of <b>IdMapper</b>.
   *
   * @author  Thomas Down
   * @author  Matthew Pocock
   * @author  Michael Heuer
   * @version $Revision: 1.2 $ $Date: 2006/01/02 20:37:34 $
   */
  class IdMapperImpl
      implements IdMapper
  {
      /*** List of global listeners. */
      private final List globalListeners;
  
      /*** Map of IdListeners keyed by ids. */
      private final Map idListeners;
  
      /*** Map of ids to items. */
      private final Map idToItem;
  
  
      /***
       * Create a new default implementation of <b>IdMapper</b>.
       */
      public IdMapperImpl()
      {
          globalListeners = new ArrayList();
          idListeners = new HashMap();
          idToItem = new HashMap();
      }
  
      /***
       * Create a new default implementation of <b>IdMapper</b>
       * with the specified map of existing ids to items.
       *
       * @param existingIds map of existing ids to items.
       */
      public IdMapperImpl(final Map existingIds)
      {
          this();
          idToItem.putAll(existingIds);
      }
  
  
      /***
       * Return the set of unresolved ids.
       *
       * @return the set of unresolved ids
       */
      public Set getUnresolvedIds()
      {
          return idListeners.keySet();
      }
  
      /*** @see IdMapper */
      public void registerItemForId(final Object id, final Object item)
          throws SAXException
      {
          // complain if we've seen this before
          if (idToItem.containsKey(id))
          {
              throw new SAXException("id already mapped: " + id + " -> " + idToItem.get(id));
          }
  
         // store for later
         idToItem.put(id, item);
 
         // inform each listener that's id agnostic
         for (Iterator i = globalListeners.iterator(); i.hasNext();)
         {
             IdListener l = (IdListener) i.next();
             l.idRegistered(id, item);
         }
 
         // inform each listener that is keen about this id and then remove them
         Object listeners = idListeners.get(id);
         if (listeners != null)
         {
             // more than one listener all kept in a set
             if (listeners instanceof Set)
             {
                 for (Iterator i = ((Set) listeners).iterator(); i.hasNext();)
                 {
                     IdListener l = (IdListener) i.next();
                     l.idRegistered(id, item);
                 }
             }
             else
             {
                 // just one listener
                 IdListener l = (IdListener) listeners;
                 l.idRegistered(id, item);
             }
         }
         idListeners.remove(id);
     }
 
 
     /*** @see IdMapper */
     public void addIdListener(final IdListener listener)
         throws SAXException
     {
         // add this listener
         globalListeners.add(listener);
 
         // tell it about all past id mappings
         for (Iterator i = idToItem.keySet().iterator(); i.hasNext();)
         {
             Object id = i.next();
             listener.idRegistered(id, idToItem.get(id));
         }
     }
 
     /*** @see IdMapper */
     public void removeIdListener(final IdListener listener)
         throws SAXException
     {
         // empty
     }
 
     /*** @see IdMapper */
     public void addIdListener(final IdListener listener, final Object id)
         throws SAXException
     {
         if (idToItem.containsKey(id))
         {
             // if we know the id mapping, then just invoke the callback directly
             listener.idRegistered(id, idToItem.get(id));
         }
         else
         {
             // ok - we don't know the mapping yet, so let's store the listener away
             Object ls = idListeners.get(id);
             if (ls == null)
             {
                 idListeners.put(id, listener);
             }
             else if (ls instanceof IdListener)
             {
                 Set lSet = new HashSet();
                 lSet.add(ls);
                 lSet.add(listener);
                 idListeners.put(id, lSet);
             }
             else
             {
                 Set lSet = (Set) ls;
                 lSet.add(listener);
             }
         }
     }
 
     /*** @see IdMapper */
     public void removeIdListener(final IdListener listener, final Object id)
         throws SAXException
     {
         // empty
     }
 }