Apache
/
commons-collections
mirror of https://github.com/apache/commons-collections.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Javadoc improvements, especially exception descriptions 

git-svn-id: https://svn.apache.org/repos/asf/jakarta/commons/proper/collections/trunk@130822 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Stephen Colebourne 2002-10-13 00:38:36 +00:00
parent 332b8ff8d8
commit 4e2452d242
6 changed files with 513 additions and 497 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

217
src/java/org/apache/commons/collections/BagUtils.java
View File

@ -1,7 +1,7 @@
/*
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/java/org/apache/commons/collections/BagUtils.java,v 1.6 2002/10/12 22:15:18 scolebourne Exp $
* $Revision: 1.6 $
* $Date: 2002/10/12 22:15:18 $
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/java/org/apache/commons/collections/BagUtils.java,v 1.7 2002/10/13 00:38:36 scolebourne Exp $
* $Revision: 1.7 $
* $Date: 2002/10/13 00:38:36 $
*
* ====================================================================
*
@ -60,22 +60,19 @@
*/
package org.apache.commons.collections;
import java.util.Comparator;
import java.util.Set;
/**
* Provides utility methods and decorators for {@link Bag}
* and {@link SortedBag} instances.<P>
* Provides utility methods and decorators for {@link Bag}
* and {@link SortedBag} instances.<P>
*
* @author Paul Jack
* @version $Id: BagUtils.java,v 1.6 2002/10/12 22:15:18 scolebourne Exp $
* @since 2.1
* @author Paul Jack
* @author Stephen Colebourne
* @version $Id: BagUtils.java,v 1.7 2002/10/13 00:38:36 scolebourne Exp $
* @since 2.1
*/
public class BagUtils {
/**
* Prevents instantiation.
*/
@ -83,8 +80,9 @@ public class BagUtils {
}
static class PredicatedBag extends CollectionUtils.PredicatedCollection
implements Bag {
static class PredicatedBag
extends CollectionUtils.PredicatedCollection
implements Bag {
public PredicatedBag(Bag b, Predicate p) {
super(b, p);
@ -114,8 +112,8 @@ public class BagUtils {
static class UnmodifiableBag
extends CollectionUtils.UnmodifiableCollection
implements Bag {
extends CollectionUtils.UnmodifiableCollection
implements Bag {
public UnmodifiableBag(Bag bag) {
super(bag);
@ -144,8 +142,8 @@ public class BagUtils {
static class SynchronizedBag
extends CollectionUtils.SynchronizedCollection
implements Bag {
extends CollectionUtils.SynchronizedCollection
implements Bag {
public SynchronizedBag(Bag bag) {
super(bag);
@ -174,8 +172,9 @@ public class BagUtils {
}
static class PredicatedSortedBag extends PredicatedBag
implements SortedBag {
static class PredicatedSortedBag
extends PredicatedBag
implements SortedBag {
public PredicatedSortedBag(SortedBag sb, Predicate p) {
super(sb, p);
@ -199,8 +198,9 @@ public class BagUtils {
}
static class SynchronizedSortedBag extends SynchronizedBag
implements SortedBag {
static class SynchronizedSortedBag
extends SynchronizedBag
implements SortedBag {
public SynchronizedSortedBag(SortedBag bag) {
super(bag);
@ -225,8 +225,9 @@ public class BagUtils {
}
static class UnmodifiableSortedBag extends UnmodifiableBag
implements SortedBag {
static class UnmodifiableSortedBag
extends UnmodifiableBag
implements SortedBag {
public UnmodifiableSortedBag(SortedBag bag) {
super(bag);
@ -252,121 +253,121 @@ public class BagUtils {
/**
* Returns a predicated bag backed by the given bag. Only objects
* that pass the test in the given predicate can be added to the bag.
* It is important not to use the original bag after invoking this
* method, as it is a backdoor for adding unvalidated objects.
* Returns a predicated bag backed by the given bag. Only objects
* that pass the test in the given predicate can be added to the bag.
* It is important not to use the original bag after invoking this
* method, as it is a backdoor for adding unvalidated objects.
*
* @param b the bag to predicate
* @param p the predicate for the bag
* @return a predicated bag backed by the given bag
* @param bag the bag to predicate, must not be null
* @param predicate the predicate for the bag, must not be null
* @return a predicated bag backed by the given bag
* @throws IllegalArgumentException if the Bag or Predicate is null
*/
public static Bag predicatedBag(Bag b, Predicate p) {
return new PredicatedBag(b, p);
public static Bag predicatedBag(Bag bag, Predicate predicate) {
return new PredicatedBag(bag, predicate);
}
/**
* Returns an unmodifiable view of the given bag. Any modification
* attempts to the returned bag will raise an
* {@link UnsupportedOperationException}.
* Returns an unmodifiable view of the given bag. Any modification
* attempts to the returned bag will raise an
* {@link UnsupportedOperationException}.
*
* @param b the bag whose unmodifiable view is to be returned
* @return an unmodifiable view of that bag
* @param bag the bag whose unmodifiable view is to be returned, must not be null
* @return an unmodifiable view of that bag
* @throws IllegalArgumentException if the Bag is null
*/
public static Bag unmodifiableBag(Bag b) {
return new UnmodifiableBag(b);
public static Bag unmodifiableBag(Bag bag) {
return new UnmodifiableBag(bag);
}
/**
* Returns a synchronized (thread-safe) bag backed by the given bag.
* In order to guarantee serial access, it is critical that all
* access to the backing bag is accomplished through the returned bag.
* <P>
* It is imperative that the user manually synchronize on the returned
* bag when iterating over it:
* Returns a synchronized (thread-safe) bag backed by the given bag.
* In order to guarantee serial access, it is critical that all
* access to the backing bag is accomplished through the returned bag.
* <p>
* It is imperative that the user manually synchronize on the returned
* bag when iterating over it:
*
* <Pre>
* Bag bag = BagUtils.synchronizedBag(new HashBag());
* ...
* synchronized(bag) {
* Iterator i = bag.iterator(); // Must be in synchronized block
* while (i.hasNext())
* foo(i.next());
* }
* }
* </Pre>
* <pre>
* Bag bag = BagUtils.synchronizedBag(new HashBag());
* ...
* synchronized(bag) {
* Iterator i = bag.iterator(); // Must be in synchronized block
* while (i.hasNext())
* foo(i.next());
* }
* }
* </pre>
*
* Failure to follow this advice may result in non-deterministic
* behavior.
* Failure to follow this advice may result in non-deterministic
* behavior.
*
* @param b the bag to synchronize
* @return a synchronized bag backed by that bag
* @param bag the bag to synchronize, must not be null
* @return a synchronized bag backed by that bag
* @throws IllegalArgumentException if the Bag is null
*/
public static Bag synchronizedBag(Bag b) {
return new SynchronizedBag(b);
public static Bag synchronizedBag(Bag bag) {
return new SynchronizedBag(bag);
}
/**
* Returns a predicated sorted bag backed by the given sorted bag.
* Only objects that pass the test in the given predicate can be
* added to the bag.
* It is important not to use the original bag after invoking this
* method, as it is a backdoor for adding unvalidated objects.
* Returns a predicated sorted bag backed by the given sorted bag.
* Only objects that pass the test in the given predicate can be
* added to the bag.
* It is important not to use the original bag after invoking this
* method, as it is a backdoor for adding unvalidated objects.
*
* @param b the sorted bag to predicate
* @param p the predicate for the bag
* @return a predicated bag backed by the given bag
* @param bag the sorted bag to predicate, must not be null
* @param predicate the predicate for the bag, must not be null
* @return a predicated bag backed by the given bag
* @throws IllegalArgumentException if the SortedBag or Predicate is null
*/
public static SortedBag predicatedSortedBag(SortedBag b, Predicate p) {
return new PredicatedSortedBag(b, p);
public static SortedBag predicatedSortedBag(SortedBag bag, Predicate predicate) {
return new PredicatedSortedBag(bag, predicate);
}
/**
* Returns an unmodifiable view of the given sorted bag. Any modification
* attempts to the returned bag will raise an
* {@link UnsupportedOperationException}.
* Returns an unmodifiable view of the given sorted bag. Any modification
* attempts to the returned bag will raise an
* {@link UnsupportedOperationException}.
*
* @param b the bag whose unmodifiable view is to be returned
* @return an unmodifiable view of that bag
* @param bag the bag whose unmodifiable view is to be returned, must not be null
* @return an unmodifiable view of that bag
* @throws IllegalArgumentException if the SortedBag is null
*/
public static SortedBag unmodifiableSortedBag(SortedBag b) {
return new UnmodifiableSortedBag(b);
public static SortedBag unmodifiableSortedBag(SortedBag bag) {
return new UnmodifiableSortedBag(bag);
}
/**
* Returns a synchronized (thread-safe) sorted bag backed by the given
* sorted bag.
* In order to guarantee serial access, it is critical that all
* access to the backing bag is accomplished through the returned bag.
* <P>
* It is imperative that the user manually synchronize on the returned
* bag when iterating over it:
* Returns a synchronized (thread-safe) sorted bag backed by the given
* sorted bag.
* In order to guarantee serial access, it is critical that all
* access to the backing bag is accomplished through the returned bag.
* <p>
* It is imperative that the user manually synchronize on the returned
* bag when iterating over it:
*
* <Pre>
* SortedBag bag = BagUtils.synchronizedSortedBag(new TreeBag());
* ...
* synchronized(bag) {
* Iterator i = bag.iterator(); // Must be in synchronized block
* while (i.hasNext())
* foo(i.next());
* }
* }
* </Pre>
* <pre>
* SortedBag bag = BagUtils.synchronizedSortedBag(new TreeBag());
* ...
* synchronized(bag) {
* Iterator i = bag.iterator(); // Must be in synchronized block
* while (i.hasNext())
* foo(i.next());
* }
* }
* </pre>
*
* Failure to follow this advice may result in non-deterministic
* behavior.
* Failure to follow this advice may result in non-deterministic
* behavior.
*
* @param b the bag to synchronize
* @return a synchronized bag backed by that bag
* @param bag the bag to synchronize, must not be null
* @return a synchronized bag backed by that bag
* @throws IllegalArgumentException if the SortedBag is null
*/
public static SortedBag synchronizedSortedBag(SortedBag b) {
return new SynchronizedSortedBag(b);
public static SortedBag synchronizedSortedBag(SortedBag bag) {
return new SynchronizedSortedBag(bag);
}
}

131
src/java/org/apache/commons/collections/BufferUtils.java
View File

@ -1,7 +1,7 @@
/*
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/java/org/apache/commons/collections/BufferUtils.java,v 1.8 2002/10/12 22:15:18 scolebourne Exp $
* $Revision: 1.8 $
* $Date: 2002/10/12 22:15:18 $
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/java/org/apache/commons/collections/BufferUtils.java,v 1.9 2002/10/13 00:38:36 scolebourne Exp $
* $Revision: 1.9 $
* $Date: 2002/10/13 00:38:36 $
*
* ====================================================================
*
@ -60,61 +60,62 @@
*/
package org.apache.commons.collections;
import java.util.Collection;
/**
* Contains static utility methods for operating on {@link Buffer} objects.
* Contains static utility methods for operating on {@link Buffer} objects.
*
* @author Paul Jack
* @version $Id: BufferUtils.java,v 1.8 2002/10/12 22:15:18 scolebourne Exp $
* @since 2.1
* @author Paul Jack
* @author Stephen Colebourne
* @version $Id: BufferUtils.java,v 1.9 2002/10/13 00:38:36 scolebourne Exp $
* @since 2.1
*/
public class BufferUtils {
/**
* Restrictive constructor
*/
private BufferUtils() {
}
/**
* Returns a synchronized buffer backed by the given buffer.
* Much like the synchronized collections returned by
* {@link java.util.Collections}, you must manually synchronize on
* the returned buffer's iterator to avoid non-deterministic behavior:
* Returns a synchronized buffer backed by the given buffer.
* Much like the synchronized collections returned by
* {@link java.util.Collections}, you must manually synchronize on
* the returned buffer's iterator to avoid non-deterministic behavior:
*
* <Pre>
* Buffer b = BufferUtils.synchronizedBuffer(myBuffer);
* synchronized (b) {
* Iterator i = b.iterator();
* while (i.hasNext()) {
* process (i.next());
* }
* }
* </Pre>
* <pre>
* Buffer b = BufferUtils.synchronizedBuffer(myBuffer);
* synchronized (b) {
* Iterator i = b.iterator();
* while (i.hasNext()) {
* process (i.next());
* }
* }
* </pre>
*
* @param b the buffer to synchronize
* @return a synchronized buffer backed by that buffer
* @param buffer the buffer to synchronize, must not be null
* @return a synchronized buffer backed by that buffer
* @throws IllegalArgumentException if the Buffer is null
*/
public static Buffer synchronizedBuffer(final Buffer b) {
return new SynchronizedBuffer(b);
public static Buffer synchronizedBuffer(final Buffer buffer) {
return new SynchronizedBuffer(buffer);
}
/**
* Returns a synchronized buffer backed by the given buffer that will
* block on {@link Buffer#get()} and {@link Buffer#remove()} operations.
* If the buffer is empty, then the {@link Buffer#get()} and
* {@link Buffer#remove()} operations will block until new elements
* are added to the buffer, rather than immediately throwing a
* <Code>BufferUnderflowException</Code>.
* Returns a synchronized buffer backed by the given buffer that will
* block on {@link Buffer#get()} and {@link Buffer#remove()} operations.
* If the buffer is empty, then the {@link Buffer#get()} and
* {@link Buffer#remove()} operations will block until new elements
* are added to the buffer, rather than immediately throwing a
* <code>BufferUnderflowException</code>.
*
* @param buf the buffer to synchronize
* @return a blocking buffer backed by that buffer
* @param buffer the buffer to synchronize, must not be null
* @return a blocking buffer backed by that buffer
* @throws IllegalArgumentException if the Buffer is null
*/
public static Buffer blockingBuffer(Buffer buf) {
return new SynchronizedBuffer(buf) {
public static Buffer blockingBuffer(Buffer buffer) {
return new SynchronizedBuffer(buffer) {
public synchronized boolean add(Object o) {
boolean r = collection.add(o);
@ -152,38 +153,38 @@ public class BufferUtils {
};
}
/**
* Returns an unmodifiable buffer backed by the given buffer.
* Returns an unmodifiable buffer backed by the given buffer.
*
* @param b the buffer to make unmodifiable
* @return an unmodifiable buffer backed by that buffer
* @param buffer the buffer to make unmodifiable, must not be null
* @return an unmodifiable buffer backed by that buffer
* @throws IllegalArgumentException if the Buffer is null
*/
public static Buffer unmodifiableBuffer(Buffer b) {
return new UnmodifiableBuffer(b);
public static Buffer unmodifiableBuffer(Buffer buffer) {
return new UnmodifiableBuffer(buffer);
}
/**
* Returns a predicated buffer backed by the given buffer. Elements are
* evaluated with the given predicate before being added to the buffer.
* If the predicate evaluation returns false, then an
* IllegalArgumentException is raised and the element is not added to
* the buffer.
* Returns a predicated buffer backed by the given buffer. Elements are
* evaluated with the given predicate before being added to the buffer.
* If the predicate evaluation returns false, then an
* IllegalArgumentException is raised and the element is not added to
* the buffer.
*
* @param buf the buffer to predicate
* @param p the predicate used to evaluate new elements
* @return a predicated buffer
* @param buffer the buffer to predicate, must not be null
* @param predicate the predicate used to evaluate new elements, must not be null
* @return a predicated buffer
* @throws IllegalArgumentException if the Buffer or Predicate is null
*/
public static Buffer predicatedBuffer(Buffer buf, final Predicate p) {
return new PredicatedBuffer(buf, p);
public static Buffer predicatedBuffer(Buffer buffer, final Predicate predicate) {
return new PredicatedBuffer(buffer, predicate);
}
private static class SynchronizedBuffer
extends CollectionUtils.SynchronizedCollection
implements Buffer {
static class SynchronizedBuffer
extends CollectionUtils.SynchronizedCollection
implements Buffer {
public SynchronizedBuffer(Buffer b) {
super(b);
@ -199,9 +200,9 @@ public class BufferUtils {
}
private static class UnmodifiableBuffer
extends CollectionUtils.UnmodifiableCollection
implements Buffer {
static class UnmodifiableBuffer
extends CollectionUtils.UnmodifiableCollection
implements Buffer {
public UnmodifiableBuffer(Buffer b) {
super(b);
@ -218,9 +219,9 @@ public class BufferUtils {
}
private static class PredicatedBuffer
extends CollectionUtils.PredicatedCollection
implements Buffer {
static class PredicatedBuffer
extends CollectionUtils.PredicatedCollection
implements Buffer {
public PredicatedBuffer(Buffer b, Predicate p) {
super(b, p);

84
src/java/org/apache/commons/collections/CollectionUtils.java
View File

@ -1,7 +1,7 @@
/*
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/java/org/apache/commons/collections/CollectionUtils.java,v 1.17 2002/10/12 21:59:45 scolebourne Exp $
* $Revision: 1.17 $
* $Date: 2002/10/12 21:59:45 $
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/java/org/apache/commons/collections/CollectionUtils.java,v 1.18 2002/10/13 00:38:36 scolebourne Exp $
* $Revision: 1.18 $
* $Date: 2002/10/13 00:38:36 $
*
* ====================================================================
*
@ -75,7 +75,6 @@ import java.util.Set;
import org.apache.commons.collections.iterators.ArrayIterator;
import org.apache.commons.collections.iterators.EnumerationIterator;
/**
* A set of {@link Collection} related utility methods.
*
@ -84,7 +83,7 @@ import org.apache.commons.collections.iterators.EnumerationIterator;
* @author Paul Jack
* @author Stephen Colebourne
* @author Steve Downey
* @version $Revision: 1.17 $ $Date: 2002/10/12 21:59:45 $
* @version $Revision: 1.18 $ $Date: 2002/10/13 00:38:36 $
*/
public class CollectionUtils {
@ -727,33 +726,37 @@ public class CollectionUtils {
}
/**
* Base class for collection decorators. I decided to do it this way
* because it seemed to result in the most reuse.
*
* Inner class tree looks like:
* Base class for collection decorators. I decided to do it this way
* because it seemed to result in the most reuse.
*
* Inner class tree looks like:
* <pre>
* CollectionWrapper
* PredicatedCollection
* PredicatedSet
* PredicatedList
* PredicatedBag
* BoundedCollection
* BoundedSet
* BoundedList
* BoundedBag
* PredicatedBuffer
* UnmodifiableCollection
* UnmodifiableBag
* UnmodifiableBuffer
* LazyCollection
* LazyList
* LazyBag
* SynchronizedCollection
* SynchronizedBuffer
* SynchronizedBag
* SynchronizedBuffer
* </pre>
*/
static class CollectionWrapper implements Collection {
static class CollectionWrapper
implements Collection {
final protected Collection collection;
protected final Collection collection;
public CollectionWrapper(Collection collection) {
if (collection == null) {
throw new IllegalArgumentException("Collection must not be null.");
throw new IllegalArgumentException("Collection must not be null");
}
this.collection = collection;
}
@ -826,14 +829,15 @@ public class CollectionUtils {
}
static class PredicatedCollection extends CollectionWrapper {
static class PredicatedCollection
extends CollectionWrapper {
final protected Predicate predicate;
protected final Predicate predicate;
public PredicatedCollection(Collection c, Predicate p) {
super(c);
if (p == null) {
throw new IllegalArgumentException("Predicate must not be null.");
throw new IllegalArgumentException("Predicate must not be null");
}
this.predicate = p;
for (Iterator iter = c.iterator(); iter.hasNext(); ) {
@ -846,7 +850,6 @@ public class CollectionUtils {
return collection.add(o);
}
public boolean addAll(Collection c2) {
for (Iterator iter = c2.iterator(); iter.hasNext(); ) {
validate(iter.next());
@ -854,18 +857,17 @@ public class CollectionUtils {
return collection.addAll(c2);
}
protected void validate(Object o) {
if (!predicate.evaluate(o)) {
throw new IllegalArgumentException("Object failed predicate.");
throw new IllegalArgumentException("Cannot add Object - Predicate rejected it");
}
}
}
static class UnmodifiableCollection extends CollectionWrapper {
static class UnmodifiableCollection
extends CollectionWrapper {
public UnmodifiableCollection(Collection c) {
super(c);
@ -904,11 +906,11 @@ public class CollectionUtils {
static class SynchronizedCollection {
final protected Collection collection;
protected final Collection collection;
public SynchronizedCollection(Collection collection) {
if (collection == null) {
throw new IllegalArgumentException("Collection must not be null.");
throw new IllegalArgumentException("Collection must not be null");
}
this.collection = collection;
}
@ -980,11 +982,15 @@ public class CollectionUtils {
}
static class UnmodifiableIterator implements Iterator {
static class UnmodifiableIterator
implements Iterator {
final protected Iterator iterator;
protected final Iterator iterator;
public UnmodifiableIterator(Iterator iterator) {
if (iterator == null) {
throw new IllegalArgumentException("Iterator must not be null");
}
this.iterator = iterator;
}
@ -1003,19 +1009,19 @@ public class CollectionUtils {
/**
* Returns a predicated collection backed by the given collection.
* Only objects that pass the test in the given predicate can be
* added to the collection.
* It is important not to use the original collection after invoking this
* method, as it is a backdoor for adding unvalidated objects.
* Returns a predicated collection backed by the given collection.
* Only objects that pass the test in the given predicate can be
* added to the collection.
* It is important not to use the original collection after invoking this
* method, as it is a backdoor for adding unvalidated objects.
*
* @param b the collection to predicate
* @param p the predicate for the collection
* @return a predicated collection backed by the given collection
* @param collection the collection to predicate, must not be null
* @param predicate the predicate for the collection, must not be null
* @return a predicated collection backed by the given collection
* @throws IllegalArgumentException if the Collection is null
*/
public static Collection predicatedCollection(Collection c, Predicate p) {
return new PredicatedCollection(c, p);
public static Collection predicatedCollection(Collection collection, Predicate predicate) {
return new PredicatedCollection(collection, predicate);
}
}

211
src/java/org/apache/commons/collections/ListUtils.java
View File

@ -1,7 +1,7 @@
/*
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/java/org/apache/commons/collections/ListUtils.java,v 1.10 2002/08/18 20:11:37 pjack Exp $
* $Revision: 1.10 $
* $Date: 2002/08/18 20:11:37 $
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/java/org/apache/commons/collections/ListUtils.java,v 1.11 2002/10/13 00:38:36 scolebourne Exp $
* $Revision: 1.11 $
* $Date: 2002/10/13 00:38:36 $
*
* ====================================================================
*
@ -65,7 +65,6 @@ import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
/**
* Contains static utility methods and decorators for {@link List}
* instances.
@ -74,9 +73,9 @@ import java.util.ListIterator;
* @author <a href="mailto:fede@apache.org">Federico Barbieri</a>
* @author <a href="mailto:donaldp@apache.org">Peter Donald</a>
* @author Paul Jack
* @author Stephen Colebourne
*/
public class ListUtils
{
public class ListUtils {
/**
* Please don't ever instantiate a <Code>ListUtils</Code>.
@ -85,95 +84,86 @@ public class ListUtils
}
/**
* Returns a new list containing all elements that are contained in
* both given lists.
* Returns a new list containing all elements that are contained in
* both given lists.
*
* @param list1 the first list
* @param list2 the second list
* @return the intersection of those two lists
* @throws NullPointerException if either list is null
* @param list1 the first list
* @param list2 the second list
* @return the intersection of those two lists
* @throws NullPointerException if either list is null
*/
public static List intersection( final List list1, final List list2 )
{
public static List intersection(final List list1, final List list2) {
final ArrayList result = new ArrayList();
final Iterator iterator = list2.iterator();
while( iterator.hasNext() )
{
while (iterator.hasNext()) {
final Object o = iterator.next();
if ( list1.contains( o ) )
{
result.add( o );
if (list1.contains(o)) {
result.add(o);
}
}
return result;
}
/**
* Subtracts all elements in the second list from the first list,
* placing the results in a new list.
* This differs from {@link List#removeAll(Collection)} in that
* cardinality is respected; if <Code>list1</Code> contains two
* occurrences of <Code>null</Code> and <Code>list2</Code> only
* contains one occurrence, then the returned list will still contain
* one occurrence.
* Subtracts all elements in the second list from the first list,
* placing the results in a new list.
* This differs from {@link List#removeAll(Collection)} in that
* cardinality is respected; if <Code>list1</Code> contains two
* occurrences of <Code>null</Code> and <Code>list2</Code> only
* contains one occurrence, then the returned list will still contain
* one occurrence.
*
* @param list1 the list to subtract from
* @param list2 the lsit to subtract
* @return a new list containing the results
* @throws NullPointerException if either list is null
* @param list1 the list to subtract from
* @param list2 the lsit to subtract
* @return a new list containing the results
* @throws NullPointerException if either list is null
*/
public static List subtract( final List list1, final List list2 )
{
final ArrayList result = new ArrayList( list1 );
public static List subtract(final List list1, final List list2) {
final ArrayList result = new ArrayList(list1);
final Iterator iterator = list2.iterator();
while( iterator.hasNext() )
{
result.remove( iterator.next() );
while (iterator.hasNext()) {
result.remove(iterator.next());
}
return result;
}
/**
* Returns the sum of the given lists. This is their intersection
* subtracted from their union.
* Returns the sum of the given lists. This is their intersection
* subtracted from their union.
*
* @param list1 the first list
* @param list2 the second list
* @return a new list containing the sum of those lists
* @throws NullPointerException if either list is null
* @param list1 the first list
* @param list2 the second list
* @return a new list containing the sum of those lists
* @throws NullPointerException if either list is null
*/
public static List sum( final List list1, final List list2 )
{
return subtract( union( list1, list2 ),
intersection( list1, list2 ) );
public static List sum(final List list1, final List list2) {
return subtract(union(list1, list2), intersection(list1, list2));
}
/**
* Returns a new list containing the second list appended to the
* first list. The {@link List#addAll(Collection)} operation is
* used to append the two given lists into a new list.
* Returns a new list containing the second list appended to the
* first list. The {@link List#addAll(Collection)} operation is
* used to append the two given lists into a new list.
*
* @param list1 the first list
* @param list2 the second list
* @return a new list containing the union of those lists
* @throws NullPointerException if either list is null
* @param list1 the first list
* @param list2 the second list
* @return a new list containing the union of those lists
* @throws NullPointerException if either list is null
*/
public static List union( final List list1, final List list2 )
{
final ArrayList result = new ArrayList( list1 );
result.addAll( list2 );
public static List union(final List list1, final List list2) {
final ArrayList result = new ArrayList(list1);
result.addAll(list2);
return result;
}
static class ListIteratorWrapper implements ListIterator {
static class ListIteratorWrapper
implements ListIterator {
final protected ListIterator iterator;
@ -220,8 +210,9 @@ public class ListUtils
}
static class PredicatedList extends CollectionUtils.PredicatedCollection
implements List {
static class PredicatedList
extends CollectionUtils.PredicatedCollection
implements List {
public PredicatedList(List list, Predicate p) {
super(list, p);
@ -290,8 +281,9 @@ public class ListUtils
}
static class FixedSizeList extends CollectionUtils.UnmodifiableCollection
implements List {
static class FixedSizeList
extends CollectionUtils.UnmodifiableCollection
implements List {
public FixedSizeList(List list) {
super(list);
@ -357,15 +349,16 @@ public class ListUtils
}
static class LazyList extends CollectionUtils.CollectionWrapper
implements List {
static class LazyList
extends CollectionUtils.CollectionWrapper
implements List {
final protected Factory factory;
protected final Factory factory;
public LazyList(List list, Factory factory) {
super(list);
if (factory == null) {
throw new IllegalArgumentException("factory may not be null");
throw new IllegalArgumentException("Factory must not be null");
}
this.factory = factory;
}
@ -452,65 +445,65 @@ public class ListUtils
/**
* Returns a predicated list backed by the given list. Only objects
* that pass the test in the given predicate can be added to the list.
* It is important not to use the original list after invoking this
* method, as it is a backdoor for adding unvalidated objects.
* Returns a predicated list backed by the given list. Only objects
* that pass the test in the given predicate can be added to the list.
* It is important not to use the original list after invoking this
* method, as it is a backdoor for adding unvalidated objects.
*
* @param list the list to predicate
* @param p the predicate for the list
* @return a predicated list backed by the given list
* @param list the list to predicate, must not be null
* @param predicate the predicate for the list, must not be null
* @return a predicated list backed by the given list
* @throws IllegalArgumentException if the List or Predicate is null
*/
public static List predicatedList(List list, Predicate p) {
return new PredicatedList(list, p);
public static List predicatedList(List list, Predicate predicate) {
return new PredicatedList(list, predicate);
}
/**
* Returns a "lazy" list whose elements will be created on demand.<P>
* <P>
* When the index passed to the returned list's {@link List#get(int) get}
* method is greater than the list's size, then the factory will be used
* to create a new object and that object will be inserted at that index.
* <P>
* For instance:
* Returns a "lazy" list whose elements will be created on demand.<P>
* <p>
* When the index passed to the returned list's {@link List#get(int) get}
* method is greater than the list's size, then the factory will be used
* to create a new object and that object will be inserted at that index.
* <p>
* For instance:
*
* <Pre>
* Factory factory = new Factory() {
* public Object create() {
* return new Date();
* }
* }
* List lazy = ListUtils.lazyList(new ArrayList(), factory);
* Object obj = lazy.get(3);
* </Pre>
* <pre>
* Factory factory = new Factory() {
* public Object create() {
* return new Date();
* }
* }
* List lazy = ListUtils.lazyList(new ArrayList(), factory);
* Object obj = lazy.get(3);
* </pre>
*
* After the above code is executed, <Code>obj</Code> will contain
* a new <Code>Date</Code> instance. Furthermore, that <Code>Date</Code>
* instance is the fourth element in the list. The first, second,
* and third element are all set to <Code>null</Code>.<P>
* After the above code is executed, <code>obj</code> will contain
* a new <code>Date</code> instance. Furthermore, that <code>Date</code>
* instance is the fourth element in the list. The first, second,
* and third element are all set to <code>null</code>.
*
* @param list the list to make lazy
* @param factory the factory for creating new objects
* @return a lazy list backed by the given list
* @param list the list to make lazy, must not be null
* @param factory the factory for creating new objects, must not be null
* @return a lazy list backed by the given list
* @throws IllegalArgumentException if the List or Factory is null
*/
public static List lazyList(List list, Factory factory) {
return new LazyList(list, factory);
}
/**
* Returns a fixed-sized list backed by the given list.
* Elements may not be added or removed from the returned list, but
* existing elements can be changed (for instance, via the
* {@link List#set(int,Object)} method).
* Returns a fixed-sized list backed by the given list.
* Elements may not be added or removed from the returned list, but
* existing elements can be changed (for instance, via the
* {@link List#set(int,Object)} method).
*
* @param list the list whose size to fix
* @return a fixed-size list backed by that list
* @param list the list whose size to fix, must not be null
* @return a fixed-size list backed by that list
* @throws IllegalArgumentException if the List is null
*/
public static List fixedSizeList(List list) {
return new FixedSizeList(list);
}
}

284
src/java/org/apache/commons/collections/MapUtils.java
View File

@ -1,7 +1,7 @@
/*
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/java/org/apache/commons/collections/MapUtils.java,v 1.12 2002/08/19 21:56:18 pjack Exp $
* $Revision: 1.12 $
* $Date: 2002/08/19 21:56:18 $
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/java/org/apache/commons/collections/MapUtils.java,v 1.13 2002/10/13 00:38:36 scolebourne Exp $
* $Revision: 1.13 $
* $Date: 2002/10/13 00:38:36 $
*
* ====================================================================
*
@ -64,29 +64,30 @@ import java.io.*;
import java.text.*;
import java.text.NumberFormat;
import java.util.*;
/** A helper class for using {@link Map Map} instances.<P>
*
* It contains various typesafe methods
* as well as other useful features like deep copying.<P>
*
* It also provides the following decorators:
*
* <UL>
* <LI>{@link #fixedSizeMap(Map)}
* <LI>{@link #fixedSizeSortedMap(SortedMap)}
* <LI>{@link #lazyMap(Map,Factory)}
* <LI>{@link #lazySortedMap(SortedMap,Factory)}
* <LI>{@link #predicatedMap(Map,Predicate,Predicate)}
* <LI>{@link #predicatedSortedMap(SortedMap,Predicate,Predicate)}
* </UL>
*
* @since 1.0
* @author <a href="mailto:jstrachan@apache.org">James Strachan</a>
* @author <a href="mailto:nissim@nksystems.com">Nissim Karpenstein</a>
* @author <a href="mailto:knielsen@apache.org">Kasper Nielsen</a>
* @author Paul Jack
*/
/**
* A helper class for using {@link Map Map} instances.<P>
*
* It contains various typesafe methods
* as well as other useful features like deep copying.<P>
*
* It also provides the following decorators:
*
* <UL>
* <LI>{@link #fixedSizeMap(Map)}
* <LI>{@link #fixedSizeSortedMap(SortedMap)}
* <LI>{@link #lazyMap(Map,Factory)}
* <LI>{@link #lazySortedMap(SortedMap,Factory)}
* <LI>{@link #predicatedMap(Map,Predicate,Predicate)}
* <LI>{@link #predicatedSortedMap(SortedMap,Predicate,Predicate)}
* </UL>
*
* @since 1.0
* @author <a href="mailto:jstrachan@apache.org">James Strachan</a>
* @author <a href="mailto:nissim@nksystems.com">Nissim Karpenstein</a>
* @author <a href="mailto:knielsen@apache.org">Kasper Nielsen</a>
* @author Paul Jack
* @author Stephen Colebourne
*/
public class MapUtils {
private static int debugIndent = 0;
@ -727,22 +728,22 @@ public class MapUtils {
}
static class PredicatedMap extends ProxyMap {
final protected Predicate keyPredicate;
final protected Predicate valuePredicate;
static class PredicatedMap
extends ProxyMap {
protected final Predicate keyPredicate;
protected final Predicate valuePredicate;
public PredicatedMap(Map map, Predicate keyPred, Predicate valuePred) {
super(map);
if (map == null) {
throw new IllegalArgumentException("map may not be null.");
throw new IllegalArgumentException("Map must not be null");
}
if (keyPred == null) {
throw new IllegalArgumentException("keyPred may not be null.");
throw new IllegalArgumentException("Key Predicate must not be null");
}
if (valuePred == null) {
throw new IllegalArgumentException("valuePred may not be null.");
throw new IllegalArgumentException("Value Predicate must not be null");
}
this.keyPredicate = keyPred;
this.valuePredicate = valuePred;
@ -778,20 +779,20 @@ public class MapUtils {
private void validate(Object key, Object value) {
if (!keyPredicate.evaluate(key)) {
throw new IllegalArgumentException("Invalid key.");
throw new IllegalArgumentException("Cannot add key - Predicate rejected it");
}
if (!valuePredicate.evaluate(value)) {
throw new IllegalArgumentException("Invalid value.");
throw new IllegalArgumentException("Cannot add value - Predicate rejected it");
}
}
}
static class PredicatedMapEntrySet
extends CollectionUtils.CollectionWrapper
implements Set {
extends CollectionUtils.CollectionWrapper
implements Set {
final private Predicate predicate;
private final Predicate predicate;
public PredicatedMapEntrySet(Set set, Predicate p) {
super(set);
@ -818,13 +819,20 @@ public class MapUtils {
}
static class PredicatedMapEntry implements Map.Entry {
static class PredicatedMapEntry
implements Map.Entry {
final private Map.Entry entry;
final private Predicate predicate;
private final Map.Entry entry;
private final Predicate predicate;
public PredicatedMapEntry(Map.Entry entry, Predicate p) {
if (entry == null) {
throw new IllegalArgumentException("Map.Entry must not be null");
}
if (p == null) {
throw new IllegalArgumentException("Predicate must not be null");
}
this.entry = entry;
this.predicate = p;
}
@ -851,26 +859,27 @@ public class MapUtils {
public Object setValue(Object o) {
if (!predicate.evaluate(o)) {
throw new IllegalArgumentException("Invalid value.");
throw new IllegalArgumentException("Cannot set value - Predicate rejected it");
}
return entry.setValue(o);
}
}
static class FixedSizeMap extends ProxyMap {
static class FixedSizeMap
extends ProxyMap {
public FixedSizeMap(Map map) {
super(map);
if (map == null) {
throw new IllegalArgumentException("map may not be null.");
throw new IllegalArgumentException("Map must not be null");
}
}
public Object put(Object key, Object value) {
if (!map.containsKey(key)) {
throw new IllegalArgumentException("Can't add new keys.");
throw new IllegalArgumentException("Cannot put new key/value pair - List is fixed size");
}
return map.put(key, value);
}
@ -879,7 +888,7 @@ public class MapUtils {
public void putAll(Map m) {
for (Iterator iter = m.keySet().iterator(); iter.hasNext(); ) {
if (!map.containsKey(iter.next())) {
throw new IllegalArgumentException("Can't add new keys.");
throw new IllegalArgumentException("Cannot put new key/value pair - List is fixed size");
}
}
map.putAll(m);
@ -888,18 +897,18 @@ public class MapUtils {
}
static class LazyMap extends ProxyMap {
final protected Factory factory;
static class LazyMap
extends ProxyMap {
protected final Factory factory;
public LazyMap(Map map, Factory factory) {
super(map);
if (map == null) {
throw new IllegalArgumentException("map may not be null.");
throw new IllegalArgumentException("Map must not be null");
}
if (factory == null) {
throw new IllegalArgumentException("factory may not be null.");
throw new IllegalArgumentException("Factory must not be null");
}
this.factory = factory;
}
@ -918,8 +927,9 @@ public class MapUtils {
static class PredicatedSortedMap extends PredicatedMap
implements SortedMap {
static class PredicatedSortedMap
extends PredicatedMap
implements SortedMap {
public PredicatedSortedMap(SortedMap map, Predicate k, Predicate v) {
super(map, k, v);
@ -962,7 +972,9 @@ public class MapUtils {
}
static class FixedSizeSortedMap extends FixedSizeMap implements SortedMap {
static class FixedSizeSortedMap
extends FixedSizeMap
implements SortedMap {
public FixedSizeSortedMap(SortedMap m) {
super(m);
@ -1002,7 +1014,9 @@ public class MapUtils {
}
static class LazySortedMap extends LazyMap implements SortedMap {
static class LazySortedMap
extends LazyMap
implements SortedMap {
public LazySortedMap(SortedMap m, Factory factory) {
super(m, factory);
@ -1043,127 +1057,129 @@ public class MapUtils {
/**
* Returns a predicated map backed by the given map. Only keys and
* values that pass the given predicates can be added to the map.
* It is important not to use the original map after invoking this
* method, as it is a backdoor for adding unvalidated objects.
* Returns a predicated map backed by the given map. Only keys and
* values that pass the given predicates can be added to the map.
* It is important not to use the original map after invoking this
* method, as it is a backdoor for adding unvalidated objects.
*
* @param map the map to predicate
* @param keyPred the predicate for keys
* @param valuePred the predicate for values
* @return a predicated map backed by the given map
* @param map the map to predicate, must not be null
* @param keyPred the predicate for keys, must not be null
* @param valuePred the predicate for values, must not be null
* @return a predicated map backed by the given map
* @throws IllegalArgumentException if the Map or Predicates are null
*/
public static Map predicatedMap(Map map, Predicate keyPred, Predicate valuePred) {
return new PredicatedMap(map, keyPred, valuePred);
}
/**
* Returns a fixed-sized map backed by the given map.
* Elements may not be added or removed from the returned map, but
* existing elements can be changed (for instance, via the
* {@link Map#put(Object,Object)} method).
* Returns a fixed-sized map backed by the given map.
* Elements may not be added or removed from the returned map, but
* existing elements can be changed (for instance, via the
* {@link Map#put(Object,Object)} method).
*
* @param map the map whose size to fix
* @return a fixed-size map backed by that map
* @param map the map whose size to fix, must not be null
* @return a fixed-size map backed by that map
* @throws IllegalArgumentException if the Map is null
*/
public static Map fixedSizeMap(Map map) {
return new FixedSizeMap(map);
}
/**
* Returns a "lazy" map whose values will be created on demand.<P>
* <P>
* When the key passed to the returned map's {@link Map#get(Object)}
* method is not present in the map, then the factory will be used
* to create a new object and that object will become the value
* associated with that key.
* <P>
* For instance:
* Returns a "lazy" map whose values will be created on demand.<P>
* <p>
* When the key passed to the returned map's {@link Map#get(Object)}
* method is not present in the map, then the factory will be used
* to create a new object and that object will become the value
* associated with that key.
* <p>
* For instance:
*
* <Pre>
* Factory factory = new Factory() {
* public Object create() {
* return new Date();
* }
* }
* Map lazy = MapUtils.lazyMap(new HashMap(), factory);
* Object obj = lazy.get("test");
* </Pre>
* <pre>
* Factory factory = new Factory() {
* public Object create() {
* return new Date();
* }
* }
* Map lazy = MapUtils.lazyMap(new HashMap(), factory);
* Object obj = lazy.get("test");
* </pre>
*
* After the above code is executed, <Code>obj</Code> will contain
* a new <Code>Date</Code> instance. Furthermore, that <Code>Date</Code>
* instance is the value for the <Code>test</Code> key.<P>
* After the above code is executed, <code>obj</code> will contain
* a new <code>Date</code> instance. Furthermore, that <code>Date</code>
* instance is the value for the <code>test</code> key.
*
* @param map the map to make lazy
* @param factory the factory for creating new objects
* @return a lazy map backed by the given map
* @param map the map to make lazy, must not be null
* @param factory the factory for creating new objects, must not be null
* @return a lazy map backed by the given map
* @throws IllegalArgumentException if the Map or Factory is null
*/
public static Map lazyMap(Map map, Factory factory) {
return new LazyMap(map, factory);
}
/**
* Returns a predicated sorted map backed by the given map. Only keys and
* values that pass the given predicates can be added to the map.
* It is important not to use the original map after invoking this
* method, as it is a backdoor for adding unvalidated objects.
* Returns a predicated sorted map backed by the given map. Only keys and
* values that pass the given predicates can be added to the map.
* It is important not to use the original map after invoking this
* method, as it is a backdoor for adding unvalidated objects.
*
* @param map the map to predicate
* @param keyPred the predicate for keys
* @param valuePred the predicate for values
* @return a predicated map backed by the given map
* @param map the map to predicate, must not be null
* @param keyPred the predicate for keys, must not be null
* @param valuePred the predicate for values, must not be null
* @return a predicated map backed by the given map
* @throws IllegalArgumentException if the SortedMap or Predicates are null
*/
public static SortedMap predicatedSortedMap(SortedMap map, Predicate keyPred, Predicate valuePred) {
return new PredicatedSortedMap(map, keyPred, valuePred);
}
/**
* Returns a fixed-sized sorted map backed by the given sorted map.
* Elements may not be added or removed from the returned map, but
* existing elements can be changed (for instance, via the
* {@link Map#put(Object,Object)} method).
* Returns a fixed-sized sorted map backed by the given sorted map.
* Elements may not be added or removed from the returned map, but
* existing elements can be changed (for instance, via the
* {@link Map#put(Object,Object)} method).
*
* @param map the map whose size to fix
* @return a fixed-size map backed by that map
* @param map the map whose size to fix, must not be null
* @return a fixed-size map backed by that map
* @throws IllegalArgumentException if the SortedMap is null
*/
public static SortedMap fixedSizeSortedMap(SortedMap map) {
return new FixedSizeSortedMap(map);
}
/**
* Returns a "lazy" sorted map whose values will be created on demand.
* <P>
* When the key passed to the returned map's {@link Map#get(Object)}
* method is not present in the map, then the factory will be used
* to create a new object and that object will become the value
* associated with that key.
* <P>
* For instance:
* Returns a "lazy" sorted map whose values will be created on demand.
* <p>
* When the key passed to the returned map's {@link Map#get(Object)}
* method is not present in the map, then the factory will be used
* to create a new object and that object will become the value
* associated with that key.
* <p>
* For instance:
*
* <Pre>
* Factory factory = new Factory() {
* public Object create() {
* return new Date();
* }
* }
* SortedMap lazy = MapUtils.lazySortedMap(new TreeMap(), factory);
* Object obj = lazy.get("test");
* </Pre>
* <pre>
* Factory factory = new Factory() {
* public Object create() {
* return new Date();
* }
* }
* SortedMap lazy = MapUtils.lazySortedMap(new TreeMap(), factory);
* Object obj = lazy.get("test");
* </pre>
*
* After the above code is executed, <Code>obj</Code> will contain
* a new <Code>Date</Code> instance. Furthermore, that <Code>Date</Code>
* instance is the value for the <Code>test</Code> key.<P>
* After the above code is executed, <code>obj</code> will contain
* a new <code>Date</code> instance. Furthermore, that <code>Date</code>
* instance is the value for the <code>test</code> key.
*
* @param map the map to make lazy
* @param factory the factory for creating new objects
* @return a lazy map backed by the given map
* @param map the map to make lazy, must not be null
* @param factory the factory for creating new objects, must not be null
* @return a lazy map backed by the given map
* @throws IllegalArgumentException if the SortedMap or Factory is null
*/
public static SortedMap lazySortedMap(SortedMap map, Factory factory) {
return new LazySortedMap(map, factory);
}
}

83
src/java/org/apache/commons/collections/SetUtils.java
View File

@ -1,7 +1,7 @@
/*
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/java/org/apache/commons/collections/SetUtils.java,v 1.6 2002/10/12 22:15:19 scolebourne Exp $
* $Revision: 1.6 $
* $Date: 2002/10/12 22:15:19 $
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/java/org/apache/commons/collections/SetUtils.java,v 1.7 2002/10/13 00:38:36 scolebourne Exp $
* $Revision: 1.7 $
* $Date: 2002/10/13 00:38:36 $
*
* ====================================================================
*
@ -60,45 +60,44 @@
*/
package org.apache.commons.collections;
import java.util.Comparator;
import java.util.Set;
import java.util.SortedSet;
/**
* Provides static utility methods and decorators for {@link Set}
* and {@link SortedSet} instances.
* Provides static utility methods and decorators for {@link Set}
* and {@link SortedSet} instances.
*
* @author Paul Jack
* @version $Id: SetUtils.java,v 1.6 2002/10/12 22:15:19 scolebourne Exp $
* @since 2.1
* @author Paul Jack
* @author Stephen Colebourne
* @version $Id: SetUtils.java,v 1.7 2002/10/13 00:38:36 scolebourne Exp $
* @since 2.1
*/
public class SetUtils {
/**
* Prevents instantiation.
* Prevents instantiation.
*/
private SetUtils() {
}
static class PredicatedSet extends CollectionUtils.PredicatedCollection
implements Set {
static class PredicatedSet
extends CollectionUtils.PredicatedCollection
implements Set {
public PredicatedSet(Set set, Predicate p) {
super(set, p);
public PredicatedSet(Set set, Predicate predicate) {
super(set, predicate);
}
}
static class PredicatedSortedSet extends PredicatedSet
implements SortedSet {
static class PredicatedSortedSet
extends PredicatedSet
implements SortedSet {
public PredicatedSortedSet(SortedSet s, Predicate p) {
super(s, p);
public PredicatedSortedSet(SortedSet set, Predicate predicate) {
super(set, predicate);
}
public SortedSet subSet(Object o1, Object o2) {
@ -135,34 +134,34 @@ public class SetUtils {
}
/**
* Returns a predicated set backed by the given set. Only objects
* that pass the test in the given predicate can be added to the set.
* It is important not to use the original set after invoking this
* method, as it is a backdoor for adding unvalidated objects.
* Returns a predicated set backed by the given set. Only objects
* that pass the test in the given predicate can be added to the set.
* It is important not to use the original set after invoking this
* method, as it is a backdoor for adding unvalidated objects.
*
* @param set the set to predicate
* @param p the predicate for the set
* @return a predicated set backed by the given set
* @param set the set to predicate, must not be null
* @param predicate the predicate for the set, must not be null
* @return a predicated set backed by the given set
* @throws IllegalArgumentException if the Set or Predicate is null
*/
public static Set predicatedSet(Set set, Predicate p) {
return new PredicatedSet(set, p);
public static Set predicatedSet(Set set, Predicate predicate) {
return new PredicatedSet(set, predicate);
}
/**
* Returns a predicated sorted set backed by the given sorted set.
* Only objects that pass the test in the given predicate can be added
* to the sorted set.
* It is important not to use the original sorted set after invoking this
* method, as it is a backdoor for adding unvalidated objects.
* Returns a predicated sorted set backed by the given sorted set.
* Only objects that pass the test in the given predicate can be added
* to the sorted set.
* It is important not to use the original sorted set after invoking this
* method, as it is a backdoor for adding unvalidated objects.
*
* @param set the sorted set to predicate
* @param p the predicate for the sorted set
* @return a predicated sorted set backed by the given sorted set
* @param set the sorted set to predicate, must not be null
* @param predicate the predicate for the sorted set, must not be null
* @return a predicated sorted set backed by the given sorted set
* @throws IllegalArgumentException if the Set or Predicate is null
*/
public static SortedSet predicatedSortedSet(SortedSet set, Predicate p) {
return new PredicatedSortedSet(set, p);
public static SortedSet predicatedSortedSet(SortedSet set, Predicate predicate) {
return new PredicatedSortedSet(set, predicate);
}
}