commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From bay...@apache.org
Subject svn commit: r815036 - /commons/proper/collections/trunk/src/java/org/apache/commons/collections/collection/CompositeCollection.java
Date Tue, 15 Sep 2009 05:54:43 GMT
Author: bayard
Date: Tue Sep 15 05:54:43 2009
New Revision: 815036

URL: http://svn.apache.org/viewvc?rev=815036&view=rev
Log:
Merging from -r468106:814127 of collections_jdk5_branch - namely where this code was generified;
mostly in r738956.

Also see the following revisions:

    ------------------------------------------------------------------------
    r471580 | scolebourne | 2006-11-05 16:22:53 -0800 (Sun, 05 Nov 2006) | 1 line
    
    Generify CompositeCollection
    ------------------------------------------------------------------------
    r471203 | scolebourne | 2006-11-04 06:28:02 -0800 (Sat, 04 Nov 2006) | 1 line
    
    Whitespace change
    ------------------------------------------------------------------------

Modified:
    commons/proper/collections/trunk/src/java/org/apache/commons/collections/collection/CompositeCollection.java

Modified: commons/proper/collections/trunk/src/java/org/apache/commons/collections/collection/CompositeCollection.java
URL: http://svn.apache.org/viewvc/commons/proper/collections/trunk/src/java/org/apache/commons/collections/collection/CompositeCollection.java?rev=815036&r1=815035&r2=815036&view=diff
==============================================================================
--- commons/proper/collections/trunk/src/java/org/apache/commons/collections/collection/CompositeCollection.java
(original)
+++ commons/proper/collections/trunk/src/java/org/apache/commons/collections/collection/CompositeCollection.java
Tue Sep 15 05:54:43 2009
@@ -22,6 +22,7 @@
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Iterator;
+import java.util.List;
 
 import org.apache.commons.collections.iterators.EmptyIterator;
 import org.apache.commons.collections.iterators.IteratorChain;
@@ -31,9 +32,10 @@
  * Decorates a collection of other collections to provide a single unified view.
  * <p>
  * Changes made to this collection will actually be made on the decorated collection.
- * Add and remove operations require the use of a pluggable strategy. If no 
+ * Add and remove operations require the use of a pluggable strategy. If no
  * strategy is provided then add and remove are unsupported.
  *
+ * @param <E> the type of the elements in the collection
  * @since Commons Collections 3.0
  * @version $Revision$ $Date$
  *
@@ -41,43 +43,62 @@
  * @author Stephen Colebourne
  * @author Phil Steitz
  */
-public class CompositeCollection implements Collection, Serializable {
-    
+public class CompositeCollection<E> implements Collection<E>, Serializable {
+
     /** CollectionMutator to handle changes to the collection */
-    protected CollectionMutator mutator;
-    
+    protected CollectionMutator<E> mutator;
+
     /** Collections in the composite */
-    protected Collection[] all;
-    
+    protected List<Collection<E>> all = new ArrayList<Collection<E>>();
+
     /**
      * Create an empty CompositeCollection.
      */
     public CompositeCollection() {
         super();
-        this.all = new Collection[0];
     }
-    
+
+    /**
+     * Create a Composite Collection with one collection.
+     *
+     * @param compositeCollection  the Collection to be appended to the composite
+     */
+    public CompositeCollection(Collection<E> compositeCollection) {
+        super();
+        addComposited(compositeCollection);
+    }
+
     /**
-     * Create a Composite Collection with only coll composited.
-     * 
-     * @param coll  a collection to decorate
+     * Create a Composite Collection with two collections.
+     *
+     * @param compositeCollection1  the Collection to be appended to the composite
+     * @param compositeCollection2  the Collection to be appended to the composite
      */
-    public CompositeCollection(Collection coll) {
-        this();
-        this.addComposited(coll);
+    public CompositeCollection(Collection<E> compositeCollection1, Collection<E>
compositeCollection2) {
+        super();
+        addComposited(compositeCollection1, compositeCollection2);
     }
-    
+
     /**
-     * Create a CompositeCollection with colls as the initial list of
-     * composited collections.
-     * 
-     * @param colls  an array of collections to decorate
+     * Create a Composite Collection with an array of collections.
+     *
+     * @param compositeCollections  the collections to composite
      */
-    public CompositeCollection(Collection[] colls) {
-        this();
-        this.addComposited(colls);
+    public CompositeCollection(Collection<E>[] compositeCollections) {
+        super();
+        addComposited(compositeCollections);
     }
-    
+
+//    /**
+//     * Create a Composite Collection extracting the collections from an iterable.
+//     *
+//     * @param compositeCollections  the collections to composite
+//     */
+//    public CompositeCollection(Iterable<Collection<E>> compositeCollections)
{
+//        super();
+//        addComposited(compositeCollections);
+//    }
+
     //-----------------------------------------------------------------------
     /**
      * Gets the size of this composite collection.
@@ -88,12 +109,12 @@
      */
     public int size() {
         int size = 0;
-        for (int i = this.all.length - 1; i >= 0; i--) {
-            size += this.all[i].size();
+        for (Collection<E> item : all) {
+            size += item.size();
         }
         return size;
     }
-    
+
     /**
      * Checks whether this composite collection is empty.
      * <p>
@@ -102,14 +123,14 @@
      * @return true if all of the contained collections are empty
      */
     public boolean isEmpty() {
-        for (int i = this.all.length - 1; i >= 0; i--) {
-            if (this.all[i].isEmpty() == false) {
+        for (Collection<? extends E> item : all) {
+            if (item.isEmpty() == false) {
                 return false;
             }
         }
         return true;
     }
-    
+
     /**
      * Checks whether this composite collection contains the object.
      * <p>
@@ -119,14 +140,14 @@
      * @return true if obj is contained in any of the contained collections
      */
     public boolean contains(Object obj) {
-        for (int i = this.all.length - 1; i >= 0; i--) {
-            if (this.all[i].contains(obj)) {
+        for (Collection<? extends E> item : all) {
+            if (item.contains(obj)) {
                 return true;
             }
         }
         return false;
     }
-    
+
     /**
      * Gets an iterator over all the collections in this composite.
      * <p>
@@ -137,31 +158,31 @@
      *  the order they were added, but this behavior should not be relied upon.
      * @see IteratorChain
      */
-    public Iterator iterator() {
-        if (this.all.length == 0) {
-            return EmptyIterator.INSTANCE;
-        }
-        IteratorChain chain = new IteratorChain();
-        for (int i = 0; i < this.all.length; ++i) {
-            chain.addIterator(this.all[i].iterator());
+    public Iterator<E> iterator() {
+        if (all.isEmpty()) {
+            return EmptyIterator.<E>getInstance();
+        }
+        IteratorChain<E> chain = new IteratorChain<E>();
+        for (Collection<? extends E> item : all) {
+            chain.addIterator(item.iterator());
         }
         return chain;
     }
-    
+
     /**
      * Returns an array containing all of the elements in this composite.
      *
      * @return an object array of all the elements in the collection
      */
     public Object[] toArray() {
-        final Object[] result = new Object[this.size()];
+        final Object[] result = new Object[size()];
         int i = 0;
-        for (Iterator it = this.iterator(); it.hasNext(); i++) {
+        for (Iterator<E> it = iterator(); it.hasNext(); i++) {
             result[i] = it.next();
         }
         return result;
     }
-    
+
     /**
      * Returns an object array, populating the supplied array if possible.
      * See <code>Collection</code> interface for full details.
@@ -169,28 +190,28 @@
      * @param array  the array to use, populating if possible
      * @return an array of all the elements in the collection
      */
-    public Object[] toArray(Object[] array) {
-        int size = this.size();
+    @SuppressWarnings("unchecked")
+    public <T> T[] toArray(T[] array) {
+        int size = size();
         Object[] result = null;
         if (array.length >= size) {
             result = array;
-        }
-        else {
+        } else {
             result = (Object[]) Array.newInstance(array.getClass().getComponentType(), size);
         }
-        
+
         int offset = 0;
-        for (int i = 0; i < this.all.length; ++i) {
-            for (Iterator it = this.all[i].iterator(); it.hasNext();) {
-                result[offset++] = it.next();
+        for (Collection<? extends E> item : all) {
+            for (E e : item) {
+                result[offset++] = e;
             }
         }
         if (result.length > size) {
             result[size] = null;
         }
-        return result;
+        return (T[]) result;
     }
-    
+
     /**
      * Adds an object to the collection, throwing UnsupportedOperationException
      * unless a CollectionMutator strategy is specified.
@@ -203,14 +224,14 @@
      * @throws NullPointerException if the object cannot be added because its null
      * @throws IllegalArgumentException if the object cannot be added
      */
-    public boolean add(Object obj) {
-        if (this.mutator == null) {
+    public boolean add(E obj) {
+        if (mutator == null) {
            throw new UnsupportedOperationException(
-           "add() is not supported on CompositeCollection without a CollectionMutator strategy");
+               "add() is not supported on CompositeCollection without a CollectionMutator
strategy");
         }
-        return this.mutator.add(this, this.all, obj);
+        return mutator.add(this, all, obj);
     }
-    
+
     /**
      * Removes an object from the collection, throwing UnsupportedOperationException
      * unless a CollectionMutator strategy is specified.
@@ -223,13 +244,13 @@
      * @throws IllegalArgumentException if the object cannot be removed
      */
     public boolean remove(Object obj) {
-        if (this.mutator == null) {
+        if (mutator == null) {
             throw new UnsupportedOperationException(
-            "remove() is not supported on CompositeCollection without a CollectionMutator
strategy");
+                "remove() is not supported on CompositeCollection without a CollectionMutator
strategy");
         }
-        return this.mutator.remove(this, this.all, obj);
+        return mutator.remove(this, all, obj);
     }
-    
+
     /**
      * Checks whether this composite contains all the elements in the specified collection.
      * <p>
@@ -239,15 +260,15 @@
      * @param coll  the collection to check for
      * @return true if all elements contained
      */
-    public boolean containsAll(Collection coll) {
-        for (Iterator it = coll.iterator(); it.hasNext();) {
-            if (this.contains(it.next()) == false) {
+    public boolean containsAll(Collection<?> coll) {
+        for (Object item : coll) {
+            if (contains(item) == false) {
                 return false;
             }
         }
         return true;
     }
-    
+
     /**
      * Adds a collection of elements to this collection, throwing
      * UnsupportedOperationException unless a CollectionMutator strategy is specified.
@@ -260,14 +281,14 @@
      * @throws NullPointerException if the object cannot be added because its null
      * @throws IllegalArgumentException if the object cannot be added
      */
-    public boolean addAll(Collection coll) {
-        if (this.mutator == null) {
+    public boolean addAll(Collection<? extends E> coll) {
+        if (mutator == null) {
             throw new UnsupportedOperationException(
-            "addAll() is not supported on CompositeCollection without a CollectionMutator
strategy");
+                "addAll() is not supported on CompositeCollection without a CollectionMutator
strategy");
         }
-        return this.mutator.addAll(this, this.all, coll);
+        return mutator.addAll(this, all, coll);
     }
-    
+
     /**
      * Removes the elements in the specified collection from this composite collection.
      * <p>
@@ -277,17 +298,17 @@
      * @return true if the collection was modified
      * @throws UnsupportedOperationException if removeAll is unsupported
      */
-    public boolean removeAll(Collection coll) {
+    public boolean removeAll(Collection<?> coll) {
         if (coll.size() == 0) {
             return false;
         }
         boolean changed = false;
-        for (int i = this.all.length - 1; i >= 0; i--) {
-            changed = (this.all[i].removeAll(coll) || changed);
+        for (Collection<? extends E> item : all) {
+            changed |= item.removeAll(coll);
         }
         return changed;
     }
-    
+
     /**
      * Retains all the elements in the specified collection in this composite collection,
      * removing all others.
@@ -298,14 +319,14 @@
      * @return true if the collection was modified
      * @throws UnsupportedOperationException if retainAll is unsupported
      */
-    public boolean retainAll(final Collection coll) {
+    public boolean retainAll(final Collection<?> coll) {
         boolean changed = false;
-        for (int i = this.all.length - 1; i >= 0; i--) {
-            changed = (this.all[i].retainAll(coll) || changed);
+        for (Collection<? extends E> item : all) {
+            changed |= item.retainAll(coll);
         }
         return changed;
     }
-    
+
     /**
      * Removes all of the elements from this collection .
      * <p>
@@ -314,88 +335,106 @@
      * @throws UnsupportedOperationException if clear is unsupported
      */
     public void clear() {
-        for (int i = 0; i < this.all.length; ++i) {
-            this.all[i].clear();
+        for (Collection<? extends E> coll : all) {
+            coll.clear();
         }
     }
-    
+
     //-----------------------------------------------------------------------
     /**
      * Specify a CollectionMutator strategy instance to handle changes.
      *
      * @param mutator  the mutator to use
      */
-    public void setMutator(CollectionMutator mutator) {
+    public void setMutator(CollectionMutator<E> mutator) {
         this.mutator = mutator;
     }
-    
+
     /**
      * Add these Collections to the list of collections in this composite
      *
-     * @param comps Collections to be appended to the composite
+     * @param compositeCollection  the Collection to be appended to the composite
      */
-    public void addComposited(Collection[] comps) {
-        ArrayList list = new ArrayList(Arrays.asList(this.all));
-        list.addAll(Arrays.asList(comps));
-        all = (Collection[]) list.toArray(new Collection[list.size()]);
+    public void addComposited(Collection<E> compositeCollection) {
+        all.add(compositeCollection);
     }
-    
+
     /**
-     * Add an additional collection to this composite.
-     * 
-     * @param c  the collection to add
+     * Add these Collections to the list of collections in this composite
+     *
+     * @param compositeCollection1  the Collection to be appended to the composite
+     * @param compositeCollection2  the Collection to be appended to the composite
      */
-    public void addComposited(Collection c) {
-        this.addComposited(new Collection[]{c});
+    public void addComposited(Collection<E> compositeCollection1, Collection<E>
compositeCollection2) {
+        all.add(compositeCollection1);
+        all.add(compositeCollection2);
     }
-    
+
     /**
-     * Add two additional collections to this composite.
-     * 
-     * @param c  the first collection to add
-     * @param d  the second collection to add
+     * Add these Collections to the list of collections in this composite
+     *
+     * @param compositeCollections  the Collections to be appended to the composite
      */
-    public void addComposited(Collection c, Collection d) {
-        this.addComposited(new Collection[]{c, d});
+    public void addComposited(Collection<E>[] compositeCollections) {
+        all.addAll(Arrays.asList(compositeCollections));
     }
-    
+
+//    /**
+//     * Add these Collections to the list of collections in this composite
+//     *
+//     * @param compositeCollections  the Collections to be appended to the composite
+//     */
+//    public void addComposited(Iterable<Collection<E>> compositeCollections)
{
+//        for (Collection<E> item : compositeCollections) {
+//            all.add(item);
+//        }
+//    }
+
     /**
      * Removes a collection from the those being decorated in this composite.
      *
      * @param coll  collection to be removed
      */
-    public void removeComposited(Collection coll) {
-        ArrayList list = new ArrayList(this.all.length);
-        list.addAll(Arrays.asList(this.all));
-        list.remove(coll);
-        this.all = (Collection[]) list.toArray(new Collection[list.size()]);
+    public void removeComposited(Collection<E> coll) {
+        all.remove(coll);
     }
-    
+
+    //-----------------------------------------------------------------------
     /**
      * Returns a new collection containing all of the elements
      *
      * @return A new ArrayList containing all of the elements in this composite.
      *         The new collection is <i>not</i> backed by this composite.
      */
-    public Collection toCollection() {
-        return new ArrayList(this);
+    public Collection<E> toCollection() {
+        return new ArrayList<E>(this);
     }
-    
+
     /**
      * Gets the collections being decorated.
      *
-     * @return Unmodifiable collection of all collections in this composite.
+     * @return Unmodifiable list of all collections in this composite.
+     */
+    public List<? extends Collection<E>> getCollections() {
+        return UnmodifiableList.decorate(all);
+    }
+
+    /**
+     * Get the collection mutator to be used for this CompositeCollection.
+     * @return CollectionMutator<E>
      */
-    public Collection getCollections() {
-        return UnmodifiableList.decorate(Arrays.asList(this.all));
+    protected CollectionMutator<E> getMutator() {
+        return mutator;
     }
-    
+
     //-----------------------------------------------------------------------
     /**
      * Pluggable strategy to handle changes to the composite.
+     *
+     * @param <E> the element being held in the collection
      */
-    public interface CollectionMutator extends Serializable {
-        
+    public interface CollectionMutator<E> extends Serializable {
+
         /**
          * Called when an object is to be added to the composite.
          *
@@ -408,8 +447,8 @@
          * @throws NullPointerException if the object cannot be added because its null
          * @throws IllegalArgumentException if the object cannot be added
          */
-        public boolean add(CompositeCollection composite, Collection[] collections, Object
obj);
-        
+        public boolean add(CompositeCollection<E> composite, List<Collection<E>>
collections, E obj);
+
         /**
          * Called when a collection is to be added to the composite.
          *
@@ -422,8 +461,8 @@
          * @throws NullPointerException if the object cannot be added because its null
          * @throws IllegalArgumentException if the object cannot be added
          */
-        public boolean addAll(CompositeCollection composite, Collection[] collections, Collection
coll);
-        
+        public boolean addAll(CompositeCollection<E> composite, List<Collection<E>>
collections, Collection<? extends E> coll);
+
         /**
          * Called when an object is to be removed to the composite.
          *
@@ -436,9 +475,9 @@
          * @throws NullPointerException if the object cannot be removed because its null
          * @throws IllegalArgumentException if the object cannot be removed
          */
-        public boolean remove(CompositeCollection composite, Collection[] collections, Object
obj);
-        
+        public boolean remove(CompositeCollection<E> composite, List<Collection<E>>
collections, Object obj);
+
     }
-    
+
 }
 



Mime
View raw message