commons-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From scolebou...@apache.org
Subject cvs commit: jakarta-commons/collections/src/java/org/apache/commons/collections MultiHashMap.java
Date Sun, 24 Nov 2002 19:36:48 GMT
scolebourne    2002/11/24 11:36:48

  Modified:    collections/src/java/org/apache/commons/collections
                        MultiHashMap.java
  Log:
  Applied fixes from Julien Buret to improve MultiMap including 
  - values() backed by real map
  - clone works properly
  - ArrayLists can be added to a MultiMap
  Javadoc class
  
  Revision  Changes    Path
  1.8       +273 -105  jakarta-commons/collections/src/java/org/apache/commons/collections/MultiHashMap.java
  
  Index: MultiHashMap.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/collections/src/java/org/apache/commons/collections/MultiHashMap.java,v
  retrieving revision 1.7
  retrieving revision 1.8
  diff -u -r1.7 -r1.8
  --- MultiHashMap.java	1 Nov 2002 19:41:00 -0000	1.7
  +++ MultiHashMap.java	24 Nov 2002 19:36:48 -0000	1.8
  @@ -60,165 +60,333 @@
    */
   package org.apache.commons.collections;
   
  +import java.io.IOException;
  +import java.io.ObjectInputStream;
  +import java.util.AbstractCollection;
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.HashMap;
   import java.util.Iterator;
   import java.util.Map;
  +import java.util.NoSuchElementException;
   import java.util.Set;
   /** 
    * <code>MultiHashMap</code> is the default implementation of the 
    * {@link org.apache.commons.collections.MultiMap MultiMap} interface.
  + * <p>
    * A <code>MultiMap</code> is a Map with slightly different semantics.
  - * Instead of returning an Object, it returns a Collection.
  - * So for example, you can put( key, new Integer(1) ); 
  - * and then a Object get( key ); will return you a Collection 
  - * instead of an Integer.
  + * Putting a value into the map will add the value to a Collection at that
  + * key. Getting a value will always return a Collection, holding all the
  + * values put to that key. This implementation uses an ArrayList as the 
  + * collection.
  + * <p>
  + * For example:
  + * <pre>
  + * MultiMap mhm = new MultiHashMap();
  + * mhm.put(key, "A");
  + * mhm.put(key, "B");
  + * mhm.put(key, "C");
  + * Collection coll = mhm.get(key);</pre>
  + * <p>
  + * <code>coll</code> will be a list containing "A", "B", "C".
    *
    * @since 2.0
    * @author Christopher Berry
    * @author <a href="mailto:jstrachan@apache.org">James Strachan</a>
    * @author Steve Downey
    * @author Stephen Colebourne
  + * @author <a href="mailto:jburet@yahoo.com">Julien Buret</a>
    */
  -public class MultiHashMap extends HashMap implements MultiMap
  -{
  -    //----------------- Data
  +public class MultiHashMap extends HashMap implements MultiMap {
  +    // deprecated name concept
       private static int sCount = 0;
       private String mName = null;
       
  -    public MultiHashMap()
  -    {
  +    //backed values collection
  +    private transient Collection values = null;
  +    
  +    // compatibility with commons-collection releases 2.0/2.1
  +    private static final long serialVersionUID = 1943563828307035349L;
  +
  +    /**
  +     * Constructor.
  +     */
  +    public MultiHashMap() {
           super();
           setName();
       }
  -    
  -    public MultiHashMap( int initialCapacity )
  -    {
  -        super( initialCapacity );
  +
  +    /**
  +     * Constructor.
  +     * 
  +     * @param initialCapacity  the initial map capacity
  +     */
  +    public MultiHashMap(int initialCapacity) {
  +        super(initialCapacity);
           setName();
       }
  -    
  -    public MultiHashMap(int initialCapacity, float loadFactor )
  -    {
  -        super( initialCapacity, loadFactor);
  +
  +    /**
  +     * Constructor.
  +     * 
  +     * @param initialCapacity  the initial map capacity
  +     * @param loadFactor  the amount 0.0-1.0 at which to resize the map
  +     */
  +    public MultiHashMap(int initialCapacity, float loadFactor) {
  +        super(initialCapacity, loadFactor);
           setName();
       }
  -    
  -    public MultiHashMap( Map mapToCopy )
  -    {
  -        super( mapToCopy );
  +
  +    /**
  +     * Constructor.
  +     * 
  +     * @param mapToCopy  a Map to copy
  +     */
  +    public MultiHashMap(Map mapToCopy) {
  +        super(mapToCopy);
  +    }
  +
  +    /**
  +     * Read the object during deserialization.
  +     */
  +    private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
{
  +        // This method is needed because the 1.2/1.3 Java deserialisation called
  +        // put and thus messed up that method
  +        
  +        // default read object
  +        s.defaultReadObject();
  +
  +        // problem only with jvm <1.4
  +        String version = "1.2";
  +        try {
  +            version = System.getProperty("java.version");
  +        } catch (SecurityException ex) {
  +            // ignore and treat as 1.2/1.3
  +        }
  +
  +        if (version.startsWith("1.2") || version.startsWith("1.3")) {
  +            for (Iterator iterator = entrySet().iterator(); iterator.hasNext();) {
  +                Map.Entry entry = (Map.Entry) iterator.next();
  +                // put has created a extra collection level, remove it
  +                super.put(entry.getKey(), ((Collection) entry.getValue()).iterator().next());
  +            }
  +        }
       }
       
  -    private void setName()
  -    {
  +    /**
  +     * Create a name for the map.
  +     */    
  +    private void setName() {
           sCount++;
           mName = "MultiMap-" + sCount;
       }
       
  -    public String getName()
  -    { return mName; }
  -    
  -    public Object put( Object key, Object value )
  -    {
  -        // NOTE:: put might be called during deserialization !!!!!!
  -        //        so we must provide a hook to handle this case
  -        //        This means that we cannot make MultiMaps of ArrayLists !!!
  -        
  -        if ( value instanceof ArrayList ) {
  -            return ( super.put( key, value ) );
  -        }
  -        
  -        ArrayList keyList = (ArrayList)(super.get( key ));
  -        if ( keyList == null ) {
  -            keyList = new ArrayList(10);
  -            
  -            super.put( key, keyList );
  +    /**
  +     * Gets the name of the map.
  +     * 
  +     * @deprecated no replacement. There is no good reason for a MultiMap to have a name
  +     * @return the name
  +     */    
  +    public String getName() {
  +        return mName;
  +    }
  +
  +    /**
  +     * Put a key and value into the map.
  +     * <p>
  +     * The value is added to a collection mapped to the key instead of 
  +     * replacing the previous value.
  +     * 
  +     * @param key  the key to set
  +     * @param value  the value to set the key to
  +     * @return the value added if the add is successful, <code>null</code>
otherwise
  +     */    
  +    public Object put(Object key, Object value) {
  +        // NOTE:: put is called during deserialization in JDK < 1.4 !!!!!!
  +        //        so we must have a readObject()
  +        Collection coll = (Collection) super.get(key);
  +        if (coll == null) {
  +            coll = createCollection(null);
  +            super.put(key, coll);
           }
  -        
  -        boolean results = keyList.add( value );
  -        
  -        return ( results ? value : null );
  +        boolean results = coll.add(value);
  +
  +        return (results ? value : null);
       }
       
  -    public boolean containsValue( Object value )
  -    {
  +    /**
  +     * Does the map contain a specific value.
  +     * <p>
  +     * This searches the collection mapped to each key, and thus could be slow.
  +     * 
  +     * @param value  the value to search for
  +     * @return true if the list contains the value
  +     */
  +    public boolean containsValue(Object value) {
           Set pairs = super.entrySet();
  -        
  -        if ( pairs == null )
  +
  +        if (pairs == null) {
               return false;
  -        
  +        }
           Iterator pairsIterator = pairs.iterator();
  -        while ( pairsIterator.hasNext() ) {
  -            Map.Entry keyValuePair = (Map.Entry)(pairsIterator.next());
  -            ArrayList list = (ArrayList)(keyValuePair.getValue());
  -            if( list.contains( value ) )
  +        while (pairsIterator.hasNext()) {
  +            Map.Entry keyValuePair = (Map.Entry) pairsIterator.next();
  +            Collection coll = (Collection) keyValuePair.getValue();
  +            if (coll.contains(value)) {
                   return true;
  +            }
           }
           return false;
       }
  -    
  -    public Object remove( Object key, Object item )
  -    {
  -        ArrayList valuesForKey = (ArrayList) super.get( key );
  -        
  -        if ( valuesForKey == null )
  +
  +    /**
  +     * Removes a specific value from map.
  +     * <p>
  +     * The item is removed from the collection mapped to the specified key.
  +     * 
  +     * @param key  the key to remove from
  +     * @param value  the value to remove
  +     * @return the value removed (which was passed in)
  +     */
  +    public Object remove(Object key, Object item) {
  +        Collection valuesForKey = (Collection) super.get(key);
  +        if (valuesForKey == null) {
               return null;
  -        
  -        valuesForKey.remove( item );
  +        }
  +        valuesForKey.remove(item);
           return item;
       }
  -    
  -    public void clear()
  -    {
  +
  +    /**
  +     * Clear the map.
  +     * <p>
  +     * This clears each collection in the map, and so may be slow.
  +     */
  +    public void clear() {
  +        // For gc, clear each list in the map
           Set pairs = super.entrySet();
           Iterator pairsIterator = pairs.iterator();
  -        while ( pairsIterator.hasNext() ) {
  -            Map.Entry keyValuePair = (Map.Entry)(pairsIterator.next());
  -            ArrayList list = (ArrayList)(keyValuePair.getValue());
  -            list.clear();
  +        while (pairsIterator.hasNext()) {
  +            Map.Entry keyValuePair = (Map.Entry) pairsIterator.next();
  +            Collection coll = (Collection) keyValuePair.getValue();
  +            coll.clear();
           }
           super.clear();
       }
  -    
  -    public void putAll( Map mapToPut )
  -    {
  -        super.putAll( mapToPut );
  -    }
  -    
  +
       /** 
  -     * Note: Currently the returned {@link Collection} is <i>not</i>
  -     * backed by this map.
  -     * @see Map#values
  -     * @see http://issues.apache.org/bugzilla/show_bug.cgi?id=9573
  -     */
  -    public Collection values()
  -    {
  -        ArrayList returnList = new ArrayList( super.size() );
  -        
  -        Set pairs = super.entrySet();
  -        Iterator pairsIterator = pairs.iterator();
  -        while ( pairsIterator.hasNext() ) {
  -            Map.Entry keyValuePair = (Map.Entry)(pairsIterator.next());
  -            ArrayList list = (ArrayList)(keyValuePair.getValue());
  -            
  -            Object[] values = list.toArray();
  -            for ( int ii=0; ii < values.length; ii++ ) {
  -                returnList.add( values[ii] );
  +     * Gets a view over all the values in the map.
  +     * <p>
  +     * The values view includes all the entries in the collections at each map key.
  +     * 
  +     * @return the collection view of all the values in the map
  +     */
  +    public Collection values() {
  +        Collection vs = values;
  +        return (vs != null ? vs : (values = new Values()));
  +    }
  +
  +    /**
  +     * Inner class to view the elements.
  +     */
  +    private class Values extends AbstractCollection {
  +
  +        public Iterator iterator() {
  +            return new ValueIterator();
  +        }
  +
  +        public int size() {
  +            int compt = 0;
  +            Iterator it = iterator();
  +            while (it.hasNext()) {
  +                it.next();
  +                compt++;
               }
  +            return compt;
  +        }
  +
  +        public void clear() {
  +            MultiHashMap.this.clear();
           }
  -        return returnList;
  +
       }
  -    
  -    // FIXME:: do we need to implement this??
  -    // public boolean equals( Object obj ) {}
  -    
  -    // --------------- From Cloneable
  -    public Object clone()
  -    {
  -        MultiHashMap obj = (MultiHashMap)(super.clone());
  +
  +    /**
  +     * Inner iterator to view the elements.
  +     */
  +    private class ValueIterator implements Iterator {
  +        private Iterator backedIterator;
  +        private Iterator tempIterator;
  +
  +        private ValueIterator() {
  +            backedIterator = MultiHashMap.super.values().iterator();
  +        }
  +
  +        private boolean searchNextIterator() {
  +            while (tempIterator == null || tempIterator.hasNext() == false) {
  +                if (backedIterator.hasNext() == false) {
  +                    return false;
  +                }
  +                tempIterator = ((Collection) backedIterator.next()).iterator();
  +            }
  +            return true;
  +        }
  +
  +        public boolean hasNext() {
  +            return searchNextIterator();
  +        }
  +
  +        public Object next() {
  +            if (searchNextIterator() == false) {
  +                throw new NoSuchElementException();
  +            }
  +            return tempIterator.next();
  +        }
  +
  +        public void remove() {
  +            if (tempIterator == null) {
  +                throw new IllegalStateException();
  +            }
  +            tempIterator.remove();
  +        }
  +
  +    }
  +
  +    /**
  +     * Clone the map.
  +     * <p>
  +     * The clone will shallow clone the collections as well as the map.
  +     * 
  +     * @return the cloned map
  +     */
  +    public Object clone() {
  +        MultiHashMap obj = (MultiHashMap) super.clone();
           obj.mName = mName;
  +
  +        // clone each Collection container
  +        for (Iterator it = entrySet().iterator(); it.hasNext();) {
  +            Map.Entry entry = (Map.Entry) it.next();
  +            Collection coll = (Collection) entry.getValue();
  +            Collection newColl = createCollection(coll);
  +            entry.setValue(newColl);
  +        }
           return obj;
       }
       
  +    /** 
  +     * Creates a new instance of the map value Collection container.
  +     * <p>
  +     * This method can be overridden to use your own collection type.
  +     *
  +     * @param coll  the collection to copy, may be null
  +     * @return the new collection
  +     */
  +    protected Collection createCollection(Collection coll) {
  +        if (coll == null) {
  +            return new ArrayList();
  +        } else {
  +            return new ArrayList(coll);
  +        }
  +    }
  +
   }
  
  
  

--
To unsubscribe, e-mail:   <mailto:commons-dev-unsubscribe@jakarta.apache.org>
For additional commands, e-mail: <mailto:commons-dev-help@jakarta.apache.org>


Mime
View raw message