IteratorEnumeration that will not
* function until {@link #setIterator(Iterator) setIterator} is
* invoked.
*/
public IteratorEnumeration() {
super();
}
/**
* Constructs a new IteratorEnumeration that will use
* the given iterator.
*
* @param iterator the iterator to use
*/
public IteratorEnumeration( Iterator iterator ) {
super(iterator);
}
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/MultiHashMap.java 0100644 0001750 0001750 00000012030 10055172400 031442 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/**
* MultiHashMap is the default implementation of the
* {@link org.apache.commons.collections.MultiMap MultiMap} interface.
* A MultiMap 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.
*
* @since 2.0
* @author Christopher Berry
* @author James Strachan
* @author Steve Downey
* @author Stephen Colebourne
*/
public class MultiHashMap extends HashMap implements MultiMap
{
//----------------- Data
private static int sCount = 0;
private String mName = null;
public MultiHashMap()
{
super();
setName();
}
public MultiHashMap( int initialCapacity )
{
super( initialCapacity );
setName();
}
public MultiHashMap(int initialCapacity, float loadFactor )
{
super( initialCapacity, loadFactor);
setName();
}
public MultiHashMap( Map mapToCopy )
{
super( mapToCopy );
}
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 );
}
boolean results = keyList.add( value );
return ( results ? value : null );
}
public boolean containsValue( Object value )
{
Set pairs = super.entrySet();
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 ) )
return true;
}
return false;
}
public Object remove( Object key, Object item )
{
ArrayList valuesForKey = (ArrayList) super.get( key );
if ( valuesForKey == null )
return null;
valuesForKey.remove( item );
return item;
}
public void clear()
{
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();
}
super.clear();
}
public void putAll( Map mapToPut )
{
super.putAll( mapToPut );
}
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] );
}
}
return returnList;
}
// FIXME:: do we need to implement this??
// public boolean equals( Object obj ) {}
// --------------- From Cloneable
public Object clone()
{
MultiHashMap obj = (MultiHashMap)(super.clone());
obj.mName = mName;
return obj;
}
}
././@LongLink 0000000 0000000 0000000 00000000146 00000000000 011566 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/BoundedFifoBuffer.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/BoundedFifoBuffer.ja 0100644 0001750 0001750 00000020461 10055172376 032120 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.AbstractCollection;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.NoSuchElementException;
/**
* The BoundedFifoBuffer is a very efficient implementation of
* Buffer that does not alter the size of the buffer at runtime.
*
* The removal order of a BoundedFifoBuffer is based on the
* insertion order; elements are removed in the same order in which they
* were added. The iteration order is the same as the removal order.
*
* The {@link #add(Object)}, {@link #remove()} and {@link #get()} operations * all perform in constant time. All other operations perform in linear * time or worse. *
* Note that this implementation is not synchronized. The following can be
* used to provide synchronized access to your BoundedFifoBuffer:
*
* Buffer fifo = BufferUtils.synchronizedBuffer(new BoundedFifoBuffer()); **
* This buffer prevents null objects from being added.
*
* @author Avalon
* @author Berin Loritsch
* @author Paul Jack
* @author Stephen Colebourne
* @since 2.1
* @version $Id: BoundedFifoBuffer.java,v 1.5.2.1 2004/05/22 12:14:02 scolebourne Exp $
*/
public class BoundedFifoBuffer extends AbstractCollection implements Buffer {
private final Object[] m_elements;
private int m_start = 0;
private int m_end = 0;
private boolean m_full = false;
/**
* Constructs a new BoundedFifoBuffer big enough to hold
* 32 elements.
*/
public BoundedFifoBuffer() {
this(32);
}
/**
* Constructs a new BoundedFifoBuffer big enough to hold
* the specified number of elements.
*
* @param size the maximum number of elements for this fifo
* @throws IllegalArgumentException if the size is less than 1
*/
public BoundedFifoBuffer(int size) {
if (size <= 0) {
throw new IllegalArgumentException("The size must be greater than 0");
}
m_elements = new Object[size];
}
/**
* Constructs a new BoundedFifoBuffer big enough to hold all
* of the elements in the specified collection. That collection's
* elements will also be added to the buffer.
*
* @param coll the collection whose elements to add
*/
public BoundedFifoBuffer(Collection coll) {
this(coll.size());
addAll(coll);
}
/**
* Returns the number of elements stored in the buffer.
*
* @return this buffer's size
*/
public int size() {
int size = 0;
if (m_end < m_start) {
size = m_elements.length - m_start + m_end;
} else if (m_end == m_start) {
size = (m_full ? m_elements.length : 0);
} else {
size = m_end - m_start;
}
return size;
}
/**
* Returns true if this buffer is empty; false otherwise.
*
* @return true if this buffer is empty
*/
public boolean isEmpty() {
return size() == 0;
}
/**
* Clears this buffer.
*/
public void clear() {
m_full = false;
m_start = 0;
m_end = 0;
Arrays.fill(m_elements, null);
}
/**
* Adds the given element to this buffer.
*
* @param element the element to add
* @return true, always
* @throws NullPointerException if the given element is null
* @throws BufferOverflowException if this buffer is full
*/
public boolean add(Object element) {
if (null == element) {
throw new NullPointerException("Attempted to add null object to buffer");
}
if (m_full) {
throw new BufferOverflowException("The buffer cannot hold more than " + m_elements.length + " objects.");
}
m_elements[m_end++] = element;
if (m_end >= m_elements.length) {
m_end = 0;
}
if (m_end == m_start) {
m_full = true;
}
return true;
}
/**
* Returns the least recently inserted element in this buffer.
*
* @return the least recently inserted element
* @throws BufferUnderflowException if the buffer is empty
*/
public Object get() {
if (isEmpty()) {
throw new BufferUnderflowException("The buffer is already empty");
}
return m_elements[m_start];
}
/**
* Removes the least recently inserted element from this buffer.
*
* @return the least recently inserted element
* @throws BufferUnderflowException if the buffer is empty
*/
public Object remove() {
if (isEmpty()) {
throw new BufferUnderflowException("The buffer is already empty");
}
Object element = m_elements[m_start];
if (null != element) {
m_elements[m_start++] = null;
if (m_start >= m_elements.length) {
m_start = 0;
}
m_full = false;
}
return element;
}
/**
* Increments the internal index.
*
* @param index the index to increment
* @return the updated index
*/
private int increment(int index) {
index++;
if (index >= m_elements.length) {
index = 0;
}
return index;
}
/**
* Decrements the internal index.
*
* @param index the index to decrement
* @return the updated index
*/
private int decrement(int index) {
index--;
if (index < 0) {
index = m_elements.length - 1;
}
return index;
}
/**
* Returns an iterator over this buffer's elements.
*
* @return an iterator over this buffer's elements
*/
public Iterator iterator() {
return new Iterator() {
private int index = m_start;
private int lastReturnedIndex = -1;
private boolean isFirst = m_full;
public boolean hasNext() {
return isFirst || (index != m_end);
}
public Object next() {
if (!hasNext()) throw new NoSuchElementException();
isFirst = false;
lastReturnedIndex = index;
index = increment(index);
return m_elements[lastReturnedIndex];
}
public void remove() {
if (lastReturnedIndex == -1) throw new IllegalStateException();
// First element can be removed quickly
if (lastReturnedIndex == m_start) {
BoundedFifoBuffer.this.remove();
lastReturnedIndex = -1;
return;
}
// Other elements require us to shift the subsequent elements
int i = lastReturnedIndex + 1;
while (i != m_end) {
if (i >= m_elements.length) {
m_elements[i - 1] = m_elements[0];
i = 0;
} else {
m_elements[i - 1] = m_elements[i];
i++;
}
}
lastReturnedIndex = -1;
m_end = decrement(m_end);
m_elements[m_end] = null;
m_full = false;
index = decrement(index);
}
};
}
}
././@LongLink 0000000 0000000 0000000 00000000146 00000000000 011566 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/SingletonIterator.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/SingletonIterator.ja 0100644 0001750 0001750 00000002510 10055172400 032235 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
/**
SingletonIterator is an {@link java.util.Iterator Iterator} over a single
* object instance.
SingletonIterator.
*
* @param object the single object to return from the iterator
*/
public SingletonIterator(Object object) {
super(object);
}
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/Buffer.java 0100644 0001750 0001750 00000004326 10055172402 030332 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.Collection;
/**
* A Buffer is a collection that allows objects to be removed in some
* well-defined order. The removal order can be based on insertion order
* (eg, a FIFO queue or a LIFO stack), on access order (eg, an LRU cache),
* on some arbitrary comparator (eg, a priority queue) or on any other
* well-defined ordering.
*
* Note that the removal order is not necessarily the same as the iteration
* order. A Buffer implementation may have equivalent removal
* and iteration orders, but this is not required.
*
* This interface does not specify any behavior for
* {@link Object#equals(Object)} and {@link Object#hashCode} methods. It
* is therefore possible for a Buffer implementation to also
* also implement {@link java.util.List}, {@link java.util.Set} or
* {@link Bag}.
*
* @author Avalon
* @author Berin Loritsch
* @author Paul Jack
* @author Stephen Colebourne
* @version $Id: Buffer.java,v 1.3.2.1 2004/05/22 12:14:01 scolebourne Exp $
* @since 2.1
*/
public interface Buffer extends Collection {
/**
* Removes the next object from the buffer.
*
* @return the removed object
* @throws BufferUnderflowException if the buffer is already empty
*/
Object remove();
/**
* Returns the next object in the buffer without removing it.
*
* @return the next object in the buffer
* @throws BufferUnderflowException if the buffer is empty
*/
Object get();
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/PriorityQueue.java 0100644 0001750 0001750 00000003740 10055172400 031744 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.NoSuchElementException;
/**
* Interface for priority queues.
* This interface does not dictate whether it is min or max heap.
*
* @since 1.0
* @author Peter Donald
*/
public interface PriorityQueue
{
/**
* Clear all elements from queue.
*/
void clear();
/**
* Test if queue is empty.
*
* @return true if queue is empty else false.
*/
boolean isEmpty();
/**
* Insert an element into queue.
*
* @param element the element to be inserted
*
* @exception ClassCastException if the specified element's
* type prevents it from being compared to other items in the queue to
* determine its relative priority.
*/
void insert( Object element );
/**
* Return element on top of heap but don't remove it.
*
* @return the element at top of heap
* @exception NoSuchElementException if isEmpty() == true
*/
Object peek() throws NoSuchElementException;
/**
* Return element on top of heap and remove it.
*
* @return the element at top of heap
* @exception NoSuchElementException if isEmpty() == true
*/
Object pop() throws NoSuchElementException;
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/comparators/ 0040755 0001750 0001750 00000000000 10072637465 030624 5 ustar tora tora ././@LongLink 0000000 0000000 0000000 00000000167 00000000000 011571 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/comparators/TransformingComparator.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/comparators/Transfor 0100644 0001750 0001750 00000004415 10055172400 032326 0 ustar tora tora /*
* Copyright 2001-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.comparators;
import java.util.Comparator;
import org.apache.commons.collections.Transformer;
/**
* Decorates another Comparator with transformation behavior. That is, the
* return value from the transform operation will be passed to the decorated
* Comparator#compare method.
*
* @see org.apache.commons.collections.Transformer * @see org.apache.commons.collections.comparators.ComparableComparator */ public class TransformingComparator implements Comparator { protected Comparator decorated; protected Transformer transformer; /** * Constructs an instance with the given Transformer and a ComparableComparator. * @param transformer what will transform the instance. */ public TransformingComparator(Transformer transformer) { this(transformer, new ComparableComparator()); } /** * Constructs an instance with the given Transformer and Comparator * @param decorated the decorated Comparator * @param getterName the getter name */ public TransformingComparator(Transformer transformer, Comparator decorated) { this.decorated = decorated; this.transformer = transformer; } /** * Returns the result of comparing the values from the transform operation. * @return the result of comparing the values from the transform operation */ public int compare(Object o1, Object o2) { Object value1 = this.transformer.transform(o1); Object value2 = this.transformer.transform(o2); return this.decorated.compare(value1, value2); } } ././@LongLink 0000000 0000000 0000000 00000000162 00000000000 011564 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/comparators/ReverseComparator.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/comparators/ReverseC 0100644 0001750 0001750 00000004271 10055172400 032246 0 ustar tora tora /* * Copyright 2001-2004 The Apache Software Foundation * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.commons.collections.comparators; import java.io.Serializable; import java.util.Comparator; /** * Reverses the order of another comparator. * * @since 2.0 * @author bayard@generationjava.com * @author Michael A. Smith * @version $Id: ReverseComparator.java,v 1.8.2.1 2004/05/22 12:14:04 scolebourne Exp $ */ public class ReverseComparator implements Comparator,Serializable { private Comparator comparator; /** * Creates a comparator that compares objects based on the inverse of their * natural ordering. Using this Constructor will create a ReverseComparator * that is functionaly identical to the Comparator returned by * java.util.Collections.reverseOrder(). * * @see java.util.Collections#reverseOrder() */ public ReverseComparator() { this(null); } /** * Creates a reverse comparator that inverts the comparison * of the passed in comparator. If you pass in a null, * the ReverseComparator defaults to reversing the * natural order, as per * java.util.Collections.reverseOrder(). * * @param comparator Comparator to reverse */ public ReverseComparator(Comparator comparator) { if(comparator != null) { this.comparator = comparator; } else { this.comparator = ComparableComparator.getInstance(); } } public int compare(Object o1, Object o2) { return comparator.compare(o2, o1); } } ././@LongLink 0000000 0000000 0000000 00000000165 00000000000 011567 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/comparators/ComparableComparator.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/comparators/Comparab 0100644 0001750 0001750 00000007557 10055172400 032266 0 ustar tora tora /* * Copyright 2001-2004 The Apache Software Foundation * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.commons.collections.comparators; import java.io.Serializable; import java.lang.Comparable; import java.util.Comparator; /** * A Comparator that compares Comparable objects. * Throws ClassCastExceptions if the objects are not * Comparable, or if they are null. * Throws ClassCastException if the compareTo of both * objects do not provide an inverse result of each other * as per the Comparable javadoc. This Comparator is useful, for example, * for enforcing the natural order in custom implementations * of SortedSet and SortedMap. * * @since 2.0 * @author bayard@generationjava.com * @version $Id: ComparableComparator.java,v 1.5.2.1 2004/05/22 12:14:04 scolebourne Exp $ */ public class ComparableComparator implements Comparator,Serializable { private static final ComparableComparator instance = new ComparableComparator(); /** * Return a shared instance of a ComparableComparator. Developers are * encouraged to use the comparator returned from this method instead of * constructing a new instance to reduce allocation and GC overhead when * multiple comparable comparators may be used in the same VM. **/ public static ComparableComparator getInstance() { return instance; } private static final long serialVersionUID=-291439688585137865L; public ComparableComparator() { } public int compare(Object o1, Object o2) { if( (o1 == null) || (o2 == null) ) { throw new ClassCastException( "There were nulls in the arguments for this method: "+ "compare("+o1 + ", " + o2 + ")" ); } if(o1 instanceof Comparable) { if(o2 instanceof Comparable) { int result1 = ((Comparable)o1).compareTo(o2); int result2 = ((Comparable)o2).compareTo(o1); // enforce comparable contract if(result1 == 0 && result2 == 0) { return 0; } else if(result1 < 0 && result2 > 0) { return result1; } else if(result1 > 0 && result2 < 0) { return result1; } else { // results inconsistent throw new ClassCastException("o1 not comparable to o2"); } } else { // o2 wasn't comparable throw new ClassCastException( "The first argument of this method was not a Comparable: " + o2.getClass().getName() ); } } else if(o2 instanceof Comparable) { // o1 wasn't comparable throw new ClassCastException( "The second argument of this method was not a Comparable: " + o1.getClass().getName() ); } else { // neither were comparable throw new ClassCastException( "Both arguments of this method were not Comparables: " + o1.getClass().getName() + " and " + o2.getClass().getName() ); } } } ././@LongLink 0000000 0000000 0000000 00000000160 00000000000 011562 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/comparators/ComparatorChain.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/comparators/Comparat 0100644 0001750 0001750 00000022734 10055172400 032302 0 ustar tora tora /* * Copyright 1999-2004 The Apache Software Foundation * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.commons.collections.comparators; import java.io.Serializable; import java.util.ArrayList; import java.util.BitSet; import java.util.Comparator; import java.util.Iterator; import java.util.List; /** *
A ComparatorChain is a Comparator that wraps one or * more Comparators in sequence. The ComparatorChain * calls each Comparator in sequence until either 1) * any single Comparator returns a non-zero result * (and that result is then returned), * or 2) the ComparatorChain is exhausted (and zero is * returned). This type of sorting is very similar * to multi-column sorting in SQL, and this class * allows Java classes to emulate that kind of behaviour * when sorting a List.
* *To further facilitate SQL-like sorting, the order of * any single Comparator in the list can be reversed.
* *Calling a method that adds new Comparators or * changes the ascend/descend sort after compare(Object, * Object) has been called will result in an * UnsupportedOperationException. However, take care * to not alter the underlying List of Comparators * or the BitSet that defines the sort order.
* *Instances of ComparatorChain are not synchronized. * The class is not thread-safe at construction time, but * it is thread-safe to perform multiple comparisons * after all the setup operations are complete.
* * @since 2.0 * @author Morgan Delagrange */ public class ComparatorChain implements Comparator,Serializable { protected List comparatorChain = null; // 0 = ascend; 1 = descend protected BitSet orderingBits = null; // ComparatorChain is "locked" after the first time // compare(Object,Object) is called protected boolean isLocked = false; /** * Construct a ComparatorChain with no Comparators. * You must add at least one Comparator before calling * the compare(Object,Object) method, or an * UnsupportedOperationException is thrown */ public ComparatorChain() { this(new ArrayList(),new BitSet()); } /** * Construct a ComparatorChain with a single Comparator, * sorting in the forward order * * @param comparator First comparator in the Comparator chain */ public ComparatorChain(Comparator comparator) { this(comparator,false); } /** * Construct a Comparator chain with a single Comparator, * sorting in the given order * * @param comparator First Comparator in the ComparatorChain * @param reverse false = forward sort; true = reverse sort */ public ComparatorChain(Comparator comparator, boolean reverse) { comparatorChain = new ArrayList(); comparatorChain.add(comparator); orderingBits = new BitSet(1); if (reverse == true) { orderingBits.set(0); } } /** * Construct a ComparatorChain from the Comparators in the * List. All Comparators will default to the forward * sort order. * * @param list List of Comparators * @see #ComparatorChain(List,BitSet) */ public ComparatorChain(List list) { this(list,new BitSet(list.size())); } /** * Construct a ComparatorChain from the Comparators in the * given List. The sort order of each column will be * drawn from the given BitSet. When determining the sort * order for Comparator at index i in the List, * the ComparatorChain will call BitSet.get(i). * If that method returns false, the forward * sort order is used; a return value of true * indicates reverse sort order. * * @param list List of Comparators. NOTE: This constructor does not perform a * defensive copy of the list * @param bits Sort order for each Comparator. Extra bits are ignored, * unless extra Comparators are added by another method. */ public ComparatorChain(List list, BitSet bits) { comparatorChain = list; orderingBits = bits; } /** * Add a Comparator to the end of the chain using the * forward sort order * * @param comparator Comparator with the forward sort order */ public void addComparator(Comparator comparator) { addComparator(comparator,false); } /** * Add a Comparator to the end of the chain using the * given sort order * * @param comparator Comparator to add to the end of the chain * @param reverse false = forward sort order; true = reverse sort order */ public void addComparator(Comparator comparator, boolean reverse) { checkLocked(); comparatorChain.add(comparator); if (reverse == true) { orderingBits.set(comparatorChain.size() - 1); } } /** * Replace the Comparator at the given index, maintaining * the existing sort order. * * @param index index of the Comparator to replace * @param comparator Comparator to place at the given index * @exception IndexOutOfBoundsException * if index < 0 or index > size() */ public void setComparator(int index, Comparator comparator) throws IndexOutOfBoundsException { setComparator(index,comparator,false); } /** * Replace the Comparator at the given index in the * ComparatorChain, using the given sort order * * @param index index of the Comparator to replace * @param comparator Comparator to set * @param reverse false = forward sort order; true = reverse sort order */ public void setComparator(int index, Comparator comparator, boolean reverse) { checkLocked(); comparatorChain.set(index,comparator); if (reverse == true) { orderingBits.set(index); } else { orderingBits.clear(index); } } /** * Change the sort order at the given index in the * ComparatorChain to a forward sort. * * @param index Index of the ComparatorChain */ public void setForwardSort(int index) { checkLocked(); orderingBits.clear(index); } /** * Change the sort order at the given index in the * ComparatorChain to a reverse sort. * * @param index Index of the ComparatorChain */ public void setReverseSort(int index) { checkLocked(); orderingBits.set(index); } /** * Number of Comparators in the current ComparatorChain. * * @return Comparator count */ public int size() { return comparatorChain.size(); } /** * Determine if modifications can still be made to the * ComparatorChain. ComparatorChains cannot be modified * once they have performed a comparison. * * @return true = ComparatorChain cannot be modified; false = * ComparatorChain can still be modified. */ public boolean isLocked() { return isLocked; } // throw an exception if the ComparatorChain is locked private void checkLocked() { if (isLocked == true) { throw new UnsupportedOperationException("Comparator ordering cannot be changed after the first comparison is performed"); } } private void checkChainIntegrity() { if (comparatorChain.size() == 0) { throw new UnsupportedOperationException("ComparatorChains must contain at least one Comparator"); } } /** * Perform comaparisons on the Objects as per * Comparator.compare(o1,o2). * * @param o1 object 1 * @param o2 object 2 * @return -1, 0, or 1 * @exception UnsupportedOperationException * if the ComparatorChain does not contain at least one * Comparator */ public int compare(Object o1, Object o2) throws UnsupportedOperationException { if (isLocked == false) { checkChainIntegrity(); isLocked = true; } // iterate over all comparators in the chain Iterator comparators = comparatorChain.iterator(); for (int comparatorIndex = 0; comparators.hasNext(); ++comparatorIndex) { Comparator comparator = (Comparator) comparators.next(); int retval = comparator.compare(o1,o2); if (retval != 0) { // invert the order if it is a reverse sort if (orderingBits.get(comparatorIndex) == true) { retval *= -1; } return retval; } } // if comparators are exhausted, return 0 return 0; } } ././@LongLink 0000000 0000000 0000000 00000000157 00000000000 011570 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/comparators/NullComparator.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/comparators/NullComp 0100644 0001750 0001750 00000015032 10055172400 032256 0 ustar tora tora /* * Copyright 2001-2004 The Apache Software Foundation * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.commons.collections.comparators; import java.io.Serializable; import java.util.Comparator; /** * A Comparator that will compare nulls to be either lower or higher than * other objects. * * @author Michael A. Smith * @version $Id: NullComparator.java,v 1.4.2.1 2004/05/22 12:14:04 scolebourne Exp $ **/ public class NullComparator implements Comparator, Serializable { /** * The comparator to use when comparing two non-null objects.
**/
private Comparator nonNullComparator;
/**
* Specifies whether a null are compared as higher than
* non-null objects.
**/
private boolean nullsAreHigh;
/**
* Construct an instance that sorts null higher than any
* non-null object it is compared with. When comparing two
* non-null objects, the {@link ComparableComparator} is
* used.
**/
public NullComparator() {
this(ComparableComparator.getInstance(), true);
}
/**
* Construct an instance that sorts null higher than any
* non-null object it is compared with. When comparing two
* non-null objects, the specified {@link Comparator} is
* used.
*
* @param nonNullComparator the comparator to use when comparing two
* non-null objects. This argument cannot be
* null
*
* @exception NullPointerException if nonNullComparator is
* null
**/
public NullComparator(Comparator nonNullComparator) {
this(nonNullComparator, true);
}
/**
* Construct an instance that sorts null higher or lower than
* any non-null object it is compared with. When comparing
* two non-null objects, the {@link ComparableComparator} is
* used.
*
* @param nullsAreHigh a true value indicates that
* null should be compared as higher than a
* non-null object. A false value indicates
* that null should be compared as lower than a
* non-null object.
**/
public NullComparator(boolean nullsAreHigh) {
this(ComparableComparator.getInstance(), nullsAreHigh);
}
/**
* Cosntruct an instance that sorts null higher or lower than
* any non-null object it is compared with. When comparing
* two non-null objects, the specified {@link Comparator} is
* used.
*
* @param nonNullComparator the comparator to use when comparing two
* non-null objects. This argument cannot be
* null
*
* @param nullsAreHigh a true value indicates that
* null should be compared as higher than a
* non-null object. A false value indicates
* that null should be compared as lower than a
* non-null object.
*
* @exception NullPointerException if nonNullComparator is
* null
**/
public NullComparator(Comparator nonNullComparator, boolean nullsAreHigh) {
this.nonNullComparator = nonNullComparator;
this.nullsAreHigh = nullsAreHigh;
if(nonNullComparator == null) {
throw new NullPointerException("null nonNullComparator");
}
}
/**
* Perform a comparison between two objects. If both objects are
* null, a 0 value is returned. If one object
* is null and the other is not, the result is determined on
* whether the Comparator was constructed to have nulls as higher or lower
* than other objects. If neither object is null, an
* underlying comparator specified in the constructor (or the default) is
* used to compare the non-null objects.
*
* @param o1 the first object to compare
*
* @param o2 the object to compare it to.
*
* @return -1 if o1 is "lower" than (less than,
* before, etc.) o2; 1 if o1 is
* "higher" than (greater than, after, etc.) o2; or
* 0 if o1 and o2 are equal.
**/
public int compare(Object o1, Object o2) {
if(o1 == o2) return 0;
if(o1 == null) return (this.nullsAreHigh ? 1 : -1);
if(o2 == null) return (this.nullsAreHigh ? -1 : 1);
return this.nonNullComparator.compare(o1, o2);
}
/**
* Implement a hash code for this comparator that is consistent with
* {@link #equals(Object)}.
*
* @return a hash code for this comparator.
**/
public int hashCode() {
return (nullsAreHigh ? -1 : 1) * nonNullComparator.hashCode();
}
/**
* Determines whether the specified object represents a comparator that is
* equal to this comparator.
*
* @param o the object to compare this comparator with.
*
* @return true if the specified object is a NullComparator
* with equivalant null comparison behavior
* (i.e. null high or low) and with equivalent underlying
* non-null object comparators.
**/
public boolean equals(Object obj) {
if(obj == null) return false;
if(obj == this) return true;
if(!obj.getClass().equals(this.getClass())) return false;
NullComparator other = (NullComparator)obj;
return ((this.nullsAreHigh == other.nullsAreHigh) &&
(this.nonNullComparator.equals(other.nonNullComparator)));
}
private static final long serialVersionUID = -5820772575483504339L;
}
././@LongLink 0000000 0000000 0000000 00000000150 00000000000 011561 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/comparators/package.html libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/comparators/package. 0100644 0001750 0001750 00000000456 10055172376 032216 0 ustar tora tora
Contains concrete {@link java.util.Comparator Comparator} implementations.
You may also consider using
{@link org.apache.commons.collections.ComparatorUtils CompatorUtils},
which is a single class that uses static methods to construct instances
of the classes in this package.
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/LRUMap.java 0100644 0001750 0001750 00000015350 10055172400 030216 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Iterator;
/**
* * An implementation of a Map which has a maximum size and uses a Least Recently Used * algorithm to remove items from the Map when the maximum size is reached and new items are added. *
* *
* A synchronized version can be obtained with:
* Collections.synchronizedMap( theMapToSynchronize )
* If it will be accessed by multiple threads, you _must_ synchronize access
* to this Map. Even concurrent get(Object) operations produce indeterminate
* behaviour.
*
* Unlike the Collections 1.0 version, this version of LRUMap does use a true * LRU algorithm. The keys for all gets and puts are moved to the front of * the list. LRUMap is now a subclass of SequencedHashMap, and the "LRU" * key is now equivalent to LRUMap.getFirst(). *
* * @since 1.0 * @author James Strachan * @author Morgan Delagrange */ public class LRUMap extends SequencedHashMap implements Externalizable { private int maximumSize = 0; /** * Default constructor, primarily for the purpose of * de-externalization. This constructors sets a default * LRU limit of 100 keys, but this value may be overridden * internally as a result of de-externalization. */ public LRUMap() { this( 100 ); } /** * Create a new LRUMap with a maximum capacity of i. * Once i capacity is achieved, subsequent gets * and puts will push keys out of the map. See . * * @param i Maximum capacity of the LRUMap */ public LRUMap(int i) { super( i ); maximumSize = i; } /** *Get the value for a key from the Map. The key * will be promoted to the Most Recently Used position. * Note that get(Object) operations will modify * the underlying Collection. Calling get(Object) * inside of an iteration over keys, values, etc. is * currently unsupported.
* * @param key Key to retrieve * @return Returns the value. Returns null if the key has a * null value or if the key has no value. */ public Object get(Object key) { if(!containsKey(key)) return null; Object value = remove(key); super.put(key,value); return value; } /** *Removes the key and its Object from the Map.
* *(Note: this may result in the "Least Recently Used" * object being removed from the Map. In that case, * the removeLRU() method is called. See javadoc for * removeLRU() for more details.)
* * @param key Key of the Object to add. * @param value Object to add * @return Former value of the key * @see #removeLRU */ public Object put( Object key, Object value ) { int mapSize = size(); Object retval = null; if ( mapSize >= maximumSize ) { // don't retire LRU if you are just // updating an existing key if (!containsKey(key)) { // lets retire the least recently used item in the cache removeLRU(); } } retval = super.put(key,value); return retval; } /** * This method is used internally by the class for * finding and removing the LRU Object. */ protected void removeLRU() { Object key = getFirstKey(); // be sure to call super.get(key), or you're likely to // get infinite promotion recursion Object value = super.get(key); remove(key); processRemovedLRU(key,value); } /** * Subclasses of LRUMap may hook into this method to * provide specialized actions whenever an Object is * automatically removed from the cache. By default, * this method does nothing. * * @param key key that was removed * @param value value of that key (can be null) */ protected void processRemovedLRU(Object key, Object value) { } // Externalizable interface //------------------------------------------------------------------------- public void readExternal( ObjectInput in ) throws IOException, ClassNotFoundException { maximumSize = in.readInt(); int size = in.readInt(); for( int i = 0; i < size; i++ ) { Object key = in.readObject(); Object value = in.readObject(); put(key,value); } } public void writeExternal( ObjectOutput out ) throws IOException { out.writeInt( maximumSize ); out.writeInt( size() ); for( Iterator iterator = keySet().iterator(); iterator.hasNext(); ) { Object key = iterator.next(); out.writeObject( key ); // be sure to call super.get(key), or you're likely to // get infinite promotion recursion Object value = super.get( key ); out.writeObject( value ); } } // Properties //------------------------------------------------------------------------- /** Getter for property maximumSize. * @return Value of property maximumSize. */ public int getMaximumSize() { return maximumSize; } /** Setter for property maximumSize. * @param maximumSize New value of property maximumSize. */ public void setMaximumSize(int maximumSize) { this.maximumSize = maximumSize; while (size() > maximumSize) { removeLRU(); } } // add a serial version uid, so that if we change things in the future // without changing the format, we can still deserialize properly. private static final long serialVersionUID = 2197433140769957051L; } ././@LongLink 0000000 0000000 0000000 00000000150 00000000000 011561 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/UnboundedFifoBuffer.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/UnboundedFifoBuffer. 0100644 0001750 0001750 00000017625 10055172400 032144 0 ustar tora tora /* * Copyright 1999-2004 The Apache Software Foundation * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.commons.collections; import java.util.AbstractCollection; import java.util.Iterator; import java.util.NoSuchElementException; /** * UnboundedFifoBuffer is a very efficient buffer implementation. * According to performance testing, it exhibits a constant access time, but it * also outperforms ArrayList when used for the same purpose. *
* The removal order of an UnboundedFifoBuffer is based on the insertion
* order; elements are removed in the same order in which they were added.
* The iteration order is the same as the removal order.
*
* The {@link #remove()} and {@link #get()} operations perform in constant time. * The {@link #add(Object)} operation performs in amortized constant time. All * other operations perform in linear time or worse. *
* Note that this implementation is not synchronized. The following can be
* used to provide synchronized access to your UnboundedFifo:
*
* Buffer fifo = BufferUtils.synchronizedBuffer(new UnboundedFifo()); **
* This buffer prevents null objects from being added. * * @author Avalon * @author Federico Barbieri * @author Berin Loritsch * @author Paul Jack * @author Stephen Colebourne * @since 2.1 * @version $Id: UnboundedFifoBuffer.java,v 1.5.2.1 2004/05/22 12:14:02 scolebourne Exp $ */ public final class UnboundedFifoBuffer extends AbstractCollection implements Buffer { protected Object[] m_buffer; protected int m_head; protected int m_tail; /** * Constructs an UnboundedFifoBuffer with the default number of elements. * It is exactly the same as performing the following: * *
* new UnboundedFifoBuffer(32);
*
*/
public UnboundedFifoBuffer() {
this(32);
}
/**
* Constructs an UnboundedFifoBuffer with the specified number of elements.
* The integer must be a positive integer.
*
* @throws IllegalArgumentException if the size is less than 1
*/
public UnboundedFifoBuffer(int size) {
if (size <= 0) {
throw new IllegalArgumentException("The size must be greater than 0");
}
m_buffer = new Object[size + 1];
m_head = 0;
m_tail = 0;
}
/**
* Returns the number of elements stored in the buffer.
*
* @return this buffer's size
*/
public int size() {
int size = 0;
if (m_tail < m_head) {
size = m_buffer.length - m_head + m_tail;
} else {
size = m_tail - m_head;
}
return size;
}
/**
* Returns true if this buffer is empty; false otherwise.
*
* @return true if this buffer is empty
*/
public boolean isEmpty() {
return (size() == 0);
}
/**
* Adds the given element to this buffer.
*
* @param element the element to add
* @return true, always
* @throws NullPointerException if the given element is null
* @throws BufferOverflowException if this buffer is full
*/
public boolean add(final Object o) {
if (null == o) {
throw new NullPointerException("Attempted to add null object to buffer");
}
if (size() + 1 >= m_buffer.length) {
Object[] tmp = new Object[((m_buffer.length - 1) * 2) + 1];
int j = 0;
for (int i = m_head; i != m_tail;) {
tmp[j] = m_buffer[i];
m_buffer[i] = null;
j++;
i++;
if (i == m_buffer.length) {
i = 0;
}
}
m_buffer = tmp;
m_head = 0;
m_tail = j;
}
m_buffer[m_tail] = o;
m_tail++;
if (m_tail >= m_buffer.length) {
m_tail = 0;
}
return true;
}
/**
* Returns the next object in the buffer.
*
* @return the next object in the buffer
* @throws BufferUnderflowException if this buffer is empty
*/
public Object get() {
if (isEmpty()) {
throw new BufferUnderflowException("The buffer is already empty");
}
return m_buffer[m_head];
}
/**
* Removes the next object from the buffer
*
* @return the removed object
* @throws BufferUnderflowException if this buffer is empty
*/
public Object remove() {
if (isEmpty()) {
throw new BufferUnderflowException("The buffer is already empty");
}
Object element = m_buffer[m_head];
if (null != element) {
m_buffer[m_head] = null;
m_head++;
if (m_head >= m_buffer.length) {
m_head = 0;
}
}
return element;
}
/**
* Increments the internal index.
*
* @param index the index to increment
* @return the updated index
*/
private int increment(int index) {
index++;
if (index >= m_buffer.length)
index = 0;
return index;
}
/**
* Decrements the internal index.
*
* @param index the index to decrement
* @return the updated index
*/
private int decrement(int index) {
index--;
if (index < 0)
index = m_buffer.length - 1;
return index;
}
/**
* Returns an iterator over this buffer's elements.
*
* @return an iterator over this buffer's elements
*/
public Iterator iterator() {
return new Iterator() {
private int index = m_head;
private int lastReturnedIndex = -1;
public boolean hasNext() {
return index != m_tail;
}
public Object next() {
if (!hasNext())
throw new NoSuchElementException();
lastReturnedIndex = index;
index = increment(index);
return m_buffer[lastReturnedIndex];
}
public void remove() {
if (lastReturnedIndex == -1)
throw new IllegalStateException();
// First element can be removed quickly
if (lastReturnedIndex == m_head) {
UnboundedFifoBuffer.this.remove();
lastReturnedIndex = -1;
return;
}
// Other elements require us to shift the subsequent elements
int i = lastReturnedIndex + 1;
while (i != m_tail) {
if (i >= m_buffer.length) {
m_buffer[i - 1] = m_buffer[0];
i = 0;
} else {
m_buffer[i - 1] = m_buffer[i];
i++;
}
}
lastReturnedIndex = -1;
m_tail = decrement(m_tail);
m_buffer[m_tail] = null;
index = decrement(index);
}
};
}
}
././@LongLink 0000000 0000000 0000000 00000000147 00000000000 011567 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/FilterListIterator.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/FilterListIterator.j 0100644 0001750 0001750 00000005324 10055172376 032235 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.ListIterator;
/**
* A proxy {@link ListIterator ListIterator} which
* takes a {@link Predicate Predicate} instance to filter
* out objects from an underlying ListIterator
* instance. Only objects for which the specified
* Predicate evaluates to true are
* returned by the iterator.
*
* @since 2.0
* @version $Revision: 1.7.2.1 $ $Date: 2004/05/22 12:14:02 $
* @author Rodney Waldhoff
* @deprecated this class has been moved to the iterators subpackage
*/
public class FilterListIterator
extends org.apache.commons.collections.iterators.FilterListIterator {
// Constructors
//-------------------------------------------------------------------------
/**
* Constructs a new FilterListIterator that will not
* function until
* {@link ProxyListIterator#setListIterator(ListIterator) setListIterator}
* and {@link #setPredicate(Predicate) setPredicate} are invoked.
*/
public FilterListIterator() {
super();
}
/**
* Constructs a new FilterListIterator that will not
* function until {@link #setPredicate(Predicate) setPredicate} is invoked.
*
* @param iterator the iterator to use
*/
public FilterListIterator(ListIterator iterator ) {
super(iterator);
}
/**
* Constructs a new FilterListIterator.
*
* @param iterator the iterator to use
* @param predicate the predicate to use
*/
public FilterListIterator(ListIterator iterator, Predicate predicate) {
super(iterator, predicate);
}
/**
* Constructs a new FilterListIterator that will not
* function until
* {@link ProxyListIterator#setListIterator(ListIterator) setListIterator}
* is invoked.
*
* @param predicate the predicate to use.
*/
public FilterListIterator(Predicate predicate) {
super(predicate);
}
}
././@LongLink 0000000 0000000 0000000 00000000147 00000000000 011567 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/ExtendedProperties.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/ExtendedProperties.j 0100644 0001750 0001750 00000160163 10055172376 032262 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.io.IOException;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.LineNumberReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Properties;
import java.util.StringTokenizer;
import java.util.Vector;
/**
* This class extends normal Java properties by adding the possibility
* to use the same key many times concatenating the value strings
* instead of overwriting them.
*
* The Extended Properties syntax is explained here: * *
key = value
* Here is an example of a valid extended properties file: * *
* # lines starting with # are comments * * # This is the simplest property * key = value * * # A long property may be separated on multiple lines * longvalue = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \ * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * * # This is a property with many tokens * tokens_on_a_line = first token, second token * * # This sequence generates exactly the same result * tokens_on_multiple_lines = first token * tokens_on_multiple_lines = second token * * # commas may be escaped in tokens * commas.excaped = Hi\, what'up? ** *
NOTE: this class has not been written for
* performance nor low memory usage. In fact, it's way slower than it
* could be and generates too much memory garbage. But since
* performance is not an issue during intialization (and there is not
* much time to improve it), I wrote it this way. If you don't like
* it, go ahead and tune it up!
*
*
* @since 1.0
* @author Stefano Mazzocchi
* @author Jon S. Stevens
* @author Dave Bryson
* @author Jason van Zyl
* @author Geir Magnusson Jr.
* @author Leon Messerschmidt
* @author Kent Johnson
* @author Daniel Rall
* @author Ilkka Priha
* @version $Id: ExtendedProperties.java,v 1.7.2.1 2004/05/22 12:14:02 scolebourne Exp $
*/
public class ExtendedProperties extends Hashtable
{
/**
* Default configurations repository.
*/
private ExtendedProperties defaults;
/**
* The file connected to this repository (holding comments and
* such).
*
* @serial
*/
protected String file;
/**
* Base path of the configuration file used to create
* this ExtendedProperties object.
*/
protected String basePath;
/**
* File separator.
*/
protected String fileSeparator = System.getProperty("file.separator");
/**
* Has this configuration been intialized.
*/
protected boolean isInitialized = false;
/**
* This is the name of the property that can point to other
* properties file for including other properties files.
*/
protected static String include = "include";
/**
* These are the keys in the order they listed
* in the configuration file. This is useful when
* you wish to perform operations with configuration
* information in a particular order.
*/
protected ArrayList keysAsListed = new ArrayList();
protected final static String START_TOKEN="${";
protected final static String END_TOKEN="}";
protected String interpolate(String base)
{
if (base == null)
{
return null;
}
int begin = -1;
int end = -1;
int prec = 0 - END_TOKEN.length();
String variable = null;
StringBuffer result = new StringBuffer();
// FIXME: we should probably allow the escaping of the start token
while ( ((begin=base.indexOf(START_TOKEN,prec+END_TOKEN.length()))>-1)
&& ((end=base.indexOf(END_TOKEN,begin))>-1) )
{
result.append(base.substring(prec+END_TOKEN.length(),begin));
variable = base.substring(begin+START_TOKEN.length(),end);
if (get(variable)!=null)
{
result.append(get(variable));
}
prec=end;
}
result.append(base.substring(prec+END_TOKEN.length(),base.length()));
return result.toString();
}
/**
* This class is used to read properties lines. These lines do
* not terminate with new-line chars but rather when there is no
* backslash sign a the end of the line. This is used to
* concatenate multiple lines for readability.
*/
class PropertiesReader extends LineNumberReader
{
/**
* Constructor.
*
* @param reader A Reader.
*/
public PropertiesReader(Reader reader)
{
super(reader);
}
/**
* Read a property.
*
* @return A String.
* @exception IOException.
*/
public String readProperty() throws IOException
{
StringBuffer buffer = new StringBuffer();
try
{
while (true)
{
String line = readLine().trim();
if ((line.length() != 0) && (line.charAt(0) != '#'))
{
if (line.endsWith("\\"))
{
line = line.substring(0, line.length() - 1);
buffer.append(line);
}
else
{
buffer.append(line);
break;
}
}
}
}
catch (NullPointerException e)
{
return null;
}
return buffer.toString();
}
}
/**
* This class divides into tokens a property value. Token
* separator is "," but commas into the property value are escaped
* using the backslash in front.
*/
class PropertiesTokenizer extends StringTokenizer
{
/**
* The property delimiter used while parsing (a comma).
*/
static final String DELIMITER = ",";
/**
* Constructor.
*
* @param string A String.
*/
public PropertiesTokenizer(String string)
{
super(string, DELIMITER);
}
/**
* Check whether the object has more tokens.
*
* @return True if the object has more tokens.
*/
public boolean hasMoreTokens()
{
return super.hasMoreTokens();
}
/**
* Get next token.
*
* @return A String.
*/
public String nextToken()
{
StringBuffer buffer = new StringBuffer();
while (hasMoreTokens())
{
String token = super.nextToken();
if (token.endsWith("\\"))
{
buffer.append(token.substring(0, token.length() - 1));
buffer.append(DELIMITER);
}
else
{
buffer.append(token);
break;
}
}
return buffer.toString().trim();
}
}
/**
* Creates an empty extended properties object.
*/
public ExtendedProperties()
{
super();
}
/**
* Creates and loads the extended properties from the specified
* file.
*
* @param file A String.
* @exception IOException.
*/
public ExtendedProperties(String file) throws IOException
{
this(file,null);
}
/**
* Creates and loads the extended properties from the specified
* file.
*
* @param file A String.
* @exception IOException.
*/
public ExtendedProperties(String file, String defaultFile)
throws IOException
{
this.file = file;
basePath = new File(file).getAbsolutePath();
basePath = basePath.substring(0, basePath.lastIndexOf(fileSeparator) + 1);
this.load(new FileInputStream(file));
if (defaultFile != null)
{
defaults = new ExtendedProperties(defaultFile);
}
}
/**
* Private initializer method that sets up the generic
* resources.
*
* @exception IOException, if there was an I/O problem.
*/
private void init( ExtendedProperties exp ) throws IOException
{
isInitialized = true;
}
/**
* Indicate to client code whether property
* resources have been initialized or not.
*/
public boolean isInitialized()
{
return isInitialized;
}
/**
* Gets the property value for including other properties files.
* By default it is "include".
*
* @return A String.
*/
public String getInclude()
{
return this.include;
}
/**
* Sets the property value for including other properties files.
* By default it is "include".
*
* @param inc A String.
*/
public void setInclude(String inc)
{
this.include = inc;
}
/**
* Load the properties from the given input stream.
*
* @param input An InputStream.
* @exception IOException.
*/
public void load( InputStream input )
throws IOException
{
load(input,null);
}
/**
* Load the properties from the given input stream
* and using the specified encoding.
*
* @param input An InputStream.
* @param enc An encoding.
* @exception IOException.
*/
public synchronized void load(InputStream input, String enc)
throws IOException
{
PropertiesReader reader = null;
if (enc != null)
{
try
{
reader =
new PropertiesReader(new InputStreamReader(input,enc));
}
catch (UnsupportedEncodingException e)
{
// Get one with the default encoding...
}
}
if (reader == null)
{
reader =
new PropertiesReader(new InputStreamReader(input));
}
try
{
while (true)
{
String line = reader.readProperty();
int equalSign = line.indexOf('=');
if (equalSign > 0)
{
String key = line.substring(0, equalSign).trim();
String value = line.substring(equalSign + 1).trim();
/*
* Configure produces lines like this ... just
* ignore them.
*/
if ("".equals(value))
continue;
if (getInclude() != null &&
key.equalsIgnoreCase(getInclude()))
{
/*
* Recursively load properties files.
*/
File file = null;
if (value.startsWith(fileSeparator))
{
/*
* We have an absolute path so we'll
* use this.
*/
file = new File(value);
}
else
{
/*
* We have a relative path, and we have
* two possible forms here. If we have the
* "./" form then just strip that off first
* before continuing.
*/
if (value.startsWith("." + fileSeparator))
{
value = value.substring(2);
}
file = new File(basePath + value);
}
if (file != null && file.exists() && file.canRead())
{
load ( new FileInputStream(file));
}
}
else
{
addProperty(key,value);
}
}
}
}
catch (NullPointerException e)
{
/*
* Should happen only when EOF is reached.
*/
return;
}
}
/**
* Gets a property from the configuration.
*
* @param key property to retrieve
* @return value as object. Will return user value if exists,
* if not then default value if exists, otherwise null
*/
public Object getProperty( String key)
{
/*
* first, try to get from the 'user value' store
*/
Object o = this.get(key);
if ( o == null)
{
/*
* if there isn't a value there, get it from the
* defaults if we have them
*/
if (defaults != null)
{
o = defaults.get(key);
}
}
return o;
}
/**
* Add a property to the configuration. If it already
* exists then the value stated here will be added
* to the configuration entry. For example, if
*
* resource.loader = file
*
* is already present in the configuration and you
*
* addProperty("resource.loader", "classpath")
*
* Then you will end up with a Vector like the
* following:
*
* ["file", "classpath"]
*
* @param String key
* @param String value
*/
public void addProperty(String key, Object token)
{
Object o = this.get(key);
/*
* $$$ GMJ
* FIXME : post 1.0 release, we need to not assume
* that a scalar is a String - it can be an Object
* so we should make a little vector-like class
* say, Foo that wraps (not extends Vector),
* so we can do things like
* if ( !( o instanceof Foo) )
* so we know it's our 'vector' container
*
* This applies throughout
*/
if (o instanceof String)
{
Vector v = new Vector(2);
v.addElement(o);
v.addElement(token);
put(key, v);
}
else if (o instanceof Vector)
{
((Vector) o).addElement(token);
}
else
{
/*
* This is the first time that we have seen
* request to place an object in the
* configuration with the key 'key'. So
* we just want to place it directly into
* the configuration ... but we are going to
* make a special exception for String objects
* that contain "," characters. We will take
* CSV lists and turn the list into a vector of
* Strings before placing it in the configuration.
* This is a concession for Properties and the
* like that cannot parse multiple same key
* values.
*/
if (token instanceof String &&
((String)token).indexOf(PropertiesTokenizer.DELIMITER) > 0)
{
PropertiesTokenizer tokenizer =
new PropertiesTokenizer((String)token);
while (tokenizer.hasMoreTokens())
{
String value = tokenizer.nextToken();
/*
* we know this is a string, so make sure it
* just goes in rather than risking vectorization
* if it contains an escaped comma
*/
addStringProperty(key,value);
}
}
else
{
/*
* We want to keep track of the order the keys
* are parsed, or dynamically entered into
* the configuration. So when we see a key
* for the first time we will place it in
* an ArrayList so that if a client class needs
* to perform operations with configuration
* in a definite order it will be possible.
*/
addPropertyDirect( key, token );
}
}
}
/**
* Adds a key/value pair to the map. This routine does
* no magic morphing. It ensures the keylist is maintained
*
* @param key key to use for mapping
* @param obj object to store
*/
private void addPropertyDirect( String key, Object obj )
{
/*
* safety check
*/
if( !containsKey( key ) )
{
keysAsListed.add(key);
}
/*
* and the value
*/
put(key, obj);
}
/**
* Sets a string property w/o checking for commas - used
* internally when a property has been broken up into
* strings that could contain escaped commas to prevent
* the inadvertant vectorization.
*
* Thanks to Leon Messerschmidt for this one.
*
*/
private void addStringProperty(String key, String token)
{
Object o = this.get(key);
/*
* $$$ GMJ
* FIXME : post 1.0 release, we need to not assume
* that a scalar is a String - it can be an Object
* so we should make a little vector-like class
* say, Foo that wraps (not extends Vector),
* so we can do things like
* if ( !( o instanceof Foo) )
* so we know it's our 'vector' container
*
* This applies throughout
*/
/*
* do the usual thing - if we have a value and
* it's scalar, make a vector, otherwise add
* to the vector
*/
if (o instanceof String)
{
Vector v = new Vector(2);
v.addElement(o);
v.addElement(token);
put(key, v);
}
else if (o instanceof Vector)
{
((Vector) o).addElement(token);
}
else
{
addPropertyDirect( key, token );
}
}
/**
* Set a property, this will replace any previously
* set values. Set values is implicitly a call
* to clearProperty(key), addProperty(key,value).
*
* @param String key
* @param String value
*/
public void setProperty(String key, Object value)
{
clearProperty(key);
addProperty(key,value);
}
/**
* Save the properties to the given outputstream.
*
* @param output An OutputStream.
* @param header A String.
* @exception IOException.
*/
public synchronized void save(OutputStream output,
String Header)
throws IOException
{
if(output != null)
{
PrintWriter theWrtr = new PrintWriter(output);
if(Header != null)
{
theWrtr.println(Header);
}
Enumeration theKeys = keys();
while(theKeys.hasMoreElements())
{
String key = (String) theKeys.nextElement();
Object value = get((Object) key);
if(value != null)
{
if(value instanceof String)
{
StringBuffer currentOutput = new StringBuffer();
currentOutput.append(key);
currentOutput.append("=");
currentOutput.append((String) value);
theWrtr.println(currentOutput.toString());
}
else if(value instanceof Vector)
{
Vector values = (Vector) value;
Enumeration valuesEnum = values.elements();
while(valuesEnum.hasMoreElements())
{
String currentElement =
(String) valuesEnum.nextElement();
StringBuffer currentOutput = new StringBuffer();
currentOutput.append(key);
currentOutput.append("=");
currentOutput.append(currentElement);
theWrtr.println(currentOutput.toString());
}
}
}
theWrtr.println();
theWrtr.flush();
}
}
}
/**
* Combines an existing Hashtable with this Hashtable.
*
* Warning: It will overwrite previous entries without warning.
*
* @param ExtendedProperties
*/
public void combine( ExtendedProperties c )
{
for (Iterator i = c.getKeys() ; i.hasNext() ;)
{
String key = (String) i.next();
setProperty( key, c.get(key) );
}
}
/**
* Clear a property in the configuration.
*
* @param String key to remove along with corresponding value.
*/
public void clearProperty(String key)
{
if (containsKey(key))
{
/*
* we also need to rebuild the keysAsListed or else
* things get *very* confusing
*/
for(int i = 0; i < keysAsListed.size(); i++)
{
if ( ( (String) keysAsListed.get(i)).equals( key ) )
{
keysAsListed.remove(i);
break;
}
}
remove(key);
}
}
/**
* Get the list of the keys contained in the configuration
* repository.
*
* @return An Iterator.
*/
public Iterator getKeys()
{
return keysAsListed.iterator();
}
/**
* Get the list of the keys contained in the configuration
* repository that match the specified prefix.
*
* @param prefix The prefix to test against.
* @return An Iterator of keys that match the prefix.
*/
public Iterator getKeys(String prefix)
{
Iterator keys = getKeys();
ArrayList matchingKeys = new ArrayList();
while( keys.hasNext() )
{
Object key = keys.next();
if( key instanceof String && ((String) key).startsWith(prefix) )
{
matchingKeys.add(key);
}
}
return matchingKeys.iterator();
}
/**
* Create an ExtendedProperties object that is a subset
* of this one. Take into account duplicate keys
* by using the setProperty() in ExtendedProperties.
*
* @param String prefix
*/
public ExtendedProperties subset(String prefix)
{
ExtendedProperties c = new ExtendedProperties();
Iterator keys = getKeys();
boolean validSubset = false;
while( keys.hasNext() )
{
Object key = keys.next();
if( key instanceof String && ((String) key).startsWith(prefix) )
{
if (!validSubset)
{
validSubset = true;
}
String newKey = null;
/*
* Check to make sure that c.subset(prefix) doesn't
* blow up when there is only a single property
* with the key prefix. This is not a useful
* subset but it is a valid subset.
*/
if ( ((String)key).length() == prefix.length())
{
newKey = prefix;
}
else
{
newKey = ((String)key).substring(prefix.length() + 1);
}
/*
* use addPropertyDirect() - this will plug the data as
* is into the Map, but will also do the right thing
* re key accounting
*/
c.addPropertyDirect( newKey, get(key) );
}
}
if (validSubset)
{
return c;
}
else
{
return null;
}
}
/**
* Display the configuration for debugging
* purposes.
*/
public void display()
{
Iterator i = getKeys();
while (i.hasNext())
{
String key = (String) i.next();
Object value = get(key);
System.out.println(key + " => " + value);
}
}
/**
* Get a string associated with the given configuration key.
*
* @param key The configuration key.
* @return The associated string.
* @exception ClassCastException is thrown if the key maps to an
* object that is not a String.
*/
public String getString(String key)
{
return getString(key, null);
}
/**
* Get a string associated with the given configuration key.
*
* @param key The configuration key.
* @param defaultValue The default value.
* @return The associated string if key is found,
* default value otherwise.
* @exception ClassCastException is thrown if the key maps to an
* object that is not a String.
*/
public String getString(String key,
String defaultValue)
{
Object value = get(key);
if (value instanceof String)
{
return (String) interpolate((String)value);
}
else if (value == null)
{
if (defaults != null)
{
return interpolate(defaults.getString(key, defaultValue));
}
else
{
return interpolate(defaultValue);
}
}
else if (value instanceof Vector)
{
return interpolate((String) ((Vector) value).get(0));
}
else
{
throw new ClassCastException(
'\'' + key + "' doesn't map to a String object");
}
}
/**
* Get a list of properties associated with the given
* configuration key.
*
* @param key The configuration key.
* @return The associated properties if key is found.
* @exception ClassCastException is thrown if the key maps to an
* object that is not a String/Vector.
* @exception IllegalArgumentException if one of the tokens is
* malformed (does not contain an equals sign).
*/
public Properties getProperties(String key)
{
return getProperties(key, new Properties());
}
/**
* Get a list of properties associated with the given
* configuration key.
*
* @param key The configuration key.
* @return The associated properties if key is found.
* @exception ClassCastException is thrown if the key maps to an
* object that is not a String/Vector.
* @exception IllegalArgumentException if one of the tokens is
* malformed (does not contain an equals sign).
*/
public Properties getProperties(String key,
Properties defaults)
{
/*
* Grab an array of the tokens for this key.
*/
String[] tokens = getStringArray(key);
/*
* Each token is of the form 'key=value'.
*/
Properties props = new Properties(defaults);
for (int i = 0; i < tokens.length; i++)
{
String token = tokens[i];
int equalSign = token.indexOf('=');
if (equalSign > 0)
{
String pkey = token.substring(0, equalSign).trim();
String pvalue = token.substring(equalSign + 1).trim();
props.put(pkey, pvalue);
}
else
{
throw new IllegalArgumentException('\'' + token +
"' does not contain " +
"an equals sign");
}
}
return props;
}
/**
* Get an array of strings associated with the given configuration
* key.
*
* @param key The configuration key.
* @return The associated string array if key is found.
* @exception ClassCastException is thrown if the key maps to an
* object that is not a String/Vector.
*/
public String[] getStringArray(String key)
{
Object value = get(key);
// What's your vector, Victor?
Vector vector;
if (value instanceof String)
{
vector = new Vector(1);
vector.addElement(value);
}
else if (value instanceof Vector)
{
vector = (Vector)value;
}
else if (value == null)
{
if (defaults != null)
{
return defaults.getStringArray(key);
}
else
{
return new String[0];
}
}
else
{
throw new ClassCastException(
'\'' + key + "' doesn't map to a String/Vector object");
}
String[] tokens = new String[vector.size()];
for (int i = 0; i < tokens.length; i++)
{
tokens[i] = (String)vector.elementAt(i);
}
return tokens;
}
/**
* Get a Vector of strings associated with the given configuration
* key.
*
* @param key The configuration key.
* @return The associated Vector.
* @exception ClassCastException is thrown if the key maps to an
* object that is not a Vector.
*/
public Vector getVector(String key)
{
return getVector(key, null);
}
/**
* Get a Vector of strings associated with the given configuration
* key.
*
* @param key The configuration key.
* @param defaultValue The default value.
* @return The associated Vector.
* @exception ClassCastException is thrown if the key maps to an
* object that is not a Vector.
*/
public Vector getVector(String key,
Vector defaultValue)
{
Object value = get(key);
if (value instanceof Vector)
{
return (Vector) value;
}
else if (value instanceof String)
{
Vector v = new Vector(1);
v.addElement((String) value);
put(key, v);
return v;
}
else if (value == null)
{
if (defaults != null)
{
return defaults.getVector(key, defaultValue);
}
else
{
return ((defaultValue == null) ?
new Vector() : defaultValue);
}
}
else
{
throw new ClassCastException(
'\'' + key + "' doesn't map to a Vector object");
}
}
/**
* Get a boolean associated with the given configuration key.
*
* @param key The configuration key.
* @return The associated boolean.
* @exception NoSuchElementException is thrown if the key doesn't
* map to an existing object.
* @exception ClassCastException is thrown if the key maps to an
* object that is not a Boolean.
*/
public boolean getBoolean(String key)
{
Boolean b = getBoolean(key, (Boolean) null);
if (b != null)
{
return b.booleanValue();
}
else
{
throw new NoSuchElementException(
'\'' + key + "' doesn't map to an existing object");
}
}
/**
* Get a boolean associated with the given configuration key.
*
* @param key The configuration key.
* @param defaultValue The default value.
* @return The associated boolean.
* @exception ClassCastException is thrown if the key maps to an
* object that is not a Boolean.
*/
public boolean getBoolean(String key, boolean defaultValue)
{
return getBoolean(key, new Boolean(defaultValue)).booleanValue();
}
/**
* Get a boolean associated with the given configuration key.
*
* @param key The configuration key.
* @param defaultValue The default value.
* @return The associated boolean if key is found and has valid
* format, default value otherwise.
* @exception ClassCastException is thrown if the key maps to an
* object that is not a Boolean.
*/
public Boolean getBoolean(String key, Boolean defaultValue)
{
Object value = get(key);
if (value instanceof Boolean)
{
return (Boolean) value;
}
else if (value instanceof String)
{
String s = testBoolean((String)value);
Boolean b = new Boolean(s);
put(key, b);
return b;
}
else if (value == null)
{
if (defaults != null)
{
return defaults.getBoolean(key, defaultValue);
}
else
{
return defaultValue;
}
}
else
{
throw new ClassCastException(
'\'' + key + "' doesn't map to a Boolean object");
}
}
/**
* Test whether the string represent by value maps to a boolean
* value or not. We will allow true, on,
* and yes for a true boolean value, and
* false, off, and no for
* false boolean values. Case of value to test for
* boolean status is ignored.
*
* @param String The value to test for boolean state.
* @return true or false if the supplied
* text maps to a boolean value, or null otherwise.
*/
public String testBoolean(String value)
{
String s = ((String)value).toLowerCase();
if (s.equals("true") || s.equals("on") || s.equals("yes"))
{
return "true";
}
else if (s.equals("false") || s.equals("off") || s.equals("no"))
{
return "false";
}
else
{
return null;
}
}
/**
* Get a byte associated with the given configuration key.
*
* @param key The configuration key.
* @return The associated byte.
* @exception NoSuchElementException is thrown if the key doesn't
* map to an existing object.
* @exception ClassCastException is thrown if the key maps to an
* object that is not a Byte.
* @exception NumberFormatException is thrown if the value mapped
* by the key has not a valid number format.
*/
public byte getByte(String key)
{
Byte b = getByte(key, null);
if (b != null)
{
return b.byteValue();
}
else
{
throw new NoSuchElementException(
'\'' + key + " doesn't map to an existing object");
}
}
/**
* Get a byte associated with the given configuration key.
*
* @param key The configuration key.
* @param defaultValue The default value.
* @return The associated byte.
* @exception ClassCastException is thrown if the key maps to an
* object that is not a Byte.
* @exception NumberFormatException is thrown if the value mapped
* by the key has not a valid number format.
*/
public byte getByte(String key,
byte defaultValue)
{
return getByte(key, new Byte(defaultValue)).byteValue();
}
/**
* Get a byte associated with the given configuration key.
*
* @param key The configuration key.
* @param defaultValue The default value.
* @return The associated byte if key is found and has valid
* format, default value otherwise.
* @exception ClassCastException is thrown if the key maps to an
* object that is not a Byte.
* @exception NumberFormatException is thrown if the value mapped
* by the key has not a valid number format.
*/
public Byte getByte(String key,
Byte defaultValue)
{
Object value = get(key);
if (value instanceof Byte)
{
return (Byte) value;
}
else if (value instanceof String)
{
Byte b = new Byte((String) value);
put(key, b);
return b;
}
else if (value == null)
{
if (defaults != null)
{
return defaults.getByte(key, defaultValue);
}
else
{
return defaultValue;
}
}
else
{
throw new ClassCastException(
'\'' + key + "' doesn't map to a Byte object");
}
}
/**
* Get a short associated with the given configuration key.
*
* @param key The configuration key.
* @return The associated short.
* @exception NoSuchElementException is thrown if the key doesn't
* map to an existing object.
* @exception ClassCastException is thrown if the key maps to an
* object that is not a Short.
* @exception NumberFormatException is thrown if the value mapped
* by the key has not a valid number format.
*/
public short getShort(String key)
{
Short s = getShort(key, null);
if (s != null)
{
return s.shortValue();
}
else
{
throw new NoSuchElementException(
'\'' + key + "' doesn't map to an existing object");
}
}
/**
* Get a short associated with the given configuration key.
*
* @param key The configuration key.
* @param defaultValue The default value.
* @return The associated short.
* @exception ClassCastException is thrown if the key maps to an
* object that is not a Short.
* @exception NumberFormatException is thrown if the value mapped
* by the key has not a valid number format.
*/
public short getShort(String key,
short defaultValue)
{
return getShort(key, new Short(defaultValue)).shortValue();
}
/**
* Get a short associated with the given configuration key.
*
* @param key The configuration key.
* @param defaultValue The default value.
* @return The associated short if key is found and has valid
* format, default value otherwise.
* @exception ClassCastException is thrown if the key maps to an
* object that is not a Short.
* @exception NumberFormatException is thrown if the value mapped
* by the key has not a valid number format.
*/
public Short getShort(String key,
Short defaultValue)
{
Object value = get(key);
if (value instanceof Short)
{
return (Short) value;
}
else if (value instanceof String)
{
Short s = new Short((String) value);
put(key, s);
return s;
}
else if (value == null)
{
if (defaults != null)
{
return defaults.getShort(key, defaultValue);
}
else
{
return defaultValue;
}
}
else
{
throw new ClassCastException(
'\'' + key + "' doesn't map to a Short object");
}
}
/**
* The purpose of this method is to get the configuration resource
* with the given name as an integer.
*
* @param name The resource name.
* @return The value of the resource as an integer.
*/
public int getInt(String name)
{
return getInteger(name);
}
/**
* The purpose of this method is to get the configuration resource
* with the given name as an integer, or a default value.
*
* @param name The resource name
* @param def The default value of the resource.
* @return The value of the resource as an integer.
*/
public int getInt(String name,
int def)
{
return getInteger(name, def);
}
/**
* Get a int associated with the given configuration key.
*
* @param key The configuration key.
* @return The associated int.
* @exception NoSuchElementException is thrown if the key doesn't
* map to an existing object.
* @exception ClassCastException is thrown if the key maps to an
* object that is not a Integer.
* @exception NumberFormatException is thrown if the value mapped
* by the key has not a valid number format.
*/
public int getInteger(String key)
{
Integer i = getInteger(key, null);
if (i != null)
{
return i.intValue();
}
else
{
throw new NoSuchElementException(
'\'' + key + "' doesn't map to an existing object");
}
}
/**
* Get a int associated with the given configuration key.
*
* @param key The configuration key.
* @param defaultValue The default value.
* @return The associated int.
* @exception ClassCastException is thrown if the key maps to an
* object that is not a Integer.
* @exception NumberFormatException is thrown if the value mapped
* by the key has not a valid number format.
*/
public int getInteger(String key,
int defaultValue)
{
Integer i = getInteger(key, null);
if (i == null)
{
return defaultValue;
}
return i.intValue();
}
/**
* Get a int associated with the given configuration key.
*
* @param key The configuration key.
* @param defaultValue The default value.
* @return The associated int if key is found and has valid
* format, default value otherwise.
* @exception ClassCastException is thrown if the key maps to an
* object that is not a Integer.
* @exception NumberFormatException is thrown if the value mapped
* by the key has not a valid number format.
*/
public Integer getInteger(String key,
Integer defaultValue)
{
Object value = get(key);
if (value instanceof Integer)
{
return (Integer) value;
}
else if (value instanceof String)
{
Integer i = new Integer((String) value);
put(key, i);
return i;
}
else if (value == null)
{
if (defaults != null)
{
return defaults.getInteger(key, defaultValue);
}
else
{
return defaultValue;
}
}
else
{
throw new ClassCastException(
'\'' + key + "' doesn't map to a Integer object");
}
}
/**
* Get a long associated with the given configuration key.
*
* @param key The configuration key.
* @return The associated long.
* @exception NoSuchElementException is thrown if the key doesn't
* map to an existing object.
* @exception ClassCastException is thrown if the key maps to an
* object that is not a Long.
* @exception NumberFormatException is thrown if the value mapped
* by the key has not a valid number format.
*/
public long getLong(String key)
{
Long l = getLong(key, null);
if (l != null)
{
return l.longValue();
}
else
{
throw new NoSuchElementException(
'\'' + key + "' doesn't map to an existing object");
}
}
/**
* Get a long associated with the given configuration key.
*
* @param key The configuration key.
* @param defaultValue The default value.
* @return The associated long.
* @exception ClassCastException is thrown if the key maps to an
* object that is not a Long.
* @exception NumberFormatException is thrown if the value mapped
* by the key has not a valid number format.
*/
public long getLong(String key,
long defaultValue)
{
return getLong(key, new Long(defaultValue)).longValue();
}
/**
* Get a long associated with the given configuration key.
*
* @param key The configuration key.
* @param defaultValue The default value.
* @return The associated long if key is found and has valid
* format, default value otherwise.
* @exception ClassCastException is thrown if the key maps to an
* object that is not a Long.
* @exception NumberFormatException is thrown if the value mapped
* by the key has not a valid number format.
*/
public Long getLong(String key,
Long defaultValue)
{
Object value = get(key);
if (value instanceof Long)
{
return (Long) value;
}
else if (value instanceof String)
{
Long l = new Long((String) value);
put(key, l);
return l;
}
else if (value == null)
{
if (defaults != null)
{
return defaults.getLong(key, defaultValue);
}
else
{
return defaultValue;
}
}
else
{
throw new ClassCastException(
'\'' + key + "' doesn't map to a Long object");
}
}
/**
* Get a float associated with the given configuration key.
*
* @param key The configuration key.
* @return The associated float.
* @exception NoSuchElementException is thrown if the key doesn't
* map to an existing object.
* @exception ClassCastException is thrown if the key maps to an
* object that is not a Float.
* @exception NumberFormatException is thrown if the value mapped
* by the key has not a valid number format.
*/
public float getFloat(String key)
{
Float f = getFloat(key, null);
if (f != null)
{
return f.floatValue();
}
else
{
throw new NoSuchElementException(
'\'' + key + "' doesn't map to an existing object");
}
}
/**
* Get a float associated with the given configuration key.
*
* @param key The configuration key.
* @param defaultValue The default value.
* @return The associated float.
* @exception ClassCastException is thrown if the key maps to an
* object that is not a Float.
* @exception NumberFormatException is thrown if the value mapped
* by the key has not a valid number format.
*/
public float getFloat(String key,
float defaultValue)
{
return getFloat(key, new Float(defaultValue)).floatValue();
}
/**
* Get a float associated with the given configuration key.
*
* @param key The configuration key.
* @param defaultValue The default value.
* @return The associated float if key is found and has valid
* format, default value otherwise.
* @exception ClassCastException is thrown if the key maps to an
* object that is not a Float.
* @exception NumberFormatException is thrown if the value mapped
* by the key has not a valid number format.
*/
public Float getFloat(String key,
Float defaultValue)
{
Object value = get(key);
if (value instanceof Float)
{
return (Float) value;
}
else if (value instanceof String)
{
Float f = new Float((String) value);
put(key, f);
return f;
}
else if (value == null)
{
if (defaults != null)
{
return defaults.getFloat(key, defaultValue);
}
else
{
return defaultValue;
}
}
else
{
throw new ClassCastException(
'\'' + key + "' doesn't map to a Float object");
}
}
/**
* Get a double associated with the given configuration key.
*
* @param key The configuration key.
* @return The associated double.
* @exception NoSuchElementException is thrown if the key doesn't
* map to an existing object.
* @exception ClassCastException is thrown if the key maps to an
* object that is not a Double.
* @exception NumberFormatException is thrown if the value mapped
* by the key has not a valid number format.
*/
public double getDouble(String key)
{
Double d = getDouble(key, null);
if (d != null)
{
return d.doubleValue();
}
else
{
throw new NoSuchElementException(
'\'' + key + "' doesn't map to an existing object");
}
}
/**
* Get a double associated with the given configuration key.
*
* @param key The configuration key.
* @param defaultValue The default value.
* @return The associated double.
* @exception ClassCastException is thrown if the key maps to an
* object that is not a Double.
* @exception NumberFormatException is thrown if the value mapped
* by the key has not a valid number format.
*/
public double getDouble(String key,
double defaultValue)
{
return getDouble(key, new Double(defaultValue)).doubleValue();
}
/**
* Get a double associated with the given configuration key.
*
* @param key The configuration key.
* @param defaultValue The default value.
* @return The associated double if key is found and has valid
* format, default value otherwise.
* @exception ClassCastException is thrown if the key maps to an
* object that is not a Double.
* @exception NumberFormatException is thrown if the value mapped
* by the key has not a valid number format.
*/
public Double getDouble(String key,
Double defaultValue)
{
Object value = get(key);
if (value instanceof Double)
{
return (Double) value;
}
else if (value instanceof String)
{
Double d = new Double((String) value);
put(key, d);
return d;
}
else if (value == null)
{
if (defaults != null)
{
return defaults.getDouble(key, defaultValue);
}
else
{
return defaultValue;
}
}
else
{
throw new ClassCastException(
'\'' + key + "' doesn't map to a Double object");
}
}
/**
* Convert a standard properties class into a configuration
* class.
*
* @param p properties object to convert into
* a ExtendedProperties object.
*
* @return ExtendedProperties configuration created from the
* properties object.
*/
public static ExtendedProperties convertProperties(Properties p)
{
ExtendedProperties c = new ExtendedProperties();
for (Enumeration e = p.keys(); e.hasMoreElements() ; )
{
String s = (String) e.nextElement();
c.setProperty(s, p.getProperty(s));
}
return c;
}
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/ArrayStack.java 0100644 0001750 0001750 00000014317 10055172376 031200 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.ArrayList;
import java.util.EmptyStackException;
/**
* An implementation of the {@link java.util.Stack} API that is based on an
* ArrayList instead of a Vector, so it is not
* synchronized to protect against multi-threaded access. The implementation
* is therefore operates faster in environments where you do not need to
* worry about multiple thread contention.
*
* The removal order of an ArrayStack is based on insertion
* order: The most recently added element is removed first. The iteration
* order is not the same as the removal order. The iterator returns
* elements from the bottom up, whereas the {@link #remove()} method removes
* them from the top down.
*
* Unlike Stack, ArrayStack accepts null entries.
*
* @author Craig R. McClanahan
* @author Paul Jack
* @author Stephen Colebourne
* @since 1.0
* @version $Id: ArrayStack.java,v 1.10.2.1 2004/05/22 12:14:01 scolebourne Exp $
* @see java.util.Stack
*/
public class ArrayStack extends ArrayList implements Buffer {
final private static long serialVersionUID = 2130079159931574599L;
//, local class serialVersionUID = -3491241305852305742
/**
* Constructs a new empty ArrayStack. The initial size
* is controlled by ArrayList and is currently 10.
*/
public ArrayStack() {
super();
}
/**
* Constructs a new empty ArrayStack with an initial size.
*
* @param initialSize the initial size to use
* @throws IllegalArgumentException if the specified initial size
* is negative
*/
public ArrayStack(int initialSize) {
super(initialSize);
}
/**
* Return true if this stack is currently empty.
*
* This method exists for compatability with java.util.Stack.
* New users of this class should use isEmpty instead.
*
* @return true if the stack is currently empty
*/
public boolean empty() {
return isEmpty();
}
/**
* Returns the top item off of this stack without removing it.
*
* @return the top item on the stack
* @throws EmptyStackException if the stack is empty
*/
public Object peek() throws EmptyStackException {
int n = size();
if (n <= 0) {
throw new EmptyStackException();
} else {
return get(n - 1);
}
}
/**
* Returns the n'th item down (zero-relative) from the top of this
* stack without removing it.
*
* @param n the number of items down to go
* @return the n'th item on the stack, zero relative
* @throws EmptyStackException if there are not enough items on the
* stack to satisfy this request
*/
public Object peek(int n) throws EmptyStackException {
int m = (size() - n) - 1;
if (m < 0) {
throw new EmptyStackException();
} else {
return get(m);
}
}
/**
* Pops the top item off of this stack and return it.
*
* @return the top item on the stack
* @throws EmptyStackException if the stack is empty
*/
public Object pop() throws EmptyStackException {
int n = size();
if (n <= 0) {
throw new EmptyStackException();
} else {
return remove(n - 1);
}
}
/**
* Pushes a new item onto the top of this stack. The pushed item is also
* returned. This is equivalent to calling add.
*
* @param item the item to be added
* @return the item just pushed
*/
public Object push(Object item) {
add(item);
return item;
}
/**
* Returns the one-based position of the distance from the top that the
* specified object exists on this stack, where the top-most element is
* considered to be at distance 1. If the object is not
* present on the stack, return -1 instead. The
* equals() method is used to compare to the items
* in this stack.
*
* @param object the object to be searched for
* @return the 1-based depth into the stack of the object, or -1 if not found
*/
public int search(Object object) {
int i = size() - 1; // Current index
int n = 1; // Current distance
while (i >= 0) {
Object current = get(i);
if ((object == null && current == null) ||
(object != null && object.equals(current))) {
return n;
}
i--;
n++;
}
return -1;
}
/**
* Returns the element on the top of the stack.
*
* @return the element on the top of the stack
* @throws BufferUnderflowException if the stack is empty
*/
public Object get() {
int size = size();
if (size == 0) {
throw new BufferUnderflowException();
}
return get(size - 1);
}
/**
* Removes the element on the top of the stack.
*
* @return the removed element
* @throws BufferUnderflowException if the stack is empty
*/
public Object remove() {
int size = size();
if (size == 0) {
throw new BufferUnderflowException();
}
return remove(size - 1);
}
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/FastArrayList.java 0100644 0001750 0001750 00000111157 10055172400 031650 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.ArrayList;
import java.util.Collection;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
/**
*
A customized implementation of java.util.ArrayList designed
* to operate in a multithreaded environment where the large majority of
* method calls are read-only, instead of structural changes. When operating
* in "fast" mode, read calls are non-synchronized and write calls perform the
* following steps:
When first created, objects of this class default to "slow" mode, where
* all accesses of any type are synchronized but no cloning takes place. This
* is appropriate for initially populating the collection, followed by a switch
* to "fast" mode (by calling setFast(true)) after initialization
* is complete.
NOTE: If you are creating and accessing an
* ArrayList only within a single thread, you should use
* java.util.ArrayList directly (with no synchronization), for
* maximum performance.
NOTE: This class is not cross-platform. * Using it may cause unexpected failures on some architectures. * It suffers from the same problems as the double-checked locking idiom. * In particular, the instruction that clones the internal collection and the * instruction that sets the internal reference to the clone can be executed * or perceived out-of-order. This means that any read operation might fail * unexpectedly, as it may be reading the state of the internal collection * before the internal collection is fully formed. * For more information on the double-checked locking idiom, see the * * Double-Checked Locking Idiom Is Broken Declartion.
* * @since 1.0 * @author Craig R. McClanahan * @version $Revision: 1.9.2.1 $ $Date: 2004/05/22 12:14:02 $ */ public class FastArrayList extends ArrayList { // ----------------------------------------------------------- Constructors /** * Construct a an empty list. */ public FastArrayList() { super(); this.list = new ArrayList(); } /** * Construct an empty list with the specified capacity. * * @param capacity The initial capacity of the empty list */ public FastArrayList(int capacity) { super(); this.list = new ArrayList(capacity); } /** * Construct a list containing the elements of the specified collection, * in the order they are returned by the collection's iterator. * * @param collection The collection whose elements initialize the contents * of this list */ public FastArrayList(Collection collection) { super(); this.list = new ArrayList(collection); } // ----------------------------------------------------- Instance Variables /** * The underlying list we are managing. */ protected ArrayList list = null; // ------------------------------------------------------------- Properties /** * Are we operating in "fast" mode? */ protected boolean fast = false; /** * Returns true if this list is operating in fast mode. * * @return true if this list is operating in fast mode */ public boolean getFast() { return (this.fast); } /** * Sets whether this list will operate in fast mode. * * @param fast true if the list should operate in fast mode */ public void setFast(boolean fast) { this.fast = fast; } // --------------------------------------------------------- Public Methods /** * Appends the specified element to the end of this list. * * @param element The element to be appended */ public boolean add(Object element) { if (fast) { synchronized (this) { ArrayList temp = (ArrayList) list.clone(); boolean result = temp.add(element); list = temp; return (result); } } else { synchronized (list) { return (list.add(element)); } } } /** * Insert the specified element at the specified position in this list, * and shift all remaining elements up one position. * * @param index Index at which to insert this element * @param element The element to be inserted * * @exception IndexOutOfBoundsException if the index is out of range */ public void add(int index, Object element) { if (fast) { synchronized (this) { ArrayList temp = (ArrayList) list.clone(); temp.add(index, element); list = temp; } } else { synchronized (list) { list.add(index, element); } } } /** * Append all of the elements in the specified Collection to the end * of this list, in the order that they are returned by the specified * Collection's Iterator. * * @param collection The collection to be appended */ public boolean addAll(Collection collection) { if (fast) { synchronized (this) { ArrayList temp = (ArrayList) list.clone(); boolean result = temp.addAll(collection); list = temp; return (result); } } else { synchronized (list) { return (list.addAll(collection)); } } } /** * Insert all of the elements in the specified Collection at the specified * position in this list, and shift any previous elements upwards as * needed. * * @param index Index at which insertion takes place * @param collection The collection to be added * * @exception IndexOutOfBoundsException if the index is out of range */ public boolean addAll(int index, Collection collection) { if (fast) { synchronized (this) { ArrayList temp = (ArrayList) list.clone(); boolean result = temp.addAll(index, collection); list = temp; return (result); } } else { synchronized (list) { return (list.addAll(index, collection)); } } } /** * Remove all of the elements from this list. The list will be empty * after this call returns. * * @exception UnsupportedOperationException ifclear()
* is not supported by this list
*/
public void clear() {
if (fast) {
synchronized (this) {
ArrayList temp = (ArrayList) list.clone();
temp.clear();
list = temp;
}
} else {
synchronized (list) {
list.clear();
}
}
}
/**
* Return a shallow copy of this FastArrayList instance.
* The elements themselves are not copied.
*/
public Object clone() {
FastArrayList results = null;
if (fast) {
results = new FastArrayList(list);
} else {
synchronized (list) {
results = new FastArrayList(list);
}
}
results.setFast(getFast());
return (results);
}
/**
* Return true if this list contains the specified element.
*
* @param element The element to test for
*/
public boolean contains(Object element) {
if (fast) {
return (list.contains(element));
} else {
synchronized (list) {
return (list.contains(element));
}
}
}
/**
* Return true if this list contains all of the elements
* in the specified Collection.
*
* @param collection Collection whose elements are to be checked
*/
public boolean containsAll(Collection collection) {
if (fast) {
return (list.containsAll(collection));
} else {
synchronized (list) {
return (list.containsAll(collection));
}
}
}
/**
* Increase the capacity of this ArrayList instance, if
* necessary, to ensure that it can hold at least the number of elements
* specified by the minimum capacity argument.
*
* @param capacity The new minimum capacity
*/
public void ensureCapacity(int capacity) {
if (fast) {
synchronized (this) {
ArrayList temp = (ArrayList) list.clone();
temp.ensureCapacity(capacity);
list = temp;
}
} else {
synchronized (list) {
list.ensureCapacity(capacity);
}
}
}
/**
* Compare the specified object with this list for equality. This
* implementation uses exactly the code that is used to define the
* list equals function in the documentation for the
* List.equals method.
*
* @param o Object to be compared to this list
*/
public boolean equals(Object o) {
// Simple tests that require no synchronization
if (o == this)
return (true);
else if (!(o instanceof List))
return (false);
List lo = (List) o;
// Compare the sets of elements for equality
if (fast) {
ListIterator li1 = list.listIterator();
ListIterator li2 = lo.listIterator();
while (li1.hasNext() && li2.hasNext()) {
Object o1 = li1.next();
Object o2 = li2.next();
if (!(o1 == null ? o2 == null : o1.equals(o2)))
return (false);
}
return (!(li1.hasNext() || li2.hasNext()));
} else {
synchronized (list) {
ListIterator li1 = list.listIterator();
ListIterator li2 = lo.listIterator();
while (li1.hasNext() && li2.hasNext()) {
Object o1 = li1.next();
Object o2 = li2.next();
if (!(o1 == null ? o2 == null : o1.equals(o2)))
return (false);
}
return (!(li1.hasNext() || li2.hasNext()));
}
}
}
/**
* Return the element at the specified position in the list.
*
* @param index The index of the element to return
*
* @exception IndexOutOfBoundsException if the index is out of range
*/
public Object get(int index) {
if (fast) {
return (list.get(index));
} else {
synchronized (list) {
return (list.get(index));
}
}
}
/**
* Return the hash code value for this list. This implementation uses
* exactly the code that is used to define the list hash function in the
* documentation for the List.hashCode method.
*/
public int hashCode() {
if (fast) {
int hashCode = 1;
java.util.Iterator i = list.iterator();
while (i.hasNext()) {
Object o = i.next();
hashCode = 31 * hashCode + (o == null ? 0 : o.hashCode());
}
return (hashCode);
} else {
synchronized (list) {
int hashCode = 1;
java.util.Iterator i = list.iterator();
while (i.hasNext()) {
Object o = i.next();
hashCode = 31 * hashCode + (o == null ? 0 : o.hashCode());
}
return (hashCode);
}
}
}
/**
* Search for the first occurrence of the given argument, testing
* for equality using the equals() method, and return
* the corresponding index, or -1 if the object is not found.
*
* @param element The element to search for
*/
public int indexOf(Object element) {
if (fast) {
return (list.indexOf(element));
} else {
synchronized (list) {
return (list.indexOf(element));
}
}
}
/**
* Test if this list has no elements.
*/
public boolean isEmpty() {
if (fast) {
return (list.isEmpty());
} else {
synchronized (list) {
return (list.isEmpty());
}
}
}
/**
* Return an iterator over the elements in this list in proper sequence.
* equals() method, and return
* the corresponding index, or -1 if the object is not found.
*
* @param element The element to search for
*/
public int lastIndexOf(Object element) {
if (fast) {
return (list.lastIndexOf(element));
} else {
synchronized (list) {
return (list.lastIndexOf(element));
}
}
}
/**
* Return an iterator of the elements of this list, in proper sequence.
* See the implementation note on iterator().
*/
public ListIterator listIterator() {
if (fast) {
return new ListIter(0);
} else {
return list.listIterator();
}
}
/**
* Return an iterator of the elements of this list, in proper sequence,
* starting at the specified position.
* See the implementation note on iterator().
*
* @param index The starting position of the iterator to return
*
* @exception IndexOutOfBoundsException if the index is out of range
*/
public ListIterator listIterator(int index) {
if (fast) {
return new ListIter(index);
} else {
return list.listIterator(index);
}
}
/**
* Remove the element at the specified position in the list, and shift
* any subsequent elements down one position.
*
* @param index Index of the element to be removed
*
* @exception IndexOutOfBoundsException if the index is out of range
*/
public Object remove(int index) {
if (fast) {
synchronized (this) {
ArrayList temp = (ArrayList) list.clone();
Object result = temp.remove(index);
list = temp;
return (result);
}
} else {
synchronized (list) {
return (list.remove(index));
}
}
}
/**
* Remove the first occurrence of the specified element from the list,
* and shift any subsequent elements down one position.
*
* @param element Element to be removed
*/
public boolean remove(Object element) {
if (fast) {
synchronized (this) {
ArrayList temp = (ArrayList) list.clone();
boolean result = temp.remove(element);
list = temp;
return (result);
}
} else {
synchronized (list) {
return (list.remove(element));
}
}
}
/**
* Remove from this collection all of its elements that are contained
* in the specified collection.
*
* @param collection Collection containing elements to be removed
*
* @exception UnsupportedOperationException if this optional operation
* is not supported by this list
*/
public boolean removeAll(Collection collection) {
if (fast) {
synchronized (this) {
ArrayList temp = (ArrayList) list.clone();
boolean result = temp.removeAll(collection);
list = temp;
return (result);
}
} else {
synchronized (list) {
return (list.removeAll(collection));
}
}
}
/**
* Remove from this collection all of its elements except those that are
* contained in the specified collection.
*
* @param collection Collection containing elements to be retained
*
* @exception UnsupportedOperationException if this optional operation
* is not supported by this list
*/
public boolean retainAll(Collection collection) {
if (fast) {
synchronized (this) {
ArrayList temp = (ArrayList) list.clone();
boolean result = temp.retainAll(collection);
list = temp;
return (result);
}
} else {
synchronized (list) {
return (list.retainAll(collection));
}
}
}
/**
* Replace the element at the specified position in this list with
* the specified element. Returns the previous object at that position.
* array
* is not a supertype of the runtime type of every element in this list
*/
public Object[] toArray(Object array[]) {
if (fast) {
return (list.toArray(array));
} else {
synchronized (list) {
return (list.toArray(array));
}
}
}
/**
* Return a String representation of this object.
*/
public String toString() {
StringBuffer sb = new StringBuffer("FastArrayList[");
sb.append(list.toString());
sb.append("]");
return (sb.toString());
}
/**
* Trim the capacity of this ArrayList instance to be the
* list's current size. An application can use this operation to minimize
* the storage of an ArrayList instance.
*/
public void trimToSize() {
if (fast) {
synchronized (this) {
ArrayList temp = (ArrayList) list.clone();
temp.trimToSize();
list = temp;
}
} else {
synchronized (list) {
list.trimToSize();
}
}
}
private class SubList implements List {
private int first;
private int last;
private List expected;
public SubList(int first, int last) {
this.first = first;
this.last = last;
this.expected = list;
}
private List get(List l) {
if (list != expected) {
throw new ConcurrentModificationException();
}
return l.subList(first, last);
}
public void clear() {
if (fast) {
synchronized (FastArrayList.this) {
ArrayList temp = (ArrayList) list.clone();
get(temp).clear();
last = first;
list = temp;
expected = temp;
}
} else {
synchronized (list) {
get(expected).clear();
}
}
}
public boolean remove(Object o) {
if (fast) {
synchronized (FastArrayList.this) {
ArrayList temp = (ArrayList) list.clone();
boolean r = get(temp).remove(o);
if (r) last--;
list = temp;
expected = temp;
return r;
}
} else {
synchronized (list) {
return get(expected).remove(o);
}
}
}
public boolean removeAll(Collection o) {
if (fast) {
synchronized (FastArrayList.this) {
ArrayList temp = (ArrayList) list.clone();
List sub = get(temp);
boolean r = sub.removeAll(o);
if (r) last = first + sub.size();
list = temp;
expected = temp;
return r;
}
} else {
synchronized (list) {
return get(expected).removeAll(o);
}
}
}
public boolean retainAll(Collection o) {
if (fast) {
synchronized (FastArrayList.this) {
ArrayList temp = (ArrayList) list.clone();
List sub = get(temp);
boolean r = sub.retainAll(o);
if (r) last = first + sub.size();
list = temp;
expected = temp;
return r;
}
} else {
synchronized (list) {
return get(expected).retainAll(o);
}
}
}
public int size() {
if (fast) {
return get(expected).size();
} else {
synchronized (list) {
return get(expected).size();
}
}
}
public boolean isEmpty() {
if (fast) {
return get(expected).isEmpty();
} else {
synchronized (list) {
return get(expected).isEmpty();
}
}
}
public boolean contains(Object o) {
if (fast) {
return get(expected).contains(o);
} else {
synchronized (list) {
return get(expected).contains(o);
}
}
}
public boolean containsAll(Collection o) {
if (fast) {
return get(expected).containsAll(o);
} else {
synchronized (list) {
return get(expected).containsAll(o);
}
}
}
public Object[] toArray(Object[] o) {
if (fast) {
return get(expected).toArray(o);
} else {
synchronized (list) {
return get(expected).toArray(o);
}
}
}
public Object[] toArray() {
if (fast) {
return get(expected).toArray();
} else {
synchronized (list) {
return get(expected).toArray();
}
}
}
public boolean equals(Object o) {
if (o == this) return true;
if (fast) {
return get(expected).equals(o);
} else {
synchronized (list) {
return get(expected).equals(o);
}
}
}
public int hashCode() {
if (fast) {
return get(expected).hashCode();
} else {
synchronized (list) {
return get(expected).hashCode();
}
}
}
public boolean add(Object o) {
if (fast) {
synchronized (FastArrayList.this) {
ArrayList temp = (ArrayList) list.clone();
boolean r = get(temp).add(o);
if (r) last++;
list = temp;
expected = temp;
return r;
}
} else {
synchronized (list) {
return get(expected).add(o);
}
}
}
public boolean addAll(Collection o) {
if (fast) {
synchronized (FastArrayList.this) {
ArrayList temp = (ArrayList) list.clone();
boolean r = get(temp).addAll(o);
if (r) last += o.size();
list = temp;
expected = temp;
return r;
}
} else {
synchronized (list) {
return get(expected).addAll(o);
}
}
}
public void add(int i, Object o) {
if (fast) {
synchronized (FastArrayList.this) {
ArrayList temp = (ArrayList) list.clone();
get(temp).add(i, o);
last++;
list = temp;
expected = temp;
}
} else {
synchronized (list) {
get(expected).add(i, o);
}
}
}
public boolean addAll(int i, Collection o) {
if (fast) {
synchronized (FastArrayList.this) {
ArrayList temp = (ArrayList) list.clone();
boolean r = get(temp).addAll(i, o);
list = temp;
if (r) last += o.size();
expected = temp;
return r;
}
} else {
synchronized (list) {
return get(expected).addAll(i, o);
}
}
}
public Object remove(int i) {
if (fast) {
synchronized (FastArrayList.this) {
ArrayList temp = (ArrayList) list.clone();
Object o = get(temp).remove(i);
last--;
list = temp;
expected = temp;
return o;
}
} else {
synchronized (list) {
return get(expected).remove(i);
}
}
}
public Object set(int i, Object a) {
if (fast) {
synchronized (FastArrayList.this) {
ArrayList temp = (ArrayList) list.clone();
Object o = get(temp).set(i, a);
list = temp;
expected = temp;
return o;
}
} else {
synchronized (list) {
return get(expected).set(i, a);
}
}
}
public Iterator iterator() {
return new SubListIter(0);
}
public ListIterator listIterator() {
return new SubListIter(0);
}
public ListIterator listIterator(int i) {
return new SubListIter(i);
}
public Object get(int i) {
if (fast) {
return get(expected).get(i);
} else {
synchronized (list) {
return get(expected).get(i);
}
}
}
public int indexOf(Object o) {
if (fast) {
return get(expected).indexOf(o);
} else {
synchronized (list) {
return get(expected).indexOf(o);
}
}
}
public int lastIndexOf(Object o) {
if (fast) {
return get(expected).lastIndexOf(o);
} else {
synchronized (list) {
return get(expected).lastIndexOf(o);
}
}
}
public List subList(int f, int l) {
if (list != expected) {
throw new ConcurrentModificationException();
}
return new SubList(first + f, f + l);
}
private class SubListIter implements ListIterator {
private List expected;
private ListIterator iter;
private int lastReturnedIndex = -1;
public SubListIter(int i) {
this.expected = list;
this.iter = SubList.this.get(expected).listIterator(i);
}
private void checkMod() {
if (list != expected) {
throw new ConcurrentModificationException();
}
}
List get() {
return SubList.this.get(expected);
}
public boolean hasNext() {
checkMod();
return iter.hasNext();
}
public Object next() {
checkMod();
lastReturnedIndex = iter.nextIndex();
return iter.next();
}
public boolean hasPrevious() {
checkMod();
return iter.hasPrevious();
}
public Object previous() {
checkMod();
lastReturnedIndex = iter.previousIndex();
return iter.previous();
}
public int previousIndex() {
checkMod();
return iter.previousIndex();
}
public int nextIndex() {
checkMod();
return iter.nextIndex();
}
public void remove() {
checkMod();
if (lastReturnedIndex < 0) {
throw new IllegalStateException();
}
get().remove(lastReturnedIndex);
last--;
expected = list;
iter = get().listIterator(previousIndex());
lastReturnedIndex = -1;
}
public void set(Object o) {
checkMod();
if (lastReturnedIndex < 0) {
throw new IllegalStateException();
}
get().set(lastReturnedIndex, o);
expected = list;
iter = get().listIterator(previousIndex() + 1);
}
public void add(Object o) {
checkMod();
int i = nextIndex();
get().add(i, o);
last++;
iter = get().listIterator(i + 1);
lastReturnedIndex = 1;
}
}
}
private class ListIter implements ListIterator {
private List expected;
private ListIterator iter;
private int lastReturnedIndex = -1;
public ListIter(int i) {
this.expected = list;
this.iter = get().listIterator(i);
}
private void checkMod() {
if (list != expected) {
throw new ConcurrentModificationException();
}
}
List get() {
return expected;
}
public boolean hasNext() {
checkMod();
return iter.hasNext();
}
public Object next() {
checkMod();
lastReturnedIndex = iter.nextIndex();
return iter.next();
}
public boolean hasPrevious() {
checkMod();
return iter.hasPrevious();
}
public Object previous() {
checkMod();
lastReturnedIndex = iter.previousIndex();
return iter.previous();
}
public int previousIndex() {
checkMod();
return iter.previousIndex();
}
public int nextIndex() {
checkMod();
return iter.nextIndex();
}
public void remove() {
checkMod();
if (lastReturnedIndex < 0) {
throw new IllegalStateException();
}
get().remove(lastReturnedIndex);
expected = list;
iter = get().listIterator(previousIndex());
lastReturnedIndex = -1;
}
public void set(Object o) {
checkMod();
if (lastReturnedIndex < 0) {
throw new IllegalStateException();
}
get().set(lastReturnedIndex, o);
expected = list;
iter = get().listIterator(previousIndex() + 1);
}
public void add(Object o) {
checkMod();
int i = nextIndex();
get().add(i, o);
iter = get().listIterator(i + 1);
lastReturnedIndex = 1;
}
}
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/SoftRefHashMap.java 0100644 0001750 0001750 00000021132 10055172400 031723 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.lang.ref.Reference;
import java.lang.ref.SoftReference;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
/**
* HashMap with SoftReference links to values which allows the values of the Map
* to be garbage collected by the JVM if it becomes low on memory.
* Derive from this class and
* override the factory method createReference() method to make
* a Map wrapped in other types of Reference.
*
* A synchronized version can be obtained with:
* Collections.synchronizedMap( theMapToSynchronize )
*
* WARNING the values() and entrySet() methods require optimisation * like the standard {@link HashMap} implementations so that iteration * over this Map is efficient. *
* * @since 1.0 * @author James.Dodd * @author James Strachan * @deprecated This class is all kinds of wonky; use ReferenceMap instead. * @see * Bug#9571 */ public class SoftRefHashMap implements Map { /** The wrapped HashMap */ private Map hashMap = new HashMap(); public SoftRefHashMap() { } /** * Removes References that have had their referents garbage collected */ public void purge() { Map map = getMap(); Set keys = map.keySet(); if ( keys == null ) { return; } for ( Iterator i = keys.iterator(); i.hasNext(); ) { Object key = (Object) i.next(); Reference ref = (Reference) map.get( key ); if ( ref.get() == null ) { map.remove( key ); } } } // Map implementation // ------------------------------------------------------- /** * Retrieves the referent of the Referenced value * @param key The key with which to retrieve the value */ public Object get( final Object key ) { Reference ref = (Reference) getMap().get( key ); if ( ref == null ) { return null; } return ref.get(); } /** * Adds a key-value mapping, wrapping the value in a Reference */ public Object put( final Object key, final Object value ) { Object answer = getMap().put( key, createReference( value ) ); if ( answer != null ) { return ((Reference) answer).get(); } return null; } /** * Returns a collection of the Referenced values */ public Collection values() { Set wrappedValues = (Set) getMap().values(); Set values = new TreeSet(); if ( wrappedValues == null ) { return values; } for ( Iterator i = wrappedValues.iterator(); i.hasNext(); ) { Reference ref = (Reference) i.next(); if ( ref != null ) { values.add( ref.get() ); } } return values; } /** * Answers whether the argument is in the domain of the mappings */ public boolean containsKey( Object key ) { return getMap().containsKey( key ); } /** * Answers whether the argument is a Referenced value */ public boolean containsValue( Object value ) { Collection values = (Collection) getMap().values(); if ( values == null ) { return false; } for ( Iterator i = values.iterator(); i.hasNext(); ) { Reference ref = (Reference) i.next(); if ( ref == null ) { continue; } Object target = ref.get(); if ( target == value ) { return true; } } return false; } /** * Put all of the mappings in the argument into this wrapped map */ public void putAll( final java.util.Map map ) { if ( map == null || map.size() == 0 ) { return; } for ( Iterator i = map.keySet().iterator(); i.hasNext(); ) { Object key = (Object) i.next(); put( key, map.get( key ) ); } } /** * Returns a set view of the mappings in the wrapped map */ public Set entrySet() { Set entries = new HashSet(); if ( size() == 0 ) { return entries; } for ( Iterator i = keySet().iterator(); i.hasNext(); ) { Object key = i.next(); Object value = get( key ); Entry entry = new Entry( key, value ); entries.add( entry ); } return entries; } /** * Removes a mapping from this map */ public Object remove( final Object key ) { Reference ref = (Reference) getMap().remove( key ); if ( ref != null ) { return ref.get(); } return null; } /** * Clears all mappings */ public void clear() { getMap().clear(); } /** * Calculates the hash code for this map */ public int hashCode() { return getMap().hashCode(); } /** * Returns the domain of the mappings */ public Set keySet() { return getMap().keySet(); } /** * Answers whether there are any mappings */ public boolean isEmpty() { return getMap().isEmpty(); } /** * Answers whether this map and the argument are 'the same' */ public boolean equals( final Object object ) { return getMap().equals( object ); } /** * Returns the number of mappings in this map */ public int size() { return getMap().size(); } // Inner Classes // --------------------------------------------------------------------- /** * A map entry, which is backed by this RefHashMap */ class Entry implements Map.Entry { /** * Constructor */ public Entry( Object key, Object value ) { this.key = key; this.value = value; } // Map.Entry interface // ----------------------------------------------------------- /** * Retrieves the key of this mapping */ public Object getKey() { return key; } /** * Retrieves the value of this mapping */ public Object getValue() { return value; } /** * Sets the value of this mapping */ public Object setValue( Object value ) { this.value = value; put( key, value ); return value; } /** * Return the hash code of this mapping. * This algorithm was taken from the JavaDoc for Map.Entry */ public int hashCode() { return ( getKey() == null ? 0 : getKey().hashCode() ) ^ ( getValue() == null ? 0 : getValue().hashCode() ); } /** The domain of this mapping */ private Object key; /** The range of this mapping */ private Object value; } /** * Returns a reference to the argument. * Override this method to make wrapped maps for other Reference types */ protected Reference createReference( Object referent ) { return new SoftReference( referent ); } /** * Retrieves the wrapped HashMap * @return The wrapped HashMap */ protected Map getMap() { return hashMap; } } libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/Predicate.java 0100644 0001750 0001750 00000002235 10055172376 031030 0 ustar tora tora /* * Copyright 1999-2004 The Apache Software Foundation * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.commons.collections; /** Performs some predicate which returns true or false based on the input object. * Predicate instances can be used to implement queries or to do filtering. * * @since 1.0 * @author James Strachan */ public interface Predicate { /** * Returns true if the input object matches this predicate. * * @return true if the input object matches this predicate, else returns false */ public boolean evaluate(Object input); } libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/Factory.java 0100644 0001750 0001750 00000002100 10055172376 030526 0 ustar tora tora /* * Copyright 1999-2004 The Apache Software Foundation * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.commons.collections; /** * Factory * A simple interface that describes the most basic means of having the ability * to create an object. * * @author Arron Bates * @version $Revision: 1.3.2.1 $ * @since 2.1 */ public interface Factory { /** Simple method from which will come the new object from the factory. * * @return Object reference to the new object. */ public Object create(); } libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/CollectionUtils.java 0100644 0001750 0001750 00000103130 10055172376 032240 0 ustar tora tora /* * Copyright 1999-2004 The Apache Software Foundation * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.commons.collections; import java.util.ArrayList; import java.util.Collection; import java.util.Enumeration; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.ListIterator; import java.util.Map; import java.util.NoSuchElementException; 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. * * @since 1.0 * @author Rodney Waldhoff * @author Paul Jack * @author Stephen Colebourne * @author Steve Downey * @version $Revision: 1.18.2.2 $ $Date: 2004/05/22 12:14:02 $ */ public class CollectionUtils { /** * The empty iterator (immutable). * @deprecated use IteratorUtils.EMPTY_ITERATOR */ public static final Iterator EMPTY_ITERATOR = IteratorUtils.EMPTY_ITERATOR; /** * Please don't ever instantiate aCollectionUtils.
*/
public CollectionUtils() {
}
/**
* Returns a {@link Collection} containing the union
* of the given {@link Collection}s.
*
* The cardinality of each element in the returned {@link Collection}
* will be equal to the maximum of the cardinality of that element
* in the two given {@link Collection}s.
*
* @see Collection#addAll
*/
public static Collection union(final Collection a, final Collection b) {
ArrayList list = new ArrayList();
Map mapa = getCardinalityMap(a);
Map mapb = getCardinalityMap(b);
Set elts = new HashSet(a);
elts.addAll(b);
Iterator it = elts.iterator();
while(it.hasNext()) {
Object obj = it.next();
for(int i=0,m=Math.max(getFreq(obj,mapa),getFreq(obj,mapb));i
* This is equivalent to
* {@link #subtract subtract}({@link #union union(a,b)},{@link #intersection intersection(a,b)})
* or
* {@link #union union}({@link #subtract subtract(a,b)},{@link #subtract subtract(b,a)}).
*/
public static Collection disjunction(final Collection a, final Collection b) {
ArrayList list = new ArrayList();
Map mapa = getCardinalityMap(a);
Map mapb = getCardinalityMap(b);
Set elts = new HashSet(a);
elts.addAll(b);
Iterator it = elts.iterator();
while(it.hasNext()) {
Object obj = it.next();
for(int i=0,m=((Math.max(getFreq(obj,mapa),getFreq(obj,mapb)))-(Math.min(getFreq(obj,mapa),getFreq(obj,mapb))));i
* That is, iff the cardinality of e in a is
* equal to the cardinality of e in b,
* for each element e in a or b.
*/
public static boolean isEqualCollection(final Collection a, final Collection b) {
if(a.size() != b.size()) {
return false;
} else {
Map mapa = getCardinalityMap(a);
Map mapb = getCardinalityMap(b);
if(mapa.size() != mapb.size()) {
return false;
} else {
Iterator it = mapa.keySet().iterator();
while(it.hasNext()) {
Object obj = it.next();
if(getFreq(obj,mapa) != getFreq(obj,mapb)) {
return false;
}
}
return true;
}
}
}
/**
* Returns the number of occurrences of obj
* in col.
*/
public static int cardinality(Object obj, final Collection col) {
int count = 0;
Iterator it = col.iterator();
while(it.hasNext()) {
Object elt = it.next();
if((null == obj && null == elt) || obj.equals(elt)) {
count++;
}
}
return count;
}
/**
* Finds the first element in the given collection which matches the given predicate.
*
* If the input collection or predicate is null, null is returned.
*
* @param collection the collection to search, may be null
* @param predicate the predicate to use, may be null
* @return the first element of the collection which matches the predicate or null if none could be found
*/
public static Object find(Collection collection, Predicate predicate) {
if (collection != null && predicate != null) {
for (Iterator iter = collection.iterator(); iter.hasNext();) {
Object item = iter.next();
if (predicate.evaluate(item)) {
return item;
}
}
}
return null;
}
/**
* Executes the given closure on each element in the collection.
*
* If the input collection is null, there is no change made.
*
* @param collection the collection to get the input from, may be null
* @param closure the closure to perform, may not be null
* @throws NullPointerException if the closure is null
*/
public static void forAllDo(Collection collection, Closure closure) {
if (collection != null) {
for (Iterator iter = collection.iterator(); iter.hasNext();) {
Object element = iter.next();
closure.execute(element);
}
}
}
/**
* Filter the collection by applying a Predicate to each element. If the
* predicate returns false, remove the element.
*
* If the input collection or predicate is null, there is no change made.
*
* @param collection the collection to get the input from, may be null
* @param predicate the predicate to use as a filter, may be null
*/
public static void filter(Collection collection, Predicate predicate) {
if (collection != null && predicate != null) {
for (Iterator iter = collection.iterator(); iter.hasNext();) {
Object element = iter.next();
if (predicate.evaluate(element) == false) {
iter.remove();
}
}
}
}
/**
* Transform the collection by applying a Transformer to each element.
*
* If the input collection or transformer is null, there is no change made.
*
* This routine is best for Lists and uses set(), however it adapts for all
* Collections that support clear() and addAll().
*
* If the input collection controls its input, such as a Set, and the
* Transformer creates duplicates (or are otherwise invalid), the
* collection may reduce in size due to calling this method.
*
* @param collection the collection to get the input from, may be null
* @param transformer the transformer to perform, may be null
*/
public static void transform(Collection collection, Transformer transformer) {
if (collection != null && transformer != null) {
if (collection instanceof List) {
List list = (List) collection;
for (ListIterator iter = list.listIterator(); iter.hasNext();) {
Object element = iter.next();
iter.set(transformer.transform(element));
}
} else {
Collection resultCollection = collect(collection, transformer);
collection.clear();
collection.addAll(resultCollection);
}
}
}
/**
* Selects all elements from input collection which match the given predicate
* into an output collection.
*
* @param inputCollection the collection to get the input from, may not be null
* @param predicate the predicate to use, may be null
* @return the elements matching the predicate (new list)
* @throws NullPointerException if the input collection is null
*/
public static Collection select(Collection inputCollection, Predicate predicate) {
ArrayList answer = new ArrayList(inputCollection.size());
select(inputCollection, predicate, answer);
return answer;
}
/**
* Selects all elements from input collection which match the given predicate
* and adds them to outputCollection.
*
* If the input collection or predicate is null, there is no change to the
* output collection.
*
* @param inputCollection the collection to get the input from, may be null
* @param predicate the predicate to use, may be null
* @param outputCollection the collection to output into, may not be null
* @return the outputCollection with the the elements matching the predicate added
* @throws NullPointerException if the input collection is null
*/
public static void select(Collection inputCollection, Predicate predicate, Collection outputCollection) {
if (inputCollection != null && predicate != null) {
for (Iterator iter = inputCollection.iterator(); iter.hasNext();) {
Object item = iter.next();
if (predicate.evaluate(item)) {
outputCollection.add(item);
}
}
}
}
/**
* Transforms all elements from inputCollection with the given transformer
* and adds them to the outputCollection.
*
* If the input transfomer is null, the result is an empty list.
*
* @param inputCollection the collection to get the input from, may not be null
* @param transformer the transformer to use, may be null
* @return the transformed result (new list)
* @throws NullPointerException if the input collection is null
*/
public static Collection collect(Collection inputCollection, Transformer transformer) {
ArrayList answer = new ArrayList(inputCollection.size());
collect(inputCollection, transformer, answer);
return answer;
}
/**
* Transforms all elements from the inputIterator with the given transformer
* and adds them to the outputCollection.
*
* If the input iterator or transfomer is null, the result is an empty list.
*
* @param inputIterator the iterator to get the input from, may be null
* @param transformer the transformer to use, may be null
* @return the transformed result (new list)
*/
public static Collection collect(Iterator inputIterator, Transformer transformer) {
ArrayList answer = new ArrayList();
collect(inputIterator, transformer, answer);
return answer;
}
/**
* Transforms all elements from inputCollection with the given transformer
* and adds them to the outputCollection.
*
* If the input collection or transfomer is null, there is no change to the
* output collection.
*
* @param inputCollection the collection to get the input from, may be null
* @param transformer the transformer to use, may be null
* @param outputCollection the collection to output into, may not be null
* @return the outputCollection with the transformed input added
* @throws NullPointerException if the output collection is null
*/
public static Collection collect(Collection inputCollection, final Transformer transformer, final Collection outputCollection) {
if (inputCollection != null) {
return collect(inputCollection.iterator(), transformer, outputCollection);
}
return outputCollection;
}
/**
* Transforms all elements from the inputIterator with the given transformer
* and adds them to the outputCollection.
*
* If the input iterator or transfomer is null, there is no change to the
* output collection.
*
* @param inputIterator the iterator to get the input from, may be null
* @param transformer the transformer to use, may be null
* @param outputCollection the collection to output into, may not be null
* @return the outputCollection with the transformed input added
* @throws NullPointerException if the output collection is null
*/
public static Collection collect(Iterator inputIterator, final Transformer transformer, final Collection outputCollection) {
if (inputIterator != null && transformer != null) {
while (inputIterator.hasNext()) {
Object item = inputIterator.next();
Object value = transformer.transform(item);
outputCollection.add(value);
}
}
return outputCollection;
}
/**
* Adds all elements in the iteration to the given collection.
*
* @param collection the collection to add to
* @param iterator the iterator of elements to add, may not be null
* @throws NullPointerException if the collection or iterator is null
*/
public static void addAll(Collection collection, Iterator iterator) {
while (iterator.hasNext()) {
collection.add(iterator.next());
}
}
/**
* Adds all elements in the enumeration to the given collection.
*
* @param collection the collection to add to
* @param enumeration the enumeration of elements to add, may not be null
* @throws NullPointerException if the collection or enumeration is null
*/
public static void addAll(Collection collection, Enumeration enumeration) {
while (enumeration.hasMoreElements()) {
collection.add(enumeration.nextElement());
}
}
/**
* Adds all elements in the array to the given collection.
*
* @param collection the collection to add to
* @param elements the array of elements to add, may be null
* @throws NullPointerException if the collection or array is null
*/
public static void addAll(Collection collection, Object[] elements) {
for (int i = 0, size = elements.length; i < size; i++) {
collection.add(elements[i]);
}
}
/**
* Given an Object, and an index, it will get the nth value in the
* object.
*
* This iterator is a valid iterator object that will iterate over
* nothing.
*
* @return an iterator over nothing
* @deprecated Use
* This iterator is a valid list iterator object that will iterate
* over nothing.
*
* @return a list iterator over nothing
* @deprecated Use
* This iterator is a valid iterator object that will iterate over
* the specified object.
*
* @param object the single object over which to iterate
* @return a singleton iterator over the object
* @deprecated Use
* This iterator is a valid list iterator object that will iterate over
* the specified object.
*
* @param object the single object over which to iterate
* @return a singleton list iterator over the object
*/
public static ListIterator singletonListIterator(Object object) {
return new SingletonListIterator(object);
}
/**
* Gets an iterator over an array.
*
* @param array the array over which to iterate
* @return an iterator over the array
* @throws NullPointerException if array is null
* @deprecated Use
* Given two ordered {@link Iterator}s
* The comparator is optional. If null is specified then natural order is used.
*
* @param comparator the comparator to use, may be null for natural order
* @param iterator1 the first iterators to use, not null
* @param iterator2 the first iterators to use, not null
* @return a combination iterator over the iterators
* @throws NullPointerException if either iterator is null
*/
public static Iterator collatedIterator(Comparator comparator, Iterator iterator1, Iterator iterator2) {
return new CollatingIterator(comparator, iterator1, iterator2);
}
/**
* Gets an iterator that provides an ordered iteration over the elements
* contained in an array of {@link Iterator}s.
*
* Given two ordered {@link Iterator}s
* The comparator is optional. If null is specified then natural order is used.
*
* @param comparator the comparator to use, may be null for natural order
* @param iterators the iterators to use, not null or empty or contain nulls
* @return a combination iterator over the iterators
* @throws NullPointerException if iterators array is null or contains a null
*/
public static Iterator collatedIterator(Comparator comparator, Iterator[] iterators) {
return new CollatingIterator(comparator, iterators);
}
/**
* Gets an iterator that provides an ordered iteration over the elements
* contained in a collection of {@link Iterator}s.
*
* Given two ordered {@link Iterator}s
* The comparator is optional. If null is specified then natural order is used.
*
* @param comparator the comparator to use, may be null for natural order
* @param iterators the iterators to use, not null or empty or contain nulls
* @return a combination iterator over the iterators
* @throws NullPointerException if iterators collection is null or contains a null
* @throws ClassCastException if the iterators collection contains the wrong object type
*/
public static Iterator collatedIterator(Comparator comparator, Collection iterators) {
return new CollatingIterator(comparator, iterators);
}
/**
* Gets an iterator that transforms the elements of another iterator.
*
* The transformation occurs during the next() method and the underlying
* iterator is unaffected by the transformation.
*
* @param iterator the iterator to use, not null
* @param transform the transform to use, not null
* @throws NullPointerException if either parameter is null
*/
public static Iterator transformedIterator(Iterator iterator, Transformer transform) {
if (iterator == null) {
throw new NullPointerException("Iterator must not be null");
}
if (transform == null) {
throw new NullPointerException("Transformer must not be null");
}
return new TransformIterator(iterator, transform);
}
/**
* Gets an iterator that filters another iterator.
*
* The returned iterator will only return objects that match the specified
* filtering predicate.
*
* @param iterator the iterator to use, not null
* @param predicate the predicate to use as a filter, not null
* @throws NullPointerException if either parameter is null
*/
public static Iterator filteredIterator(Iterator iterator, Predicate predicate) {
if (iterator == null) {
throw new NullPointerException("Iterator must not be null");
}
if (predicate == null) {
throw new NullPointerException("Predicate must not be null");
}
return new FilterIterator(iterator, predicate);
}
/**
* Gets a list iterator that filters another list iterator.
*
* The returned iterator will only return objects that match the specified
* filtering predicate.
*
* @param listIterator the list iterator to use, not null
* @param predicate the predicate to use as a filter, not null
* @throws NullPointerException if either parameter is null
*/
public static ListIterator filteredListIterator(ListIterator listIterator, Predicate predicate) {
if (listIterator == null) {
throw new NullPointerException("ListIterator must not be null");
}
if (predicate == null) {
throw new NullPointerException("Predicate must not be null");
}
return new FilterListIterator(listIterator, predicate);
}
/**
* Gets an iterator that provides an iterator view of the given enumeration.
*
* @param enumeration the enumeration to use
*/
public static Iterator asIterator(Enumeration enumeration) {
if (enumeration == null) {
throw new NullPointerException("Enumeration must not be null");
}
return new EnumerationIterator(enumeration);
}
/**
* Gets an iterator that provides an iterator view of the given enumeration
* that will remove elements from the specified collection.
*
* @param enumeration the enumeration to use
* @param collection the collection to remove elements form
*/
public static Iterator asIterator(Enumeration enumeration, Collection removeCollection) {
if (enumeration == null) {
throw new NullPointerException("Enumeration must not be null");
}
if (removeCollection == null) {
throw new NullPointerException("Collection must not be null");
}
return new EnumerationIterator(enumeration, removeCollection);
}
/**
* Gets an enumeration that wraps an iterator.
*
* @param iterator the iterator to use, not null
* @throws NullPointerException if iterator is null
*/
public static Enumeration asEnumeration(Iterator iterator) {
if (iterator == null) {
throw new NullPointerException("Iterator must not be null");
}
return new IteratorEnumeration(iterator);
}
/**
* Gets a list iterator based on a simple iterator.
*
* As the wrapped Iterator is traversed, a LinkedList of its values is
* cached, permitting all required operations of ListIterator.
*
* @param iterator the iterator to use, not null
* @throws NullPointerException if iterator parameter is null
*/
public static ListIterator toListIterator(Iterator iterator) {
if (iterator == null) {
throw new NullPointerException("Iterator must not be null");
}
return new ListIteratorWrapper(iterator);
}
/**
* Gets an array based on an iterator.
*
* As the wrapped Iterator is traversed, an ArrayList of its values is
* created. At the end, this is converted to an array.
*
* @param iterator the iterator to use, not null
* @throws NullPointerException if iterator parameter is null
*/
public static Object[] toArray(Iterator iterator) {
if (iterator == null) {
throw new NullPointerException("Iterator must not be null");
}
List list = toList(iterator, 100);
return list.toArray();
}
/**
* Gets an array based on an iterator.
*
* As the wrapped Iterator is traversed, an ArrayList of its values is
* created. At the end, this is converted to an array.
*
* @param iterator the iterator to use, not null
* @param arrayClass the class of array to create
* @throws NullPointerException if iterator parameter is null
* @throws NullPointerException if arrayClass is null
* @throws ClassCastException if the arrayClass is invalid
*/
public static Object[] toArray(Iterator iterator, Class arrayClass) {
if (iterator == null) {
throw new NullPointerException("Iterator must not be null");
}
if (arrayClass == null) {
throw new NullPointerException("Array class must not be null");
}
List list = toList(iterator, 100);
return list.toArray((Object[]) Array.newInstance(arrayClass, list.size()));
}
/**
* Gets a list based on an iterator.
*
* As the wrapped Iterator is traversed, an ArrayList of its values is
* created. At the end, the list is returned.
*
* @param iterator the iterator to use, not null
* @throws NullPointerException if iterator parameter is null
*/
public static List toList(Iterator iterator) {
return toList(iterator, 10);
}
/**
* Gets a list based on an iterator.
*
* As the wrapped Iterator is traversed, an ArrayList of its values is
* created. At the end, the list is returned.
*
* @param iterator the iterator to use, not null
* @param estimatedSize the initial size of the ArrayList
* @throws NullPointerException if iterator parameter is null
* @throws IllegalArgumentException if the size is less than 1
*/
public static List toList(Iterator iterator, int estimatedSize) {
if (iterator == null) {
throw new NullPointerException("Iterator must not be null");
}
if (estimatedSize < 1) {
throw new IllegalArgumentException("Estimated size must be greater than 0");
}
List list = new ArrayList(estimatedSize);
while (iterator.hasNext()) {
list.add(iterator.next());
}
return list;
}
/**
* Gets a suitable Iterator for the given object.
*
* This method can handles objects as follows
*
* This class provides a way to collect a list of unique strings and join
* them with an optional separator.
*
* @deprecated This class is not a Stack, it is a String utility. As such
* it is deprecated in favour of the
* The removal order of a binary heap is based on either the natural sort
* order of its elements or a specified {@link Comparator}. The
* {@link #remove()} method always returns the first element as determined
* by the sort order. (The
* The {@link #add(Object)} and {@link #remove()} operations perform
* in logarithmic time. The {@link #get()} operation performs in constant
* time. All other operations perform in linear time or worse.
*
* Note that this implementation is not synchronized. Use
* {@link BufferUtils#synchronizedBuffer(Buffer)} to provide
* synchronized access to a
* Implements all of the optional {@link List} operations, the
* stack/queue/dequeue operations available in {@link java.util.LinkedList}
* and supports a {@link ListIterator} that allows concurrent modifications
* to the underlying list (see {@link #cursor}).
*
* Note that this implementation is not synchronized.
*
* @since 1.0
* @author Rodney Waldhoff
* @version $Id: CursorableLinkedList.java,v 1.10.2.1 2004/05/22 12:14:02 scolebourne Exp $
* @see java.util.LinkedList
*/
public class CursorableLinkedList implements List, Serializable {
//--- public methods ---------------------------------------------
/**
* Appends the specified element to the end of this list.
*
* @param o element to be appended to this list.
* @return true
*/
public boolean add(Object o) {
insertListable(_head.prev(),null,o);
return true;
}
/**
* Inserts the specified element at the specified position in this list.
* Shifts the element currently at that position (if any) and any subsequent
* elements to the right (adds one to their indices).
*
* @param index index at which the specified element is to be inserted.
* @param element element to be inserted.
*
* @throws ClassCastException if the class of the specified element
* prevents it from being added to this list.
* @throws IllegalArgumentException if some aspect of the specified
* element prevents it from being added to this list.
* @throws IndexOutOfBoundsException if the index is out of range
* (index < 0 || index > size()).
*/
public void add(int index, Object element) {
if(index == _size) {
add(element);
} else {
if(index < 0 || index > _size) {
throw new IndexOutOfBoundsException(String.valueOf(index) + " < 0 or " + String.valueOf(index) + " > " + _size);
}
Listable succ = (isEmpty() ? null : getListableAt(index));
Listable pred = (null == succ ? null : succ.prev());
insertListable(pred,succ,element);
}
}
/**
* Appends all of the elements in the specified collection to the end of
* this list, in the order that they are returned by the specified
* {@link Collection}'s {@link Iterator}. The behavior of this operation is
* unspecified if the specified collection is modified while
* the operation is in progress. (Note that this will occur if the
* specified collection is this list, and it's nonempty.)
*
* @param c collection whose elements are to be added to this list.
* @return true if this list changed as a result of the call.
*
* @throws ClassCastException if the class of an element in the specified
* collection prevents it from being added to this list.
* @throws IllegalArgumentException if some aspect of an element in the
* specified collection prevents it from being added to this
* list.
*/
public boolean addAll(Collection c) {
if(c.isEmpty()) {
return false;
}
Iterator it = c.iterator();
while(it.hasNext()) {
insertListable(_head.prev(),null,it.next());
}
return true;
}
/**
* Inserts all of the elements in the specified collection into this
* list at the specified position. Shifts the element currently at
* that position (if any) and any subsequent elements to the right
* (increases their indices). The new elements will appear in this
* list in the order that they are returned by the specified
* {@link Collection}'s {@link Iterator}. The behavior of this operation is
* unspecified if the specified collection is modified while the
* operation is in progress. (Note that this will occur if the specified
* collection is this list, and it's nonempty.)
*
* @param index index at which to insert first element from the specified
* collection.
* @param c elements to be inserted into this list.
* @return true if this list changed as a result of the call.
*
* @throws ClassCastException if the class of one of elements of the
* specified collection prevents it from being added to this
* list.
* @throws IllegalArgumentException if some aspect of one of elements of
* the specified collection prevents it from being added to
* this list.
* @throws IndexOutOfBoundsException if the index is out of range (index
* < 0 || index > size()).
*/
public boolean addAll(int index, Collection c) {
if(c.isEmpty()) {
return false;
} else if(_size == index || _size == 0) {
return addAll(c);
} else {
Listable succ = getListableAt(index);
Listable pred = (null == succ) ? null : succ.prev();
Iterator it = c.iterator();
while(it.hasNext()) {
pred = insertListable(pred,succ,it.next());
}
return true;
}
}
/**
* Inserts the specified element at the beginning of this list.
* (Equivalent to {@link #add(int,java.lang.Object) add(0,o)}).
*
* @param o element to be prepended to this list.
* @return true
*/
public boolean addFirst(Object o) {
insertListable(null,_head.next(),o);
return true;
}
/**
* Inserts the specified element at the end of this list.
* (Equivalent to {@link #add(java.lang.Object)}).
*
* @param o element to be appended to this list.
* @return true
*/
public boolean addLast(Object o) {
insertListable(_head.prev(),null,o);
return true;
}
/**
* Removes all of the elements from this list. This
* list will be empty after this call returns (unless
* it throws an exception).
*/
public void clear() {
/*
// this is the quick way, but would force us
// to break all the cursors
_modCount++;
_head.setNext(null);
_head.setPrev(null);
_size = 0;
*/
Iterator it = iterator();
while(it.hasNext()) {
it.next();
it.remove();
}
}
/**
* Returns true if this list contains the specified element.
* More formally, returns true if and only if this list contains
* at least one element e such that
* (o==null ? e==null : o.equals(e)).
*
* @param o element whose presence in this list is to be tested.
* @return true if this list contains the specified element.
*/
public boolean contains(Object o) {
for(Listable elt = _head.next(), past = null; null != elt && past != _head.prev(); elt = (past = elt).next()) {
if((null == o && null == elt.value()) ||
(o != null && o.equals(elt.value()))) {
return true;
}
}
return false;
}
/**
* Returns true if this list contains all of the elements of the
* specified collection.
*
* @param c collection to be checked for containment in this list.
* @return true if this list contains all of the elements of the
* specified collection.
*/
public boolean containsAll(Collection c) {
Iterator it = c.iterator();
while(it.hasNext()) {
if(!this.contains(it.next())) {
return false;
}
}
return true;
}
/**
* Returns a {@link ListIterator} for iterating through the
* elements of this list. Unlike {@link #iterator}, a cursor
* is not bothered by concurrent modifications to the
* underlying list.
*
* Specifically, when elements are added to the list before or
* after the cursor, the cursor simply picks them up automatically.
* When the "current" (i.e., last returned by {@link ListIterator#next}
* or {@link ListIterator#previous}) element of the list is removed,
* the cursor automatically adjusts to the change (invalidating the
* last returned value--i.e., it cannot be removed).
*
* Note that the returned {@link ListIterator} does not support the
* {@link ListIterator#nextIndex} and {@link ListIterator#previousIndex}
* methods (they throw {@link UnsupportedOperationException} when invoked.
*
* Clients must close the cursor when they are done using it.
* The returned {@link ListIterator} will be an instance of
* {@link CursorableLinkedList.Cursor}. To close the cursor,
* cast the {@link ListIterator} to {@link CursorableLinkedList.Cursor}
* and invoke the {@link CursorableLinkedList.Cursor#close} method.
*
* @see #cursor(int)
* @see #listIterator
* @see CursorableLinkedList.Cursor
*/
public CursorableLinkedList.Cursor cursor() {
return new Cursor(0);
}
/**
* Returns a {@link ListIterator} for iterating through the
* elements of this list, initialized such that
* {@link ListIterator#next} will return the element at
* the specified index (if any) and {@link ListIterator#previous}
* will return the element immediately preceeding it (if any).
* Unlike {@link #iterator}, a cursor
* is not bothered by concurrent modifications to the
* underlying list.
*
* @see #cursor
* @see #listIterator(int)
* @see CursorableLinkedList.Cursor
* @throws IndexOutOfBoundsException if the index is out of range (index
* < 0 || index > size()).
*/
public CursorableLinkedList.Cursor cursor(int i) {
return new Cursor(i);
}
/**
* Compares the specified object with this list for equality. Returns
* true if and only if the specified object is also a list, both
* lists have the same size, and all corresponding pairs of elements in
* the two lists are equal. (Two elements e1 and
* e2 are equal if (e1==null ? e2==null :
* e1.equals(e2)).) In other words, two lists are defined to be
* equal if they contain the same elements in the same order. This
* definition ensures that the equals method works properly across
* different implementations of the List interface.
*
* @param o the object to be compared for equality with this list.
* @return true if the specified object is equal to this list.
*/
public boolean equals(Object o) {
if(o == this) {
return true;
} else if(!(o instanceof List)) {
return false;
}
Iterator it = ((List)o).listIterator();
for(Listable elt = _head.next(), past = null; null != elt && past != _head.prev(); elt = (past = elt).next()) {
if(!it.hasNext() || (null == elt.value() ? null != it.next() : !(elt.value().equals(it.next()))) ) {
return false;
}
}
return !it.hasNext();
}
/**
* Returns the element at the specified position in this list.
*
* @param index index of element to return.
* @return the element at the specified position in this list.
*
* @throws IndexOutOfBoundsException if the index is out of range (index
* < 0 || index >= size()).
*/
public Object get(int index) {
return getListableAt(index).value();
}
/**
* Returns the element at the beginning of this list.
*/
public Object getFirst() {
try {
return _head.next().value();
} catch(NullPointerException e) {
throw new NoSuchElementException();
}
}
/**
* Returns the element at the end of this list.
*/
public Object getLast() {
try {
return _head.prev().value();
} catch(NullPointerException e) {
throw new NoSuchElementException();
}
}
/**
* Returns the hash code value for this list. The hash code of a list
* is defined to be the result of the following calculation:
*
*
* When you construct a
*
* Different types of references can be specified for keys
* and values. The keys can be configured to be weak but
* the values hard, in which case this class will behave
* like a
*
*
* The algorithms used are basically the same as those
* in {@link java.util.HashMap}. In particular, you
* can specify a load factor and capacity to suit your
* needs. All optional {@link Map} operations are
* supported.
*
* However, this {@link Map} implementation does not
* allow null elements. Attempting to add a null key or
* or a null value to the map will raise a
*
*
* As usual, this implementation is not synchronized. You
* can use {@link java.util.Collections#synchronizedMap} to
* provide synchronized access to a
*
* Ordinarily, stale mappings are only removed during
* a write operation; typically a write operation will
* occur often enough that you'll never need to manually
* invoke this method.
*
* Note that this method is not synchronized! Special
* care must be taken if, for instance, you want stale
* mappings to be removed on a periodic basis by some
* background thread.
*/
private void purge() {
Reference ref = queue.poll();
while (ref != null) {
purge(ref);
ref = queue.poll();
}
}
private void purge(Reference ref) {
// The hashCode of the reference is the hashCode of the
// mapping key, even if the reference refers to the
// mapping value...
int hash = ref.hashCode();
int index = indexFor(hash);
Entry previous = null;
Entry entry = table[index];
while (entry != null) {
if (entry.purge(ref)) {
if (previous == null) table[index] = entry.next;
else previous.next = entry.next;
this.size--;
return;
}
previous = entry;
entry = entry.next;
}
}
/**
* Returns the size of this map.
*
* @return the size of this map
*/
public int size() {
purge();
return size;
}
/**
* Returns
* Neither the key nor the value may be null.
*
* @param key the key of the mapping
* @param value the value of the mapping
* @return the last value associated with that key, or
* null if no value was associated with the key
* @throws NullPointerException if either the key or value
* is null
*/
public Object put(Object key, Object value) {
if (key == null) throw new NullPointerException("null keys not allowed");
if (value == null) throw new NullPointerException("null values not allowed");
purge();
if (size + 1 > threshold) resize();
int hash = key.hashCode();
int index = indexFor(hash);
Entry entry = table[index];
while (entry != null) {
if ((hash == entry.hash) && key.equals(entry.getKey())) {
Object result = entry.getValue();
entry.setValue(value);
return result;
}
entry = entry.next;
}
this.size++;
modCount++;
key = toReference(keyType, key, hash);
value = toReference(valueType, value, hash);
table[index] = new Entry(key, hash, value, table[index]);
return null;
}
/**
* Removes the key and its associated value from this map.
*
* @param key the key to remove
* @return the value associated with that key, or null if
* the key was not in the map
*/
public Object remove(Object key) {
if (key == null) return null;
purge();
int hash = key.hashCode();
int index = indexFor(hash);
Entry previous = null;
Entry entry = table[index];
while (entry != null) {
if ((hash == entry.hash) && key.equals(entry.getKey())) {
if (previous == null) table[index] = entry.next;
else previous.next = entry.next;
this.size--;
modCount++;
return entry.getValue();
}
previous = entry;
entry = entry.next;
}
return null;
}
/**
* Clears this map.
*/
public void clear() {
Arrays.fill(table, null);
size = 0;
while (queue.poll() != null); // drain the queue
}
/**
* Returns a set view of this map's entries.
*
* @return a set view of this map's entries
*/
public Set entrySet() {
if (entrySet != null) return entrySet;
entrySet = new AbstractSet() {
public int size() {
return ReferenceMap.this.size();
}
public void clear() {
ReferenceMap.this.clear();
}
public boolean contains(Object o) {
if (o == null) return false;
if (!(o instanceof Map.Entry)) return false;
Map.Entry e = (Map.Entry)o;
Entry e2 = getEntry(e.getKey());
return (e2 != null) && e.equals(e2);
}
public boolean remove(Object o) {
boolean r = contains(o);
if (r) {
Map.Entry e = (Map.Entry)o;
ReferenceMap.this.remove(e.getKey());
}
return r;
}
public Iterator iterator() {
return new EntryIterator();
}
public Object[] toArray() {
return toArray(new Object[0]);
}
public Object[] toArray(Object[] arr) {
ArrayList list = new ArrayList();
Iterator iterator = iterator();
while (iterator.hasNext()) {
Entry e = (Entry)iterator.next();
list.add(new DefaultMapEntry(e.getKey(), e.getValue()));
}
return list.toArray(arr);
}
};
return entrySet;
}
/**
* Returns a set view of this map's keys.
*
* @return a set view of this map's keys
*/
public Set keySet() {
if (keySet != null) return keySet;
keySet = new AbstractSet() {
public int size() {
return size;
}
public Iterator iterator() {
return new KeyIterator();
}
public boolean contains(Object o) {
return containsKey(o);
}
public boolean remove(Object o) {
Object r = ReferenceMap.this.remove(o);
return r != null;
}
public void clear() {
ReferenceMap.this.clear();
}
};
return keySet;
}
/**
* Returns a collection view of this map's values.
*
* @return a collection view of this map's values.
*/
public Collection values() {
if (values != null) return values;
values = new AbstractCollection() {
public int size() {
return size;
}
public void clear() {
ReferenceMap.this.clear();
}
public Iterator iterator() {
return new ValueIterator();
}
};
return values;
}
// If getKey() or getValue() returns null, it means
// the mapping is stale and should be removed.
private class Entry implements Map.Entry {
Object key;
Object value;
int hash;
Entry next;
public Entry(Object key, int hash, Object value, Entry next) {
this.key = key;
this.hash = hash;
this.value = value;
this.next = next;
}
public Object getKey() {
return (keyType > HARD) ? ((Reference)key).get() : key;
}
public Object getValue() {
return (valueType > HARD) ? ((Reference)value).get() : value;
}
public Object setValue(Object object) {
Object old = getValue();
if (valueType > HARD) ((Reference)value).clear();
value = toReference(valueType, object, hash);
return old;
}
public boolean equals(Object o) {
if (o == null) return false;
if (o == this) return true;
if (!(o instanceof Map.Entry)) return false;
Map.Entry entry = (Map.Entry)o;
Object key = entry.getKey();
Object value = entry.getValue();
if ((key == null) || (value == null)) return false;
return key.equals(getKey()) && value.equals(getValue());
}
public int hashCode() {
Object v = getValue();
return hash ^ ((v == null) ? 0 : v.hashCode());
}
public String toString() {
return getKey() + "=" + getValue();
}
boolean purge(Reference ref) {
boolean r = (keyType > HARD) && (key == ref);
r = r || ((valueType > HARD) && (value == ref));
if (r) {
if (keyType > HARD) ((Reference)key).clear();
if (valueType > HARD) ((Reference)value).clear();
}
return r;
}
}
private class EntryIterator implements Iterator {
// These fields keep track of where we are in the table.
int index;
Entry entry;
Entry previous;
// These Object fields provide hard references to the
// current and next entry; this assures that if hasNext()
// returns true, next() will actually return a valid element.
Object nextKey, nextValue;
Object currentKey, currentValue;
int expectedModCount;
public EntryIterator() {
index = (size() != 0 ? table.length : 0);
// have to do this here! size() invocation above
// may have altered the modCount.
expectedModCount = modCount;
}
public boolean hasNext() {
checkMod();
while (nextNull()) {
Entry e = entry;
int i = index;
while ((e == null) && (i > 0)) {
i--;
e = table[i];
}
entry = e;
index = i;
if (e == null) {
currentKey = null;
currentValue = null;
return false;
}
nextKey = e.getKey();
nextValue = e.getValue();
if (nextNull()) entry = entry.next;
}
return true;
}
private void checkMod() {
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
private boolean nextNull() {
return (nextKey == null) || (nextValue == null);
}
protected Entry nextEntry() {
checkMod();
if (nextNull() && !hasNext()) throw new NoSuchElementException();
previous = entry;
entry = entry.next;
currentKey = nextKey;
currentValue = nextValue;
nextKey = null;
nextValue = null;
return previous;
}
public Object next() {
return nextEntry();
}
public void remove() {
checkMod();
if (previous == null) throw new IllegalStateException();
ReferenceMap.this.remove(currentKey);
previous = null;
currentKey = null;
currentValue = null;
expectedModCount = modCount;
}
}
private class ValueIterator extends EntryIterator {
public Object next() {
return nextEntry().getValue();
}
}
private class KeyIterator extends EntryIterator {
public Object next() {
return nextEntry().getKey();
}
}
// These two classes store the hashCode of the key of
// of the mapping, so that after they're dequeued a quick
// lookup of the bucket in the table can occur.
private static class SoftRef extends SoftReference {
private int hash;
public SoftRef(int hash, Object r, ReferenceQueue q) {
super(r, q);
this.hash = hash;
}
public int hashCode() {
return hash;
}
}
private static class WeakRef extends WeakReference {
private int hash;
public WeakRef(int hash, Object r, ReferenceQueue q) {
super(r, q);
this.hash = hash;
}
public int hashCode() {
return hash;
}
}
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/ProxyMap.java 0100644 0001750 0001750 00000010021 10055172400 030663 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
/**
* This An example use case is where the wrapped Note that this interface violates the {@link Collection} contract.
* The behavior specified in many of these methods is not the same
* as the behavior specified by {@link Collection}. The noncompliant methods
* are clearly marked with "(Violation)" in their summary line. A future
* version of this class will specify the same behavior as {@link Collection},
* which unfortunately will break backwards compatibility with this version.
*
* @since 2.0
* @author Chuck Burdick
**/
public interface Bag extends Collection {
/**
* Return the number of occurrences (cardinality) of the given
* object currently in the bag. If the object does not exist in the
* bag, return 0.
**/
public int getCount(Object o);
/**
* (Violation)
* Add the given object to the bag and keep a count. If the object
* is already in the {@link #uniqueSet()} then increment its count as
* reported by {@link #getCount(Object)}. Otherwise add it to the {@link
* #uniqueSet()} and report its count as 1.
*
* Since this method always increases the size of the bag,
* according to the {@link Collection#add(Object)} contract, it
* should always return According to the {@link Collection#remove(Object)} method,
* this method should only remove the first occurrence of the
* given object, not all occurrences. A future version of this
* method will comply with the contract by only removing one occurrence
* of the given object.
*
* @see #remove(Object, int)
* @return The {@link Collection#containsAll(Collection)} method specifies
* that cardinality should not be respected; this method should
* return true if the bag contains at least one of every object contained
* in the given collection. A future version of this method will comply
* with that contract.
**/
public boolean containsAll(Collection c);
/**
* (Violation)
* Remove all elements represented in the given collection,
* respecting cardinality. That is, if the given collection
* The {@link Collection#removeAll(Collection)} method specifies
* that cardinality should not be respected; this method should
* remove all occurrences of every object contained in the
* given collection. A future version of this method will comply
* with that contract.
*
* @return The {@link Collection#retainAll(Collection)} method specifies
* that cardinality should not be respected; this method should
* keep all occurrences of every object contained in the
* given collection. A future version of this method will comply
* with that contract.
*
* @return
*
* The map will be used to map bag elements to a number; the number represents
* the number of occurrences of that element in the bag.
*
* @since 2.0
* @author Chuck Burdick
* @author Michael A. Smith
**/
public abstract class DefaultMapBag implements Bag {
private Map _map = null;
private int _total = 0;
private int _mods = 0;
/**
* Constructor. Subclasses should invoke {@link #setMap(Map)} in
* their constructors.
*/
public DefaultMapBag() {
}
/**
* Adds a new element to the bag by incrementing its count in the
* underlying map.
*
* @see Bag#add(Object)
*/
public boolean add(Object o) {
return add(o, 1);
}
/**
* Adds a new element to the bag by incrementing its count in the map.
*
* @see Bag#add(Object, int)
*/
public boolean add(Object o, int i) {
_mods++;
if (i > 0) {
int count = (i + getCount(o));
_map.put(o, new Integer(count));
_total += i;
return (count == i);
} else {
return false;
}
}
/**
* Invokes {@link #add(Object)} for each element in the given collection.
*
* @see Bag#addAll(Collection)
*/
public boolean addAll(Collection c) {
boolean changed = false;
Iterator i = c.iterator();
while (i.hasNext()) {
boolean added = add(i.next());
changed = changed || added;
}
return changed;
}
/**
* Clears the bag by clearing the underlying map.
*/
public void clear() {
_mods++;
_map.clear();
_total = 0;
}
/**
* Determines if the bag contains the given element by checking if the
* underlying map contains the element as a key.
*
* @return true if the bag contains the given element
*/
public boolean contains(Object o) {
return _map.containsKey(o);
}
public boolean containsAll(Collection c) {
return containsAll(new HashBag(c));
}
/**
* Returns
*
* Each bucket in the hash table has its own monitor, so two threads can
* safely operate on the map at the same time, often without incurring any
* monitor contention. This means that you don't have to wrap instances
* of this class with {@link java.util.Collections#synchronizedMap(Map)};
* instances are already thread-safe. Unfortunately, however, this means
* that this map implementation behaves in ways you may find disconcerting.
* Bulk operations, such as {@link #putAll(Map) putAll} or the
* {@link Collection#retainAll(Collection) retainAll} operation in collection
* views, are not atomic. If two threads are simultaneously
* executing
*
*
*
* Also, much like an encyclopedia, the results of {@link #size()} and
* {@link #isEmpty()} are out-of-date as soon as they are produced.
*
* The iterators returned by the collection views of this class are not
* fail-fast. They will never raise a
* {@link java.util.ConcurrentModificationException}. Keys and values
* added to the map after the iterator is created do not necessarily appear
* during iteration. Similarly, the iterator does not necessarily fail to
* return keys and values that were removed after the iterator was created.
*
* Finally, unlike {@link java.util.HashMap}-style implementations, this
* class never rehashes the map. The number of buckets is fixed
* at construction time and never altered. Performance may degrade if
* you do not allocate enough buckets upfront.
*
* The {@link #atomic(Runnable)} method is provided to allow atomic iterations
* and bulk operations; however, overuse of {@link #atomic(Runnable) atomic}
* will basically result in a map that's slower than an ordinary synchronized
* {@link java.util.HashMap}.
*
* Use this class if you do not require reliable bulk operations and
* iterations, or if you can make your own guarantees about how bulk
* operations will affect the map.
*
* @author Berin Loritsch
* @author Gerhard Froehlich
* @author Michael A. Smith
* @author Paul Jack
* @version CVS $Revision: 1.6.2.1 $ $Date: 2004/05/22 12:14:02 $
* @since Collections 2.1
*/
public final class StaticBucketMap implements Map
{
private static final int DEFAULT_BUCKETS = 255;
private Node[] m_buckets;
private Lock[] m_locks;
/**
* Initializes the map with the default number of buckets (255).
*/
public StaticBucketMap()
{
this( DEFAULT_BUCKETS );
}
/**
* Initializes the map with a specified number of buckets. The number
* of buckets is never below 17, and is always an odd number (StaticBucketMap
* ensures this). The number of buckets is inversely proportional to the
* chances for thread contention. The fewer buckets, the more chances for
* thread contention. The more buckets the fewer chances for thread
* contention.
*
* @param numBuckets the number of buckets for this map
*/
public StaticBucketMap( int numBuckets )
{
int size = Math.max( 17, numBuckets );
// Ensure that bucketSize is never a power of 2 (to ensure maximal distribution)
if( size % 2 == 0 )
{
size--;
}
m_buckets = new Node[ size ];
m_locks = new Lock[ size ];
for( int i = 0; i < size; i++ )
{
m_locks[ i ] = new Lock();
}
}
/**
* Determine the exact hash entry for the key. The hash algorithm
* is rather simplistic, but it does the job:
*
*
* He is the entry's hashCode, Hk is the key's hashCode, and n is
* the number of buckets.
*
* This returns true if the single object hasn't been returned yet.
*
* @return true if the single object hasn't been returned yet
*/
public boolean hasNext() {
return first;
}
/**
* Get the next object from the iterator.
*
* This returns the single object if it hasn't been returned yet.
*
* @return the single object
* @throws NoSuchElementException if the single object has already
* been returned
*/
public Object next() {
if (!first) {
throw new NoSuchElementException();
}
Object answer = object;
object = null;
first = false;
return answer;
}
/**
* Remove always throws {@link UnsupportedOperationException}.
*
* @throws UnsupportedOperationException always
*/
public void remove() {
throw new UnsupportedOperationException("remove() is not supported by this iterator");
}
}
././@LongLink 0000000 0000000 0000000 00000000160 00000000000 011562 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/CollatingIterator.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/CollatingI 0100644 0001750 0001750 00000030577 10055172400 032247 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.iterators;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.ArrayList;
import java.util.BitSet;
/**
* Provides an ordered iteration over the elements contained in
* a collection of ordered {@link Iterator}s. In other words,
* given two ordered {@link Iterator}s
* This returns true if the single object hasn't been returned yet.
*
* @return true if the single object hasn't been returned yet
*/
public boolean hasNext() {
return first;
}
/**
* Is a previous object available from the iterator.
*
* This returns true if the single object has been returned.
*
* @return true if the single object has been returned
*/
public boolean hasPrevious() {
return !first;
}
/**
* Returns the index of the element that would be returned by a subsequent
* call to next.
*
* @return 0 or 1 depending on current state.
*/
public int nextIndex() {
return (first ? 0 : 1);
}
/**
* Returns the index of the element that would be returned by a subsequent
* call to previous. A return value of -1 indicates that the iterator is currently at
* the start.
*
* @return 0 or -1 depending on current state.
*/
public int previousIndex() {
return (first ? -1 : 0);
}
/**
* Get the next object from the iterator.
*
* This returns the single object if it hasn't been returned yet.
*
* @return the single object
* @throws NoSuchElementException if the single object has already
* been returned
*/
public Object next() {
if (!first) {
throw new NoSuchElementException();
}
first = false;
nextCalled = true;
return object;
}
/**
* Get the previous object from the iterator.
*
* This returns the single object if it has been returned.
*
* @return the single object
* @throws NoSuchElementException if the single object has not already
* been returned
*/
public Object previous() {
if (first) {
throw new NoSuchElementException();
}
first = true;
return object;
}
/**
* Remove always throws {@link UnsupportedOperationException}.
*
* @throws UnsupportedOperationException always
*/
public void remove() {
throw new UnsupportedOperationException("remove() is not supported by this iterator");
}
/**
* Add always throws {@link UnsupportedOperationException}.
*
* @throws UnsupportedOperationException always
*/
public void add(Object obj) {
throw new UnsupportedOperationException("add() is not supported by this iterator");
}
/**
* Set sets the value of the singleton.
*
* @param obj the object to set
* @throws IllegalStateException if next has not been called
*/
public void set(Object obj) {
if (nextCalled == false) {
throw new IllegalStateException();
}
this.object = obj;
}
}
././@LongLink 0000000 0000000 0000000 00000000154 00000000000 011565 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/ArrayIterator.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/ArrayItera 0100644 0001750 0001750 00000015540 10055172376 032272 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.iterators;
import java.lang.reflect.Array;
import java.util.Iterator;
import java.util.NoSuchElementException;
/** Implements an {@link Iterator} over an array of objects.
*
* @since 1.0
* @author James Strachan
* @author Mauricio S. Moura
* @author Michael A. Smith
* @version $Revision: 1.1.2.1 $
*/
public class ArrayIterator implements Iterator {
private Object array;
private int length = 0;
private int index = 0;
/**
* Construct an ArrayIterator. Using this constructor, the iterator is
* equivalent to an empty iterator until {@link #setArray(Object)} is
* called to establish the array to iterate over.
**/
public ArrayIterator() {
}
/**
* Construct an ArrayIterator that will iterate over the values in the
* specified array.
*
* @param array the array to iterate over.
*
* @exception IllegalArgumentException if An IteratorChain is an Iterator that wraps one or
* more Iterators. When any method from the
* Iterator interface is called, the IteratorChain will
* proxy to a single underlying Iterator. The
* IteratorChain will invoke the Iterators in sequence until
* all Iterators are exhausted completely. Under many circumstances, linking Iterators together
* in this manner is more efficient (and convenient)
* than reading out the contents of each Iterator into a
* List and creating a new Iterator. Calling a method that adds new Iteratorafter
* a method in the Iterator interface
* has been called will result in an
* UnsupportedOperationException. Subclasses should take care
* to not alter the underlying List of Iterators.
* This class provides an implementation of an empty list iterator.
* This class provides for binary compatability between Commons Collections
* 2.1.1 and 3.1 due to issues with
* This class provides an implementation of an empty iterator.
* This class provides for binary compatability between Commons Collections
* 2.1.1 and 3.1 due to issues with
*
* 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.
*
* For instance:
*
* Although this map is sequenced, it cannot implement {@link
* java.util.List} because of incompatible interface definitions. The remove
* methods in List and Map have different return values (see: {@link
* java.util.List#remove(Object)} and {@link java.util.Map#remove(Object)}).
*
* This class is not thread safe. When a thread safe implementation is
* required, use {@link Collections#synchronizedMap(Map)} as it is documented,
* or use explicit synchronization controls.
*
* @since 2.0
* @author Michael A. Smith
* @author Daniel Rall
* @author Henning P. Schmiedehausen
*/
public class SequencedHashMap implements Map, Cloneable, Externalizable {
/**
* {@link java.util.Map.Entry} that doubles as a node in the linked list
* of sequenced mappings.
**/
private static class Entry implements Map.Entry {
// Note: This class cannot easily be made clonable. While the actual
// implementation of a clone would be simple, defining the semantics is
// difficult. If a shallow clone is implemented, then entry.next.prev !=
// entry, which is unintuitive and probably breaks all sorts of assumptions
// in code that uses this implementation. If a deep clone is
// implementated, then what happens when the linked list is cyclical (as is
// the case with SequencedHashMap)? It's impossible to know in the clone
// when to stop cloning, and thus you end up in a recursive loop,
// continuously cloning the "next" in the list.
private final Object key;
private Object value;
// package private to allow the SequencedHashMap to access and manipulate
// them.
Entry next = null;
Entry prev = null;
public Entry(Object key, Object value) {
this.key = key;
this.value = value;
}
// per Map.Entry.getKey()
public Object getKey() {
return this.key;
}
// per Map.Entry.getValue()
public Object getValue() {
return this.value;
}
// per Map.Entry.setValue()
public Object setValue(Object value) {
Object oldValue = this.value;
this.value = value;
return oldValue;
}
public int hashCode() {
// implemented per api docs for Map.Entry.hashCode()
return ((getKey() == null ? 0 : getKey().hashCode()) ^
(getValue()==null ? 0 : getValue().hashCode()));
}
public boolean equals(Object obj) {
if(obj == null) return false;
if(obj == this) return true;
if(!(obj instanceof Map.Entry)) return false;
Map.Entry other = (Map.Entry)obj;
// implemented per api docs for Map.Entry.equals(Object)
return((getKey() == null ?
other.getKey() == null :
getKey().equals(other.getKey())) &&
(getValue() == null ?
other.getValue() == null :
getValue().equals(other.getValue())));
}
public String toString() {
return "[" + getKey() + "=" + getValue() + "]";
}
}
/**
* Construct an empty sentinel used to hold the head (sentinel.next) and the
* tail (sentinel.prev) of the list. The sentinal has a An alternative to this method is to use {@link #keySet()}
*
* @see #keySet()
* @return The ordered list of keys.
*/
public List sequence()
{
List l = new ArrayList(size());
Iterator iter = keySet().iterator();
while(iter.hasNext()) {
l.add(iter.next());
}
return Collections.unmodifiableList(l);
}
/**
* Removes the element at the specified index.
*
* @param index The index of the object to remove.
* @return The previous value coressponding the
*
* @author Paul Jack
* @author Stephen Colebourne
* @version $Id: BagUtils.java,v 1.7.2.1 2004/05/22 12:14:01 scolebourne Exp $
* @since 2.1
*/
public class BagUtils {
/**
* Prevents instantiation.
*/
private BagUtils() {
}
static class PredicatedBag
extends CollectionUtils.PredicatedCollection
implements Bag {
public PredicatedBag(Bag b, Predicate p) {
super(b, p);
}
public boolean add(Object o, int count) {
validate(o);
return getBag().add(o, count);
}
public boolean remove(Object o, int count) {
return getBag().remove(o, count);
}
public Set uniqueSet() {
return getBag().uniqueSet();
}
public int getCount(Object o) {
return getBag().getCount(o);
}
private Bag getBag() {
return (Bag)collection;
}
}
static class UnmodifiableBag
extends CollectionUtils.UnmodifiableCollection
implements Bag {
public UnmodifiableBag(Bag bag) {
super(bag);
}
private Bag getBag() {
return (Bag)collection;
}
public boolean add(Object o, int count) {
throw new UnsupportedOperationException();
}
public boolean remove(Object o, int count) {
throw new UnsupportedOperationException();
}
public Set uniqueSet() {
return ((Bag)collection).uniqueSet();
}
public int getCount(Object o) {
return ((Bag)collection).getCount(o);
}
}
static class SynchronizedBag
extends CollectionUtils.SynchronizedCollection
implements Bag {
public SynchronizedBag(Bag bag) {
super(bag);
}
public synchronized boolean add(Object o, int count) {
return getBag().add(o, count);
}
public synchronized boolean remove(Object o, int count) {
return getBag().remove(o, count);
}
public synchronized Set uniqueSet() {
return getBag().uniqueSet();
}
public synchronized int getCount(Object o) {
return getBag().getCount(o);
}
private Bag getBag() {
return (Bag)collection;
}
}
static class PredicatedSortedBag
extends PredicatedBag
implements SortedBag {
public PredicatedSortedBag(SortedBag sb, Predicate p) {
super(sb, p);
}
public Comparator comparator() {
return getSortedBag().comparator();
}
public Object first() {
return getSortedBag().first();
}
public Object last() {
return getSortedBag().last();
}
private SortedBag getSortedBag() {
return (SortedBag)collection;
}
}
static class SynchronizedSortedBag
extends SynchronizedBag
implements SortedBag {
public SynchronizedSortedBag(SortedBag bag) {
super(bag);
}
public synchronized Comparator comparator() {
return getSortedBag().comparator();
}
public synchronized Object first() {
return getSortedBag().first();
}
public synchronized Object last() {
return getSortedBag().last();
}
private SortedBag getSortedBag() {
return (SortedBag)collection;
}
}
static class UnmodifiableSortedBag
extends UnmodifiableBag
implements SortedBag {
public UnmodifiableSortedBag(SortedBag bag) {
super(bag);
}
public Comparator comparator() {
return getSortedBag().comparator();
}
public Object first() {
return getSortedBag().first();
}
public Object last() {
return getSortedBag().last();
}
private SortedBag getSortedBag() {
return (SortedBag)collection;
}
}
/**
* 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 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 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}.
*
* @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 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.
*
* It is imperative that the user manually synchronize on the returned
* bag when iterating over it:
*
*
* It is imperative that the user manually synchronize on the returned
* bag when iterating over it:
*
*
* Most of the utility in this class can also be found in the
*
* Note that every method in this class allows you to specify
*
* The second comparator is used if the first comparator returns
* that equal.
*
* @param comparator1 the first comparator to use, not null
* @param comparator2 the first comparator to use, not null
* @return a combination comparator over the comparators
* @throws NullPointerException if either comparator is null
*/
public static Comparator chainedComparator(Comparator comparator1, Comparator comparator2) {
return chainedComparator(new Comparator[] {comparator1, comparator2});
}
/**
* Gets a comparator that compares using an array of {@link Comparator}s.
*
* The second comparator is used if the first comparator returns
* that equal and so on.
*
* @param iterators the comparators to use, not null or empty or contain nulls
* @return a combination comparator over the comparators
* @throws NullPointerException if comparators array is null or contains a null
*/
public static Comparator chainedComparator(Comparator[] comparators) {
ComparatorChain chain = new ComparatorChain();
for (int i = 0; i < comparators.length; i++) {
if (comparators[i] == null) {
throw new NullPointerException("Comparator cannot be null");
}
chain.addComparator(comparators[i]);
}
return chain;
}
/**
* Gets a comparator that compares using a collection of {@link Comparator}s.
*
* The second comparator is used if the first comparator returns
* that equal and so on.
*
* @param comparators the comparators to use, not null or empty or contain nulls
* @return a combination comparator over the comparators
* @throws NullPointerException if comparators collection is null or contains a null
* @throws ClassCastException if the comparators collection contains the wrong object type
*/
public static Comparator chainedComparator(Collection comparators) {
return chainedComparator(
(Comparator[]) comparators.toArray(new Comparator[comparators.size()])
);
}
/**
* Gets a comparator that reverses the order of the given
* comparator.
*
* @param comparator the comparator whose order to reverse
* @return a comparator who reverses that order
* @see ReverseComparator
*/
public static Comparator reversedComparator(Comparator comparator) {
if (comparator == null) {
comparator = NATURAL_COMPARATOR;
}
return new ReverseComparator(comparator);
}
/**
* Gets a Comparator that controls the comparison of
* The returned comparator will consider a null value to be less than
* any nonnull value, and equal to any other null value. Two nonnull
* values will be evaluated with the given comparator.
*
* @param comparator the comparator that wants to allow nulls
* @return a version of that comparator that allows nulls
* @see NullComparator
*/
public static Comparator nullLowComparator(Comparator comparator) {
if (comparator == null) {
comparator = NATURAL_COMPARATOR;
}
return new NullComparator(comparator, false);
}
/**
* Gets a Comparator that controls the comparison of
* The returned comparator will consider a null value to be greater than
* any nonnull value, and equal to any other null value. Two nonnull
* values will be evaluated with the given comparator.
*
* @param comparator the comparator that wants to allow nulls
* @return a version of that comparator that allows nulls
* @see NullComparator
*/
public static Comparator nullHighComparator(Comparator comparator) {
if (comparator == null) {
comparator = NATURAL_COMPARATOR;
}
return new NullComparator(comparator, true);
}
/**
* Gets a Comparator that passes transformed objects to the given comparator.
*
* Objects passed to the returned comparator will first be transformed
* by the given transformer before they are compared by the given
* comparator.
*
* @param comparator the sort order to use
* @param transformer the transformer to use
* @return a comparator that transforms its input objects before comparing them
* @see TransformingComparator
*/
public static Comparator transformedComparator(Comparator comparator, Transformer transformer) {
if (comparator == null) {
comparator = NATURAL_COMPARATOR;
}
return new TransformingComparator(transformer, comparator);
}
/**
* Returns the smaller of the given objects according to the given
* comparator.
*
* @param o1 the first object to compare
* @param o2 the second object to compare
* @param comparator the sort order to use
* @return the smaller of the two objects
*/
public static Object min(Object o1, Object o2, Comparator comparator) {
if (comparator == null) {
comparator = NATURAL_COMPARATOR;
}
int c = comparator.compare(o1, o2);
return (c < 0) ? o1 : o2;
}
/**
* Returns the smaller of the given objects according to the given
* comparator.
*
* @param o1 the first object to compare
* @param o2 the second object to compare
* @param comparator the sort order to use
* @return the smaller of the two objects
*/
public static Object max(Object o1, Object o2, Comparator comparator) {
if (comparator == null) {
comparator = NATURAL_COMPARATOR;
}
int c = comparator.compare(o1, o2);
return (c > 0) ? o1 : o2;
}
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/SetUtils.java 0100644 0001750 0001750 00000007731 10055172400 030676 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.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.
*
* @author Paul Jack
* @author Stephen Colebourne
* @version $Id: SetUtils.java,v 1.7.2.1 2004/05/22 12:14:02 scolebourne Exp $
* @since 2.1
*/
public class SetUtils {
/**
* Prevents instantiation.
*/
private SetUtils() {
}
static class PredicatedSet
extends CollectionUtils.PredicatedCollection
implements Set {
public PredicatedSet(Set set, Predicate predicate) {
super(set, predicate);
}
}
static class PredicatedSortedSet
extends PredicatedSet
implements SortedSet {
public PredicatedSortedSet(SortedSet set, Predicate predicate) {
super(set, predicate);
}
public SortedSet subSet(Object o1, Object o2) {
SortedSet sub = getSortedSet().subSet(o1, o2);
return new PredicatedSortedSet(sub, predicate);
}
public SortedSet headSet(Object o1) {
SortedSet sub = getSortedSet().headSet(o1);
return new PredicatedSortedSet(sub, predicate);
}
public SortedSet tailSet(Object o1) {
SortedSet sub = getSortedSet().tailSet(o1);
return new PredicatedSortedSet(sub, predicate);
}
public Object first() {
return getSortedSet().first();
}
public Object last() {
return getSortedSet().last();
}
public Comparator comparator() {
return getSortedSet().comparator();
}
private SortedSet getSortedSet() {
return (SortedSet)collection;
}
}
/**
* 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, 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 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.
*
* @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 predicate) {
return new PredicatedSortedSet(set, predicate);
}
}
././@LongLink 0000000 0000000 0000000 00000000145 00000000000 011565 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/ArrayEnumeration.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/ArrayEnumeration.jav 0100644 0001750 0001750 00000003730 10055172402 032243 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.Enumeration;
import java.util.List;
import java.util.NoSuchElementException;
/**
* Enumeration wrapper for array.
*
* @since 1.0
* @author Peter Donald
* @deprecated This class has significant overlap with ArrayIterator,
* and Collections focuses mainly on Java2-style
* collections. If you need to enumerate an array,
* create an {@link ArrayIterator} and wrap it with an
* {@link IteratorEnumeration} instead.
*/
public final class ArrayEnumeration
implements Enumeration
{
protected Object[] m_elements;
protected int m_index;
public ArrayEnumeration( final List elements )
{
m_elements = elements.toArray();
}
public ArrayEnumeration( final Object[] elements )
{
if(elements == null) {
m_elements = new Object[0];
} else {
m_elements = elements;
}
}
public boolean hasMoreElements()
{
return ( m_index < m_elements.length );
}
public Object nextElement()
{
if( !hasMoreElements() )
{
throw new NoSuchElementException("No more elements exist");
}
return m_elements[ m_index++ ];
}
}
././@LongLink 0000000 0000000 0000000 00000000146 00000000000 011566 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/ProxyListIterator.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/ProxyListIterator.ja 0100644 0001750 0001750 00000003337 10055172376 032274 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.ListIterator;
/**
* A proxy {@link ListIterator ListIterator} which delegates its
* methods to a proxy instance.
*
* @since 2.0
* @see ProxyIterator
* @version $Revision: 1.4.2.1 $ $Date: 2004/05/22 12:14:02 $
* @author Rodney Waldhoff
* @deprecated this class has been moved to the iterators subpackage
*/
public class ProxyListIterator
extends org.apache.commons.collections.iterators.ProxyListIterator {
// Constructor
//-------------------------------------------------------------------------
/**
* Constructs a new
*
* If no such constructor exists, and the given type is a primitive
* type, then the given value is converted to a string using its
* {@link Object#toString() toString()} method, and that string is
* parsed into the correct primitve type using, for instance,
* {@link Integer#valueOf(String)} to convert the string into an
*
*
* If no special constructor exists and the given type is not a
* primitive type, this method returns the original value.
*
* @param newType the type to convert the value to
* @param value the value to conert
* @return the converted value
* @throws NumberFormatException if newType is a primitive type, and
* the string representation of the given value cannot be converted
* to that type
* @throws InstantiationException if the constructor found with
* reflection raises it
* @throws InvocationTargetExcetpion if the constructor found with
* reflection raises it
* @throws IllegalAccessException never
* @throws IllegalArgumentException never
*/
protected Object convertType( Class newType, Object value )
throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
// try call constructor
Class[] types = { value.getClass() };
try {
Constructor constructor = newType.getConstructor( types );
Object[] arguments = { value };
return constructor.newInstance( arguments );
}
catch ( NoSuchMethodException e ) {
// try using the transformers
Transformer transformer = getTypeTransformer( newType );
if ( transformer != null ) {
return transformer.transform( value );
}
return value;
}
}
/**
* Returns a transformer for the given primitive type.
*
* @param aType the primitive type whose transformer to return
* @return a transformer that will convert strings into that type,
* or null if the given type is not a primitive type
*/
protected Transformer getTypeTransformer( Class aType ) {
return (Transformer) defaultTransformers.get( aType );
}
/**
* Logs the given exception to
*
* This Map is intended for applications that need to be able to look
* up a key-value pairing by either key or value, and need to do so
* with equal efficiency.
*
* While that goal could be accomplished by taking a pair of TreeMaps
* and redirecting requests to the appropriate TreeMap (e.g.,
* containsKey would be directed to the TreeMap that maps values to
* keys, containsValue would be directed to the TreeMap that maps keys
* to values), there are problems with that implementation,
* particularly when trying to keep the two TreeMaps synchronized with
* each other. And if the data contained in the TreeMaps is large, the
* cost of redundant storage becomes significant.
*
* This solution keeps the data properly synchronized and minimizes
* the data storage. The red-black algorithm is based on TreeMap's,
* but has been modified to simultaneously map a tree node by key and
* by value. This doubles the cost of put operations (but so does
* using two TreeMaps), and nearly doubles the cost of remove
* operations (there is a savings in that the lookup of the node to be
* removed only has to be performed once). And since only one node
* contains the key and value, storage is significantly less than that
* required by two TreeMaps.
*
* There are some limitations placed on data kept in this Map. The
* biggest one is this:
*
* When performing a put operation, neither the key nor the value may
* already exist in the Map. In the java.util Map implementations
* (HashMap, TreeMap), you can perform a put with an already mapped
* key, and neither cares about duplicate values at all ... but this
* implementation's put method with throw an IllegalArgumentException
* if either the key or the value is already in the Map.
*
* Obviously, that same restriction (and consequence of failing to
* heed that restriction) applies to the putAll method.
*
* The Map.Entry instances returned by the appropriate methods will
* not allow setValue() and will throw an
* UnsupportedOperationException on attempts to call that method.
*
* New methods are added to take advantage of the fact that values are
* kept sorted independently of their keys:
*
* Object getKeyForValue(Object value) is the opposite of get; it
* takes a value and returns its key, if any.
*
* Object removeValue(Object value) finds and removes the specified
* value and returns the now un-used key.
*
* Set entrySetByValue() returns the Map.Entry's in a Set whose
* iterator will iterate over the Map.Entry's in ascending order by
* their corresponding values.
*
* Set keySetByValue() returns the keys in a Set whose iterator will
* iterate over the keys in ascending order by their corresponding
* values.
*
* Collection valuesByValue() returns the values in a Collection whose
* iterator will iterate over the values in ascending order.
*
* @since 2.0
* @author Marc Johnson (marcj at users dot sourceforge dot net)
*/
// final for performance
public final class DoubleOrderedMap extends AbstractMap {
private Node[] rootNode = new Node[]{ null,
null };
private int nodeCount = 0;
private int modifications = 0;
private Set[] setOfKeys = new Set[]{ null,
null };
private Set[] setOfEntries = new Set[]{ null,
null };
private Collection[] collectionOfValues = new Collection[]{
null,
null };
private static final int KEY = 0;
private static final int VALUE = 1;
private static final int SUM_OF_INDICES = KEY + VALUE;
private static final int FIRST_INDEX = 0;
private static final int NUMBER_OF_INDICES = 2;
private static final String[] dataName = new String[]{ "key",
"value"
};
/**
* Construct a new DoubleOrderedMap
*/
public DoubleOrderedMap() {}
/**
* Constructs a new DoubleOrderedMap from an existing Map, with keys and
* values sorted
*
* @param map the map whose mappings are to be placed in this map.
*
* @exception ClassCastException if the keys in the map are not
* Comparable, or are not mutually
* comparable; also if the values in
* the map are not Comparable, or
* are not mutually Comparable
* @exception NullPointerException if any key or value in the map
* is null
* @exception IllegalArgumentException if there are duplicate keys
* or duplicate values in the
* map
*/
public DoubleOrderedMap(final Map map)
throws ClassCastException, NullPointerException,
IllegalArgumentException {
putAll(map);
}
/**
* Returns the key to which this map maps the specified value.
* Returns null if the map contains no mapping for this value.
*
* @param value value whose associated key is to be returned.
*
* @return the key to which this map maps the specified value, or
* null if the map contains no mapping for this value.
*
* @exception ClassCastException if the value is of an
* inappropriate type for this map.
* @exception NullPointerException if the value is null
*/
public Object getKeyForValue(final Object value)
throws ClassCastException, NullPointerException {
return doGet((Comparable) value, VALUE);
}
/**
* Removes the mapping for this value from this map if present
*
* @param value value whose mapping is to be removed from the map.
*
* @return previous key associated with specified value, or null
* if there was no mapping for value.
*/
public Object removeValue(final Object value) {
return doRemove((Comparable) value, VALUE);
}
/**
* Returns a set view of the mappings contained in this map. Each
* element in the returned set is a Map.Entry. The set is backed
* by the map, so changes to the map are reflected in the set, and
* vice-versa. If the map is modified while an iteration over the
* set is in progress, the results of the iteration are
* undefined. The set supports element removal, which removes the
* corresponding mapping from the map, via the Iterator.remove,
* Set.remove, removeAll, retainAll and clear operations. It does
* not support the add or addAll operations.
*
* The difference between this method and entrySet is that
* entrySet's iterator() method returns an iterator that iterates
* over the mappings in ascending order by key. This method's
* iterator method iterates over the mappings in ascending order
* by value.
*
* @return a set view of the mappings contained in this map.
*/
public Set entrySetByValue() {
if (setOfEntries[VALUE] == null) {
setOfEntries[VALUE] = new AbstractSet() {
public Iterator iterator() {
return new DoubleOrderedMapIterator(VALUE) {
protected Object doGetNext() {
return lastReturnedNode;
}
};
}
public boolean contains(Object o) {
if (!(o instanceof Map.Entry)) {
return false;
}
Map.Entry entry = (Map.Entry) o;
Object key = entry.getKey();
Node node = lookup((Comparable) entry.getValue(),
VALUE);
return (node != null) && node.getData(KEY).equals(key);
}
public boolean remove(Object o) {
if (!(o instanceof Map.Entry)) {
return false;
}
Map.Entry entry = (Map.Entry) o;
Object key = entry.getKey();
Node node = lookup((Comparable) entry.getValue(),
VALUE);
if ((node != null) && node.getData(KEY).equals(key)) {
doRedBlackDelete(node);
return true;
}
return false;
}
public int size() {
return DoubleOrderedMap.this.size();
}
public void clear() {
DoubleOrderedMap.this.clear();
}
};
}
return setOfEntries[VALUE];
}
/**
* Returns a set view of the keys contained in this map. The set
* is backed by the map, so changes to the map are reflected in
* the set, and vice-versa. If the map is modified while an
* iteration over the set is in progress, the results of the
* iteration are undefined. The set supports element removal,
* which removes the corresponding mapping from the map, via the
* Iterator.remove, Set.remove, removeAll, retainAll, and clear
* operations. It does not support the add or addAll
* operations.
*
* The difference between this method and keySet is that keySet's
* iterator() method returns an iterator that iterates over the
* keys in ascending order by key. This method's iterator method
* iterates over the keys in ascending order by value.
*
* @return a set view of the keys contained in this map.
*/
public Set keySetByValue() {
if (setOfKeys[VALUE] == null) {
setOfKeys[VALUE] = new AbstractSet() {
public Iterator iterator() {
return new DoubleOrderedMapIterator(VALUE) {
protected Object doGetNext() {
return lastReturnedNode.getData(KEY);
}
};
}
public int size() {
return DoubleOrderedMap.this.size();
}
public boolean contains(Object o) {
return containsKey(o);
}
public boolean remove(Object o) {
int oldnodeCount = nodeCount;
DoubleOrderedMap.this.remove(o);
return nodeCount != oldnodeCount;
}
public void clear() {
DoubleOrderedMap.this.clear();
}
};
}
return setOfKeys[VALUE];
}
/**
* Returns a collection view of the values contained in this
* map. The collection is backed by the map, so changes to the map
* are reflected in the collection, and vice-versa. If the map is
* modified while an iteration over the collection is in progress,
* the results of the iteration are undefined. The collection
* supports element removal, which removes the corresponding
* mapping from the map, via the Iterator.remove,
* Collection.remove, removeAll, retainAll and clear operations.
* It does not support the add or addAll operations.
*
* The difference between this method and values is that values's
* iterator() method returns an iterator that iterates over the
* values in ascending order by key. This method's iterator method
* iterates over the values in ascending order by key.
*
* @return a collection view of the values contained in this map.
*/
public Collection valuesByValue() {
if (collectionOfValues[VALUE] == null) {
collectionOfValues[VALUE] = new AbstractCollection() {
public Iterator iterator() {
return new DoubleOrderedMapIterator(VALUE) {
protected Object doGetNext() {
return lastReturnedNode.getData(VALUE);
}
};
}
public int size() {
return DoubleOrderedMap.this.size();
}
public boolean contains(Object o) {
return containsValue(o);
}
public boolean remove(Object o) {
int oldnodeCount = nodeCount;
removeValue(o);
return nodeCount != oldnodeCount;
}
public boolean removeAll(Collection c) {
boolean modified = false;
Iterator iter = c.iterator();
while (iter.hasNext()) {
if (removeValue(iter.next()) != null) {
modified = true;
}
}
return modified;
}
public void clear() {
DoubleOrderedMap.this.clear();
}
};
}
return collectionOfValues[VALUE];
}
/**
* common remove logic (remove by key or remove by value)
*
* @param o the key, or value, that we're looking for
* @param index KEY or VALUE
*
* @return the key, if remove by value, or the value, if remove by
* key. null if the specified key or value could not be
* found
*/
private Object doRemove(final Comparable o, final int index) {
Node node = lookup(o, index);
Object rval = null;
if (node != null) {
rval = node.getData(oppositeIndex(index));
doRedBlackDelete(node);
}
return rval;
}
/**
* common get logic, used to get by key or get by value
*
* @param o the key or value that we're looking for
* @param index KEY or VALUE
*
* @return the key (if the value was mapped) or the value (if the
* key was mapped); null if we couldn't find the specified
* object
*/
private Object doGet(final Comparable o, final int index) {
checkNonNullComparable(o, index);
Node node = lookup(o, index);
return ((node == null)
? null
: node.getData(oppositeIndex(index)));
}
/**
* Get the opposite index of the specified index
*
* @param index KEY or VALUE
*
* @return VALUE (if KEY was specified), else KEY
*/
private int oppositeIndex(final int index) {
// old trick ... to find the opposite of a value, m or n,
// subtract the value from the sum of the two possible
// values. (m + n) - m = n; (m + n) - n = m
return SUM_OF_INDICES - index;
}
/**
* do the actual lookup of a piece of data
*
* @param data the key or value to be looked up
* @param index KEY or VALUE
*
* @return the desired Node, or null if there is no mapping of the
* specified data
*/
private Node lookup(final Comparable data, final int index) {
Node rval = null;
Node node = rootNode[index];
while (node != null) {
int cmp = compare(data, node.getData(index));
if (cmp == 0) {
rval = node;
break;
} else {
node = (cmp < 0)
? node.getLeft(index)
: node.getRight(index);
}
}
return rval;
}
/**
* Compare two objects
*
* @param o1 the first object
* @param o2 the second object
*
* @return negative value if o1 < o2; 0 if o1 == o2; positive
* value if o1 > o2
*/
private static int compare(final Comparable o1, final Comparable o2) {
return ((Comparable) o1).compareTo(o2);
}
/**
* find the least node from a given node. very useful for starting
* a sorting iterator ...
*
* @param node the node from which we will start searching
* @param index KEY or VALUE
*
* @return the smallest node, from the specified node, in the
* specified mapping
*/
private static Node leastNode(final Node node, final int index) {
Node rval = node;
if (rval != null) {
while (rval.getLeft(index) != null) {
rval = rval.getLeft(index);
}
}
return rval;
}
/**
* get the next larger node from the specified node
*
* @param node the node to be searched from
* @param index KEY or VALUE
*
* @return the specified node
*/
private Node nextGreater(final Node node, final int index) {
Node rval = null;
if (node == null) {
rval = null;
} else if (node.getRight(index) != null) {
// everything to the node's right is larger. The least of
// the right node's descendents is the next larger node
rval = leastNode(node.getRight(index), index);
} else {
// traverse up our ancestry until we find an ancestor that
// is null or one whose left child is our ancestor. If we
// find a null, then this node IS the largest node in the
// tree, and there is no greater node. Otherwise, we are
// the largest node in the subtree on that ancestor's left
// ... and that ancestor is the next greatest node
Node parent = node.getParent(index);
Node child = node;
while ((parent != null) && (child == parent.getRight(index))) {
child = parent;
parent = parent.getParent(index);
}
rval = parent;
}
return rval;
}
/**
* copy the color from one node to another, dealing with the fact
* that one or both nodes may, in fact, be null
*
* @param from the node whose color we're copying; may be null
* @param to the node whose color we're changing; may be null
* @param index KEY or VALUE
*/
private static void copyColor(final Node from, final Node to,
final int index) {
if (to != null) {
if (from == null) {
// by default, make it black
to.setBlack(index);
} else {
to.copyColor(from, index);
}
}
}
/**
* is the specified node red? if the node does not exist, no, it's
* black, thank you
*
* @param node the node (may be null) in question
* @param index KEY or VALUE
*/
private static boolean isRed(final Node node, final int index) {
return ((node == null)
? false
: node.isRed(index));
}
/**
* is the specified black red? if the node does not exist, sure,
* it's black, thank you
*
* @param node the node (may be null) in question
* @param index KEY or VALUE
*/
private static boolean isBlack(final Node node, final int index) {
return ((node == null)
? true
: node.isBlack(index));
}
/**
* force a node (if it exists) red
*
* @param node the node (may be null) in question
* @param index KEY or VALUE
*/
private static void makeRed(final Node node, final int index) {
if (node != null) {
node.setRed(index);
}
}
/**
* force a node (if it exists) black
*
* @param node the node (may be null) in question
* @param index KEY or VALUE
*/
private static void makeBlack(final Node node, final int index) {
if (node != null) {
node.setBlack(index);
}
}
/**
* get a node's grandparent. mind you, the node, its parent, or
* its grandparent may not exist. no problem
*
* @param node the node (may be null) in question
* @param index KEY or VALUE
*/
private static Node getGrandParent(final Node node, final int index) {
return getParent(getParent(node, index), index);
}
/**
* get a node's parent. mind you, the node, or its parent, may not
* exist. no problem
*
* @param node the node (may be null) in question
* @param index KEY or VALUE
*/
private static Node getParent(final Node node, final int index) {
return ((node == null)
? null
: node.getParent(index));
}
/**
* get a node's right child. mind you, the node may not exist. no
* problem
*
* @param node the node (may be null) in question
* @param index KEY or VALUE
*/
private static Node getRightChild(final Node node, final int index) {
return (node == null)
? null
: node.getRight(index);
}
/**
* get a node's left child. mind you, the node may not exist. no
* problem
*
* @param node the node (may be null) in question
* @param index KEY or VALUE
*/
private static Node getLeftChild(final Node node, final int index) {
return (node == null)
? null
: node.getLeft(index);
}
/**
* is this node its parent's left child? mind you, the node, or
* its parent, may not exist. no problem. if the node doesn't
* exist ... it's its non-existent parent's left child. If the
* node does exist but has no parent ... no, we're not the
* non-existent parent's left child. Otherwise (both the specified
* node AND its parent exist), check.
*
* @param node the node (may be null) in question
* @param index KEY or VALUE
*/
private static boolean isLeftChild(final Node node, final int index) {
return (node == null)
? true
: ((node.getParent(index) == null)
? false
: (node == node.getParent(index).getLeft(index)));
}
/**
* is this node its parent's right child? mind you, the node, or
* its parent, may not exist. no problem. if the node doesn't
* exist ... it's its non-existent parent's right child. If the
* node does exist but has no parent ... no, we're not the
* non-existent parent's right child. Otherwise (both the
* specified node AND its parent exist), check.
*
* @param node the node (may be null) in question
* @param index KEY or VALUE
*/
private static boolean isRightChild(final Node node, final int index) {
return (node == null)
? true
: ((node.getParent(index) == null)
? false
: (node == node.getParent(index).getRight(index)));
}
/**
* do a rotate left. standard fare in the world of balanced trees
*
* @param node the node to be rotated
* @param index KEY or VALUE
*/
private void rotateLeft(final Node node, final int index) {
Node rightChild = node.getRight(index);
node.setRight(rightChild.getLeft(index), index);
if (rightChild.getLeft(index) != null) {
rightChild.getLeft(index).setParent(node, index);
}
rightChild.setParent(node.getParent(index), index);
if (node.getParent(index) == null) {
// node was the root ... now its right child is the root
rootNode[index] = rightChild;
} else if (node.getParent(index).getLeft(index) == node) {
node.getParent(index).setLeft(rightChild, index);
} else {
node.getParent(index).setRight(rightChild, index);
}
rightChild.setLeft(node, index);
node.setParent(rightChild, index);
}
/**
* do a rotate right. standard fare in the world of balanced trees
*
* @param node the node to be rotated
* @param index KEY or VALUE
*/
private void rotateRight(final Node node, final int index) {
Node leftChild = node.getLeft(index);
node.setLeft(leftChild.getRight(index), index);
if (leftChild.getRight(index) != null) {
leftChild.getRight(index).setParent(node, index);
}
leftChild.setParent(node.getParent(index), index);
if (node.getParent(index) == null) {
// node was the root ... now its left child is the root
rootNode[index] = leftChild;
} else if (node.getParent(index).getRight(index) == node) {
node.getParent(index).setRight(leftChild, index);
} else {
node.getParent(index).setLeft(leftChild, index);
}
leftChild.setRight(node, index);
node.setParent(leftChild, index);
}
/**
* complicated red-black insert stuff. Based on Sun's TreeMap
* implementation, though it's barely recognizeable any more
*
* @param insertedNode the node to be inserted
* @param index KEY or VALUE
*/
private void doRedBlackInsert(final Node insertedNode, final int index)
{
Node currentNode = insertedNode;
makeRed(currentNode, index);
while ((currentNode != null) && (currentNode != rootNode[index])
&& (isRed(currentNode.getParent(index), index))) {
if (isLeftChild(getParent(currentNode, index), index)) {
Node y = getRightChild(getGrandParent(currentNode, index),
index);
if (isRed(y, index)) {
makeBlack(getParent(currentNode, index), index);
makeBlack(y, index);
makeRed(getGrandParent(currentNode, index), index);
currentNode = getGrandParent(currentNode, index);
} else {
if (isRightChild(currentNode, index)) {
currentNode = getParent(currentNode, index);
rotateLeft(currentNode, index);
}
makeBlack(getParent(currentNode, index), index);
makeRed(getGrandParent(currentNode, index), index);
if (getGrandParent(currentNode, index) != null) {
rotateRight(getGrandParent(currentNode, index),
index);
}
}
} else {
// just like clause above, except swap left for right
Node y = getLeftChild(getGrandParent(currentNode, index),
index);
if (isRed(y, index)) {
makeBlack(getParent(currentNode, index), index);
makeBlack(y, index);
makeRed(getGrandParent(currentNode, index), index);
currentNode = getGrandParent(currentNode, index);
} else {
if (isLeftChild(currentNode, index)) {
currentNode = getParent(currentNode, index);
rotateRight(currentNode, index);
}
makeBlack(getParent(currentNode, index), index);
makeRed(getGrandParent(currentNode, index), index);
if (getGrandParent(currentNode, index) != null) {
rotateLeft(getGrandParent(currentNode, index),
index);
}
}
}
}
makeBlack(rootNode[index], index);
}
/**
* complicated red-black delete stuff. Based on Sun's TreeMap
* implementation, though it's barely recognizeable any more
*
* @param deletedNode the node to be deleted
*/
private void doRedBlackDelete(final Node deletedNode) {
for (int index = FIRST_INDEX; index < NUMBER_OF_INDICES; index++) {
// if deleted node has both left and children, swap with
// the next greater node
if ((deletedNode.getLeft(index) != null)
&& (deletedNode.getRight(index) != null)) {
swapPosition(nextGreater(deletedNode, index), deletedNode,
index);
}
Node replacement = ((deletedNode.getLeft(index) != null)
? deletedNode.getLeft(index)
: deletedNode.getRight(index));
if (replacement != null) {
replacement.setParent(deletedNode.getParent(index), index);
if (deletedNode.getParent(index) == null) {
rootNode[index] = replacement;
} else if (deletedNode
== deletedNode.getParent(index).getLeft(index)) {
deletedNode.getParent(index).setLeft(replacement,
index);
} else {
deletedNode.getParent(index).setRight(replacement,
index);
}
deletedNode.setLeft(null, index);
deletedNode.setRight(null, index);
deletedNode.setParent(null, index);
if (isBlack(deletedNode, index)) {
doRedBlackDeleteFixup(replacement, index);
}
} else {
// replacement is null
if (deletedNode.getParent(index) == null) {
// empty tree
rootNode[index] = null;
} else {
// deleted node had no children
if (isBlack(deletedNode, index)) {
doRedBlackDeleteFixup(deletedNode, index);
}
if (deletedNode.getParent(index) != null) {
if (deletedNode
== deletedNode.getParent(index)
.getLeft(index)) {
deletedNode.getParent(index).setLeft(null,
index);
} else {
deletedNode.getParent(index).setRight(null,
index);
}
deletedNode.setParent(null, index);
}
}
}
}
shrink();
}
/**
* complicated red-black delete stuff. Based on Sun's TreeMap
* implementation, though it's barely recognizeable any more. This
* rebalances the tree (somewhat, as red-black trees are not
* perfectly balanced -- perfect balancing takes longer)
*
* @param replacementNode the node being replaced
* @param index KEY or VALUE
*/
private void doRedBlackDeleteFixup(final Node replacementNode,
final int index) {
Node currentNode = replacementNode;
while ((currentNode != rootNode[index])
&& (isBlack(currentNode, index))) {
if (isLeftChild(currentNode, index)) {
Node siblingNode =
getRightChild(getParent(currentNode, index), index);
if (isRed(siblingNode, index)) {
makeBlack(siblingNode, index);
makeRed(getParent(currentNode, index), index);
rotateLeft(getParent(currentNode, index), index);
siblingNode = getRightChild(getParent(currentNode,
index),
index);
}
if (isBlack(getLeftChild(siblingNode, index), index)
&& isBlack(getRightChild(siblingNode, index),
index)) {
makeRed(siblingNode, index);
currentNode = getParent(currentNode, index);
} else {
if (isBlack(getRightChild(siblingNode, index), index)) {
makeBlack(getLeftChild(siblingNode, index), index);
makeRed(siblingNode, index);
rotateRight(siblingNode, index);
siblingNode =
getRightChild(getParent(currentNode, index),
index);
}
copyColor(getParent(currentNode, index), siblingNode,
index);
makeBlack(getParent(currentNode, index), index);
makeBlack(getRightChild(siblingNode, index), index);
rotateLeft(getParent(currentNode, index), index);
currentNode = rootNode[index];
}
} else {
Node siblingNode = getLeftChild(getParent(currentNode,
index),
index);
if (isRed(siblingNode, index)) {
makeBlack(siblingNode, index);
makeRed(getParent(currentNode, index), index);
rotateRight(getParent(currentNode, index), index);
siblingNode = getLeftChild(getParent(currentNode,
index),
index);
}
if (isBlack(getRightChild(siblingNode, index), index)
&& isBlack(getLeftChild(siblingNode, index), index))
{
makeRed(siblingNode, index);
currentNode = getParent(currentNode, index);
} else {
if (isBlack(getLeftChild(siblingNode, index), index)) {
makeBlack(getRightChild(siblingNode, index), index);
makeRed(siblingNode, index);
rotateLeft(siblingNode, index);
siblingNode =
getLeftChild(getParent(currentNode, index),
index);
}
copyColor(getParent(currentNode, index), siblingNode,
index);
makeBlack(getParent(currentNode, index), index);
makeBlack(getLeftChild(siblingNode, index), index);
rotateRight(getParent(currentNode, index), index);
currentNode = rootNode[index];
}
}
}
makeBlack(currentNode, index);
}
/**
* swap two nodes (except for their content), taking care of
* special cases where one is the other's parent ... hey, it
* happens.
*
* @param x one node
* @param y another node
* @param index KEY or VALUE
*/
private void swapPosition(final Node x, final Node y, final int index) {
// Save initial values.
Node xFormerParent = x.getParent(index);
Node xFormerLeftChild = x.getLeft(index);
Node xFormerRightChild = x.getRight(index);
Node yFormerParent = y.getParent(index);
Node yFormerLeftChild = y.getLeft(index);
Node yFormerRightChild = y.getRight(index);
boolean xWasLeftChild =
(x.getParent(index) != null)
&& (x == x.getParent(index).getLeft(index));
boolean yWasLeftChild =
(y.getParent(index) != null)
&& (y == y.getParent(index).getLeft(index));
// Swap, handling special cases of one being the other's parent.
if (x == yFormerParent) { // x was y's parent
x.setParent(y, index);
if (yWasLeftChild) {
y.setLeft(x, index);
y.setRight(xFormerRightChild, index);
} else {
y.setRight(x, index);
y.setLeft(xFormerLeftChild, index);
}
} else {
x.setParent(yFormerParent, index);
if (yFormerParent != null) {
if (yWasLeftChild) {
yFormerParent.setLeft(x, index);
} else {
yFormerParent.setRight(x, index);
}
}
y.setLeft(xFormerLeftChild, index);
y.setRight(xFormerRightChild, index);
}
if (y == xFormerParent) { // y was x's parent
y.setParent(x, index);
if (xWasLeftChild) {
x.setLeft(y, index);
x.setRight(yFormerRightChild, index);
} else {
x.setRight(y, index);
x.setLeft(yFormerLeftChild, index);
}
} else {
y.setParent(xFormerParent, index);
if (xFormerParent != null) {
if (xWasLeftChild) {
xFormerParent.setLeft(y, index);
} else {
xFormerParent.setRight(y, index);
}
}
x.setLeft(yFormerLeftChild, index);
x.setRight(yFormerRightChild, index);
}
// Fix children's parent pointers
if (x.getLeft(index) != null) {
x.getLeft(index).setParent(x, index);
}
if (x.getRight(index) != null) {
x.getRight(index).setParent(x, index);
}
if (y.getLeft(index) != null) {
y.getLeft(index).setParent(y, index);
}
if (y.getRight(index) != null) {
y.getRight(index).setParent(y, index);
}
x.swapColors(y, index);
// Check if root changed
if (rootNode[index] == x) {
rootNode[index] = y;
} else if (rootNode[index] == y) {
rootNode[index] = x;
}
}
/**
* check if an object is fit to be proper input ... has to be
* Comparable and non-null
*
* @param o the object being checked
* @param index KEY or VALUE (used to put the right word in the
* exception message)
*
* @exception NullPointerException if o is null
* @exception ClassCastException if o is not Comparable
*/
private static void checkNonNullComparable(final Object o,
final int index) {
if (o == null) {
throw new NullPointerException(dataName[index]
+ " cannot be null");
}
if (!(o instanceof Comparable)) {
throw new ClassCastException(dataName[index]
+ " must be Comparable");
}
}
/**
* check a key for validity (non-null and implements Comparable)
*
* @param key the key to be checked
*
* @exception NullPointerException if key is null
* @exception ClassCastException if key is not Comparable
*/
private static void checkKey(final Object key) {
checkNonNullComparable(key, KEY);
}
/**
* check a value for validity (non-null and implements Comparable)
*
* @param value the value to be checked
*
* @exception NullPointerException if value is null
* @exception ClassCastException if value is not Comparable
*/
private static void checkValue(final Object value) {
checkNonNullComparable(value, VALUE);
}
/**
* check a key and a value for validity (non-null and implements
* Comparable)
*
* @param key the key to be checked
* @param value the value to be checked
*
* @exception NullPointerException if key or value is null
* @exception ClassCastException if key or value is not Comparable
*/
private static void checkKeyAndValue(final Object key,
final Object value) {
checkKey(key);
checkValue(value);
}
/**
* increment the modification count -- used to check for
* concurrent modification of the map through the map and through
* an Iterator from one of its Set or Collection views
*/
private void modify() {
modifications++;
}
/**
* bump up the size and note that the map has changed
*/
private void grow() {
modify();
nodeCount++;
}
/**
* decrement the size and note that the map has changed
*/
private void shrink() {
modify();
nodeCount--;
}
/**
* insert a node by its value
*
* @param newNode the node to be inserted
*
* @exception IllegalArgumentException if the node already exists
* in the value mapping
*/
private void insertValue(final Node newNode)
throws IllegalArgumentException {
Node node = rootNode[VALUE];
while (true) {
int cmp = compare(newNode.getData(VALUE), node.getData(VALUE));
if (cmp == 0) {
throw new IllegalArgumentException(
"Cannot store a duplicate value (\""
+ newNode.getData(VALUE) + "\") in this Map");
} else if (cmp < 0) {
if (node.getLeft(VALUE) != null) {
node = node.getLeft(VALUE);
} else {
node.setLeft(newNode, VALUE);
newNode.setParent(node, VALUE);
doRedBlackInsert(newNode, VALUE);
break;
}
} else { // cmp > 0
if (node.getRight(VALUE) != null) {
node = node.getRight(VALUE);
} else {
node.setRight(newNode, VALUE);
newNode.setParent(node, VALUE);
doRedBlackInsert(newNode, VALUE);
break;
}
}
}
}
/* ********** START implementation of Map ********** */
/**
* Returns the number of key-value mappings in this map. If the
* map contains more than Integer.MAXVALUE elements, returns
* Integer.MAXVALUE.
*
* @return the number of key-value mappings in this map.
*/
public int size() {
return nodeCount;
}
/**
* Returns true if this map contains a mapping for the specified
* key.
*
* @param key key whose presence in this map is to be tested.
*
* @return true if this map contains a mapping for the specified
* key.
*
* @exception ClassCastException if the key is of an inappropriate
* type for this map.
* @exception NullPointerException if the key is null
*/
public boolean containsKey(final Object key)
throws ClassCastException, NullPointerException {
checkKey(key);
return lookup((Comparable) key, KEY) != null;
}
/**
* Returns true if this map maps one or more keys to the
* specified value.
*
* @param value value whose presence in this map is to be tested.
*
* @return true if this map maps one or more keys to the specified
* value.
*/
public boolean containsValue(final Object value) {
checkValue(value);
return lookup((Comparable) value, VALUE) != null;
}
/**
* Returns the value to which this map maps the specified
* key. Returns null if the map contains no mapping for this key.
*
* @param key key whose associated value is to be returned.
*
* @return the value to which this map maps the specified key, or
* null if the map contains no mapping for this key.
*
* @exception ClassCastException if the key is of an inappropriate
* type for this map.
* @exception NullPointerException if the key is null
*/
public Object get(final Object key)
throws ClassCastException, NullPointerException {
return doGet((Comparable) key, KEY);
}
/**
* Associates the specified value with the specified key in this
* map.
*
* @param key key with which the specified value is to be
* associated.
* @param value value to be associated with the specified key.
*
* @return null
*
* @exception ClassCastException if the class of the specified key
* or value prevents it from being
* stored in this map.
* @exception NullPointerException if the specified key or value
* is null
* @exception IllegalArgumentException if the key duplicates an
* existing key, or if the
* value duplicates an
* existing value
*/
public Object put(final Object key, final Object value)
throws ClassCastException, NullPointerException,
IllegalArgumentException {
checkKeyAndValue(key, value);
Node node = rootNode[KEY];
if (node == null) {
Node root = new Node((Comparable) key, (Comparable) value);
rootNode[KEY] = root;
rootNode[VALUE] = root;
grow();
} else {
while (true) {
int cmp = compare((Comparable) key, node.getData(KEY));
if (cmp == 0) {
throw new IllegalArgumentException(
"Cannot store a duplicate key (\"" + key
+ "\") in this Map");
} else if (cmp < 0) {
if (node.getLeft(KEY) != null) {
node = node.getLeft(KEY);
} else {
Node newNode = new Node((Comparable) key,
(Comparable) value);
insertValue(newNode);
node.setLeft(newNode, KEY);
newNode.setParent(node, KEY);
doRedBlackInsert(newNode, KEY);
grow();
break;
}
} else { // cmp > 0
if (node.getRight(KEY) != null) {
node = node.getRight(KEY);
} else {
Node newNode = new Node((Comparable) key,
(Comparable) value);
insertValue(newNode);
node.setRight(newNode, KEY);
newNode.setParent(node, KEY);
doRedBlackInsert(newNode, KEY);
grow();
break;
}
}
}
}
return null;
}
/**
* Removes the mapping for this key from this map if present
*
* @param key key whose mapping is to be removed from the map.
*
* @return previous value associated with specified key, or null
* if there was no mapping for key.
*/
public Object remove(final Object key) {
return doRemove((Comparable) key, KEY);
}
/**
* Removes all mappings from this map
*/
public void clear() {
modify();
nodeCount = 0;
rootNode[KEY] = null;
rootNode[VALUE] = null;
}
/**
* Returns a set view of the keys contained in this map. The set
* is backed by the map, so changes to the map are reflected in
* the set, and vice-versa. If the map is modified while an
* iteration over the set is in progress, the results of the
* iteration are undefined. The set supports element removal,
* which removes the corresponding mapping from the map, via the
* Iterator.remove, Set.remove, removeAll, retainAll, and clear
* operations. It does not support the add or addAll operations.
*
* @return a set view of the keys contained in this map.
*/
public Set keySet() {
if (setOfKeys[KEY] == null) {
setOfKeys[KEY] = new AbstractSet() {
public Iterator iterator() {
return new DoubleOrderedMapIterator(KEY) {
protected Object doGetNext() {
return lastReturnedNode.getData(KEY);
}
};
}
public int size() {
return DoubleOrderedMap.this.size();
}
public boolean contains(Object o) {
return containsKey(o);
}
public boolean remove(Object o) {
int oldNodeCount = nodeCount;
DoubleOrderedMap.this.remove(o);
return nodeCount != oldNodeCount;
}
public void clear() {
DoubleOrderedMap.this.clear();
}
};
}
return setOfKeys[KEY];
}
/**
* Returns a collection view of the values contained in this
* map. The collection is backed by the map, so changes to the map
* are reflected in the collection, and vice-versa. If the map is
* modified while an iteration over the collection is in progress,
* the results of the iteration are undefined. The collection
* supports element removal, which removes the corresponding
* mapping from the map, via the Iterator.remove,
* Collection.remove, removeAll, retainAll and clear operations.
* It does not support the add or addAll operations.
*
* @return a collection view of the values contained in this map.
*/
public Collection values() {
if (collectionOfValues[KEY] == null) {
collectionOfValues[KEY] = new AbstractCollection() {
public Iterator iterator() {
return new DoubleOrderedMapIterator(KEY) {
protected Object doGetNext() {
return lastReturnedNode.getData(VALUE);
}
};
}
public int size() {
return DoubleOrderedMap.this.size();
}
public boolean contains(Object o) {
return containsValue(o);
}
public boolean remove(Object o) {
int oldNodeCount = nodeCount;
removeValue(o);
return nodeCount != oldNodeCount;
}
public boolean removeAll(Collection c) {
boolean modified = false;
Iterator iter = c.iterator();
while (iter.hasNext()) {
if (removeValue(iter.next()) != null) {
modified = true;
}
}
return modified;
}
public void clear() {
DoubleOrderedMap.this.clear();
}
};
}
return collectionOfValues[KEY];
}
/**
* Returns a set view of the mappings contained in this map. Each
* element in the returned set is a Map.Entry. The set is backed
* by the map, so changes to the map are reflected in the set, and
* vice-versa. If the map is modified while an iteration over the
* set is in progress, the results of the iteration are
* undefined. The set supports element removal, which removes the
* corresponding mapping from the map, via the Iterator.remove,
* Set.remove, removeAll, retainAll and clear operations. It does
* not support the add or addAll operations.
*
* @return a set view of the mappings contained in this map.
*/
public Set entrySet() {
if (setOfEntries[KEY] == null) {
setOfEntries[KEY] = new AbstractSet() {
public Iterator iterator() {
return new DoubleOrderedMapIterator(KEY) {
protected Object doGetNext() {
return lastReturnedNode;
}
};
}
public boolean contains(Object o) {
if (!(o instanceof Map.Entry)) {
return false;
}
Map.Entry entry = (Map.Entry) o;
Object value = entry.getValue();
Node node = lookup((Comparable) entry.getKey(),
KEY);
return (node != null)
&& node.getData(VALUE).equals(value);
}
public boolean remove(Object o) {
if (!(o instanceof Map.Entry)) {
return false;
}
Map.Entry entry = (Map.Entry) o;
Object value = entry.getValue();
Node node = lookup((Comparable) entry.getKey(),
KEY);
if ((node != null) && node.getData(VALUE).equals(value))
{
doRedBlackDelete(node);
return true;
}
return false;
}
public int size() {
return DoubleOrderedMap.this.size();
}
public void clear() {
DoubleOrderedMap.this.clear();
}
};
}
return setOfEntries[KEY];
}
/* ********** END implementation of Map ********** */
private abstract class DoubleOrderedMapIterator implements Iterator {
private int expectedModifications;
protected Node lastReturnedNode;
private Node nextNode;
private int iteratorType;
/**
* Constructor
*
* @param type
*/
DoubleOrderedMapIterator(final int type) {
iteratorType = type;
expectedModifications = DoubleOrderedMap.this.modifications;
lastReturnedNode = null;
nextNode = leastNode(rootNode[iteratorType],
iteratorType);
}
/**
* @return 'next', whatever that means for a given kind of
* DoubleOrderedMapIterator
*/
protected abstract Object doGetNext();
/* ********** START implementation of Iterator ********** */
/**
* @return true if the iterator has more elements.
*/
public final boolean hasNext() {
return nextNode != null;
}
/**
* @return the next element in the iteration.
*
* @exception NoSuchElementException if iteration has no more
* elements.
* @exception ConcurrentModificationException if the
* DoubleOrderedMap is
* modified behind
* the iterator's
* back
*/
public final Object next()
throws NoSuchElementException,
ConcurrentModificationException {
if (nextNode == null) {
throw new NoSuchElementException();
}
if (modifications != expectedModifications) {
throw new ConcurrentModificationException();
}
lastReturnedNode = nextNode;
nextNode = nextGreater(nextNode, iteratorType);
return doGetNext();
}
/**
* Removes from the underlying collection the last element
* returned by the iterator. This method can be called only
* once per call to next. The behavior of an iterator is
* unspecified if the underlying collection is modified while
* the iteration is in progress in any way other than by
* calling this method.
*
* @exception IllegalStateException if the next method has not
* yet been called, or the
* remove method has already
* been called after the last
* call to the next method.
* @exception ConcurrentModificationException if the
* DoubleOrderedMap is
* modified behind
* the iterator's
* back
*/
public final void remove()
throws IllegalStateException,
ConcurrentModificationException {
if (lastReturnedNode == null) {
throw new IllegalStateException();
}
if (modifications != expectedModifications) {
throw new ConcurrentModificationException();
}
doRedBlackDelete(lastReturnedNode);
expectedModifications++;
lastReturnedNode = null;
}
/* ********** END implementation of Iterator ********** */
} // end private abstract class DoubleOrderedMapIterator
// final for performance
private static final class Node implements Map.Entry {
private Comparable[] data;
private Node[] leftNode;
private Node[] rightNode;
private Node[] parentNode;
private boolean[] blackColor;
private int hashcodeValue;
private boolean calculatedHashCode;
/**
* Make a new cell with given key and value, and with null
* links, and black (true) colors.
*
* @param key
* @param value
*/
Node(final Comparable key, final Comparable value) {
data = new Comparable[]{ key, value };
leftNode = new Node[]{ null, null };
rightNode = new Node[]{ null, null };
parentNode = new Node[]{ null, null };
blackColor = new boolean[]{ true, true };
calculatedHashCode = false;
}
/**
* get the specified data
*
* @param index KEY or VALUE
*
* @return the key or value
*/
private Comparable getData(final int index) {
return data[index];
}
/**
* Set this node's left node
*
* @param node the new left node
* @param index KEY or VALUE
*/
private void setLeft(final Node node, final int index) {
leftNode[index] = node;
}
/**
* get the left node
*
* @param index KEY or VALUE
*
* @return the left node -- may be null
*/
private Node getLeft(final int index) {
return leftNode[index];
}
/**
* Set this node's right node
*
* @param node the new right node
* @param index KEY or VALUE
*/
private void setRight(final Node node, final int index) {
rightNode[index] = node;
}
/**
* get the right node
*
* @param index KEY or VALUE
*
* @return the right node -- may be null
*/
private Node getRight(final int index) {
return rightNode[index];
}
/**
* Set this node's parent node
*
* @param node the new parent node
* @param index KEY or VALUE
*/
private void setParent(final Node node, final int index) {
parentNode[index] = node;
}
/**
* get the parent node
*
* @param index KEY or VALUE
*
* @return the parent node -- may be null
*/
private Node getParent(final int index) {
return parentNode[index];
}
/**
* exchange colors with another node
*
* @param node the node to swap with
* @param index KEY or VALUE
*/
private void swapColors(final Node node, final int index) {
// Swap colors -- old hacker's trick
blackColor[index] ^= node.blackColor[index];
node.blackColor[index] ^= blackColor[index];
blackColor[index] ^= node.blackColor[index];
}
/**
* is this node black?
*
* @param index KEY or VALUE
*
* @return true if black (which is represented as a true boolean)
*/
private boolean isBlack(final int index) {
return blackColor[index];
}
/**
* is this node red?
*
* @param index KEY or VALUE
*
* @return true if non-black
*/
private boolean isRed(final int index) {
return !blackColor[index];
}
/**
* make this node black
*
* @param index KEY or VALUE
*/
private void setBlack(final int index) {
blackColor[index] = true;
}
/**
* make this node red
*
* @param index KEY or VALUE
*/
private void setRed(final int index) {
blackColor[index] = false;
}
/**
* make this node the same color as another
*
* @param node the node whose color we're adopting
* @param index KEY or VALUE
*/
private void copyColor(final Node node, final int index) {
blackColor[index] = node.blackColor[index];
}
/* ********** START implementation of Map.Entry ********** */
/**
* @return the key corresponding to this entry.
*/
public Object getKey() {
return data[KEY];
}
/**
* @return the value corresponding to this entry.
*/
public Object getValue() {
return data[VALUE];
}
/**
* Optional operation that is not permitted in this
* implementation
*
* @param ignored
*
* @return does not return
*
* @exception UnsupportedOperationException
*/
public Object setValue(Object ignored)
throws UnsupportedOperationException {
throw new UnsupportedOperationException(
"Map.Entry.setValue is not supported");
}
/**
* Compares the specified object with this entry for equality.
* Returns true if the given object is also a map entry and
* the two entries represent the same mapping.
*
* @param o object to be compared for equality with this map
* entry.
* @return true if the specified object is equal to this map
* entry.
*/
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof Map.Entry)) {
return false;
}
Map.Entry e = (Map.Entry) o;
return data[KEY].equals(e.getKey())
&& data[VALUE].equals(e.getValue());
}
/**
* @return the hash code value for this map entry.
*/
public int hashCode() {
if (!calculatedHashCode) {
hashcodeValue = data[KEY].hashCode()
^ data[VALUE].hashCode();
calculatedHashCode = true;
}
return hashcodeValue;
}
/* ********** END implementation of Map.Entry ********** */
}
} // end public class DoubleOrderedMap
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/TreeBag.java 0100644 0001750 0001750 00000003536 10055172400 030432 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.Collection;
import java.util.Comparator;
import java.util.SortedMap;
import java.util.TreeMap;
/**
* An implementation of {@link Bag} that is backed by a {@link
* TreeMap}. Order will be maintained among the unique representative
* members.
*
* @since 2.0
* @author Chuck Burdick
**/
public class TreeBag extends DefaultMapBag implements SortedBag, Bag {
/**
* Constructs a new empty
*
* It contains various typesafe methods
* as well as other useful features like deep copying.
*
* It also provides the following decorators:
*
*
*
* Any value that is not a {@link Boolean}, {@link String} or
* {@link Number} results in null being returned.
*
* @param map the map whose value to look up
* @param key the key whose value to look up in that map
* @return a {@link Boolean} or null
*/
public static Boolean getBoolean( Map map, Object key ) {
if ( map != null ) {
Object answer = map.get( key );
if ( answer != null ) {
if ( answer instanceof Boolean ) {
return (Boolean) answer;
}
else
if ( answer instanceof String ) {
return new Boolean( (String) answer );
}
else
if ( answer instanceof Number ) {
Number n = (Number) answer;
return ( n.intValue() != 0 ) ? Boolean.TRUE : Boolean.FALSE;
}
}
}
return null;
}
/**
* Looks up the given key in the given map, converting the result into
* a {@link Number}. If the map is null, this method returns null.
* Otherwise, if the key maps to a {@link Number}, then that number
* is returned as-is. Otherwise, if the key maps to a {@link String},
* that string is parsed into a number using the system default
* {@link NumberFormat}.
*
* If the value is not a {@link Number} or a {@link String}, or if
* the value is a {@link String} that cannot be parsed into a
* {@link Number}, then null is returned.
*
* @param map the map whose value to look up
* @param key the key whose value to look up in that map
* @return a {@link Number} or null
*/
public static Number getNumber( Map map, Object key ) {
if ( map != null ) {
Object answer = map.get( key );
if ( answer != null ) {
if ( answer instanceof Number ) {
return (Number) answer;
}
else
if ( answer instanceof String ) {
try {
String text = (String) answer;
return NumberFormat.getInstance().parse( text );
}
catch (ParseException e) {
logInfo( e );
}
}
}
}
return null;
}
/**
* Looks up the given key in the given map, converting the result into
* a {@link Byte}. First, {@link #getNumber(Map,Object)} is invoked.
* If the result is null, then null is returned. Otherwise, the
* byte value of the resulting {@link Number} is returned.
*
* @param map the map whose value to look up
* @param key the key whose value to look up in that map
* @return a {@link Byte} or null
*/
public static Byte getByte( Map map, Object key ) {
Number answer = getNumber( map, key );
if ( answer == null ) {
return null;
}
else
if ( answer instanceof Byte ) {
return (Byte) answer;
}
return new Byte( answer.byteValue() );
}
/**
* Looks up the given key in the given map, converting the result into
* a {@link Short}. First, {@link #getNumber(Map,Object)} is invoked.
* If the result is null, then null is returned. Otherwise, the
* short value of the resulting {@link Number} is returned.
*
* @param map the map whose value to look up
* @param key the key whose value to look up in that map
* @return a {@link Short} or null
*/
public static Short getShort( Map map, Object key ) {
Number answer = getNumber( map, key );
if ( answer == null ) {
return null;
}
else
if ( answer instanceof Short ) {
return (Short) answer;
}
return new Short( answer.shortValue() );
}
/**
* Looks up the given key in the given map, converting the result into
* an {@link Integer}. First, {@link #getNumber(Map,Object)} is invoked.
* If the result is null, then null is returned. Otherwise, the
* integer value of the resulting {@link Number} is returned.
*
* @param map the map whose value to look up
* @param key the key whose value to look up in that map
* @return an {@link Integer} or null
*/
public static Integer getInteger( Map map, Object key ) {
Number answer = getNumber( map, key );
if ( answer == null ) {
return null;
}
else
if ( answer instanceof Integer ) {
return (Integer) answer;
}
return new Integer( answer.intValue() );
}
/**
* Looks up the given key in the given map, converting the result into
* a {@link Long}. First, {@link #getNumber(Map,Object)} is invoked.
* If the result is null, then null is returned. Otherwise, the
* long value of the resulting {@link Number} is returned.
*
* @param map the map whose value to look up
* @param key the key whose value to look up in that map
* @return a {@link Long} or null
*/
public static Long getLong( Map map, Object key ) {
Number answer = getNumber( map, key );
if ( answer == null ) {
return null;
}
else
if ( answer instanceof Long ) {
return (Long) answer;
}
return new Long( answer.longValue() );
}
/**
* Looks up the given key in the given map, converting the result into
* a {@link Float}. First, {@link #getNumber(Map,Object)} is invoked.
* If the result is null, then null is returned. Otherwise, the
* float value of the resulting {@link Number} is returned.
*
* @param map the map whose value to look up
* @param key the key whose value to look up in that map
* @return a {@link Float} or null
*/
public static Float getFloat( Map map, Object key ) {
Number answer = getNumber( map, key );
if ( answer == null ) {
return null;
}
else
if ( answer instanceof Float ) {
return (Float) answer;
}
return new Float( answer.floatValue() );
}
/**
* Looks up the given key in the given map, converting the result into
* a {@link Double}. First, {@link #getNumber(Map,Object)} is invoked.
* If the result is null, then null is returned. Otherwise, the
* double value of the resulting {@link Number} is returned.
*
* @param map the map whose value to look up
* @param key the key whose value to look up in that map
* @return a {@link Double} or null
*/
public static Double getDouble( Map map, Object key ) {
Number answer = getNumber( map, key );
if ( answer == null ) {
return null;
}
else
if ( answer instanceof Double ) {
return (Double) answer;
}
return new Double( answer.doubleValue() );
}
/**
* Looks up the given key in the given map, returning another map.
* If the given map is null or if the given key doesn't map to another
* map, then this method returns null. Otherwise the mapped map is
* returned.
*
* @param map the map whose value to look up
* @param key the key whose value to look up in that map
* @return a {@link Map} or null
*/
public static Map getMap( Map map, Object key ) {
if ( map != null ) {
Object answer = map.get( key );
if ( answer != null && answer instanceof Map ) {
return (Map) answer;
}
}
return null;
}
// Type safe getters with default values
//-------------------------------------------------------------------------
/**
* Looks up the given key in the given map, converting null into the
* given default value.
*
* @param map the map whose value to look up
* @param key the key of the value to look up in that map
* @param defaultValue what to return if the value is null
* @return the value in the map, or defaultValue if the original value
* is null or the map is null
*/
public static Object getObject( Map map, Object key, Object defaultValue ) {
if ( map != null ) {
Object answer = map.get( key );
if ( answer != null ) {
return answer;
}
}
return defaultValue;
}
/**
* Looks up the given key in the given map, converting the result into
* a string, using the default value if the the conversion fails.
*
* @param map the map whose value to look up
* @param key the key of the value to look up in that map
* @param defaultValue what to return if the value is null or if the
* conversion fails
* @return the value in the map as a string, or defaultValue if the
* original value is null, the map is null or the string conversion
* fails
*/
public static String getString( Map map, Object key, String defaultValue ) {
String answer = getString( map, key );
if ( answer == null ) {
answer = defaultValue;
}
return answer;
}
/**
* Looks up the given key in the given map, converting the result into
* a boolean, using the default value if the the conversion fails.
*
* @param map the map whose value to look up
* @param key the key of the value to look up in that map
* @param defaultValue what to return if the value is null or if the
* conversion fails
* @return the value in the map as a boolean, or defaultValue if the
* original value is null, the map is null or the boolean conversion
* fails
*/
public static Boolean getBoolean( Map map, Object key, Boolean defaultValue ) {
Boolean answer = getBoolean( map, key );
if ( answer == null ) {
answer = defaultValue;
}
return answer;
}
/**
* Looks up the given key in the given map, converting the result into
* a number, using the default value if the the conversion fails.
*
* @param map the map whose value to look up
* @param key the key of the value to look up in that map
* @param defaultValue what to return if the value is null or if the
* conversion fails
* @return the value in the map as a number, or defaultValue if the
* original value is null, the map is null or the number conversion
* fails
*/
public static Number getNumber( Map map, Object key, Number defaultValue ) {
Number answer = getNumber( map, key );
if ( answer == null ) {
answer = defaultValue;
}
return answer;
}
/**
* Looks up the given key in the given map, converting the result into
* a byte, using the default value if the the conversion fails.
*
* @param map the map whose value to look up
* @param key the key of the value to look up in that map
* @param defaultValue what to return if the value is null or if the
* conversion fails
* @return the value in the map as a number, or defaultValue if the
* original value is null, the map is null or the number conversion
* fails
*/
public static Byte getByte( Map map, Object key, Byte defaultValue ) {
Byte answer = getByte( map, key );
if ( answer == null ) {
answer = defaultValue;
}
return answer;
}
/**
* Looks up the given key in the given map, converting the result into
* a short, using the default value if the the conversion fails.
*
* @param map the map whose value to look up
* @param key the key of the value to look up in that map
* @param defaultValue what to return if the value is null or if the
* conversion fails
* @return the value in the map as a number, or defaultValue if the
* original value is null, the map is null or the number conversion
* fails
*/
public static Short getShort( Map map, Object key, Short defaultValue ) {
Short answer = getShort( map, key );
if ( answer == null ) {
answer = defaultValue;
}
return answer;
}
/**
* Looks up the given key in the given map, converting the result into
* an integer, using the default value if the the conversion fails.
*
* @param map the map whose value to look up
* @param key the key of the value to look up in that map
* @param defaultValue what to return if the value is null or if the
* conversion fails
* @return the value in the map as a number, or defaultValue if the
* original value is null, the map is null or the number conversion
* fails
*/
public static Integer getInteger( Map map, Object key, Integer defaultValue ) {
Integer answer = getInteger( map, key );
if ( answer == null ) {
answer = defaultValue;
}
return answer;
}
/**
* Looks up the given key in the given map, converting the result into
* a long, using the default value if the the conversion fails.
*
* @param map the map whose value to look up
* @param key the key of the value to look up in that map
* @param defaultValue what to return if the value is null or if the
* conversion fails
* @return the value in the map as a number, or defaultValue if the
* original value is null, the map is null or the number conversion
* fails
*/
public static Long getLong( Map map, Object key, Long defaultValue ) {
Long answer = getLong( map, key );
if ( answer == null ) {
answer = defaultValue;
}
return answer;
}
/**
* Looks up the given key in the given map, converting the result into
* a float, using the default value if the the conversion fails.
*
* @param map the map whose value to look up
* @param key the key of the value to look up in that map
* @param defaultValue what to return if the value is null or if the
* conversion fails
* @return the value in the map as a number, or defaultValue if the
* original value is null, the map is null or the number conversion
* fails
*/
public static Float getFloat( Map map, Object key, Float defaultValue ) {
Float answer = getFloat( map, key );
if ( answer == null ) {
answer = defaultValue;
}
return answer;
}
/**
* Looks up the given key in the given map, converting the result into
* a double, using the default value if the the conversion fails.
*
* @param map the map whose value to look up
* @param key the key of the value to look up in that map
* @param defaultValue what to return if the value is null or if the
* conversion fails
* @return the value in the map as a number, or defaultValue if the
* original value is null, the map is null or the number conversion
* fails
*/
public static Double getDouble( Map map, Object key, Double defaultValue ) {
Double answer = getDouble( map, key );
if ( answer == null ) {
answer = defaultValue;
}
return answer;
}
/**
* Looks up the given key in the given map, converting the result into
* a map, using the default value if the the conversion fails.
*
* @param map the map whose value to look up
* @param key the key of the value to look up in that map
* @param defaultValue what to return if the value is null or if the
* conversion fails
* @return the value in the map as a number, or defaultValue if the
* original value is null, the map is null or the map conversion
* fails
*/
public static Map getMap( Map map, Object key, Map defaultValue ) {
Map answer = getMap( map, key );
if ( answer == null ) {
answer = defaultValue;
}
return answer;
}
// Conversion methods
//-------------------------------------------------------------------------
/**
* Gets a new Properties object initialised with the values from a Map.
* A null input will return an empty properties object.
*
* @param map the map to convert to a Properties object
* @return the properties object
*/
public static Properties toProperties(Map map) {
Properties answer = new Properties();
if (map != null) {
for (Iterator iter = map.entrySet().iterator(); iter.hasNext();) {
Map.Entry entry = (Map.Entry) iter.next();
Object key = entry.getKey();
Object value = entry.getValue();
answer.put(key, value);
}
}
return answer;
}
// Printing methods
//-------------------------------------------------------------------------
/**
* Prints the given map with nice line breaks.
*
* @param out the stream to print to
* @param key the key that maps to the map in some other map
* @param map the map to print
*/
public static synchronized void verbosePrint( PrintStream out, Object key, Map map ) {
debugPrintIndent( out );
out.println( key + " = " );
debugPrintIndent( out );
out.println( "{" );
++debugIndent;
for ( Iterator iter = map.entrySet().iterator(); iter.hasNext(); ) {
Map.Entry entry = (Map.Entry) iter.next();
String childKey = (String) entry.getKey();
Object childValue = entry.getValue();
if ( childValue instanceof Map ) {
verbosePrint( out, childKey, (Map) childValue );
}
else {
debugPrintIndent( out );
out.println( childKey + " = " + childValue);
}
}
--debugIndent;
debugPrintIndent( out );
out.println( "}" );
}
/**
* Prints the given map with nice line breaks.
*
* @param out the stream to print to
* @param key the key that maps to the map in some other map
* @param map the map to print
*/
public static synchronized void debugPrint( PrintStream out, Object key, Map map ) {
debugPrintIndent( out );
out.println( key + " = " );
debugPrintIndent( out );
out.println( "{" );
++debugIndent;
for ( Iterator iter = map.entrySet().iterator(); iter.hasNext(); ) {
Map.Entry entry = (Map.Entry) iter.next();
String childKey = (String) entry.getKey();
Object childValue = entry.getValue();
if ( childValue instanceof Map ) {
verbosePrint( out, childKey, (Map) childValue );
}
else {
debugPrintIndent( out );
String typeName = ( childValue != null )
? childValue.getClass().getName()
: null;
out.println( childKey + " = " + childValue + " class: " + typeName );
}
}
--debugIndent;
debugPrintIndent( out );
out.println( "}" );
}
// Implementation methods
//-------------------------------------------------------------------------
/**
* Writes indentation to the given stream.
*
* @param out the stream to indent
*/
protected static void debugPrintIndent( PrintStream out ) {
for ( int i = 0; i < debugIndent; i++ ) {
out.print( " " );
}
}
/**
* Logs the given exception to
*
* 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.
*
* For instance:
*
*
* 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.
*
* For instance:
*
* A customized implementation of When first created, objects of this class default to "slow" mode, where
* all accesses of any type are synchronized but no cloning takes place. This
* is appropriate for initially populating the collection, followed by a switch
* to "fast" mode (by calling NOTE: If you are creating and accessing a
* NOTE: This class is not cross-platform.
* Using it may cause unexpected failures on some architectures.
* It suffers from the same problems as the double-checked locking idiom.
* In particular, the instruction that clones the internal collection and the
* instruction that sets the internal reference to the clone can be executed
* or perceived out-of-order. This means that any read operation might fail
* unexpectedly, as it may be reading the state of the internal collection
* before the internal collection is fully formed.
* For more information on the double-checked locking idiom, see the
*
* Double-Checked Locking Idiom Is Broken Declartion. A customized implementation of When first created, objects of this class default to "slow" mode, where
* all accesses of any type are synchronized but no cloning takes place. This
* is appropriate for initially populating the collection, followed by a switch
* to "fast" mode (by calling NOTE: If you are creating and accessing a
* NOTE: This class is not cross-platform.
* Using it may cause unexpected failures on some architectures.
* It suffers from the same problems as the double-checked locking idiom.
* In particular, the instruction that clones the internal collection and the
* instruction that sets the internal reference to the clone can be executed
* or perceived out-of-order. This means that any read operation might fail
* unexpectedly, as it may be reading the state of the internal collection
* before the internal collection is fully formed.
* For more information on the double-checked locking idiom, see the
*
* Double-Checked Locking Idiom Is Broken Declartion.
Java Collections Framework extensions.
See also the java.util package.
* To use, simply extend this class, and implement
* the {@link #makeList} method.
*
* If your {@link List} fails one of these tests by design,
* you may still use this base set of cases. Simply override the
* test case (method) your {@link List} fails.
*
* @author Rodney Waldhoff
* @author Paul Jack
* @version $Id: TestList.java,v 1.13.2.1 2004/05/22 12:14:05 scolebourne Exp $
*/
public abstract class TestList extends TestCollection {
public TestList(String testName) {
super(testName);
}
/**
* Return a new, empty {@link List} to be used for testing.
*
* @return an empty list for testing.
*/
protected abstract List makeEmptyList();
/**
* Return a new, full {@link List} to be used for testing.
*
* @return a full list for testing
*/
protected List makeFullList() {
// only works if list supports optional "addAll(Collection)"
List list = makeEmptyList();
list.addAll(Arrays.asList(getFullElements()));
return list;
}
/**
* Returns {@link makeEmptyList()}.
*
* @return an empty list to be used for testing
*/
final protected Collection makeCollection() {
return makeEmptyList();
}
/**
* Returns {@link makeFullList()}.
*
* @return a full list to be used for testing
*/
final protected Collection makeFullCollection() {
return makeFullList();
}
/**
* Returns the {@link collection} field cast to a {@link List}.
*
* @return the collection field as a List
*/
protected List getList() {
return (List)collection;
}
/**
* Returns the {@link confirmed} field cast to a {@link List}.
*
* @return the confirmed field as a List
*/
protected List getConfirmedList() {
return (List)confirmed;
}
/**
* Tests bounds checking for {@link List#add(int, Object)} on an
* empty list.
*/
public void testListAddByIndexBoundsChecking() {
if (!isAddSupported()) return;
List list = makeEmptyList();
Object element = getOtherElements()[0];
try {
list.add(Integer.MIN_VALUE, element);
fail("List.add should throw IndexOutOfBoundsException " +
"[Integer.MIN_VALUE]");
} catch(IndexOutOfBoundsException e) {
// expected
}
try {
list.add(-1, element);
fail("List.add should throw IndexOutOfBoundsException [-1]");
} catch(IndexOutOfBoundsException e) {
// expected
}
try {
list.add(1, element);
fail("List.add should throw IndexOutOfBoundsException [1]");
} catch(IndexOutOfBoundsException e) {
// expected
}
try {
list.add(Integer.MAX_VALUE, element);
fail("List.add should throw IndexOutOfBoundsException " +
"[Integer.MAX_VALUE]");
} catch(IndexOutOfBoundsException e) {
// expected
}
}
/**
* Tests bounds checking for {@link List#add(int, Object)} on a
* full list.
*/
public void testListAddByIndexBoundsChecking2() {
if (!isAddSupported()) return;
List list = makeFullList();
Object element = getOtherElements()[0];
try {
list.add(Integer.MIN_VALUE, element);
fail("List.add should throw IndexOutOfBoundsException " +
"[Integer.MIN_VALUE]");
} catch(IndexOutOfBoundsException e) {
// expected
}
try {
list.add(-1, element);
fail("List.add should throw IndexOutOfBoundsException [-1]");
} catch(IndexOutOfBoundsException e) {
// expected
}
try {
list.add(list.size() + 1, element);
fail("List.add should throw IndexOutOfBoundsException [size + 1]");
} catch(IndexOutOfBoundsException e) {
// expected
}
try {
list.add(Integer.MAX_VALUE, element);
fail("List.add should throw IndexOutOfBoundsException " +
"[Integer.MAX_VALUE]");
} catch(IndexOutOfBoundsException e) {
// expected
}
}
/**
* Tests {@link List#add(int,Object)}.
*/
public void testListAddByIndex() {
if (!isAddSupported()) return;
Object element = getOtherElements()[0];
int max = getFullElements().length;
for (int i = 0; i <= max; i++) {
resetFull();
((List)collection).add(i, element);
((List)confirmed).add(i, element);
verify();
}
}
/**
* Tests {@link List#equals(Object)}.
*/
public void testListEquals() {
resetEmpty();
List list = getList();
assertTrue("Empty lists should be equal", list.equals(confirmed));
verify();
assertTrue("Empty list should equal self", list.equals(list));
verify();
List list2 = Arrays.asList(getFullElements());
assertTrue("Empty list shouldn't equal full", !list.equals(list2));
verify();
list2 = Arrays.asList(getOtherElements());
assertTrue("Empty list shouldn't equal other", !list.equals(list2));
verify();
resetFull();
list = getList();
assertTrue("Full lists should be equal", list.equals(confirmed));
verify();
assertTrue("Full list should equal self", list.equals(list));
verify();
list2 = makeEmptyList();
assertTrue("Full list shouldn't equal empty", !list.equals(list2));
verify();
list2 = Arrays.asList(getOtherElements());
assertTrue("Full list shouldn't equal other", !list.equals(list2));
verify();
list2 = Arrays.asList(getFullElements());
Collections.reverse(list2);
assertTrue("Full list shouldn't equal full list with same elements" +
" but different order", !list.equals(list2));
verify();
assertTrue("List shouldn't equal String", !list.equals(""));
verify();
final List listForC = Arrays.asList(getFullElements());
Collection c = new AbstractCollection() {
public int size() {
return listForC.size();
}
public Iterator iterator() {
return listForC.iterator();
}
};
assertTrue("List shouldn't equal nonlist with same elements " +
" in same order", !list.equals(c));
verify();
}
/**
* Tests {@link List#hashCode()}.
*/
public void testListHashCode() {
resetEmpty();
int hash1 = collection.hashCode();
int hash2 = confirmed.hashCode();
assertEquals("Empty lists should have equal hashCodes", hash1, hash2);
verify();
resetFull();
hash1 = collection.hashCode();
hash2 = confirmed.hashCode();
assertEquals("Full lists should have equal hashCodes", hash1, hash2);
verify();
}
/**
* Tests {@link List#get(int)}.
*/
public void testListGetByIndex() {
resetFull();
List list = getList();
Object[] elements = getFullElements();
for (int i = 0; i < elements.length; i++) {
assertEquals("List should contain correct elements",
elements[i], list.get(i));
verify();
}
}
/**
* Tests bounds checking for {@link List#get(int)} on an
* empty list.
*/
public void testListGetByIndexBoundsChecking() {
List list = makeEmptyList();
try {
list.get(Integer.MIN_VALUE);
fail("List.get should throw IndexOutOfBoundsException " +
"[Integer.MIN_VALUE]");
} catch(IndexOutOfBoundsException e) {
// expected
}
try {
list.get(-1);
fail("List.get should throw IndexOutOfBoundsException [-1]");
} catch(IndexOutOfBoundsException e) {
// expected
}
try {
list.get(0);
fail("List.get should throw IndexOutOfBoundsException [0]");
} catch(IndexOutOfBoundsException e) {
// expected
}
try {
list.get(1);
fail("List.get should throw IndexOutOfBoundsException [1]");
} catch(IndexOutOfBoundsException e) {
// expected
}
try {
list.get(Integer.MAX_VALUE);
fail("List.get should throw IndexOutOfBoundsException " +
"[Integer.MAX_VALUE]");
} catch(IndexOutOfBoundsException e) {
// expected
}
}
/**
* Tests bounds checking for {@link List#get(int)} on a
* full list.
*/
public void testListGetByIndexBoundsChecking2() {
List list = makeFullList();
try {
list.get(Integer.MIN_VALUE);
fail("List.get should throw IndexOutOfBoundsException " +
"[Integer.MIN_VALUE]");
} catch(IndexOutOfBoundsException e) {
// expected
}
try {
list.get(-1);
fail("List.get should throw IndexOutOfBoundsException [-1]");
} catch(IndexOutOfBoundsException e) {
// expected
}
try {
list.get(getFullElements().length);
fail("List.get should throw IndexOutOfBoundsException [size]");
} catch(IndexOutOfBoundsException e) {
// expected
}
try {
list.get(Integer.MAX_VALUE);
fail("List.get should throw IndexOutOfBoundsException " +
"[Integer.MAX_VALUE]");
} catch(IndexOutOfBoundsException e) {
// expected
}
}
/**
* Tests {@link List#indexOf()}.
*/
public void testListIndexOf() {
resetFull();
List list1 = getList();
List list2 = getConfirmedList();
Iterator iterator = list2.iterator();
while (iterator.hasNext()) {
Object element = iterator.next();
assertEquals("indexOf should return correct result",
list1.indexOf(element), list2.indexOf(element));
verify();
}
Object[] other = getOtherElements();
for (int i = 0; i < other.length; i++) {
assertEquals("indexOf should return -1 for nonexistent element",
list1.indexOf(other[i]), -1);
verify();
}
}
/**
* Tests {@link List#lastIndexOf()}.
*/
public void testListLastIndexOf() {
resetFull();
List list1 = getList();
List list2 = getConfirmedList();
Iterator iterator = list2.iterator();
while (iterator.hasNext()) {
Object element = iterator.next();
assertEquals("lastIndexOf should return correct result",
list1.lastIndexOf(element), list2.lastIndexOf(element));
verify();
}
Object[] other = getOtherElements();
for (int i = 0; i < other.length; i++) {
assertEquals("lastIndexOf should return -1 for nonexistent " +
"element", list1.lastIndexOf(other[i]), -1);
verify();
}
}
/**
* Tests bounds checking for {@link List#set(int,Object)} on an
* empty list.
*/
public void testListSetByIndexBoundsChecking() {
List list = makeEmptyList();
Object element = getOtherElements()[0];
try {
list.set(Integer.MIN_VALUE, element);
fail("List.set should throw IndexOutOfBoundsException " +
"[Integer.MIN_VALUE]");
} catch(IndexOutOfBoundsException e) {
// expected
}
try {
list.set(-1, element);
fail("List.set should throw IndexOutOfBoundsException [-1]");
} catch(IndexOutOfBoundsException e) {
// expected
}
try {
list.set(0, element);
fail("List.set should throw IndexOutOfBoundsException [0]");
} catch(IndexOutOfBoundsException e) {
// expected
}
try {
list.set(1, element);
fail("List.set should throw IndexOutOfBoundsException [1]");
} catch(IndexOutOfBoundsException e) {
// expected
}
try {
list.set(Integer.MAX_VALUE, element);
fail("List.set should throw IndexOutOfBoundsException " +
"[Integer.MAX_VALUE]");
} catch(IndexOutOfBoundsException e) {
// expected
}
}
/**
* Tests bounds checking for {@link List#set(int,Object)} on a
* full list.
*/
public void testListSetByIndexBoundsChecking2() {
List list = makeFullList();
Object element = getOtherElements()[0];
try {
list.set(Integer.MIN_VALUE, element);
fail("List.set should throw IndexOutOfBoundsException " +
"[Integer.MIN_VALUE]");
} catch(IndexOutOfBoundsException e) {
// expected
}
try {
list.set(-1, element);
fail("List.set should throw IndexOutOfBoundsException [-1]");
} catch(IndexOutOfBoundsException e) {
// expected
}
try {
list.set(getFullElements().length, element);
fail("List.set should throw IndexOutOfBoundsException [size]");
} catch(IndexOutOfBoundsException e) {
// expected
}
try {
list.set(Integer.MAX_VALUE, element);
fail("List.set should throw IndexOutOfBoundsException " +
"[Integer.MAX_VALUE]");
} catch(IndexOutOfBoundsException e) {
// expected
}
}
/**
* Test {@link List#set(int,Object)}.
*/
public void testListSetByIndex() {
resetFull();
Object[] elements = getFullElements();
Object[] other = getOtherElements();
for (int i = 0; i < elements.length; i++) {
Object n = other[i % other.length];
Object v = ((List)collection).set(i, n);
assertEquals("Set should return correct element", elements[i], v);
((List)confirmed).set(i, n);
verify();
}
}
/**
* Tests bounds checking for {@link List#remove(int)} on an
* empty list.
*/
public void testListRemoveByIndexBoundsChecking() {
if (!isRemoveSupported()) return;
List list = makeEmptyList();
try {
list.remove(Integer.MIN_VALUE);
fail("List.remove should throw IndexOutOfBoundsException " +
"[Integer.MIN_VALUE]");
} catch(IndexOutOfBoundsException e) {
// expected
}
try {
list.remove(-1);
fail("List.remove should throw IndexOutOfBoundsException [-1]");
} catch(IndexOutOfBoundsException e) {
// expected
}
try {
list.remove(0);
fail("List.remove should throw IndexOutOfBoundsException [0]");
} catch(IndexOutOfBoundsException e) {
// expected
}
try {
list.remove(1);
fail("List.remove should throw IndexOutOfBoundsException [1]");
} catch(IndexOutOfBoundsException e) {
// expected
}
try {
list.remove(Integer.MAX_VALUE);
fail("List.remove should throw IndexOutOfBoundsException " +
"[Integer.MAX_VALUE]");
} catch(IndexOutOfBoundsException e) {
// expected
}
}
/**
* Tests bounds checking for {@link List#remove(int)} on a
* full list.
*/
public void testListRemoveByIndexBoundsChecking2() {
if (!isRemoveSupported()) return;
List list = makeFullList();
try {
list.remove(Integer.MIN_VALUE);
fail("List.remove should throw IndexOutOfBoundsException " +
"[Integer.MIN_VALUE]");
} catch(IndexOutOfBoundsException e) {
// expected
}
try {
list.remove(-1);
fail("List.remove should throw IndexOutOfBoundsException [-1]");
} catch(IndexOutOfBoundsException e) {
// expected
}
try {
list.remove(getFullElements().length);
fail("List.remove should throw IndexOutOfBoundsException [size]");
} catch(IndexOutOfBoundsException e) {
// expected
}
try {
list.remove(Integer.MAX_VALUE);
fail("List.remove should throw IndexOutOfBoundsException " +
"[Integer.MAX_VALUE]");
} catch(IndexOutOfBoundsException e) {
// expected
}
}
/**
* Tests {@link List#remove(int)}.
*/
public void testListRemoveByIndex() {
if (!isRemoveSupported()) return;
int max = getFullElements().length;
for (int i = 0; i < max; i++) {
resetFull();
Object o1 = ((List)collection).remove(i);
Object o2 = ((List)confirmed).remove(i);
assertEquals("remove should return correct element", o1, o2);
verify();
}
}
/**
* Tests the read-only bits of {@link List#listIterator()}.
*/
public void testListListIterator() {
resetFull();
forwardTest(getList().listIterator(), 0);
backwardTest(getList().listIterator(), 0);
}
/**
* Tests the read-only bits of {@link List#listIterator(int)}.
*/
public void testListListIteratorByIndex() {
resetFull();
for (int i = 0; i < confirmed.size(); i++) {
forwardTest(getList().listIterator(i), i);
backwardTest(getList().listIterator(i), i);
}
}
/**
* Traverses to the end of the given iterator.
*
* @param iter the iterator to traverse
* @param i the starting index
*/
private void forwardTest(ListIterator iter, int i) {
List list = getList();
int max = getFullElements().length;
while (i < max) {
assertTrue("Iterator should have next", iter.hasNext());
assertEquals("Iterator.nextIndex should work",
iter.nextIndex(), i);
assertEquals("Iterator.previousIndex should work",
iter.previousIndex(), i - 1);
Object o = iter.next();
assertEquals("Iterator returned correct element", list.get(i), o);
i++;
}
assertTrue("Iterator shouldn't have next", !iter.hasNext());
assertEquals("nextIndex should be size", iter.nextIndex(), max);
assertEquals("previousIndex should be size - 1",
iter.previousIndex(), max - 1);
try {
iter.next();
fail("Exhausted iterator should raise NoSuchElement");
} catch (NoSuchElementException e) {
// expected
}
}
/**
* Traverses to the beginning of the given iterator.
*
* @param iter the iterator to traverse
* @param i the starting index
*/
private void backwardTest(ListIterator iter, int i) {
List list = getList();
int max = getFullElements().length;
while (i > 0) {
assertTrue("Iterator should have next", iter.hasPrevious());
assertEquals("Iterator.nextIndex should work",
iter.nextIndex(), i);
assertEquals("Iterator.previousIndex should work",
iter.previousIndex(), i - 1);
Object o = iter.previous();
assertEquals("Iterator returned correct element",
list.get(i - 1), o);
i--;
}
assertTrue("Iterator shouldn't have previous", !iter.hasPrevious());
assertEquals("nextIndex should be 0", iter.nextIndex(), 0);
assertEquals("previousIndex should be -1",
iter.previousIndex(), -1);
try {
iter.previous();
fail("Exhausted iterator should raise NoSuchElement");
} catch (NoSuchElementException e) {
// expected
}
}
/**
* Tests the {@link ListIterator#add(Object)} method of the list
* iterator.
*/
public void testListIteratorAdd() {
if (!isAddSupported()) return;
resetEmpty();
List list1 = getList();
List list2 = getConfirmedList();
Object[] elements = getFullElements();
ListIterator iter1 = list1.listIterator();
ListIterator iter2 = list2.listIterator();
for (int i = 0; i < elements.length; i++) {
iter1.add(elements[i]);
iter2.add(elements[i]);
verify();
}
resetFull();
iter1 = getList().listIterator();
iter2 = getConfirmedList().listIterator();
for (int i = 0; i < elements.length; i++) {
iter1.next();
iter2.next();
iter1.add(elements[i]);
iter2.add(elements[i]);
verify();
}
}
/**
* Tests the {@link ListIterator#set(Object)} method of the list
* iterator.
*/
public void testListIteratorSet() {
if (!isAddSupported()) return;
Object[] elements = getFullElements();
resetFull();
ListIterator iter1 = getList().listIterator();
ListIterator iter2 = getConfirmedList().listIterator();
for (int i = 0; i < elements.length; i++) {
iter1.next();
iter2.next();
iter1.set(elements[i]);
iter2.set(elements[i]);
verify();
}
}
public void testEmptyListSerialization()
throws IOException, ClassNotFoundException {
List list = makeEmptyList();
if (!(list instanceof Serializable)) return;
byte[] objekt = writeExternalFormToBytes((Serializable) list);
List list2 = (List) readExternalFormFromBytes(objekt);
assertTrue("Both lists are empty",list.size() == 0);
assertTrue("Both lists are empty",list2.size() == 0);
}
public void testFullListSerialization()
throws IOException, ClassNotFoundException {
List list = makeFullList();
int size = getFullElements().length;
if (!(list instanceof Serializable)) return;
byte[] objekt = writeExternalFormToBytes((Serializable) list);
List list2 = (List) readExternalFormFromBytes(objekt);
assertEquals("Both lists are same size",list.size(), size);
assertEquals("Both lists are same size",list2.size(), size);
}
/**
* Compare the current serialized form of the List
* against the canonical version in CVS.
*/
public void testEmptyListCompatibility() throws IOException, ClassNotFoundException {
/**
* Create canonical objects with this code
List list = makeEmptyList();
if (!(list instanceof Serializable)) return;
writeExternalFormToDisk((Serializable) list, getCanonicalEmptyCollectionName(list));
*/
// test to make sure the canonical form has been preserved
if (!(makeEmptyList() instanceof Serializable)) return;
List list = (List) readExternalFormFromDisk(getCanonicalEmptyCollectionName(makeEmptyList()));
assertTrue("List is empty",list.size() == 0);
}
/**
* Compare the current serialized form of the List
* against the canonical version in CVS.
*/
public void testFullListCompatibility() throws IOException, ClassNotFoundException {
/**
* Create canonical objects with this code
List list = makeFullList();
if (!(list instanceof Serializable)) return;
writeExternalFormToDisk((Serializable) list, getCanonicalFullCollectionName(list));
*/
// test to make sure the canonical form has been preserved
if (!(makeFullList() instanceof Serializable)) return;
List list = (List) readExternalFormFromDisk(getCanonicalFullCollectionName(makeFullList()));
assertEquals("List is the right size",list.size(), 4);
}
/**
* Returns an empty {@link ArrayList}.
*/
protected Collection makeConfirmedCollection() {
ArrayList list = new ArrayList();
return list;
}
/**
* Returns a full {@link ArrayList}.
*/
protected Collection makeConfirmedFullCollection() {
ArrayList list = new ArrayList();
list.addAll(Arrays.asList(getFullElements()));
return list;
}
/**
* Verifies that the test list implementation matches the confirmed list
* implementation.
*/
protected void verify() {
super.verify();
List list1 = getList();
List list2 = getConfirmedList();
assertEquals("List should equal confirmed", list1, list2);
assertEquals("Confirmed should equal list", list2, list1);
assertEquals("Hash codes should be equal",
list1.hashCode(), list2.hashCode());
int i = 0;
Iterator iterator1 = list1.iterator();
Iterator iterator2 = list2.iterator();
Object[] array = list1.toArray();
while (iterator2.hasNext()) {
assertTrue("List iterator should have next", iterator1.hasNext());
Object o1 = iterator1.next();
Object o2 = iterator2.next();
assertEquals("Iterator elements should be equal", o1, o2);
o2 = list1.get(i);
assertEquals("get should return correct element", o1, o2);
o2 = array[i];
assertEquals("toArray should have correct element", o1, o2);
i++;
}
}
/**
* Returns a {@link BulkTest} for testing {@link List#subList(int,int)}.
* The returned bulk test will run through every
* You should create a concrete subclass of this class to test any custom
* {@link Collection} implementation. At minimum, you'll have to
* implement the {@link #makeCollection()} method. You might want to
* override some of the additional protected methods as well:
*
* Element Population Methods
*
* Override these if your collection restricts what kind of elements are
* allowed (for instance, if
*
* Override these if your collection doesn't support certain operations:
*
*
* Fixtures are used to verify that the the operation results in correct state
* for the collection. Basically, the operation is performed against your
* collection implementation, and an identical operation is performed against a
* confirmed collection implementation. A confirmed collection
* implementation is something like
*
* The {@link #collection} field holds an instance of your collection
* implementation; the {@link #confirmed} field holds an instance of the
* confirmed collection implementation. The {@link #resetEmpty()} and
* {@link #resetFull()} methods set these fields to empty or full collections,
* so that tests can proceed from a known state.
*
* After a modification operation to both {@link #collection} and
* {@link #confirmed}, the {@link #verify()} method is invoked to compare
* the results. You may want to override {@link #verify()} to perform
* additional verifications. For instance, when testing the collection
* views of a map, {@link TestMap} would override {@link #verify()} to make
* sure the map is changed after the collection view is changed.
*
* If you're extending this class directly, you will have to provide
* implementations for the following:
*
*
* If you're extending {@link TestList}, {@link TestSet},
* or {@link TestBag}, you probably don't have to worry about the
* above methods, because those three classes already override the methods
* to provide standard JDK confirmed collections.
*
* Other notes
*
* If your {@link Collection} fails one of these tests by design,
* you may still use this base set of cases. Simply override the
* test case (method) your {@link Collection} fails. For instance, the
* {@link #testIteratorFailFast()} method is provided since most collections
* have fail-fast iterators; however, that's not strictly required by the
* collection contract, so you may want to override that method to do
* nothing.
*
* @author Rodney Waldhoff
* @author Paul Jack
* @author Michael A. Smith
* @version $Id: TestCollection.java,v 1.9.2.1 2004/05/22 12:14:05 scolebourne Exp $
*/
public abstract class TestCollection extends TestObject {
//
// NOTE:
//
// Collection doesn't define any semantics for equals, and recommends you
// use reference-based default behavior of Object.equals. (And a test for
// that already exists in TestObject). Tests for equality of lists, sets
// and bags will have to be written in test subclasses. Thus, there is no
// tests on Collection.equals nor any for Collection.hashCode.
//
// These fields are used by reset() and verify(), and any test
// method that tests a modification.
/**
* A collection instance that will be used for testing.
*/
protected Collection collection;
/**
* Confirmed collection. This is an instance of a collection that is
* confirmed to conform exactly to the java.util.Collection contract.
* Modification operations are tested by performing a mod on your
* collection, performing the exact same mod on an equivalent confirmed
* collection, and then calling verify() to make sure your collection
* still matches the confirmed collection.
*/
protected Collection confirmed;
public TestCollection(String testName) {
super(testName);
}
/**
* Resets the {@link #collection} and {@link #confirmed} fields to empty
* collections. Invoke this method before performing a modification
* test.
*/
protected void resetEmpty() {
this.collection = makeCollection();
this.confirmed = makeConfirmedCollection();
}
/**
* Resets the {@link #collection} and {@link #confirmed} fields to full
* collections. Invoke this method before performing a modification
* test.
*/
protected void resetFull() {
this.collection = makeFullCollection();
this.confirmed = makeConfirmedFullCollection();
}
/**
* Specifies whether equal elements in the collection are, in fact,
* distinguishable with information not readily available. That is, if a
* particular value is to be removed from the collection, then there is
* one and only one value that can be removed, even if there are other
* elements which are equal to it.
*
* In most collection cases, elements are not distinguishable (equal is
* equal), thus this method defaults to return false. In some cases,
* however, they are. For example, the collection returned from the map's
* values() collection view are backed by the map, so while there may be
* two values that are equal, their associated keys are not. Since the
* keys are distinguishable, the values are.
*
* This flag is used to skip some verifications for iterator.remove()
* where it is impossible to perform an equivalent modification on the
* confirmed collection because it is not possible to determine which
* value in the confirmed collection to actually remove. Tests that
* override the default (i.e. where equal elements are distinguishable),
* should provide additional tests on iterator.remove() to make sure the
* proper elements are removed when remove() is called on the iterator.
**/
protected boolean areEqualElementsDistinguishable() {
return false;
}
/**
* Verifies that {@link #collection} and {@link #confirmed} have
* identical state.
*/
protected void verify() {
int confirmedSize = confirmed.size();
assertEquals("Collection size should match confirmed collection's",
confirmedSize, collection.size());
assertEquals("Collection isEmpty() result should match confirmed " +
" collection's",
confirmed.isEmpty(), collection.isEmpty());
// verify the collections are the same by attempting to match each
// object in the collection and confirmed collection. To account for
// duplicates and differing orders, each confirmed element is copied
// into an array and a flag is maintained for each element to determine
// whether it has been matched once and only once. If all elements in
// the confirmed collection are matched once and only once and there
// aren't any elements left to be matched in the collection,
// verification is a success.
// copy each collection value into an array
Object[] confirmedValues = new Object[confirmedSize];
Iterator iter;
iter = confirmed.iterator();
int pos = 0;
while(iter.hasNext()) {
confirmedValues[pos++] = iter.next();
}
// allocate an array of boolean flags for tracking values that have
// been matched once and only once.
boolean[] matched = new boolean[confirmedSize];
// now iterate through the values of the collection and try to match
// the value with one in the confirmed array.
iter = collection.iterator();
while(iter.hasNext()) {
Object o = iter.next();
boolean match = false;
for(int i = 0; i < confirmedSize; i++) {
if(matched[i]) {
// skip values already matched
continue;
}
if(o == confirmedValues[i] ||
(o != null && o.equals(confirmedValues[i]))) {
// values matched
matched[i] = true;
match = true;
break;
}
}
// no match found!
if(!match) {
fail("Collection should not contain a value that the " +
"confirmed collection does not have.");
}
}
// make sure there aren't any unmatched values
for(int i = 0; i < confirmedSize; i++) {
if(!matched[i]) {
// the collection didn't match all the confirmed values
fail("Collection should contain all values that are in the " +
"confirmed collection");
}
}
}
/**
* Returns a confirmed empty collection.
* For instance, an {@link java.util.ArrayList} for lists or a
* {@link java.util.HashSet} for sets.
*
* @return a confirmed empty collection
*/
protected abstract Collection makeConfirmedCollection();
/**
* Returns a confirmed full collection.
* For instance, an {@link java.util.ArrayList} for lists or a
* {@link java.util.HashSet} for sets. The returned collection
* should contain the elements returned by {@link #getFullElements()}.
*
* @return a confirmed full collection
*/
protected abstract Collection makeConfirmedFullCollection();
/**
* Returns true if the collections produced by
* {@link #makeCollection()} and {@link #makeFullCollection()}
* support the
* Default implementation returns true. Override if your collection
* class does not support add or addAll.
*/
protected boolean isAddSupported() {
return true;
}
/**
* Returns true if the collections produced by
* {@link #makeCollection()} and {@link #makeFullCollection()}
* support the
* The default implementation returns a heterogenous array of
* objects with some duplicates and with the null element.
* Override if you require specific testing elements. Note that if you
* override {@link #makeFullCollection()}, you must override
* this method to reflect the contents of a full collection.
*/
protected Object[] getFullElements() {
ArrayList list = new ArrayList();
list.addAll(Arrays.asList(getFullNonNullElements()));
list.add(4, null);
return list.toArray();
}
/**
* Returns an array of elements that are not contained in a
* full collection. Every element in the returned array must
* not exist in a collection returned by {@link #makeFullCollection()}.
* The default implementation returns a heterogenous array of elements
* without null. Note that some of the tests add these elements
* to an empty or full collection, so if your collection restricts
* certain kinds of elements, you should override this method.
*/
protected Object[] getOtherElements() {
return getOtherNonNullElements();
}
/**
* Return a new, empty {@link Collection} to be used for testing.
*/
protected abstract Collection makeCollection();
/**
* Returns a full collection to be used for testing. The collection
* returned by this method should contain every element returned by
* {@link #getFullElements()}. The default implementation, in fact,
* simply invokes
* The forces at work here are similar to those in {@link TestCollection}.
* If your class implements the full Map interface, including optional
* operations, simply extend this class, and implement the {@link
* #makeEmptyMap()} method.
*
* On the other hand, if your map implemenation is wierd, you may have to
* override one or more of the other protected methods. They're described
* below.
*
* Entry Population Methods
*
* Override these methods if your map requires special entries:
*
*
*
* Override these methods if your map doesn't support certain operations:
*
*
*
* For tests on modification operations (puts and removes), fixtures are used
* to verify that that operation results in correct state for the map and its
* collection views. Basically, the modification is performed against your
* map implementation, and an identical modification is performed against
* a confirmed map implementation. A confirmed map implementation is
* something like
*
* The upshot of all that is that any test that modifies the map in
* any way will verify that all of the map's state is still
* correct, including the state of its collection views. So for instance
* if a key is removed by the map's key set's iterator, then the entry set
* is checked to make sure the key/value pair no longer appears.
*
* The {@link #map} field holds an instance of your collection implementation.
* The {@link #entrySet}, {@link #keySet} and {@link #values} fields hold
* that map's collection views. And the {@link #confirmed} field holds
* an instance of the confirmed collection implementation. The
* {@link #resetEmpty()} and {@link #resetFull()} methods set these fields to
* empty or full maps, so that tests can proceed from a known state.
*
* After a modification operation to both {@link #map} and {@link #confirmed},
* the {@link #verify()} method is invoked to compare the results. The {@link
* verify()} method calls separate methods to verify the map and its three
* collection views ({@link verifyMap(), {@link verifyEntrySet()}, {@link
* verifyKeySet()}, and {@link verifyValues()}). You may want to override one
* of the verification methodsto perform additional verifications. For
* instance, {@link TestDoubleOrderedMap} would want override its {@link
* #verifyValues()} method to verify that the values are unique and in
* ascending order.
*
* Other Notes
*
* If your {@link Map} fails one of these tests by design, you may still use
* this base set of cases. Simply override the test case (method) your {@link
* Map} fails and/or the methods that define the assumptions used by the test
* cases. For example, if your map does not allow duplicate values, override
* {@link #useDuplicateValues()} and have it return
*
* @param keys the array of keys
* @param values the array of values
* @return an array of Map.Entry of those keys to those values
*/
private Map.Entry[] makeEntryArray(Object[] keys, Object[] values) {
Map.Entry[] result = new Map.Entry[keys.length];
for (int i = 0; i < keys.length; i++) {
result[i] = new DefaultMapEntry(keys[i], values[i]);
}
return result;
}
/**
* Bulk test {@link Map#entrySet()}. This method runs through all of
* the tests in {@link TestSet}.
* After modification operations, {@link #verify()} is invoked to ensure
* that the map and the other collection views are still valid.
*
* @return a {@link TestSet} instance for testing the map's entry set
*/
public BulkTest bulkTestMapEntrySet() {
return new TestMapEntrySet();
}
class TestMapEntrySet extends TestSet {
public TestMapEntrySet() {
super("");
}
// Have to implement manually; entrySet doesn't support addAll
protected Object[] getFullElements() {
Object[] k = getSampleKeys();
Object[] v = getSampleValues();
return makeEntryArray(k, v);
}
// Have to implement manually; entrySet doesn't support addAll
protected Object[] getOtherElements() {
Object[] k = getOtherKeys();
Object[] v = getOtherValues();
return makeEntryArray(k, v);
}
protected Set makeEmptySet() {
return makeEmptyMap().entrySet();
}
protected Set makeFullSet() {
return makeFullMap().entrySet();
}
protected boolean isAddSupported() {
// Collection views don't support add operations.
return false;
}
protected boolean isRemoveSupported() {
// Entry set should only support remove if map does
return isAddRemoveModifiable();
}
protected void resetFull() {
TestMap.this.resetFull();
collection = map.entrySet();
TestMapEntrySet.this.confirmed = TestMap.this.confirmed.entrySet();
}
protected void resetEmpty() {
TestMap.this.resetEmpty();
collection = map.entrySet();
TestMapEntrySet.this.confirmed = TestMap.this.confirmed.entrySet();
}
protected void verify() {
super.verify();
TestMap.this.verify();
}
}
/**
* Bulk test {@link Map#keySet()}. This method runs through all of
* the tests in {@link TestSet}.
* After modification operations, {@link #verify()} is invoked to ensure
* that the map and the other collection views are still valid.
*
* @return a {@link TestSet} instance for testing the map's key set
*/
public BulkTest bulkTestMapKeySet() {
return new TestMapKeySet();
}
class TestMapKeySet extends TestSet {
public TestMapKeySet() {
super("");
}
protected Object[] getFullElements() {
return getSampleKeys();
}
protected Object[] getOtherElements() {
return getOtherKeys();
}
protected Set makeEmptySet() {
return makeEmptyMap().keySet();
}
protected Set makeFullSet() {
return makeFullMap().keySet();
}
protected boolean isAddSupported() {
return false;
}
protected boolean isRemoveSupported() {
return isAddRemoveModifiable();
}
protected void resetEmpty() {
TestMap.this.resetEmpty();
collection = map.keySet();
TestMapKeySet.this.confirmed = TestMap.this.confirmed.keySet();
}
protected void resetFull() {
TestMap.this.resetFull();
collection = map.keySet();
TestMapKeySet.this.confirmed = TestMap.this.confirmed.keySet();
}
protected void verify() {
super.verify();
TestMap.this.verify();
}
}
/**
* Bulk test {@link Map#values()}. This method runs through all of
* the tests in {@link TestCollection}.
* After modification operations, {@link #verify()} is invoked to ensure
* that the map and the other collection views are still valid.
*
* @return a {@link TestCollection} instance for testing the map's
* values collection
*/
public BulkTest bulkTestMapValues() {
return new TestMapValues();
}
class TestMapValues extends TestCollection {
public TestMapValues() {
super("");
}
protected Object[] getFullElements() {
return getSampleValues();
}
protected Object[] getOtherElements() {
return getOtherValues();
}
protected Collection makeCollection() {
return makeEmptyMap().values();
}
protected Collection makeFullCollection() {
return makeFullMap().values();
}
protected boolean isAddSupported() {
return false;
}
protected boolean isRemoveSupported() {
return isAddRemoveModifiable();
}
protected boolean areEqualElementsDistinguishable() {
// equal values are associated with different keys, so they are
// distinguishable.
return true;
}
protected Collection makeConfirmedCollection() {
// never gets called, reset methods are overridden
return null;
}
protected Collection makeConfirmedFullCollection() {
// never gets called, reset methods are overridden
return null;
}
protected void resetFull() {
TestMap.this.resetFull();
collection = map.values();
TestMapValues.this.confirmed = TestMap.this.confirmed.values();
}
protected void resetEmpty() {
TestMap.this.resetEmpty();
collection = map.values();
TestMapValues.this.confirmed = TestMap.this.confirmed.values();
}
protected void verify() {
super.verify();
TestMap.this.verify();
}
// TODO: should test that a remove on the values collection view
// removes the proper mapping and not just any mapping that may have
// the value equal to the value returned from the values iterator.
}
/**
* Resets the {@link #map}, {@link #entrySet}, {@link #keySet},
* {@link #values} and {@link #confirmed} fields to empty.
*/
protected void resetEmpty() {
this.map = makeEmptyMap();
views();
this.confirmed = new HashMap();
}
/**
* Resets the {@link #map}, {@link #entrySet}, {@link #keySet},
* {@link #values} and {@link #confirmed} fields to full.
*/
protected void resetFull() {
this.map = makeFullMap();
views();
this.confirmed = new HashMap();
Object[] k = getSampleKeys();
Object[] v = getSampleValues();
for (int i = 0; i < k.length; i++) {
confirmed.put(k[i], v[i]);
}
}
/**
* Resets the collection view fields.
*/
private void views() {
this.keySet = map.keySet();
this.values = map.values();
this.entrySet = map.entrySet();
}
/**
* Verifies that {@link #map} is still equal to {@link #confirmed}.
* This method checks that the map is equal to the HashMap,
* and that the map's collection views are still equal to
* the HashMap's collection views. An
* To use, simply extend this class, and implement
* the {@link #makeObject()} method.
*
* If your {@link Object} fails one of these tests by design,
* you may still use this base set of cases. Simply override the
* test case (method) your {@link Object} fails.
*
* @author Rodney Waldhoff
* @version $Id: TestObject.java,v 1.13.2.1 2004/05/22 12:14:05 scolebourne Exp $
*/
public abstract class TestObject extends BulkTest {
public TestObject(String testName) {
super(testName);
}
// current major release for Collections
public static final int COLLECTIONS_MAJOR_VERSION = 2;
/**
* This constant makes it possible for TestMap (and other subclasses,
* if necessary) to automatically check CVS for a versionX copy of a
* Serialized object, so we can make sure that compatibility is maintained.
* See, for example, TestMap.getCanonicalFullMapName(Map map).
* Subclasses can override this variable, indicating compatibility
* with earlier Collections versions.
* Defaults to 1, the earliest Collections version. (Note: some
* collections did not even exist in this version).
*
* @return 1
*/
public int getCompatibilityVersion() {
return 1;
}
/**
* Return a new, empty {@link Object} to used for testing.
*/
public abstract Object makeObject();
public void testObjectEqualsSelf() {
Object obj = makeObject();
assertEquals("A Object should equal itself",obj,obj);
}
public void testObjectHashCodeEqualsSelfHashCode() {
Object obj = makeObject();
assertEquals("hashCode should be repeatable",obj.hashCode(),obj.hashCode());
}
public void testObjectHashCodeEqualsContract() {
Object obj1 = makeObject();
if(obj1.equals(obj1)) {
assertEquals("[1] When two objects are equal, their hashCodes should be also.",obj1.hashCode(),obj1.hashCode());
}
Object obj2 = makeObject();
if(obj1.equals(obj2)) {
assertEquals("[2] When two objects are equal, their hashCodes should be also.",obj1.hashCode(),obj2.hashCode());
assertTrue("When obj1.equals(obj2) is true, then obj2.equals(obj1) should also be true", obj2.equals(obj1));
}
}
private void writeExternalFormToStream(Serializable o, OutputStream stream)
throws IOException {
ObjectOutputStream oStream = new ObjectOutputStream(stream);
oStream.writeObject(o);
}
/**
* Write a Serializable or Externalizable object as
* a file at the given path. NOT USEFUL as part
* of a unit test; this is just a utility method
* for creating disk-based objects in CVS that can become
* the basis for compatibility tests using
* readExternalFormFromDisk(String path)
*
* @param o Object to serialize
* @param path path to write the serialized Object
* @exception IOException
*/
protected void writeExternalFormToDisk(Serializable o, String path)
throws IOException {
FileOutputStream fileStream = new FileOutputStream(path);
writeExternalFormToStream(o,fileStream);
}
/**
* Converts a Serializable or Externalizable object to
* bytes. Useful for in-memory tests of serialization
*
* @param o Object to convert to bytes
* @return serialized form of the Object
* @exception IOException
*/
protected byte[] writeExternalFormToBytes(Serializable o)
throws IOException {
ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
writeExternalFormToStream(o,byteStream);
return byteStream.toByteArray();
}
private Object readExternalFormFromStream(InputStream stream)
throws IOException, ClassNotFoundException {
ObjectInputStream oStream = new ObjectInputStream(stream);
return oStream.readObject();
}
/**
* Reads a Serialized or Externalized Object from disk.
* Useful for creating compatibility tests betweeen
* different CVS versions of the same class
*
* @param path path to the serialized Object
* @return the Object at the given path
* @exception IOException
* @exception ClassNotFoundException
*/
protected Object readExternalFormFromDisk(String path)
throws IOException, ClassNotFoundException {
FileInputStream stream = new FileInputStream(path);
return readExternalFormFromStream(stream);
}
/**
* Read a Serialized or Externalized Object from bytes.
* Useful for verifying serialization in memory.
*
* @param b byte array containing a serialized Object
* @return Object contained in the bytes
* @exception IOException
* @exception ClassNotFoundException
*/
protected Object readExternalFormFromBytes(byte[] b)
throws IOException, ClassNotFoundException {
ByteArrayInputStream stream = new ByteArrayInputStream(b);
return readExternalFormFromStream(stream);
}
/**
* Sanity check method, makes sure that any Serializable
* class can be serialized and de-serialized in memory,
* using the handy makeObject() method
*
* @exception IOException
* @exception ClassNotFoundException
*/
public void testSimpleSerialization()
throws IOException, ClassNotFoundException {
Object o = makeObject();
if (o instanceof Serializable) {
byte[] objekt = writeExternalFormToBytes((Serializable) o);
Object p = readExternalFormFromBytes(objekt);
}
}
public String getCanonicalEmptyCollectionName(Object object) {
StringBuffer retval = new StringBuffer();
retval.append("data/test/");
String colName = object.getClass().getName();
colName = colName.substring(colName.lastIndexOf(".")+1,colName.length());
retval.append(colName);
retval.append(".emptyCollection.version");
retval.append(getCompatibilityVersion());
retval.append(".obj");
return retval.toString();
}
public String getCanonicalFullCollectionName(Object object) {
StringBuffer retval = new StringBuffer();
retval.append("data/test/");
String colName = object.getClass().getName();
colName = colName.substring(colName.lastIndexOf(".")+1,colName.length());
retval.append(colName);
retval.append(".fullCollection.version");
retval.append(getCompatibilityVersion());
retval.append(".obj");
return retval.toString();
}
/**
* Override this method if a subclass is testing a
* Collections that cannot serialize an "empty" Collection
* (e.g. Comparators have no contents)
*
* @return true
*/
public boolean supportsEmptyCollections() {
return true;
}
/**
* Override this method if a subclass is testing a
* Collections that cannot serialize a "full" Collection
* (e.g. Comparators have no contents)
*
* @return true
*/
public boolean supportsFullCollections() {
return true;
}
/**
* If the test object is serializable, confirm that
* a canonical form exists in CVS
*
*/
public void testCanonicalEmptyCollectionExists() {
if (!supportsEmptyCollections()) {
return;
}
Object object = makeObject();
if (!(object instanceof Serializable)) {
return;
}
String name = getCanonicalEmptyCollectionName(object);
assertTrue("Canonical empty collection is not in CVS",
new File(name).exists());
}
/**
* If the test object is serializable, confirm that
* a canonical form exists in CVS
*
*/
public void testCanonicalFullCollectionExists() {
if (!supportsFullCollections()) {
return;
}
Object object = makeObject();
if (!(object instanceof Serializable)) {
return;
}
String name = getCanonicalFullCollectionName(object);
assertTrue("Canonical full collection is not in CVS",
new File(name).exists());
}
}
libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestTreeMap.java 0100644 0001750 0001750 00000003447 10055172402 031357 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.TreeMap;
/**
* @author Jason van Zyl
* @version $Id: TestTreeMap.java,v 1.6.2.1 2004/05/22 12:14:05 scolebourne Exp $
*/
public abstract class TestTreeMap extends TestMap
{
public TestTreeMap(String testName)
{
super(testName);
}
public static void main(String args[])
{
String[] testCaseName = { TestTreeMap.class.getName() };
junit.textui.TestRunner.main(testCaseName);
}
public boolean useNullKey() {
return false;
}
protected TreeMap map = null;
public void setUp()
{
map = (TreeMap) makeEmptyMap();
}
public void testNewMap()
{
assertTrue("New map is empty", map.isEmpty());
assertEquals("New map has size zero", map.size(), 0);
}
public void testSearch()
{
map.put("first", "First Item");
map.put("second", "Second Item");
assertEquals("Top item is 'Second Item'", map.get("first"), "First Item");
assertEquals("Next Item is 'First Item'", map.get("second"), "Second Item");
}
}
././@LongLink 0000000 0000000 0000000 00000000154 00000000000 011565 L ustar root root libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestUnboundedFifoBuffer.java libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestUnboundedFifoBuf 0100644 0001750 0001750 00000007400 10055172400 032255 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import junit.framework.Test;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
* Test cases for UnboundedFifoBuffer.
*/
public class TestUnboundedFifoBuffer extends TestCollection {
public TestUnboundedFifoBuffer(String n) {
super(n);
}
public static Test suite() {
return BulkTest.makeSuite(TestUnboundedFifoBuffer.class);
}
/**
* Returns an empty UnboundedFifoBuffer with a small capacity.
*
* @return an empty UnboundedFifoBuffer
*/
public Collection makeCollection() {
return new UnboundedFifoBuffer(5);
}
/**
* Returns an empty ArrayList.
*
* @return an empty ArrayList
*/
public Collection makeConfirmedCollection() {
return new ArrayList();
}
/**
* Returns a full ArrayList.
*
* @return a full ArrayList
*/
public Collection makeConfirmedFullCollection() {
Collection c = makeConfirmedCollection();
c.addAll(java.util.Arrays.asList(getFullElements()));
return c;
}
/**
* Overridden because UnboundedFifoBuffer doesn't allow null elements.
*
* @return an array of random elements without the null element
*/
public Object[] getFullElements() {
return getFullNonNullElements();
}
/**
* Overridden because UnboundedFifoBuffer's iterators aren't fail-fast.
*/
public void testCollectionIteratorFailFast() {
}
/**
* Verifies that the ArrayList has the same elements in the same
* sequence as the UnboundedFifoBuffer.
*/
public void verify() {
super.verify();
Iterator iterator1 = collection.iterator();
Iterator iterator2 = confirmed.iterator();
while (iterator2.hasNext()) {
assertTrue(iterator1.hasNext());
Object o1 = iterator1.next();
Object o2 = iterator2.next();
assertEquals(o1, o2);
}
}
/**
* Tests that UnboundedFifoBuffer removes elements in the right order.
*/
public void testUnboundedFifoBufferRemove() {
resetFull();
int size = confirmed.size();
for (int i = 0; i < size; i++) {
Object o1 = ((UnboundedFifoBuffer)collection).remove();
Object o2 = ((ArrayList)confirmed).remove(0);
assertEquals("Removed objects should be equal", o1, o2);
verify();
}
}
/**
* Tests that the constructor correctly throws an exception.
*/
public void testConstructorException1() {
try {
new UnboundedFifoBuffer(0);
} catch (IllegalArgumentException ex) {
return;
}
fail();
}
/**
* Tests that the constructor correctly throws an exception.
*/
public void testConstructorException2() {
try {
new UnboundedFifoBuffer(-20);
} catch (IllegalArgumentException ex) {
return;
}
fail();
}
}
././@LongLink 0000000 0000000 0000000 00000000145 00000000000 011565 L ustar root root libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestMultiHashMap.java libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestMultiHashMap.jav 0100644 0001750 0001750 00000016561 10055172376 032230 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import junit.framework.Test;
import junit.framework.TestSuite;
/**
* Unit Tests for
* To use, simply extend this class, and implement
* the {@link #makeBag} method.
*
* If your {@link Bag} fails one of these tests by design,
* you may still use this base set of cases. Simply override the
* test case (method) your {@link Bag} fails.
*
* @author Chuck Burdick
* @version $Id: TestBag.java,v 1.5.2.1 2004/05/22 12:14:05 scolebourne Exp $
*/
// TODO: this class should really extend from TestCollection, but the bag
// implementations currently do not conform to the Collection interface. Once
// those are fixed or at least a strategy is made for resolving the issue, this
// can be changed back to extend TestCollection instead.
public abstract class TestBag extends TestObject {
public TestBag(String testName) {
super(testName);
}
/**
* Return a new, empty {@link Bag} to used for testing.
*/
public abstract Bag makeBag();
public Object makeObject() {
return makeBag();
}
public void testBagAdd() {
Bag bag = makeBag();
bag.add("A");
assertTrue("Should contain 'A'", bag.contains("A"));
assertEquals("Should have count of 1",
1, bag.getCount("A"));
bag.add("A");
assertTrue("Should contain 'A'", bag.contains("A"));
assertEquals("Should have count of 2",
2, bag.getCount("A"));
bag.add("B");
assertTrue(bag.contains("A"));
assertTrue(bag.contains("B"));
}
public void testBagEqualsSelf() {
Bag bag = makeBag();
assertTrue(bag.equals(bag));
bag.add("elt");
assertTrue(bag.equals(bag));
bag.add("elt"); // again
assertTrue(bag.equals(bag));
bag.add("elt2");
assertTrue(bag.equals(bag));
}
public void testRemove() {
Bag bag = makeBag();
bag.add("A");
assertEquals("Should have count of 1", 1, bag.getCount("A"));
bag.remove("A");
assertEquals("Should have count of 0", 0, bag.getCount("A"));
bag.add("A");
bag.add("A");
bag.add("A");
bag.add("A");
assertEquals("Should have count of 4", 4, bag.getCount("A"));
bag.remove("A", 0);
assertEquals("Should have count of 4", 4, bag.getCount("A"));
bag.remove("A", 2);
assertEquals("Should have count of 2", 2, bag.getCount("A"));
bag.remove("A");
assertEquals("Should have count of 0", 0, bag.getCount("A"));
}
public void testRemoveAll() {
Bag bag = makeBag();
bag.add("A", 2);
assertEquals("Should have count of 2", 2, bag.getCount("A"));
bag.add("B");
bag.add("C");
assertEquals("Should have count of 4", 4, bag.size());
List delete = new ArrayList();
delete.add("A");
delete.add("B");
bag.removeAll(delete);
assertEquals("Should have count of 1", 1, bag.getCount("A"));
assertEquals("Should have count of 0", 0, bag.getCount("B"));
assertEquals("Should have count of 1", 1, bag.getCount("C"));
assertEquals("Should have count of 2", 2, bag.size());
}
public void testContains() {
Bag bag = makeBag();
bag.add("A");
bag.add("A");
bag.add("A");
bag.add("B");
bag.add("B");
List compare = new ArrayList();
compare.add("A");
compare.add("B");
assertEquals("Other list has 1 'B'", 1,
(new HashBag(compare)).getCount("B"));
assertTrue("Bag has at least 1 'B'", 1 <= bag.getCount("B"));
assertTrue("Bag contains items in the list", bag.containsAll(compare));
compare.add("A");
compare.add("B");
assertEquals("Other list has 2 'B'", 2,
(new HashBag(compare)).getCount("B"));
assertTrue("Bag has at least 2 'B'", 2 <= bag.getCount("B"));
assertTrue("Bag contains items in the list", bag.containsAll(compare));
compare.add("A");
compare.add("B");
assertEquals("Other list has 3 'B'", 3,
(new HashBag(compare)).getCount("B"));
assertTrue("Bag does not have 3 'B'", 3 > bag.getCount("B"));
assertTrue("Bag contains items in the list", !bag.containsAll(compare));
}
public void testSize() {
Bag bag = makeBag();
bag.add("A");
bag.add("A");
bag.add("A");
bag.add("B");
bag.add("B");
assertEquals("Should have 5 total items", 5, bag.size());
bag.remove("A", 2);
assertEquals("Should have 1 'A'", 1, bag.getCount("A"));
assertEquals("Should have 3 total items", 3, bag.size());
bag.remove("B");
assertEquals("Should have 1 total item", 1, bag.size());
}
public void testRetainAll() {
Bag bag = makeBag();
bag.add("A");
bag.add("A");
bag.add("A");
bag.add("B");
bag.add("B");
bag.add("C");
List retains = new ArrayList();
retains.add("B");
retains.add("C");
bag.retainAll(retains);
assertEquals("Should have 2 total items", 2, bag.size());
}
public void testIterator() {
Bag bag = makeBag();
bag.add("A");
bag.add("A");
bag.add("B");
assertEquals("Bag should have 3 items", 3, bag.size());
Iterator i = bag.iterator();
boolean foundA = false;
while (i.hasNext()) {
String element = (String) i.next();
// ignore the first A, remove the second via Iterator.remove()
if (element.equals("A")) {
if (foundA == false) {
foundA = true;
} else {
i.remove();
}
}
}
assertTrue("Bag should still contain 'A'", bag.contains("A"));
assertEquals("Bag should have 2 items", 2, bag.size());
assertEquals("Bag should have 1 'A'", 1, bag.getCount("A"));
}
public void testIteratorFail() {
Bag bag = makeBag();
bag.add("A");
bag.add("A");
bag.add("B");
Iterator i = bag.iterator();
i.next();
bag.remove("A");
try {
i.next();
fail("Should throw ConcurrentModificationException");
} catch (ConcurrentModificationException e) {
// expected
}
}
}
libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestSet.java 0100644 0001750 0001750 00000012702 10055172402 030547 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
/**
* Tests base {@link Set} methods and contracts.
*
* Since {@link Set} doesn't stipulate much new behavior that isn't already
* found in {@link Collection}, this class basically just adds tests for
* {@link Set#equals()} and {@link Set#hashCode()} along with an updated
* {@link #verify()} that ensures elements do not appear more than once in the
* set.
*
* To use, subclass and override the {@link #makeEmptySet()}
* method. You may have to override other protected methods if your
* set is not modifiable, or if your set restricts what kinds of
* elements may be added; see {@link TestCollection} for more details.
*
* @author Paul Jack
* @version $Id: TestSet.java,v 1.2.2.1 2004/05/22 12:14:05 scolebourne Exp $
*/
public abstract class TestSet extends TestCollection {
/**
* Constructor.
*
* @param name name for test
*/
public TestSet(String name) {
super(name);
}
/**
* Makes an empty collection by invoking {@link #makeEmptySet()}.
*
* @return an empty collection
*/
protected final Collection makeCollection() {
return makeEmptySet();
}
/**
* Makes a full collection by invoking {@link #makeFullSet()}.
*
* @return a full collection
*/
protected final Collection makeFullCollection() {
return makeFullSet();
}
/**
* Return the {@link TestCollection#collection} fixture, but cast as a
* Set.
*/
protected Set getSet() {
return (Set)collection;
}
/**
* Returns an empty {@link HashSet} for use in modification testing.
*
* @return a confirmed empty collection
*/
protected Collection makeConfirmedCollection() {
return new HashSet();
}
/**
* Returns a full {@link HashSet} for use in modification testing.
*
* @return a confirmed full collection
*/
protected Collection makeConfirmedFullCollection() {
HashSet set = new HashSet();
set.addAll(Arrays.asList(getFullElements()));
return set;
}
/**
* Return the {@link TestCollection#confirmed} fixture, but cast as a
* Set.
**/
protected Set getConfirmedSet() {
return (Set)confirmed;
}
/**
* Makes an empty set. The returned set should have no elements.
*
* @return an empty set
*/
protected abstract Set makeEmptySet();
/**
* Makes a full set by first creating an empty set and then adding
* all the elements returned by {@link #getFullElements()}.
*
* Override if your set does not support the add operation.
*
* @return a full set
*/
protected Set makeFullSet() {
Set set = makeEmptySet();
set.addAll(Arrays.asList(getFullElements()));
return set;
}
/**
* Tests {@link Set#equals(Object)}.
*/
public void testSetEquals() {
resetEmpty();
assertEquals("Empty sets should be equal",
getSet(), getConfirmedSet());
verify();
HashSet set2 = new HashSet();
set2.add("foo");
assertTrue("Empty set shouldn't equal nonempty set",
!getSet().equals(set2));
resetFull();
assertEquals("Full sets should be equal", getSet(), getConfirmedSet());
verify();
set2.clear();
set2.addAll(Arrays.asList(getOtherElements()));
assertTrue("Sets with different contents shouldn't be equal",
!getSet().equals(set2));
}
/**
* Tests {@link Set#hashCode()}.
*/
public void testSetHashCode() {
resetEmpty();
assertEquals("Empty sets have equal hashCodes",
getSet().hashCode(), getConfirmedSet().hashCode());
resetFull();
assertEquals("Equal sets have equal hashCodes",
getSet().hashCode(), getConfirmedSet().hashCode());
}
/**
* Provides additional verifications for sets.
*/
protected void verify() {
super.verify();
assertEquals("Sets should be equal", confirmed, collection);
assertEquals("Sets should have equal hashCodes",
confirmed.hashCode(), collection.hashCode());
HashSet set = new HashSet();
Iterator iterator = collection.iterator();
while (iterator.hasNext()) {
assertTrue("Set.iterator should only return unique elements",
set.add(iterator.next()));
}
}
}
libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestListUtils.java 0100644 0001750 0001750 00000004502 10055172402 031747 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import junit.framework.Test;
public class TestListUtils extends BulkTest {
public TestListUtils(String name) {
super(name);
}
public static Test suite() {
return BulkTest.makeSuite(TestListUtils.class);
}
public void testNothing() {
}
public BulkTest bulkTestPredicatedList() {
return new TestPredicatedCollection("") {
public Collection predicatedCollection() {
Predicate p = getPredicate();
return ListUtils.predicatedList(new ArrayList(), p);
}
public BulkTest bulkTestAll() {
return new TestList("") {
public List makeEmptyList() {
return (List)predicatedCollection();
}
public Object[] getFullElements() {
return getFullNonNullStringElements();
}
public Object[] getOtherElements() {
return getOtherNonNullStringElements();
}
};
}
};
}
public void testLazyList() {
List list = ListUtils.lazyList(new ArrayList(), new Factory() {
private int index;
public Object create() {
index++;
return new Integer(index);
}
});
Integer I = (Integer)list.get(5);
assertEquals(6, list.size());
I = (Integer)list.get(5);
assertEquals(6, list.size());
}
}
libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/iterators/ 0040755 0001750 0001750 00000000000 10072637467 030346 5 ustar tora tora ././@LongLink 0000000 0000000 0000000 00000000166 00000000000 011570 L ustar root root libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/iterators/TestListIteratorWrapper.java libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/iterators/TestListIt 0100644 0001750 0001750 00000007730 10055172376 032337 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.iterators;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.NoSuchElementException;
import junit.framework.Test;
import junit.framework.TestSuite;
/**
* Tests the ListIteratorWrapper to insure that it simulates
* a ListIterator correctly.
*
* @author Morgan Delagrange
* @version $Id: TestListIteratorWrapper.java,v 1.2.2.1 2004/05/22 12:14:04 scolebourne Exp $
*/
public class TestListIteratorWrapper extends TestIterator {
protected String[] testArray = {
"One", "Two", "Three", "Four", "Five", "Six"
};
protected List list1 = null;
public static Test suite() {
return new TestSuite(TestListIteratorWrapper.class);
}
public TestListIteratorWrapper(String testName) {
super(testName);
}
public void setUp() {
list1 = new ArrayList();
list1.add("One");
list1.add("Two");
list1.add("Three");
list1.add("Four");
list1.add("Five");
list1.add("Six");
}
public Iterator makeEmptyIterator() {
ArrayList list = new ArrayList();
return new ListIteratorWrapper(list.iterator());
}
public Iterator makeFullIterator() {
Iterator i = list1.iterator();
return new ListIteratorWrapper(i);
}
/**
* Return a new, empty {@link Object} to used for testing.
*/
public Object makeObject() {
return makeFullIterator();
}
public void testIterator() {
ListIterator iter = (ListIterator) makeFullIterator();
for ( int i = 0; i < testArray.length; i++ ) {
Object testValue = testArray[i];
Object iterValue = iter.next();
assertEquals( "Iteration value is correct", testValue, iterValue );
}
assertTrue("Iterator should now be empty", ! iter.hasNext() );
try {
Object testValue = iter.next();
} catch (Exception e) {
assertTrue("NoSuchElementException must be thrown",
e.getClass().equals((new NoSuchElementException()).getClass()));
}
// now, read it backwards
for (int i = testArray.length - 1; i > -1; --i) {
Object testValue = testArray[i];
Object iterValue = iter.previous();
assertEquals( "Iteration value is correct", testValue, iterValue );
}
try {
Object testValue = iter.previous();
} catch (Exception e) {
assertTrue("NoSuchElementException must be thrown",
e.getClass().equals((new NoSuchElementException()).getClass()));
}
// now, read it forwards again
for ( int i = 0; i < testArray.length; i++ ) {
Object testValue = testArray[i];
Object iterValue = iter.next();
assertEquals( "Iteration value is correct", testValue, iterValue );
}
}
public void testRemove() {
Iterator iter = (Iterator) makeFullIterator();
try {
iter.remove();
fail("FilterIterator does not support the remove() method");
} catch (UnsupportedOperationException e) {
}
}
}
././@LongLink 0000000 0000000 0000000 00000000161 00000000000 011563 L ustar root root libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/iterators/TestArrayIterator2.java libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/iterators/TestArrayI 0100644 0001750 0001750 00000013043 10055172400 032274 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.iterators;
import junit.framework.*;
import java.util.Iterator;
import java.util.NoSuchElementException;
/**
* Tests the ArrayIterator with primitive type arrays
*
* @author Morgan Delagrange
* @author James Strachan
* @version $Id: TestArrayIterator2.java,v 1.1.2.1 2004/05/22 12:14:04 scolebourne Exp $
*/
public class TestArrayIterator2 extends TestIterator {
protected int[] testArray = {
2, 4, 6, 8
};
public static Test suite() {
return new TestSuite(TestArrayIterator2.class);
}
public TestArrayIterator2(String testName) {
super(testName);
}
public Iterator makeEmptyIterator() {
return new ArrayIterator(new int[0]);
}
public Iterator makeFullIterator() {
return new ArrayIterator(testArray);
}
/**
* Return a new, empty {@link Object} to used for testing.
*/
public Object makeObject() {
return makeFullIterator();
}
public void testIterator() {
Iterator iter = (Iterator) makeFullIterator();
for ( int i = 0; i < testArray.length; i++ ) {
Integer testValue = new Integer( testArray[i] );
Number iterValue = (Number) iter.next();
assertEquals( "Iteration value is correct", testValue, iterValue );
}
assertTrue("Iterator should now be empty", ! iter.hasNext() );
try {
Object testValue = iter.next();
} catch (Exception e) {
assertTrue("NoSuchElementException must be thrown",
e.getClass().equals((new NoSuchElementException()).getClass()));
}
}
// proves that an ArrayIterator set with the constructor has the same number of elements
// as an ArrayIterator set with setArray(Object)
public void testSetArray() {
Iterator iter1 = new ArrayIterator(testArray);
int count1 = 0;
while (iter1.hasNext()) {
++count1;
iter1.next();
}
assertEquals("the count should be right using the constructor",
count1,testArray.length);
ArrayIterator iter2 = new ArrayIterator();
iter2.setArray(testArray);
int count2 = 0;
while (iter2.hasNext()) {
++count2;
iter2.next();
}
assertEquals("the count should be right using setArray(Object)",
count2,testArray.length);
}
public void testIndexedArray() {
Iterator iter = new ArrayIterator(testArray,2);
int count = 0;
while (iter.hasNext()) {
++count;
iter.next();
}
assertEquals("the count should be right using ArrayIterator(Object,2) ",
count,testArray.length-2);
iter = new ArrayIterator(testArray,1,testArray.length-1);
count = 0;
while (iter.hasNext()) {
++count;
iter.next();
}
assertEquals("the count should be right using ArrayIterator(Object,1,"+
(testArray.length-1)+") ", count, testArray.length-2);
try {
iter = new ArrayIterator(testArray,-1);
fail("new ArrayIterator(Object,-1) should throw an "+
"ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException aioobe) {
// expected
}
try {
iter = new ArrayIterator(testArray,testArray.length+1);
fail("new ArrayIterator(Object,length+1) should throw an "+
"ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException aioobe) {
// expected
}
try {
iter = new ArrayIterator(testArray,0,-1);
fail("new ArrayIterator(Object,0,-1) should throw an "+
"ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException aioobe) {
// expected
}
try {
iter = new ArrayIterator(testArray,0,testArray.length+1);
fail("new ArrayIterator(Object,0,length+1) should throw an "+
"ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException aioobe) {
// expected
}
try {
iter = new ArrayIterator(testArray,1,1);
fail("new ArrayIterator(Object,1,1) should throw an "+
"IllegalArgumentException");
} catch(IllegalArgumentException iae) {
// expected
}
try {
iter = new ArrayIterator(testArray,testArray.length-1,testArray.length-2);
fail("new ArrayIterator(Object,length-2,length-1) should throw an "+
"IllegalArgumentException");
} catch(IllegalArgumentException iae) {
// expected
}
}
}
././@LongLink 0000000 0000000 0000000 00000000160 00000000000 011562 L ustar root root libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/iterators/TestArrayIterator.java libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/iterators/TestArrayI 0100644 0001750 0001750 00000006054 10055172376 032314 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.iterators;
import junit.framework.*;
import java.util.Iterator;
import java.util.NoSuchElementException;
/**
* Tests the ArrayIterator to ensure that the next() method will actually
* perform the iteration rather than the hasNext() method.
* The code of this test was supplied by Mauricio S. Moura
*
* @author James Strachan
* @author Mauricio S. Moura
* @author Morgan Delagrange
* @version $Id: TestArrayIterator.java,v 1.1.2.1 2004/05/22 12:14:04 scolebourne Exp $
*/
public class TestArrayIterator extends TestIterator {
protected String[] testArray = {
"One", "Two", "Three"
};
public static Test suite() {
return new TestSuite(TestArrayIterator.class);
}
public TestArrayIterator(String testName) {
super(testName);
}
public Iterator makeEmptyIterator() {
return new ArrayIterator(new Object[0]);
}
public Iterator makeFullIterator() {
return new ArrayIterator(testArray);
}
/**
* Return a new, empty {@link Object} to used for testing.
*/
public Object makeObject() {
return makeFullIterator();
}
public void testIterator() {
Iterator iter = (Iterator) makeFullIterator();
for ( int i = 0; i < testArray.length; i++ ) {
Object testValue = testArray[i];
Object iterValue = iter.next();
assertEquals( "Iteration value is correct", testValue, iterValue );
}
assertTrue("Iterator should now be empty", ! iter.hasNext() );
try {
Object testValue = iter.next();
} catch (Exception e) {
assertTrue("NoSuchElementException must be thrown",
e.getClass().equals((new NoSuchElementException()).getClass()));
}
}
public void testNullArray() {
try {
Iterator iter = new ArrayIterator(null);
fail("Constructor should throw a NullPointerException when " +
"constructed with a null array");
} catch (NullPointerException e) {
// expected
}
ArrayIterator iter = new ArrayIterator();
try {
iter.setArray(null);
fail("setArray(null) should throw a NullPointerException");
} catch (NullPointerException e) {
// expected
}
}
}
././@LongLink 0000000 0000000 0000000 00000000161 00000000000 011563 L ustar root root libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/iterators/TestFilterIterator.java libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/iterators/TestFilter 0100644 0001750 0001750 00000011735 10055172400 032340 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.iterators;
import junit.framework.TestSuite;
import junit.framework.Test;
import java.util.Iterator;
import java.util.NoSuchElementException;
import org.apache.commons.collections.Predicate;
/**
*
* @author Jan Sorensen
*/
public class TestFilterIterator extends TestIterator {
/** Creates new TestFilterIterator */
public TestFilterIterator(String name) {
super(name);
}
private String[] array;
private FilterIterator iterator;
/**
* Set up instance variables required by this test case.
*/
public void setUp() {
array = new String[] { "a", "b", "c" };
initIterator();
}
/**
* Tear down instance variables required by this test case.
*/
public void tearDown() {
iterator = null;
}
/**
* Return the tests included in this test suite.
*/
public static Test suite() {
return (new TestSuite(TestFilterIterator.class));
}
/**
* Returns an full iterator wrapped in a
* FilterIterator that blocks all the elements
*
* @return "empty" FilterIterator
*/
public Iterator makeEmptyIterator() {
return makeBlockAllFilter(new ArrayIterator(array));
}
/**
* Returns an array with elements wrapped in a pass-through
* FilterIterator
*
* @return
*/
public Iterator makeFullIterator() {
return makePassThroughFilter(new ArrayIterator(array));
}
public Object makeObject() {
return makeFullIterator();
}
public void testRepeatedHasNext() {
for (int i = 0; i <= array.length; i++) {
assertTrue(iterator.hasNext());
}
}
public void testRepeatedNext() {
for (int i = 0; i < array.length; i++)
iterator.next();
verifyNoMoreElements();
}
public void testReturnValues() {
verifyElementsInPredicate(new String[0]);
verifyElementsInPredicate(new String[] { "a" });
verifyElementsInPredicate(new String[] { "b" });
verifyElementsInPredicate(new String[] { "c" });
verifyElementsInPredicate(new String[] { "a", "b" });
verifyElementsInPredicate(new String[] { "a", "c" });
verifyElementsInPredicate(new String[] { "b", "c" });
verifyElementsInPredicate(new String[] { "a", "b", "c" });
}
private void verifyNoMoreElements() {
assertTrue(!iterator.hasNext());
try {
iterator.next();
fail("NoSuchElementException expected");
}
catch (NoSuchElementException e) {
// success
}
}
private void verifyElementsInPredicate(final String[] elements) {
Predicate pred = new Predicate() {
public boolean evaluate(Object x) {
for (int i = 0; i < elements.length; i++)
if (elements[i].equals(x))
return true;
return false;
}
};
initIterator();
iterator.setPredicate(pred);
for (int i = 0; i < elements.length; i++) {
String s = (String)iterator.next();
assertEquals(elements[i], s);
assertTrue(i == elements.length - 1 ? !iterator.hasNext() : iterator.hasNext());
}
verifyNoMoreElements();
}
private void initIterator() {
iterator = makePassThroughFilter(new ArrayIterator(array));
}
/**
* Returns a FilterIterator that does not filter
* any of its elements
*
* @param i the Iterator to "filter"
* @return "filtered" iterator
*/
protected FilterIterator makePassThroughFilter(Iterator i) {
Predicate pred = new Predicate() {
public boolean evaluate(Object x) { return true; }
};
return new FilterIterator(i,pred);
}
/**
* Returns a FilterIterator that blocks
* all of its elements
*
* @param i the Iterator to "filter"
* @return "filtered" iterator
*/
protected FilterIterator makeBlockAllFilter(Iterator i) {
Predicate pred = new Predicate() {
public boolean evaluate(Object x) { return false; }
};
return new FilterIterator(i,pred);
}
}
././@LongLink 0000000 0000000 0000000 00000000160 00000000000 011562 L ustar root root libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/iterators/TestIteratorChain.java libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/iterators/TestIterat 0100644 0001750 0001750 00000010063 10055172400 032334 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.iterators;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
import junit.framework.Test;
import junit.framework.TestSuite;
/**
* Tests the ArrayIterator to ensure that the next() method will actually
* perform the iteration rather than the hasNext() method.
* The code of this test was supplied by Mauricio S. Moura
*
* @author James Strachan
* @author Mauricio S. Moura
* @author Morgan Delagrange
* @version $Id: TestIteratorChain.java,v 1.2.2.1 2004/05/22 12:14:04 scolebourne Exp $
*/
public class TestIteratorChain extends TestIterator {
protected String[] testArray = {
"One", "Two", "Three", "Four", "Five", "Six"
};
protected List list1 = null;
protected List list2 = null;
protected List list3 = null;
public static Test suite() {
return new TestSuite(TestIteratorChain.class);
}
public TestIteratorChain(String testName) {
super(testName);
}
public void setUp() {
list1 = new ArrayList();
list1.add("One");
list1.add("Two");
list1.add("Three");
list2 = new ArrayList();
list2.add("Four");
list3 = new ArrayList();
list3.add("Five");
list3.add("Six");
}
public Iterator makeEmptyIterator() {
ArrayList list = new ArrayList();
return new IteratorChain(list.iterator());
}
public Iterator makeFullIterator() {
IteratorChain chain = new IteratorChain();
Iterator i = list1.iterator();
chain.addIterator(list1.iterator());
chain.addIterator(list2.iterator());
chain.addIterator(list3.iterator());
return chain;
}
/**
* Return a new, empty {@link Object} to used for testing.
*/
public Object makeObject() {
return makeFullIterator();
}
public void testIterator() {
Iterator iter = (Iterator) makeFullIterator();
for ( int i = 0; i < testArray.length; i++ ) {
Object testValue = testArray[i];
Object iterValue = iter.next();
assertEquals( "Iteration value is correct", testValue, iterValue );
}
assertTrue("Iterator should now be empty", ! iter.hasNext() );
try {
Object testValue = iter.next();
} catch (Exception e) {
assertTrue("NoSuchElementException must be thrown",
e.getClass().equals((new NoSuchElementException()).getClass()));
}
}
public void testRemove() {
Iterator iter = (Iterator) makeFullIterator();
try {
iter.remove();
fail("Calling remove before the first call to next() should throw an exception");
} catch (IllegalStateException e) {
}
for ( int i = 0; i < testArray.length; i++ ) {
Object testValue = testArray[i];
Object iterValue = iter.next();
assertEquals( "Iteration value is correct", testValue, iterValue );
if (! iterValue.equals("Four")) {
iter.remove();
}
}
assertTrue("List is empty",list1.size() == 0);
assertTrue("List is empty",list2.size() == 1);
assertTrue("List is empty",list3.size() == 0);
}
}
././@LongLink 0000000 0000000 0000000 00000000170 00000000000 011563 L ustar root root libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/iterators/TestSingletonListIterator.java libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/iterators/TestSingle 0100644 0001750 0001750 00000010241 10055172376 032337 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.iterators;
import junit.framework.*;
import java.util.Iterator;
import java.util.ListIterator;
import java.util.NoSuchElementException;
/**
* Tests the SingletonListIterator.
*
* @author Stephen Colebourne
* @version $Id: TestSingletonListIterator.java,v 1.1.2.1 2004/05/22 12:14:04 scolebourne Exp $
*/
public class TestSingletonListIterator extends TestIterator {
private static final Object testValue = "foo";
public static Test suite() {
return new TestSuite(TestSingletonListIterator.class);
}
public TestSingletonListIterator(String testName) {
super(testName);
}
/**
* Returns null. SingletonListIterator can never be empty;
* they always have exactly one element.
*
* @return null
*/
public Iterator makeEmptyIterator() {
return null;
}
public Iterator makeFullIterator() {
return new SingletonListIterator( testValue );
}
/**
* Return a new, empty {@link Object} to used for testing.
*/
public Object makeObject() {
return makeFullIterator();
}
/**
* Whether or not we are testing an iterator that can be
* empty. SingletonIterators are never empty;
*
* @return false
*/
public boolean supportsEmptyIterator() {
return false;
}
public void testIterator() {
ListIterator iter = (ListIterator) makeObject();
assertTrue( "Iterator should have next item", iter.hasNext() );
assertTrue( "Iterator should have no previous item", !iter.hasPrevious() );
assertEquals( "Iteration next index", 0, iter.nextIndex() );
assertEquals( "Iteration previous index", -1, iter.previousIndex() );
Object iterValue = iter.next();
assertEquals( "Iteration value is correct", testValue, iterValue );
assertTrue( "Iterator should have no next item", !iter.hasNext() );
assertTrue( "Iterator should have previous item", iter.hasPrevious() );
assertEquals( "Iteration next index", 1, iter.nextIndex() );
assertEquals( "Iteration previous index", 0, iter.previousIndex() );
iterValue = iter.previous();
assertEquals( "Iteration value is correct", testValue, iterValue );
assertTrue( "Iterator should have next item", iter.hasNext() );
assertTrue( "Iterator should have no previous item", !iter.hasPrevious() );
assertEquals( "Iteration next index", 0, iter.nextIndex() );
assertEquals( "Iteration previous index", -1, iter.previousIndex() );
iterValue = iter.next();
assertEquals( "Iteration value is correct", testValue, iterValue );
assertTrue( "Iterator should have no next item", !iter.hasNext() );
assertTrue( "Iterator should have previous item", iter.hasPrevious() );
assertEquals( "Iteration next index", 1, iter.nextIndex() );
assertEquals( "Iteration previous index", 0, iter.previousIndex() );
try {
iter.next();
} catch (Exception e) {
assertTrue("NoSuchElementException must be thrown",
e.getClass().equals((new NoSuchElementException()).getClass()));
}
iter.previous();
try {
iter.previous();
} catch (Exception e) {
assertTrue("NoSuchElementException must be thrown",
e.getClass().equals((new NoSuchElementException()).getClass()));
}
}
}
././@LongLink 0000000 0000000 0000000 00000000167 00000000000 011571 L ustar root root libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/iterators/TestUniqueFilterIterator.java libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/iterators/TestUnique 0100644 0001750 0001750 00000006566 10055172400 032367 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.iterators;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
import junit.framework.Test;
import junit.framework.TestSuite;
/**
* Tests the ArrayIterator to ensure that the next() method will actually
* perform the iteration rather than the hasNext() method.
* The code of this test was supplied by Mauricio S. Moura
*
* @author James Strachan
* @author Mauricio S. Moura
* @author Morgan Delagrange
* @version $Id: TestUniqueFilterIterator.java,v 1.2.2.1 2004/05/22 12:14:04 scolebourne Exp $
*/
public class TestUniqueFilterIterator extends TestIterator {
protected String[] testArray = {
"One", "Two", "Three", "Four", "Five", "Six"
};
protected List list1 = null;
public static Test suite() {
return new TestSuite(TestUniqueFilterIterator.class);
}
public TestUniqueFilterIterator(String testName) {
super(testName);
}
public void setUp() {
list1 = new ArrayList();
list1.add("One");
list1.add("Two");
list1.add("Three");
list1.add("Two");
list1.add("One");
list1.add("Four");
list1.add("Five");
list1.add("Five");
list1.add("Six");
list1.add("Five");
}
public Iterator makeEmptyIterator() {
ArrayList list = new ArrayList();
return new UniqueFilterIterator(list.iterator());
}
public Iterator makeFullIterator() {
Iterator i = list1.iterator();
return new UniqueFilterIterator(i);
}
/**
* Return a new, empty {@link Object} to used for testing.
*/
public Object makeObject() {
return makeFullIterator();
}
public void testIterator() {
Iterator iter = (Iterator) makeFullIterator();
for ( int i = 0; i < testArray.length; i++ ) {
Object testValue = testArray[i];
Object iterValue = iter.next();
assertEquals( "Iteration value is correct", testValue, iterValue );
}
assertTrue("Iterator should now be empty", ! iter.hasNext() );
try {
Object testValue = iter.next();
} catch (Exception e) {
assertTrue("NoSuchElementException must be thrown",
e.getClass().equals((new NoSuchElementException()).getClass()));
}
}
public void testRemove() {
Iterator iter = (Iterator) makeFullIterator();
try {
iter.remove();
fail("FilterIterator does not support the remove() method");
} catch (UnsupportedOperationException e) {
}
}
}
././@LongLink 0000000 0000000 0000000 00000000153 00000000000 011564 L ustar root root libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/iterators/TestIterator.java libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/iterators/TestIterat 0100644 0001750 0001750 00000005671 10055172376 032361 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.iterators;
import java.util.Iterator;
import java.util.NoSuchElementException;
import org.apache.commons.collections.TestObject;
/**
* Base class for tetsing Iterator interface
*
* @author Morgan Delagrange
*/
public abstract class TestIterator extends TestObject {
public TestIterator(String testName) {
super(testName);
}
public abstract Iterator makeEmptyIterator();
public abstract Iterator makeFullIterator();
/**
* Whether or not we are testing an iterator that can be
* empty. Default is true.
*
* @return true if Iterators can be empty
*/
public boolean supportsEmptyIterator() {
return true;
}
/**
* Whether or not we are testing an iterator that can contain
* elements. Default is true.
*
* @return true if Iterators can be empty
*/
public boolean supportsFullIterator() {
return true;
}
/**
* Should throw a NoSuchElementException.
*/
public void testEmptyIterator() {
if (supportsEmptyIterator() == false) {
return;
}
Iterator iter = makeEmptyIterator();
assertTrue("hasNext() should return false for empty iterators",iter.hasNext() == false);
try {
iter.next();
fail("NoSuchElementException must be thrown when Iterator is exhausted");
} catch (NoSuchElementException e) {
}
}
/**
* NoSuchElementException (or any other exception)
* should not be thrown for the first element.
* NoSuchElementException must be thrown when
* hasNext() returns false
*/
public void testFullIterator() {
if (supportsFullIterator() == false) {
return;
}
Iterator iter = makeFullIterator();
assertTrue("hasNext() should return true for at least one element",iter.hasNext());
try {
iter.next();
} catch (NoSuchElementException e) {
fail("Full iterators must have at least one element");
}
while (iter.hasNext()) {
iter.next();
}
try {
iter.next();
fail("NoSuchElementException must be thrown when Iterator is exhausted");
} catch (NoSuchElementException e) {
}
}
}
././@LongLink 0000000 0000000 0000000 00000000146 00000000000 011566 L ustar root root libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/iterators/TestAll.java libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/iterators/TestAll.ja 0100644 0001750 0001750 00000003552 10055172376 032226 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.iterators;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
/**
* Entry point for all Collections tests.
* @author Rodney Waldhoff
* @version $Id: TestAll.java,v 1.2.2.1 2004/05/22 12:14:04 scolebourne Exp $
*/
public class TestAll extends TestCase {
public TestAll(String testName) {
super(testName);
}
public static Test suite() {
TestSuite suite = new TestSuite();
suite.addTest(TestArrayIterator.suite());
suite.addTest(TestArrayIterator2.suite());
suite.addTest(TestCollatingIterator.suite());
suite.addTest(TestFilterIterator.suite());
suite.addTest(TestFilterListIterator.suite());
suite.addTest(TestIteratorChain.suite());
suite.addTest(TestListIteratorWrapper.suite());
suite.addTest(TestSingletonIterator.suite());
suite.addTest(TestSingletonListIterator.suite());
suite.addTest(TestUniqueFilterIterator.suite());
return suite;
}
public static void main(String args[]) {
String[] testCaseName = { TestAll.class.getName() };
junit.textui.TestRunner.main(testCaseName);
}
}
././@LongLink 0000000 0000000 0000000 00000000164 00000000000 011566 L ustar root root libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/iterators/TestSingletonIterator.java libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/iterators/TestSingle 0100644 0001750 0001750 00000005217 10055172402 032334 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.iterators;
import junit.framework.*;
import java.util.Iterator;
import java.util.NoSuchElementException;
/**
* Tests the SingletonIterator to ensure that the next() method will actually
* perform the iteration rather than the hasNext() method.
*
* @author James Strachan
* @version $Id: TestSingletonIterator.java,v 1.1.2.1 2004/05/22 12:14:04 scolebourne Exp $
*/
public class TestSingletonIterator extends TestIterator {
private static final Object testValue = "foo";
public static Test suite() {
return new TestSuite(TestSingletonIterator.class);
}
public TestSingletonIterator(String testName) {
super(testName);
}
/**
* Returns null. SingletonIterators can never be empty;
* they always have exactly one element.
*
* @return null
*/
public Iterator makeEmptyIterator() {
return null;
}
public Iterator makeFullIterator() {
return new SingletonIterator( testValue );
}
/**
* Return a new, empty {@link Object} to used for testing.
*/
public Object makeObject() {
return makeFullIterator();
}
/**
* Whether or not we are testing an iterator that can be
* empty. SingletonIterators are never empty;
*
* @return false
*/
public boolean supportsEmptyIterator() {
return false;
}
public void testIterator() {
Iterator iter = (Iterator) makeObject();
assertTrue( "Iterator has a first item", iter.hasNext() );
Object iterValue = iter.next();
assertEquals( "Iteration value is correct", testValue, iterValue );
assertTrue("Iterator should now be empty", ! iter.hasNext() );
try {
Object testValue = iter.next();
}
catch (Exception e) {
assertTrue("NoSuchElementException must be thrown",
e.getClass().equals((new NoSuchElementException()).getClass()));
}
}
}
././@LongLink 0000000 0000000 0000000 00000000165 00000000000 011567 L ustar root root libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/iterators/TestFilterListIterator.java libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/iterators/TestFilter 0100644 0001750 0001750 00000037656 10055172400 032352 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.iterators;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import junit.framework.Test;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
import java.util.Random;
import org.apache.commons.collections.Predicate;
/**
* @version $Revision: 1.2.2.1 $ $Date: 2004/05/22 12:14:04 $
* @author Rodney Waldhoff
*/
public class TestFilterListIterator extends TestCase {
public TestFilterListIterator(String testName) {
super(testName);
}
public static Test suite() {
return new TestSuite(TestFilterListIterator.class);
}
public static void main(String args[]) {
String[] testCaseName = { TestFilterListIterator.class.getName() };
junit.textui.TestRunner.main(testCaseName);
}
private ArrayList list = null;
private ArrayList odds = null;
private ArrayList evens = null;
private ArrayList threes = null;
private ArrayList fours = null;
private ArrayList sixes = null;
private Predicate truePred = null;
private Predicate falsePred = null;
private Predicate evenPred = null;
private Predicate oddPred = null;
private Predicate threePred = null;
private Predicate fourPred = null;
private Random random = new Random();
public void setUp() {
list = new ArrayList();
odds = new ArrayList();
evens = new ArrayList();
threes = new ArrayList();
fours = new ArrayList();
sixes = new ArrayList();
for(int i=0;i<20;i++) {
list.add(new Integer(i));
if(i%2 == 0) { evens.add(new Integer(i)); }
if(i%2 == 1) { odds.add(new Integer(i)); }
if(i%3 == 0) { threes.add(new Integer(i)); }
if(i%4 == 0) { fours.add(new Integer(i)); }
if(i%6 == 0) { sixes.add(new Integer(i)); }
}
truePred = new Predicate() {
public boolean evaluate(Object x) {
return true;
}
};
falsePred = new Predicate() {
public boolean evaluate(Object x) {
return true;
}
};
evenPred = new Predicate() {
public boolean evaluate(Object x) {
return (((Integer)x).intValue()%2 == 0);
}
};
oddPred = new Predicate() {
public boolean evaluate(Object x) {
return (((Integer)x).intValue()%2 == 1);
}
};
threePred = new Predicate() {
public boolean evaluate(Object x) {
return (((Integer)x).intValue()%3 == 0);
}
};
fourPred = new Predicate() {
public boolean evaluate(Object x) {
return (((Integer)x).intValue()%4 == 0);
}
};
}
public void tearDown() {
list = null;
odds = null;
evens = null;
threes = null;
fours = null;
sixes = null;
truePred = null;
falsePred = null;
evenPred = null;
oddPred = null;
threePred = null;
fourPred = null;
}
public void testWalkLists() {
// this just confirms that our walkLists method works OK
walkLists(list,list.listIterator());
}
public void testManual() {
// do this one "by hand" as a sanity check
FilterListIterator filtered = new FilterListIterator(list.listIterator(),threePred);
assertEquals(new Integer(0),filtered.next());
assertEquals(new Integer(3),filtered.next());
assertEquals(new Integer(6),filtered.next());
assertEquals(new Integer(9),filtered.next());
assertEquals(new Integer(12),filtered.next());
assertEquals(new Integer(15),filtered.next());
assertEquals(new Integer(18),filtered.next());
assertEquals(new Integer(18),filtered.previous());
assertEquals(new Integer(15),filtered.previous());
assertEquals(new Integer(12),filtered.previous());
assertEquals(new Integer(9),filtered.previous());
assertEquals(new Integer(6),filtered.previous());
assertEquals(new Integer(3),filtered.previous());
assertEquals(new Integer(0),filtered.previous());
assertTrue(!filtered.hasPrevious());
assertEquals(new Integer(0),filtered.next());
assertEquals(new Integer(3),filtered.next());
assertEquals(new Integer(6),filtered.next());
assertEquals(new Integer(9),filtered.next());
assertEquals(new Integer(12),filtered.next());
assertEquals(new Integer(15),filtered.next());
assertEquals(new Integer(18),filtered.next());
assertTrue(!filtered.hasNext());
assertEquals(new Integer(18),filtered.previous());
assertEquals(new Integer(15),filtered.previous());
assertEquals(new Integer(12),filtered.previous());
assertEquals(new Integer(9),filtered.previous());
assertEquals(new Integer(6),filtered.previous());
assertEquals(new Integer(3),filtered.previous());
assertEquals(new Integer(0),filtered.previous());
assertEquals(new Integer(0),filtered.next());
assertEquals(new Integer(0),filtered.previous());
assertEquals(new Integer(0),filtered.next());
assertEquals(new Integer(3),filtered.next());
assertEquals(new Integer(6),filtered.next());
assertEquals(new Integer(6),filtered.previous());
assertEquals(new Integer(3),filtered.previous());
assertEquals(new Integer(3),filtered.next());
assertEquals(new Integer(6),filtered.next());
assertEquals(new Integer(9),filtered.next());
assertEquals(new Integer(12),filtered.next());
assertEquals(new Integer(15),filtered.next());
assertEquals(new Integer(15),filtered.previous());
assertEquals(new Integer(12),filtered.previous());
assertEquals(new Integer(9),filtered.previous());
}
public void testTruePredicate() {
FilterListIterator filtered = new FilterListIterator(list.listIterator(),truePred);
walkLists(list,filtered);
}
public void testFalsePredicate() {
FilterListIterator filtered = new FilterListIterator(list.listIterator(),falsePred);
walkLists(new ArrayList(),filtered);
}
public void testEvens() {
FilterListIterator filtered = new FilterListIterator(list.listIterator(),evenPred);
walkLists(evens,filtered);
}
public void testOdds() {
FilterListIterator filtered = new FilterListIterator(list.listIterator(),oddPred);
walkLists(odds,filtered);
}
public void testThrees() {
FilterListIterator filtered = new FilterListIterator(list.listIterator(),threePred);
walkLists(threes,filtered);
}
public void testFours() {
FilterListIterator filtered = new FilterListIterator(list.listIterator(),fourPred);
walkLists(fours,filtered);
}
public void testNestedSixes() {
FilterListIterator filtered = new FilterListIterator(
new FilterListIterator(list.listIterator(),threePred),
evenPred
);
walkLists(sixes,filtered);
}
public void testNestedSixes2() {
FilterListIterator filtered = new FilterListIterator(
new FilterListIterator(list.listIterator(),evenPred),
threePred
);
walkLists(sixes,filtered);
}
public void testNestedSixes3() {
FilterListIterator filtered = new FilterListIterator(
new FilterListIterator(list.listIterator(),threePred),
evenPred
);
walkLists(sixes,new FilterListIterator(filtered,truePred));
}
public void testNextChangesPrevious() {
{
FilterListIterator filtered = new FilterListIterator(list.listIterator(),threePred);
nextNextPrevious(threes.listIterator(),filtered);
}
{
FilterListIterator filtered = new FilterListIterator(list.listIterator(),truePred);
nextNextPrevious(list.listIterator(),filtered);
}
}
public void testPreviousChangesNext() {
{
FilterListIterator filtered = new FilterListIterator(list.listIterator(),threePred);
ListIterator expected = threes.listIterator();
walkForward(expected,filtered);
previousPreviousNext(expected,filtered);
}
{
FilterListIterator filtered = new FilterListIterator(list.listIterator(),truePred);
ListIterator expected = list.listIterator();
walkForward(expected,filtered);
previousPreviousNext(expected,filtered);
}
}
public void testFailingHasNextBug() {
FilterListIterator filtered = new FilterListIterator(list.listIterator(),fourPred);
ListIterator expected = fours.listIterator();
while(expected.hasNext()) {
expected.next();
filtered.next();
}
assertTrue(filtered.hasPrevious());
assertTrue(!filtered.hasNext());
assertEquals(expected.previous(),filtered.previous());
}
// Utilities
private void walkForward(ListIterator expected, ListIterator testing) {
while(expected.hasNext()) {
assertEquals(expected.nextIndex(),testing.nextIndex());
assertEquals(expected.previousIndex(),testing.previousIndex());
assertTrue(testing.hasNext());
assertEquals(expected.next(),testing.next());
}
}
private void walkBackward(ListIterator expected, ListIterator testing) {
while(expected.hasPrevious()) {
assertEquals(expected.nextIndex(),testing.nextIndex());
assertEquals(expected.previousIndex(),testing.previousIndex());
assertTrue(testing.hasPrevious());
assertEquals(expected.previous(),testing.previous());
}
}
private void nextNextPrevious(ListIterator expected, ListIterator testing) {
// calls to next() should change the value returned by previous()
// even after previous() has been set by a call to hasPrevious()
assertEquals(expected.next(),testing.next());
assertEquals(expected.hasPrevious(),testing.hasPrevious());
Object expecteda = expected.next();
Object testinga = testing.next();
assertEquals(expecteda,testinga);
Object expectedb = expected.previous();
Object testingb = testing.previous();
assertEquals(expecteda,expectedb);
assertEquals(testinga,testingb);
}
private void previousPreviousNext(ListIterator expected, ListIterator testing) {
// calls to previous() should change the value returned by next()
// even after next() has been set by a call to hasNext()
assertEquals(expected.previous(),testing.previous());
assertEquals(expected.hasNext(),testing.hasNext());
Object expecteda = expected.previous();
Object testinga = testing.previous();
assertEquals(expecteda,testinga);
Object expectedb = expected.next();
Object testingb = testing.next();
assertEquals(expecteda,testingb);
assertEquals(expecteda,expectedb);
assertEquals(testinga,testingb);
}
private void walkLists(List list, ListIterator testing) {
ListIterator expected = list.listIterator();
// walk all the way forward
walkForward(expected,testing);
// walk all the way back
walkBackward(expected,testing);
// forward,back,foward
while(expected.hasNext()) {
assertEquals(expected.nextIndex(),testing.nextIndex());
assertEquals(expected.previousIndex(),testing.previousIndex());
assertTrue(testing.hasNext());
assertEquals(expected.next(),testing.next());
assertTrue(testing.hasPrevious());
assertEquals(expected.previous(),testing.previous());
assertTrue(testing.hasNext());
assertEquals(expected.next(),testing.next());
}
// walk all the way back
walkBackward(expected,testing);
for(int i=0;i
*
* A simple test method is the type of test traditionally
* supplied by by {@link TestCase}. To define a simple test, create a public
* no-argument method whose name starts with "test". You can specify the
* the name of simple test in the constructor of
*
* A bulk test method, on the other hand, returns a new instance
* of
*
* For instance, consider the following two classes:
*
*
*
*
*
*
*
* Note that if you want to use the bulk test methods, you must
* define your
*
* @return a clone of this
*
* If a simple test that's defined by this
*
* A simple test's name is formed by taking the class name of the
* root
*
* The class is examined for simple and bulk test methods; any child
* bulk tests are also examined recursively; and the results are stored
* in a hierarchal {@link TestSuite}.
*
* The given class must be a subclass of
*
* @param c the class to examine for simple and bulk tests
* @return a {@link TestSuite} containing all the simple and bulk tests
* defined by that class
*/
public static TestSuite makeSuite(Class c) {
if (Modifier.isAbstract(c.getModifiers())) {
throw new IllegalArgumentException("Class must not be abstract.");
}
if (!BulkTest.class.isAssignableFrom(c)) {
throw new IllegalArgumentException("Class must extend BulkTest.");
}
return new BulkTestSuiteMaker(c).make();
}
}
// It was easier to use a separate class to do all the reflection stuff
// for making the TestSuite instances. Having permanent state around makes
// it easier to handle the recursion.
class BulkTestSuiteMaker {
/** The class that defines simple and bulk tests methods. */
private Class startingClass;
/** List of ignored simple test names. */
private List ignored;
/** The TestSuite we're currently populating. Can change over time. */
private TestSuite result;
/**
* The prefix for simple test methods. Used to check if a test is in
* the ignored list.
*/
private String prefix;
/**
* Constructor.
*
* @param startingClass the starting class
*/
public BulkTestSuiteMaker(Class startingClass) {
this.startingClass = startingClass;
}
/**
* Makes a hierarchal TestSuite based on the starting class.
*
* @return the hierarchal TestSuite for startingClass
*/
public TestSuite make() {
this.result = new TestSuite();
this.prefix = getBaseName(startingClass);
result.setName(prefix);
BulkTest bulk = makeFirstTestCase(startingClass);
ignored = new ArrayList();
String[] s = bulk.ignoredSimpleTests();
if (s != null) {
ignored.addAll(Arrays.asList(s));
}
make(bulk);
return result;
}
/**
* Appends all the simple tests and bulk tests defined by the given
* instance's class to the current TestSuite.
*
* @param bulk An instance of the class that defines simple and bulk
* tests for us to append
*/
void make(BulkTest bulk) {
Class c = bulk.getClass();
Method[] all = c.getMethods();
for (int i = 0; i < all.length; i++) {
if (isTest(all[i])) addTest(bulk, all[i]);
if (isBulk(all[i])) addBulk(bulk, all[i]);
}
}
/**
* Adds the simple test defined by the given method to the TestSuite.
*
* @param bulk The instance of the class that defined the method
* (I know it's wierd. But the point is, we can clone the instance
* and not have to worry about constructors.)
* @param m The simple test method
*/
void addTest(BulkTest bulk, Method m) {
BulkTest bulk2 = (BulkTest)bulk.clone();
bulk2.setName(m.getName());
bulk2.verboseName = prefix + "." + m.getName();
if (ignored.contains(bulk2.verboseName)) return;
result.addTest(bulk2);
}
/**
* Adds a whole new suite of tests that are defined by the result of
* the given bulk test method. In other words, the given bulk test
* method is invoked, and the resulting BulkTest instance is examined
* for yet more simple and bulk tests.
*
* @param bulk The instance of the class that defined the method
* @param m The bulk test method
*/
void addBulk(BulkTest bulk, Method m) {
BulkTest bulk2;
try {
bulk2 = (BulkTest)m.invoke(bulk, null);
if (bulk2 == null) return;
} catch (InvocationTargetException e) {
throw new Error(); // FIXME;
} catch (IllegalAccessException e) {
throw new Error(); // FIXME;
}
// Save current state on the stack.
String oldPrefix = prefix;
TestSuite oldResult = result;
prefix = prefix + "." + m.getName();
result = new TestSuite();
result.setName(m.getName());
make(bulk2);
oldResult.addTest(result);
// Restore the old state
prefix = oldPrefix;
result = oldResult;
}
/**
* Returns the base name of the given class.
*
* @param c the class
* @return the name of that class, minus any package names
*/
private static String getBaseName(Class c) {
String name = c.getName();
int p = name.lastIndexOf('.');
if (p > 0) {
name = name.substring(p + 1);
}
return name;
}
// These three methods are used to create a valid BulkTest instance
// from a class.
private static Constructor getTestCaseConstructor(Class c) {
try {
return c.getConstructor(new Class[] { String.class });
} catch (NoSuchMethodException e) {
throw new IllegalArgumentException(c + " must provide " +
"a (String) constructor");
}
}
private static BulkTest makeTestCase(Class c, Method m) {
Constructor con = getTestCaseConstructor(c);
try {
return (BulkTest)con.newInstance(new String[] { m.getName() });
} catch (InvocationTargetException e) {
e.printStackTrace();
throw new RuntimeException(); // FIXME;
} catch (IllegalAccessException e) {
throw new Error(); // should never occur
} catch (InstantiationException e) {
throw new RuntimeException(); // FIXME;
}
}
private static BulkTest makeFirstTestCase(Class c) {
Method[] all = c.getMethods();
for (int i = 0; i < all.length; i++) {
if (isTest(all[i])) return makeTestCase(c, all[i]);
}
throw new IllegalArgumentException(c.getName() + " must provide "
+ " at least one test method.");
}
/**
* Returns true if the given method is a simple test method.
*/
private static boolean isTest(Method m) {
if (!m.getName().startsWith("test")) return false;
if (m.getReturnType() != Void.TYPE) return false;
if (m.getParameterTypes().length != 0) return false;
int mods = m.getModifiers();
if (Modifier.isStatic(mods)) return false;
if (Modifier.isAbstract(mods)) return false;
return true;
}
/**
* Returns true if the given method is a bulk test method.
*/
private static boolean isBulk(Method m) {
if (!m.getName().startsWith("bulkTest")) return false;
if (m.getReturnType() != BulkTest.class) return false;
if (m.getParameterTypes().length != 0) return false;
int mods = m.getModifiers();
if (Modifier.isStatic(mods)) return false;
if (Modifier.isAbstract(mods)) return false;
return true;
}
}
././@LongLink 0000000 0000000 0000000 00000000145 00000000000 011565 L ustar root root libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestReferenceMap.java libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestReferenceMap.jav 0100644 0001750 0001750 00000011353 10055172376 032222 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
import junit.framework.Test;
/**
* Tests for ReferenceMap.
*
* @author Paul Jack
* @version $Id: TestReferenceMap.java,v 1.2.2.1 2004/05/22 12:14:05 scolebourne Exp $
*/
public class TestReferenceMap extends TestMap {
private static Random random = new Random();
private Object[] hardKeys;
private Object[] hardValues;
private HashMap refs = new HashMap();
public TestReferenceMap(String testName) {
super(testName);
}
public static Test suite() {
return BulkTest.makeSuite(TestReferenceMap.class);
}
public static void main(String args[]) {
String[] testCaseName = { TestReferenceMap.class.getName() };
junit.textui.TestRunner.main(testCaseName);
}
public Map makeEmptyMap() {
ReferenceMap map = new ReferenceMap(ReferenceMap.WEAK, ReferenceMap.WEAK);
return map;
}
public boolean useNullKey() {
return false;
}
public boolean useNullValue() {
return false;
}
/*
// Unfortunately, these tests all rely on System.gc(), which is
// not reliable across platforms. Not sure how to code the tests
// without using System.gc() though...
// They all passed on my platform though. :)
public void testPurge() {
ReferenceMap map = new ReferenceMap(ReferenceMap.WEAK, ReferenceMap.WEAK);
Object[] hard = new Object[10];
for (int i = 0; i < hard.length; i++) {
hard[i] = new Object();
map.put(hard[i], new Object());
}
System.gc();
assertTrue("map should be empty after purge of weak values", map.isEmpty());
for (int i = 0; i < hard.length; i++) {
map.put(new Object(), hard[i]);
}
System.gc();
assertTrue("map should be empty after purge of weak keys", map.isEmpty());
for (int i = 0; i < hard.length; i++) {
map.put(new Object(), hard[i]);
map.put(hard[i], new Object());
}
System.gc();
assertTrue("map should be empty after purge of weak keys and values", map.isEmpty());
}
public void testGetAfterGC() {
ReferenceMap map = new ReferenceMap(ReferenceMap.WEAK, ReferenceMap.WEAK);
for (int i = 0; i < 10; i++) {
map.put(new Integer(i), new Integer(i));
}
System.gc();
for (int i = 0; i < 10; i++) {
Integer I = new Integer(i);
assertTrue("map.containsKey should return false for GC'd element", !map.containsKey(I));
assertTrue("map.get should return null for GC'd element", map.get(I) == null);
}
}
public void testEntrySetIteratorAfterGC() {
ReferenceMap map = new ReferenceMap(ReferenceMap.WEAK, ReferenceMap.WEAK);
Object[] hard = new Object[10];
for (int i = 0; i < 10; i++) {
hard[i] = new Integer(10 + i);
map.put(new Integer(i), new Integer(i));
map.put(hard[i], hard[i]);
}
System.gc();
Iterator iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry entry = (Map.Entry)iterator.next();
Integer key = (Integer)entry.getKey();
Integer value = (Integer)entry.getValue();
assertTrue("iterator should skip GC'd keys", key.intValue() >= 10);
assertTrue("iterator should skip GC'd values", value.intValue() >= 10);
}
}
*/
/*
// Uncomment to create test files in /data/test
public void testCreateTestFiles() throws Exception {
ReferenceMap m = (ReferenceMap)makeEmptyMap();
writeExternalFormToDisk(m, getCanonicalEmptyCollectionName(m));
m = (ReferenceMap)makeFullMap();
writeExternalFormToDisk(m, getCanonicalFullCollectionName(m));
}
*/
public int getCompatibilityVersion() {
return 2; // actually 2.1, but can't represent that as an int
}
}
libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestHashBag.java 0100644 0001750 0001750 00000002515 10055172400 031310 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import junit.framework.*;
/**
* Extension of {@link TestBag} for exercising the {@link HashBag}
* implementation.
*
* @author Chuck Burdick
* @version $Id: TestHashBag.java,v 1.1.4.1 2004/05/22 12:14:05 scolebourne Exp $ */
public class TestHashBag extends TestBag {
public TestHashBag(String testName) {
super(testName);
}
public static Test suite() {
return new TestSuite(TestHashBag.class);
}
public static void main(String args[]) {
String[] testCaseName = { TestHashBag.class.getName() };
junit.textui.TestRunner.main(testCaseName);
}
public Bag makeBag() {
return new HashBag();
}
}
././@LongLink 0000000 0000000 0000000 00000000155 00000000000 011566 L ustar root root libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestCursorableLinkedList.java libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestCursorableLinked 0100644 0001750 0001750 00000074604 10055172400 032333 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import junit.framework.*;
import java.util.*;
/**
* @author Rodney Waldhoff
* @version $Id: TestCursorableLinkedList.java,v 1.6.2.1 2004/05/22 12:14:05 scolebourne Exp $
*/
public class TestCursorableLinkedList extends TestList {
public TestCursorableLinkedList(String testName) {
super(testName);
}
public static Test suite() {
return BulkTest.makeSuite(TestCursorableLinkedList.class);
}
public static void main(String args[]) {
String[] testCaseName = { TestCursorableLinkedList.class.getName() };
junit.textui.TestRunner.main(testCaseName);
}
private CursorableLinkedList list = null;
public void setUp() {
list = new CursorableLinkedList();
}
public List makeEmptyList() {
return new CursorableLinkedList();
}
public void testAdd() {
assertEquals("[]",list.toString());
assertTrue(list.add(new Integer(1)));
assertEquals("[1]",list.toString());
assertTrue(list.add(new Integer(2)));
assertEquals("[1, 2]",list.toString());
assertTrue(list.add(new Integer(3)));
assertEquals("[1, 2, 3]",list.toString());
assertTrue(list.addFirst(new Integer(0)));
assertEquals("[0, 1, 2, 3]",list.toString());
assertTrue(list.addLast(new Integer(4)));
assertEquals("[0, 1, 2, 3, 4]",list.toString());
list.add(0,new Integer(-2));
assertEquals("[-2, 0, 1, 2, 3, 4]",list.toString());
list.add(1,new Integer(-1));
assertEquals("[-2, -1, 0, 1, 2, 3, 4]",list.toString());
list.add(7,new Integer(5));
assertEquals("[-2, -1, 0, 1, 2, 3, 4, 5]",list.toString());
java.util.List list2 = new java.util.LinkedList();
list2.add("A");
list2.add("B");
list2.add("C");
assertTrue(list.addAll(list2));
assertEquals("[-2, -1, 0, 1, 2, 3, 4, 5, A, B, C]",list.toString());
assertTrue(list.addAll(3,list2));
assertEquals("[-2, -1, 0, A, B, C, 1, 2, 3, 4, 5, A, B, C]",list.toString());
}
public void testClear() {
assertEquals(0,list.size());
assertTrue(list.isEmpty());
list.clear();
assertEquals(0,list.size());
assertTrue(list.isEmpty());
list.add("element");
assertEquals(1,list.size());
assertTrue(!list.isEmpty());
list.clear();
assertEquals(0,list.size());
assertTrue(list.isEmpty());
list.add("element1");
list.add("element2");
assertEquals(2,list.size());
assertTrue(!list.isEmpty());
list.clear();
assertEquals(0,list.size());
assertTrue(list.isEmpty());
for(int i=0;i<1000;i++) {
list.add(new Integer(i));
}
assertEquals(1000,list.size());
assertTrue(!list.isEmpty());
list.clear();
assertEquals(0,list.size());
assertTrue(list.isEmpty());
}
public void testContains() {
assertTrue(!list.contains("A"));
assertTrue(list.add("A"));
assertTrue(list.contains("A"));
assertTrue(list.add("B"));
assertTrue(list.contains("A"));
assertTrue(list.addFirst("a"));
assertTrue(list.contains("A"));
assertTrue(list.remove("a"));
assertTrue(list.contains("A"));
assertTrue(list.remove("A"));
assertTrue(!list.contains("A"));
}
public void testContainsAll() {
assertTrue(list.containsAll(list));
java.util.List list2 = new java.util.LinkedList();
assertTrue(list.containsAll(list2));
list2.add("A");
assertTrue(!list.containsAll(list2));
list.add("B");
list.add("A");
assertTrue(list.containsAll(list2));
list2.add("B");
assertTrue(list.containsAll(list2));
list2.add("C");
assertTrue(!list.containsAll(list2));
list.add("C");
assertTrue(list.containsAll(list2));
list2.add("C");
assertTrue(list.containsAll(list2));
assertTrue(list.containsAll(list));
}
public void testCursorNavigation() {
list.add("1");
list.add("2");
list.add("3");
list.add("4");
list.add("5");
CursorableLinkedList.Cursor it = list.cursor();
assertTrue(it.hasNext());
assertTrue(!it.hasPrevious());
assertEquals("1",it.next());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals("1",it.previous());
assertTrue(it.hasNext());
assertTrue(!it.hasPrevious());
assertEquals("1",it.next());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals("2",it.next());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals("2",it.previous());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals("2",it.next());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals("3",it.next());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals("4",it.next());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals("5",it.next());
assertTrue(!it.hasNext());
assertTrue(it.hasPrevious());
assertEquals("5",it.previous());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals("4",it.previous());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals("3",it.previous());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals("2",it.previous());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals("1",it.previous());
assertTrue(it.hasNext());
assertTrue(!it.hasPrevious());
it.close();
}
public void testCursorSet() {
list.add("1");
list.add("2");
list.add("3");
list.add("4");
list.add("5");
CursorableLinkedList.Cursor it = list.cursor();
assertEquals("1",it.next());
it.set("a");
assertEquals("a",it.previous());
it.set("A");
assertEquals("A",it.next());
assertEquals("2",it.next());
it.set("B");
assertEquals("3",it.next());
assertEquals("4",it.next());
it.set("D");
assertEquals("5",it.next());
it.set("E");
assertEquals("[A, B, 3, D, E]",list.toString());
it.close();
}
public void testCursorRemove() {
list.add("1");
list.add("2");
list.add("3");
list.add("4");
list.add("5");
CursorableLinkedList.Cursor it = list.cursor();
try {
it.remove();
} catch(IllegalStateException e) {
// expected
}
assertEquals("1",it.next());
assertEquals("2",it.next());
assertEquals("[1, 2, 3, 4, 5]",list.toString());
it.remove();
assertEquals("[1, 3, 4, 5]",list.toString());
assertEquals("3",it.next());
assertEquals("3",it.previous());
assertEquals("1",it.previous());
it.remove();
assertEquals("[3, 4, 5]",list.toString());
assertTrue(!it.hasPrevious());
assertEquals("3",it.next());
it.remove();
assertEquals("[4, 5]",list.toString());
try {
it.remove();
} catch(IllegalStateException e) {
// expected
}
assertEquals("4",it.next());
assertEquals("5",it.next());
it.remove();
assertEquals("[4]",list.toString());
assertEquals("4",it.previous());
it.remove();
assertEquals("[]",list.toString());
it.close();
}
public void testCursorAdd() {
CursorableLinkedList.Cursor it = list.cursor();
it.add("1");
assertEquals("[1]",list.toString());
it.add("3");
assertEquals("[1, 3]",list.toString());
it.add("5");
assertEquals("[1, 3, 5]",list.toString());
assertEquals("5",it.previous());
it.add("4");
assertEquals("[1, 3, 4, 5]",list.toString());
assertEquals("4",it.previous());
assertEquals("3",it.previous());
it.add("2");
assertEquals("[1, 2, 3, 4, 5]",list.toString());
it.close();
}
public void testEqualsAndHashCode() {
assertTrue(list.equals(list));
assertEquals(list.hashCode(),list.hashCode());
list.add("A");
assertTrue(list.equals(list));
assertEquals(list.hashCode(),list.hashCode());
CursorableLinkedList list2 = new CursorableLinkedList();
assertTrue(!list.equals(list2));
assertTrue(!list2.equals(list));
java.util.List list3 = new java.util.LinkedList();
assertTrue(!list.equals(list3));
assertTrue(!list3.equals(list));
assertTrue(list2.equals(list3));
assertTrue(list3.equals(list2));
assertEquals(list2.hashCode(),list3.hashCode());
list2.add("A");
assertTrue(list.equals(list2));
assertTrue(list2.equals(list));
assertTrue(!list2.equals(list3));
assertTrue(!list3.equals(list2));
list3.add("A");
assertTrue(list2.equals(list3));
assertTrue(list3.equals(list2));
assertEquals(list2.hashCode(),list3.hashCode());
list.add("B");
assertTrue(list.equals(list));
assertTrue(!list.equals(list2));
assertTrue(!list2.equals(list));
assertTrue(!list.equals(list3));
assertTrue(!list3.equals(list));
list2.add("B");
list3.add("B");
assertTrue(list.equals(list));
assertTrue(list.equals(list2));
assertTrue(list2.equals(list));
assertTrue(list2.equals(list3));
assertTrue(list3.equals(list2));
assertEquals(list2.hashCode(),list3.hashCode());
list.add("C");
list2.add("C");
list3.add("C");
assertTrue(list.equals(list));
assertTrue(list.equals(list2));
assertTrue(list2.equals(list));
assertTrue(list2.equals(list3));
assertTrue(list3.equals(list2));
assertEquals(list.hashCode(),list2.hashCode());
assertEquals(list2.hashCode(),list3.hashCode());
list.add("D");
list2.addFirst("D");
assertTrue(list.equals(list));
assertTrue(!list.equals(list2));
assertTrue(!list2.equals(list));
}
public void testGet() {
try {
list.get(0);
fail("shouldn't get here");
} catch(IndexOutOfBoundsException e) {
// expected
}
assertTrue(list.add("A"));
assertEquals("A",list.get(0));
assertTrue(list.add("B"));
assertEquals("A",list.get(0));
assertEquals("B",list.get(1));
try {
list.get(-1);
fail("shouldn't get here");
} catch(IndexOutOfBoundsException e) {
// expected
}
try {
list.get(2);
fail("shouldn't get here");
} catch(IndexOutOfBoundsException e) {
// expected
}
}
public void testIndexOf() {
assertEquals(-1,list.indexOf("A"));
assertEquals(-1,list.lastIndexOf("A"));
list.add("A");
assertEquals(0,list.indexOf("A"));
assertEquals(0,list.lastIndexOf("A"));
assertEquals(-1,list.indexOf("B"));
assertEquals(-1,list.lastIndexOf("B"));
list.add("B");
assertEquals(0,list.indexOf("A"));
assertEquals(0,list.lastIndexOf("A"));
assertEquals(1,list.indexOf("B"));
assertEquals(1,list.lastIndexOf("B"));
list.addFirst("B");
assertEquals(1,list.indexOf("A"));
assertEquals(1,list.lastIndexOf("A"));
assertEquals(0,list.indexOf("B"));
assertEquals(2,list.lastIndexOf("B"));
}
public void testIsEmpty() {
assertTrue(list.isEmpty());
list.add("element");
assertTrue(!list.isEmpty());
list.remove("element");
assertTrue(list.isEmpty());
list.add("element");
assertTrue(!list.isEmpty());
list.clear();
assertTrue(list.isEmpty());
}
public void testIterator() {
list.add("1");
list.add("2");
list.add("3");
list.add("4");
list.add("5");
Iterator it = list.iterator();
assertTrue(it.hasNext());
assertEquals("1",it.next());
assertTrue(it.hasNext());
assertEquals("2",it.next());
assertTrue(it.hasNext());
assertEquals("3",it.next());
assertTrue(it.hasNext());
assertEquals("4",it.next());
assertTrue(it.hasNext());
assertEquals("5",it.next());
assertTrue(!it.hasNext());
it = list.iterator();
assertTrue(it.hasNext());
assertEquals("1",it.next());
it.remove();
assertEquals("[2, 3, 4, 5]",list.toString());
assertTrue(it.hasNext());
assertEquals("2",it.next());
it.remove();
assertEquals("[3, 4, 5]",list.toString());
assertTrue(it.hasNext());
assertEquals("3",it.next());
it.remove();
assertEquals("[4, 5]",list.toString());
assertTrue(it.hasNext());
assertEquals("4",it.next());
it.remove();
assertEquals("[5]",list.toString());
assertTrue(it.hasNext());
assertEquals("5",it.next());
it.remove();
assertEquals("[]",list.toString());
assertTrue(!it.hasNext());
}
public void testListIteratorNavigation() {
list.add("1");
list.add("2");
list.add("3");
list.add("4");
list.add("5");
ListIterator it = list.listIterator();
assertTrue(it.hasNext());
assertTrue(!it.hasPrevious());
assertEquals(-1,it.previousIndex());
assertEquals(0,it.nextIndex());
assertEquals("1",it.next());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals(0,it.previousIndex());
assertEquals(1,it.nextIndex());
assertEquals("1",it.previous());
assertTrue(it.hasNext());
assertTrue(!it.hasPrevious());
assertEquals(-1,it.previousIndex());
assertEquals(0,it.nextIndex());
assertEquals("1",it.next());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals(0,it.previousIndex());
assertEquals(1,it.nextIndex());
assertEquals("2",it.next());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals(1,it.previousIndex());
assertEquals(2,it.nextIndex());
assertEquals("2",it.previous());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals(0,it.previousIndex());
assertEquals(1,it.nextIndex());
assertEquals("2",it.next());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals(1,it.previousIndex());
assertEquals(2,it.nextIndex());
assertEquals("3",it.next());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals(2,it.previousIndex());
assertEquals(3,it.nextIndex());
assertEquals("4",it.next());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals(3,it.previousIndex());
assertEquals(4,it.nextIndex());
assertEquals("5",it.next());
assertTrue(!it.hasNext());
assertTrue(it.hasPrevious());
assertEquals(4,it.previousIndex());
assertEquals(5,it.nextIndex());
assertEquals("5",it.previous());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals(3,it.previousIndex());
assertEquals(4,it.nextIndex());
assertEquals("4",it.previous());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals(2,it.previousIndex());
assertEquals(3,it.nextIndex());
assertEquals("3",it.previous());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals(1,it.previousIndex());
assertEquals(2,it.nextIndex());
assertEquals("2",it.previous());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals(0,it.previousIndex());
assertEquals(1,it.nextIndex());
assertEquals("1",it.previous());
assertTrue(it.hasNext());
assertTrue(!it.hasPrevious());
assertEquals(-1,it.previousIndex());
assertEquals(0,it.nextIndex());
}
public void testListIteratorSet() {
list.add("1");
list.add("2");
list.add("3");
list.add("4");
list.add("5");
ListIterator it = list.listIterator();
assertEquals("1",it.next());
it.set("a");
assertEquals("a",it.previous());
it.set("A");
assertEquals("A",it.next());
assertEquals("2",it.next());
it.set("B");
assertEquals("3",it.next());
assertEquals("4",it.next());
it.set("D");
assertEquals("5",it.next());
it.set("E");
assertEquals("[A, B, 3, D, E]",list.toString());
}
public void testListIteratorRemove() {
list.add("1");
list.add("2");
list.add("3");
list.add("4");
list.add("5");
ListIterator it = list.listIterator();
try {
it.remove();
} catch(IllegalStateException e) {
// expected
}
assertEquals("1",it.next());
assertEquals("2",it.next());
assertEquals("[1, 2, 3, 4, 5]",list.toString());
it.remove();
assertEquals("[1, 3, 4, 5]",list.toString());
assertEquals("3",it.next());
assertEquals("3",it.previous());
assertEquals("1",it.previous());
it.remove();
assertEquals("[3, 4, 5]",list.toString());
assertTrue(!it.hasPrevious());
assertEquals("3",it.next());
it.remove();
assertEquals("[4, 5]",list.toString());
try {
it.remove();
} catch(IllegalStateException e) {
// expected
}
assertEquals("4",it.next());
assertEquals("5",it.next());
it.remove();
assertEquals("[4]",list.toString());
assertEquals("4",it.previous());
it.remove();
assertEquals("[]",list.toString());
}
public void testListIteratorAdd() {
ListIterator it = list.listIterator();
it.add("1");
assertEquals("[1]",list.toString());
it.add("3");
assertEquals("[1, 3]",list.toString());
it.add("5");
assertEquals("[1, 3, 5]",list.toString());
assertEquals("5",it.previous());
it.add("4");
assertEquals("[1, 3, 4, 5]",list.toString());
assertEquals("4",it.previous());
assertEquals("3",it.previous());
it.add("2");
assertEquals("[1, 2, 3, 4, 5]",list.toString());
}
public void testRemoveAll() {
list.add("1");
list.add("2");
list.add("3");
list.add("4");
list.add("5");
HashSet set = new HashSet();
set.add("A");
set.add("2");
set.add("C");
set.add("4");
set.add("D");
assertTrue(list.removeAll(set));
assertEquals("[1, 3, 5]",list.toString());
assertTrue(!list.removeAll(set));
}
public void testRemoveByIndex() {
list.add("1");
list.add("2");
list.add("3");
list.add("4");
list.add("5");
assertEquals("[1, 2, 3, 4, 5]",list.toString());
assertEquals("1",list.remove(0));
assertEquals("[2, 3, 4, 5]",list.toString());
assertEquals("3",list.remove(1));
assertEquals("[2, 4, 5]",list.toString());
assertEquals("4",list.remove(1));
assertEquals("[2, 5]",list.toString());
assertEquals("5",list.remove(1));
assertEquals("[2]",list.toString());
assertEquals("2",list.remove(0));
assertEquals("[]",list.toString());
}
public void testRemove() {
list.add("1");
list.add("1");
list.add("2");
list.add("3");
list.add("4");
list.add("5");
list.add("2");
list.add("3");
list.add("4");
list.add("5");
assertEquals("[1, 1, 2, 3, 4, 5, 2, 3, 4, 5]",list.toString());
assertTrue(!list.remove("6"));
assertTrue(list.remove("5"));
assertEquals("[1, 1, 2, 3, 4, 2, 3, 4, 5]",list.toString());
assertTrue(list.remove("5"));
assertEquals("[1, 1, 2, 3, 4, 2, 3, 4]",list.toString());
assertTrue(!list.remove("5"));
assertTrue(list.remove("1"));
assertEquals("[1, 2, 3, 4, 2, 3, 4]",list.toString());
assertTrue(list.remove("1"));
assertEquals("[2, 3, 4, 2, 3, 4]",list.toString());
assertTrue(list.remove("2"));
assertEquals("[3, 4, 2, 3, 4]",list.toString());
assertTrue(list.remove("2"));
assertEquals("[3, 4, 3, 4]",list.toString());
assertTrue(list.remove("3"));
assertEquals("[4, 3, 4]",list.toString());
assertTrue(list.remove("3"));
assertEquals("[4, 4]",list.toString());
assertTrue(list.remove("4"));
assertEquals("[4]",list.toString());
assertTrue(list.remove("4"));
assertEquals("[]",list.toString());
}
public void testRetainAll() {
list.add("1");
list.add("1");
list.add("2");
list.add("2");
list.add("3");
list.add("3");
list.add("4");
list.add("4");
list.add("5");
list.add("5");
HashSet set = new HashSet();
set.add("A");
set.add("2");
set.add("C");
set.add("4");
set.add("D");
assertTrue(list.retainAll(set));
assertEquals("[2, 2, 4, 4]",list.toString());
assertTrue(!list.retainAll(set));
}
public void testSet() {
list.add("1");
list.add("2");
list.add("3");
list.add("4");
list.add("5");
assertEquals("[1, 2, 3, 4, 5]",list.toString());
list.set(0,"A");
assertEquals("[A, 2, 3, 4, 5]",list.toString());
list.set(1,"B");
assertEquals("[A, B, 3, 4, 5]",list.toString());
list.set(2,"C");
assertEquals("[A, B, C, 4, 5]",list.toString());
list.set(3,"D");
assertEquals("[A, B, C, D, 5]",list.toString());
list.set(4,"E");
assertEquals("[A, B, C, D, E]",list.toString());
}
public void testSubList() {
list.add("A");
list.add("B");
list.add("C");
list.add("D");
list.add("E");
assertEquals("[A, B, C, D, E]",list.toString());
assertEquals("[A, B, C, D, E]",list.subList(0,5).toString());
assertEquals("[B, C, D, E]",list.subList(1,5).toString());
assertEquals("[C, D, E]",list.subList(2,5).toString());
assertEquals("[D, E]",list.subList(3,5).toString());
assertEquals("[E]",list.subList(4,5).toString());
assertEquals("[]",list.subList(5,5).toString());
}
public void testSubListAddEnd() {
list.add("A");
list.add("B");
list.add("C");
list.add("D");
list.add("E");
List sublist = list.subList(5,5);
sublist.add("F");
assertEquals("[A, B, C, D, E, F]",list.toString());
assertEquals("[F]",sublist.toString());
sublist.add("G");
assertEquals("[A, B, C, D, E, F, G]",list.toString());
assertEquals("[F, G]",sublist.toString());
}
public void testSubListAddBegin() {
list.add("A");
list.add("B");
list.add("C");
list.add("D");
list.add("E");
List sublist = list.subList(0,0);
sublist.add("a");
assertEquals("[a, A, B, C, D, E]",list.toString());
assertEquals("[a]",sublist.toString());
sublist.add("b");
assertEquals("[a, b, A, B, C, D, E]",list.toString());
assertEquals("[a, b]",sublist.toString());
}
public void testSubListAddMiddle() {
list.add("A");
list.add("B");
list.add("C");
list.add("D");
list.add("E");
List sublist = list.subList(1,3);
sublist.add("a");
assertEquals("[A, B, C, a, D, E]",list.toString());
assertEquals("[B, C, a]",sublist.toString());
sublist.add("b");
assertEquals("[A, B, C, a, b, D, E]",list.toString());
assertEquals("[B, C, a, b]",sublist.toString());
}
public void testSubListRemove() {
list.add("A");
list.add("B");
list.add("C");
list.add("D");
list.add("E");
List sublist = list.subList(1,4);
assertEquals("[B, C, D]",sublist.toString());
assertEquals("[A, B, C, D, E]",list.toString());
sublist.remove("C");
assertEquals("[B, D]",sublist.toString());
assertEquals("[A, B, D, E]",list.toString());
sublist.remove(1);
assertEquals("[B]",sublist.toString());
assertEquals("[A, B, E]",list.toString());
sublist.clear();
assertEquals("[]",sublist.toString());
assertEquals("[A, E]",list.toString());
}
public void testToArray() {
list.add("1");
list.add("2");
list.add("3");
list.add("4");
list.add("5");
Object[] elts = list.toArray();
assertEquals("1",elts[0]);
assertEquals("2",elts[1]);
assertEquals("3",elts[2]);
assertEquals("4",elts[3]);
assertEquals("5",elts[4]);
assertEquals(5,elts.length);
String[] elts2 = (String[])(list.toArray(new String[0]));
assertEquals("1",elts2[0]);
assertEquals("2",elts2[1]);
assertEquals("3",elts2[2]);
assertEquals("4",elts2[3]);
assertEquals("5",elts2[4]);
assertEquals(5,elts2.length);
String[] elts3 = new String[5];
assertSame(elts3,list.toArray(elts3));
assertEquals("1",elts3[0]);
assertEquals("2",elts3[1]);
assertEquals("3",elts3[2]);
assertEquals("4",elts3[3]);
assertEquals("5",elts3[4]);
assertEquals(5,elts3.length);
String[] elts4 = new String[3];
String[] elts4b = (String[])(list.toArray(elts4));
assertTrue(elts4 != elts4b);
assertEquals("1",elts4b[0]);
assertEquals("2",elts4b[1]);
assertEquals("3",elts4b[2]);
assertEquals("4",elts4b[3]);
assertEquals("5",elts4b[4]);
assertEquals(5,elts4b.length);
}
public void testSerialization() throws Exception {
list.add("A");
list.add("B");
list.add("C");
list.add("D");
list.add("E");
java.io.ByteArrayOutputStream buf = new java.io.ByteArrayOutputStream();
java.io.ObjectOutputStream out = new java.io.ObjectOutputStream(buf);
out.writeObject(list);
out.flush();
out.close();
java.io.ByteArrayInputStream bufin = new java.io.ByteArrayInputStream(buf.toByteArray());
java.io.ObjectInputStream in = new java.io.ObjectInputStream(bufin);
Object list2 = in.readObject();
assertTrue(list != list2);
assertTrue(list2.equals(list));
assertTrue(list.equals(list2));
}
public void testLongSerialization() throws Exception {
// recursive serialization will cause a stack
// overflow exception with long lists
for(int i=0;i<10000;i++) {
list.add(new Integer(i));
}
java.io.ByteArrayOutputStream buf = new java.io.ByteArrayOutputStream();
java.io.ObjectOutputStream out = new java.io.ObjectOutputStream(buf);
out.writeObject(list);
out.flush();
out.close();
java.io.ByteArrayInputStream bufin = new java.io.ByteArrayInputStream(buf.toByteArray());
java.io.ObjectInputStream in = new java.io.ObjectInputStream(bufin);
Object list2 = in.readObject();
assertTrue(list != list2);
assertTrue(list2.equals(list));
assertTrue(list.equals(list2));
}
/**
* Ignore the serialization tests for sublists and sub-sublists.
*
* @return an array of sublist serialization test names
*/
public String[] ignoredSimpleTests() {
ArrayList list = new ArrayList();
String prefix = "TestCursorableLinkedList";
String bulk = ".bulkTestSubList";
String[] ignored = new String[] {
".testEmptyListSerialization",
".testFullListSerialization",
".testEmptyListCompatibility",
".testFullListCompatibility",
".testSimpleSerialization",
".testCanonicalEmptyCollectionExists",
".testCanonicalFullCollectionExists"
};
for (int i = 0; i < ignored.length; i++) {
list.add(prefix + bulk + ignored[i]);
list.add(prefix + bulk + bulk + ignored[i]);
}
return (String[])list.toArray(new String[0]);
}
}
libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestFastTreeMap.java 0100644 0001750 0001750 00000003757 10055172400 032177 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.Map;
import java.util.TreeMap;
import junit.framework.Test;
/**
* @author Jason van Zyl
* @version $Id: TestFastTreeMap.java,v 1.9.2.1 2004/05/22 12:14:05 scolebourne Exp $
*/
public class TestFastTreeMap extends TestTreeMap
{
public TestFastTreeMap(String testName)
{
super(testName);
}
public static Test suite()
{
return BulkTest.makeSuite(TestFastTreeMap.class);
}
public static void main(String args[])
{
String[] testCaseName = { TestFastTreeMap.class.getName() };
junit.textui.TestRunner.main(testCaseName);
}
public Map makeEmptyMap() {
FastTreeMap ftm = new FastTreeMap();
ftm.setFast(false);
return (ftm);
}
public Map makeConfirmedEmptyMap() {
return new TreeMap();
}
/**
* The comparator for the fast tree map does not support null keys.
**/
public boolean useNullKey() {
return false;
}
/**
* There is a bug in JDK1.2.2 TreeMap; the keySet will incorrectly
* return false when a null value is removed
*/
public boolean useNullValue() {
return false;
}
public void setUp()
{
map = (TreeMap) makeEmptyMap();
}
}
libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestProxyMap.java 0100644 0001750 0001750 00000003515 10055172400 031573 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
/**
* Tests the {@link org.apache.commons.collections.ProxyMap} class.
*
* @author Daniel Rall
* @since 2.0
*/
public abstract class TestProxyMap extends TestMap
{
public TestProxyMap(String testName)
{
super(testName);
}
public static void main(String args[])
{
String[] testCaseName = { TestProxyMap.class.getName() };
junit.textui.TestRunner.main(testCaseName);
}
public boolean useNullKey() {
return false;
}
protected ProxyMap map = null;
public void setUp()
{
map = (ProxyMap) makeEmptyMap();
}
public void testNewMap()
{
assertTrue("New map is empty", map.isEmpty());
assertEquals("New map has size zero", map.size(), 0);
}
public void testSearch()
{
map.put("first", "First Item");
map.put("second", "Second Item");
assertEquals("Top item is 'Second Item'", map.get("first"),
"First Item");
assertEquals("Next Item is 'First Item'", map.get("second"),
"Second Item");
map.clear();
}
}
libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestArrayStack.java 0100644 0001750 0001750 00000007044 10055172400 032061 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import junit.framework.*;
import java.util.*;
/**
* @author Craig McClanahan
* @version $Id: TestArrayStack.java,v 1.7.2.1 2004/05/22 12:14:05 scolebourne Exp $
*/
public class TestArrayStack extends TestArrayList {
public TestArrayStack(String testName) {
super(testName);
}
public static Test suite() {
return BulkTest.makeSuite(TestArrayStack.class);
}
public static void main(String args[]) {
String[] testCaseName = { TestArrayStack.class.getName() };
junit.textui.TestRunner.main(testCaseName);
}
public List makeEmptyList() {
return new ArrayStack();
}
protected ArrayStack stack = null;
public void setUp() {
stack = (ArrayStack) makeEmptyList();
list = stack;
}
public void testNewStack() {
assertTrue("New stack is empty", stack.empty());
assertEquals("New stack has size zero", stack.size(), 0);
try {
stack.peek();
fail("peek() should have thrown EmptyStackException");
} catch (EmptyStackException e) {
; // Expected result
}
try {
stack.pop();
fail("pop() should have thrown EmptyStackException");
} catch (EmptyStackException e) {
; // Expected result
}
}
public void testPushPeekPop() {
stack.push("First Item");
assertTrue("Stack is not empty", !stack.empty());
assertEquals("Stack size is one", stack.size(), 1);
assertEquals("Top item is 'First Item'",
(String) stack.peek(), "First Item");
assertEquals("Stack size is one", stack.size(), 1);
stack.push("Second Item");
assertEquals("Stack size is two", stack.size(), 2);
assertEquals("Top item is 'Second Item'",
(String) stack.peek(), "Second Item");
assertEquals("Stack size is two", stack.size(), 2);
assertEquals("Popped item is 'Second Item'",
(String) stack.pop(), "Second Item");
assertEquals("Top item is 'First Item'",
(String) stack.peek(), "First Item");
assertEquals("Stack size is one", stack.size(), 1);
assertEquals("Popped item is 'First Item'",
(String) stack.pop(), "First Item");
assertEquals("Stack size is zero", stack.size(), 0);
}
public void testSearch() {
stack.push("First Item");
stack.push("Second Item");
assertEquals("Top item is 'Second Item'",
stack.search("Second Item"), 1);
assertEquals("Next Item is 'First Item'",
stack.search("First Item"), 2);
assertEquals("Cannot find 'Missing Item'",
stack.search("Missing Item"), -1);
}
}
././@LongLink 0000000 0000000 0000000 00000000147 00000000000 011567 L ustar root root libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestFastArrayList1.java libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestFastArrayList1.j 0100644 0001750 0001750 00000003234 10055172400 032133 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.ArrayList;
import java.util.List;
import junit.framework.Test;
/**
* Test FastArrayList implementation in fast mode.
*
* @author Jason van Zyl
* @version $Id: TestFastArrayList1.java,v 1.4.2.1 2004/05/22 12:14:05 scolebourne Exp $
*/
public class TestFastArrayList1 extends TestFastArrayList
{
public TestFastArrayList1(String testName)
{
super(testName);
}
public static Test suite()
{
return BulkTest.makeSuite(TestFastArrayList1.class);
}
public static void main(String args[])
{
String[] testCaseName = { TestFastArrayList1.class.getName() };
junit.textui.TestRunner.main(testCaseName);
}
public void setUp()
{
list = (ArrayList) makeEmptyList();
}
public List makeEmptyList()
{
FastArrayList fal = new FastArrayList();
fal.setFast(true);
return (fal);
}
}
libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestFastHashMap.java 0100644 0001750 0001750 00000003214 10055172376 032163 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.Map;
import junit.framework.Test;
/**
* @author Jason van Zyl
* @version $Id: TestFastHashMap.java,v 1.8.2.1 2004/05/22 12:14:05 scolebourne Exp $
*/
public class TestFastHashMap extends TestMap
{
public TestFastHashMap(String testName)
{
super(testName);
}
public static Test suite()
{
return BulkTest.makeSuite(TestFastHashMap.class);
}
public static void main(String args[])
{
String[] testCaseName = { TestFastHashMap.class.getName() };
junit.textui.TestRunner.main(testCaseName);
}
public Map makeEmptyMap() {
FastHashMap fhm = new FastHashMap();
fhm.setFast(false);
return (fhm);
}
/**
* There is a bug in JDK1.2 HashMap; the keySet() will incorrectly
* return false when a null value is removed.
*/
public boolean useNullValue() {
return false;
}
}
././@LongLink 0000000 0000000 0000000 00000000146 00000000000 011566 L ustar root root libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestFastArrayList.java libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestFastArrayList.ja 0100644 0001750 0001750 00000003111 10055172402 032207 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.ArrayList;
import java.util.List;
import junit.framework.Test;
/**
* @author Jason van Zyl
* @version $Id: TestFastArrayList.java,v 1.6.2.1 2004/05/22 12:14:05 scolebourne Exp $
*/
public class TestFastArrayList extends TestArrayList
{
public TestFastArrayList(String testName)
{
super(testName);
}
public static Test suite()
{
return BulkTest.makeSuite(TestFastArrayList.class);
}
public static void main(String args[])
{
String[] testCaseName = { TestFastArrayList.class.getName() };
junit.textui.TestRunner.main(testCaseName);
}
public void setUp()
{
list = (ArrayList) makeEmptyList();
}
public List makeEmptyList()
{
FastArrayList fal = new FastArrayList();
fal.setFast(false);
return (fal);
}
}
libcommons-collections-java-2.1.1.orig/data/ 0040755 0001750 0001750 00000000000 10055172376 017466 5 ustar tora tora libcommons-collections-java-2.1.1.orig/data/test/ 0040755 0001750 0001750 00000000000 10072637470 020445 5 ustar tora tora libcommons-collections-java-2.1.1.orig/data/test/FastTreeMap.fullCollection.version1.obj 0100644 0001750 0001750 00000001166 10055172376 030037 0 ustar tora tora ¬í sr *org.apache.commons.collections.FastTreeMapx©9‚¨s]' Z fastL mapt Ljava/util/TreeMap;xr java.util.TreeMap Áö>-%jæ L
comparatort Ljava/util/Comparator;xppw t againt againvt allt allvt bart barvt bazt bazvt blaht blahvt foot foovt geet geevt gollyt gollyvt goodbyet goodbyevt gosht goshvt hellot hellovt keypt key2t valuet
nonnullkeyq ~ t seet seevt tmpt tmpvt we'llt we'llvt yout youvx sq ~ pw q ~ q ~ q ~ q ~ q ~ q ~
q ~ q ~ q ~
q ~ q ~ q ~ q ~ q ~ q ~ q ~ q ~ q ~ q ~ q ~ q ~ q ~ q ~ pq ~ q ~ q ~ q ~ q ~ q ~ q ~ !q ~ "q ~ #q ~ $q ~ %q ~ &x libcommons-collections-java-2.1.1.orig/data/test/FastArrayList.fullCollection.version1.obj 0100644 0001750 0001750 00000000276 10055172400 030401 0 ustar tora tora ¬í sr ,org.apache.commons.collections.FastArrayList¼Ã ³ax Z fastL listt Ljava/util/ArrayList;xr java.util.ArrayListxÒ ™Ça I sizexp w
x sq ~ w
t 1t 3t 4q ~ x libcommons-collections-java-2.1.1.orig/data/test/FastHashMap.emptyCollection.version1.obj 0100644 0001750 0001750 00000000310 10055172400 030171 0 ustar tora tora ¬í sr *org.apache.commons.collections.FastHashMapÏT&ƒˆŽ Z fastL mapt Ljava/util/HashMap;xr java.util.HashMapÚÁÃ`Ñ F
loadFactorI thresholdxp?@ w x sq ~ ?@ w x libcommons-collections-java-2.1.1.orig/data/test/CursorableLinkedList.fullCollection.version1.obj 0100644 0001750 0001750 00000000304 10055172376 031741 0 ustar tora tora ¬í sr 3org.apache.commons.collections.CursorableLinkedListz¡,´´özÁ I _modCountL _cursorst Ljava/util/List;xp sr java.util.ArrayListxÒ ™Ça I sizexp w
xw t 1t 3t 4q ~ x libcommons-collections-java-2.1.1.orig/data/test/LRUMap.emptyCollection.version2.obj 0100644 0001750 0001750 00000000203 10055172376 027150 0 ustar tora tora ¬í sr %org.apache.commons.collections.LRUMap ~ÙÌC¤» xr /org.apache.commons.collections.SequencedHashMap.ê"“©"& xpw d x libcommons-collections-java-2.1.1.orig/data/test/ArrayStack.fullCollection.version1.obj 0100644 0001750 0001750 00000000203 10055172376 027717 0 ustar tora tora ¬í sr )org.apache.commons.collections.ArrayStack µ×/G xr java.util.ArrayListxÒ ™Ça I sizexp w
t 1t 3t 4q ~ x libcommons-collections-java-2.1.1.orig/data/test/MultiHashMap.emptyCollection.version2.obj 0100644 0001750 0001750 00000000267 10055172400 030402 0 ustar tora tora ¬í sr +org.apache.commons.collections.MultiHashMapøí ŠÕ L mNamet Ljava/lang/String;xr java.util.HashMapÚÁÃ`Ñ F
loadFactorI thresholdxp?@ w xt MultiMap-26 libcommons-collections-java-2.1.1.orig/data/test/MultiHashMap.fullCollection.version2.obj 0100644 0001750 0001750 00000001411 10055172400 030176 0 ustar tora tora ¬í sr +org.apache.commons.collections.MultiHashMapøí ŠÕ L mNamet Ljava/lang/String;xr java.util.HashMapÚÁÃ`Ñ F
loadFactorI thresholdxp?@ #w / t gollysr java.util.ArrayListxÒ ™Ça I sizexp w
t gollyvxt goodbyesq ~ w
t goodbyevxt allsq ~ w
t allvxt blahsq ~ w
t blahvxt geesq ~ w
t geevxt yousq ~ w
t youvxt againsq ~ w
t againvxt hellosq ~ w
t hellovxt we'llsq ~ w
t we'llvxt bazsq ~ w
t bazvxt goshsq ~ w
t goshvxt barsq ~ w
t barvxt foosq ~ w
t foovxt seesq ~ w
t seevxt tmpsq ~ w
t tmpvxt key2sq ~ w
t valuexpsq ~ w
q ~ 4xt keysq ~ w
pxxt MultiMap-28 libcommons-collections-java-2.1.1.orig/data/test/ReverseComparator.version2.obj 0100644 0001750 0001750 00000000257 10055172400 026337 0 ustar tora tora ’ sr
The introduction of the Collections API by Sun in JDK 1.2 has been a
boon to quick and effective Java programming. Ready access to
powerful data structures has accelerated development by reducing the
need for custom container classes around each core object. Most Java2
APIs are significantly easier to use because of the Collections API.
However, there are certain holes left unfilled by Sun's
implementations, and the Jakarta-Commons Collections Component strives
to fulfill them. Among the features of this package are:
An alphabetical list of the package can be found in the collections
status document.
The JavaDoc API documents are available online.
The Collections package contains a set of Java classes that
extend or augment the Java Collections Framework.
The following classes are included: comparators subpackage: iterators subpackage: The Collections package is dependent upon the following external
components for development and use: Current Release:
Version 2.1
Planned Next Release: ? The following individuals are the primary developers and maintainers of this
component. Developers who plan to use Collections in their own
projects are encouraged to collaborate on the future development of this
component to ensure that it continues to meet a variety of needs. Want to help? Here's some "to do" items the team has identified. Collections 2.0 includes a significant number of new collections, in addition to several
useful Comparator classes. Descriptions of the new collections and comparators follow.
(For descriptions of all classes in Collections, see the STATUS.html file.) These collections are new to Collections 2.0: These are the new Comparator classes: ArrayEnumeration ArrayEnumeration has been deprecated. This class has significant overlap with
ArrayIterator, and Collections focuses mainly on Java2-style
collections. If you need to enumerate an array,
create an ArrayIterator and wrap it with an
IteratorEnumeration instead. ArrayIterator Bugs fixed: LRUMap LRUMap has been reimplemented as a subclass of
SynchronizedHashMap. The new implementation of
LRUMap should be faster, and it also offers true LRU
capabilities; now any get(Object) or
put(Object,Object) from this collection
promotes the key to the Most Recently Used position. LRUMap 2.0 compatibility changes: New features: Bugs fixed: BeanMap BeanMap's entrySet() now properly returns a set containing Map.Entry
objects. Previously, entrySet() was equivalent to keySet() (returns a set of
the readable properties) and there was no mechanism to retrieve all of the
readable properties along with their values. Additionally, the BeanMap clone
method has been revamped to work better for subclasses. BeanMap 2.0 compatibility changes: Bugs fixed: PriorityQueue Changed to allow priority queue implementations that support determining
priorities using means other than the object's natural ordering (i.e. a
priority queue that does not depend on the object implementing the Comparable
interface). PriorityQueue 2.0 compatibility changes: BinaryHeap Changed to allow the specification of a Comparator that should be used to
compare objects to determine "priority" of the objects. If no comparator is
specified, the object's natural ordering is used. BinaryHeap 2.0 compatibility changes: New features:
This is a patch release of Commons Collections 2.1
The latest version of Commons Collections is 3.0.
Unfortunately, the release of version 3.0 introduced a binary incompatibility
with 2.1 in the
Regrettably, despite the issue being discovered by other teams, no feedback was
given to the Commons Collections team, preventing a simple solution.
Please provide feedback to Commons Collections when you find issues like this!
This patch to Commons Collections is designed to allow version 2.1.1 to co-exist
with version 3.1. The patch contains the following changes:
To make your code compatible with both 2.1.1 and 3.1 and later, remove all
deprecation warnings from your code and re-release.
If you have no deprecation warnings after installing this jar, your code is
already compatible, and will run with versions 2.1, 2.1.1, 3.0 and later.
Collections 2.1 includes a significant number of new collections
in addition to various bug fixes and refactoring changes. The major additions
are:
The decorators are found on classes named
Access to Iterators and Comparators has also been brought in line, by the provision
of These collections are new to Collections 2.1: These comparators are new to Collections 2.1: These iterators are new to Collections 2.1: These are the new utility classes: ArrayStack Now implements the Buffer interface. The Buffer.get() and Buffer.remove()
methods are implemented in terms of peek() and pop(). The class has also
been altered to allow null elements inline with ArrayList. BeanMap A new method was added to allow a bulk putAll(Map) operation only for
bean properties that are actually writeable. The new method, named
putAllWriteable(Map), can be used to set one bean's state to another's
by using two BeanMaps. BinaryHeap Now implements the Buffer interface. Since Buffer is a subinterface of
Collection, BinaryHeap is also a Collection. This makes it much more
interoperable with existing APIs. The Buffer.get() and Buffer.remove()
methods are implemented in terms of peek() and pop(). CollectionUtils Modified the index(Object,Object) method to work for arbitrary collections.
Previously the method only worked for Lists. Added the
predicatedCollection(Collection, Predicate) method. CursorableLinkedList Fixed NullPointerExceptions that were raised by contains(Object),
indexOf(Object), lastIndexOf(Object) and remove(Object) if the given
Object was null. DefaultMapBag A basic toString() method was added to aid in debugging. FastArrayList Added severe warning about possible unexpected failures of this class on
some architectures. Fixed the subList(int,int) method so that changes to the
sublist are reflected in the original list, even in fast mode. FastHashMap Added severe warning about possible unexpected failures of this class on
some architectures. Fixed the collection views so changes to the
map are reflected in the collection views and vice-versa, even in fast
mode. FastTreeMap Added severe warning about possible unexpected failures of this class on
some architectures. Fixed the collection views so changes to the
map are reflected in the collection views and vice-versa, even in fast
mode. LRUMap The get(Object) method was fixed to ensure that if containsKey(foo)
returns false, then get(foo) will not change that. (Before, invoking
get(Object) on a nonexistent key could cause that key to incorrectly map
to a null value). Also, the changes to SequencedHashMap were inherited
by LRUMap. ListUtils The previous version of this class was deprecated; it has been
un-deprecated. Decorators were added to allow predicated, lazy and
fixed-size lists. MapUtils Added decorators to allow predicated, lazy and fixed-size maps and
sorted maps. ProxyMap Fixed a bug in the equals(Object) method. Before the equals(Object)
method infinitely recursively called itself until a StackOverflowError
was raised. This version of the method properly delegates the method
call to the underlying map. SequencedHashMap The iterators on collection views now raise a ConcurrentModificationException
if the map is modified through something other than the iterator. The
equals(Object) and hashCode() methods were fixed to correctly implement
the Map specification. The remove(Object) methods in the keySet() and
entrySet() were fixed so that they correctly return false after removing
a null key. SoftRefHashMap SoftRefHashMap has been deprecated because it was all kinds of
wonky. Its semantics were never well-defined, many of its operations had
unintuitive side-effects, it violated the java.util.Map contract in several
places and its internal algorithms were inefficient. A new class,
ReferenceMap, is a more general solution that can be used in place of
SoftRefHashMap.
StringStack StringStack has been deprecated because it was unsuitable for
inclusion in collections. It enabled a delimited String to be built up.
This functionality is better placed in StringUtils in the lang project.
Documentation Almost every class released in 2.0 was touched to improve on, or in
some cases complete, the JavaDoc. Those documentation changes are not
described in detail below; but the goal was simply to have the public
and protected Collections API completely documentated. If a class released
in 2.0 had missing public or protected JavaDoc, then the class was modified
to add it. New Testing Suite The unit testing framework used to test collections and maps underwent
a major overhaul between 2.0 and 2.1. The new tests check for stricter
Collection and Map contract conformance. Many bugs were found and addressed
with the new tests; bug fixes are described below. The testing suite is
not considered part of the binary release and may undergo further changes. New iterators Subpackage All of the iterator classes released in Collections 2.0 have been
moved to an iterators subpackage in Collections 2.1. Versions of
the iterators still exist in the main package, but have been deprecated.
This was a simple organizational move that will hopefully make the packages
easier to navigate and absorb. The affected classes from 2.0 are: In addition, new iterators were added to the subpackage; these are
described below. Note that other than being in a new package, no other changes were made
to the iterator implementations. The Collections package contains a set of Java classes that extend
or augment the Java Collections Framework. This developers guide seeks to set
out rules for the naming of classes and methods within the package. The purpose
of this, as with all naming standards, is to improve the coherency and
consistency of the whole API. The philosophy of the naming standards is to follow those of
java.util.Collections. Collection interfaces are new types of collections not included in Java.
Examples include Collection implementation are new implementations of collection interfaces.
Examples include Utility classes provide additional functionality around an interface and
its basic implementations. Examples include CollectionUtils and ListUtils. Each class shall follow the naming pattern XxxUtils where Xxx relates to the
object being returned by the class, for example Where the method in a Utils class is a decorator, the name shall consist of
an adjective followed by the collection type. Typically such adjective is
formed by appending an -ed suffix (meaning "having"/"characterized by") to the
word describing the type of decorator. For example,
Typically, these decorators should be implemented as non-public, static,
inner classes; however, if warranted due to maintenance or other reasons, these
decorator classes may be moved to top-level classes in a subpackage. The
naming of such a subpackage should be discussed and agreed upon on the
developers mailing list.
The Java Collections Framework provides a set of abstract data
type interfaces and implementations that offer both a wealth
of useful functionality, and a solid foundation for extending
that functionality.
Many Jakarta projects have needs or design criteria that extend
beyond the core Collections API, such as introducing new abstract
data types (e.g., Avalon's BinaryHeap) or changing the behaviour of
existing abstract data types (e.g., Struts' FastHashMap).
In keeping with the spirit of the Collections API and of abstract
data types in general, these components can and should be shared
assets. A Commons package for abstract data types would
encourage the development and reuse of a robust set of collections
classes.
The package will create and maintain a set of collections and
related classes designed to be compatible with the Java Collections
Framework, and to be distributed under the ASF license.
Collections relies only on standard JDK 1.2 (or later) APIs for
production deployment. It utilizes the JUnit unit testing framework for
developing and executing unit tests, but this is of interest only to
developers of the component. Collections will also be a dependency for
several future proposed components for the Jakarta Commons subproject.
No external configuration files are utilized.
The initial codebase was harvested from existing and proposed
Jakarta packages, including the Commons Database Connection Pool,
Struts, and Avalon.
The proposed package name for the new component is
true iff some element of a
* is also an element of b (or, equivalently, if
* some element of b is also an element of a).
* In other words, this method returns true
* iff the {@link #intersection} of a and b
* is not empty.
* @since 2.1
* @param a a non-null Collection
* @param b a non-null Collection
* @return true iff the intersection of a and b is non-empty
* @see #intersection
*/
public static boolean containsAny(final Collection a, final Collection b) {
// TO DO: we may be able to optimize this by ensuring either a or b
// is the larger of the two Collections, but I'm not sure which.
for(Iterator iter = a.iterator(); iter.hasNext();) {
if(b.contains(iter.next())) {
return true;
}
}
return false;
}
/**
* Returns a {@link Map} mapping each unique element in
* the given {@link Collection} to an {@link Integer}
* representing the number of occurances of that element
* in the {@link Collection}.
* An entry that maps to null indicates that the
* element does not appear in the given {@link Collection}.
*/
public static Map getCardinalityMap(final Collection col) {
HashMap count = new HashMap();
Iterator it = col.iterator();
while(it.hasNext()) {
Object obj = it.next();
Integer c = (Integer)(count.get(obj));
if(null == c) {
count.put(obj,new Integer(1));
} else {
count.put(obj,new Integer(c.intValue() + 1));
}
}
return count;
}
/**
* Returns true iff a is a sub-collection of b,
* that is, iff the cardinality of e in a is less
* than or equal to the cardinality of e in b,
* for each element e in a.
*
* @see #isProperSubCollection
* @see Collection#containsAll
*/
public static boolean isSubCollection(final Collection a, final Collection b) {
Map mapa = getCardinalityMap(a);
Map mapb = getCardinalityMap(b);
Iterator it = a.iterator();
while (it.hasNext()) {
Object obj = it.next();
if (getFreq(obj, mapa) > getFreq(obj, mapb)) {
return false;
}
}
return true;
}
/**
* Returns true iff a is a proper sub-collection of b,
* that is, iff the cardinality of e in a is less
* than or equal to the cardinality of e in b,
* for each element e in a, and there is at least one
* element f such that the cardinality of f in b
* is strictly greater than the cardinality of f in a.
*
* @see #isSubCollection
* @see Collection#containsAll
*/
public static boolean isProperSubCollection(final Collection a, final Collection b) {
// XXX optimize me!
return CollectionUtils.isSubCollection(a,b) && (!(CollectionUtils.isEqualCollection(a,b)));
}
/**
* Returns true iff the given {@link Collection}s contain
* exactly the same elements with exactly the same cardinality.
*
*
*
* @param obj the object to get an index of
* @param index the index to get
* @throws IndexOutOfBoundsException
* @throws NoSuchElementException
*/
public static Object index(Object obj, int idx) {
return index(obj, new Integer(idx));
}
/**
* Given an Object, and a key (index), it will get value associated with
* that key in the Object. The following checks are made:
*
*
*
* @param obj the object to get an index of
* @param index the index to get
* @return the object at the specified index
* @throws IndexOutOfBoundsException
* @throws NoSuchElementException
*/
public static Object index(Object obj, Object index) {
if(obj instanceof Map) {
Map map = (Map)obj;
if(map.containsKey(index)) {
return map.get(index);
}
}
int idx = -1;
if(index instanceof Integer) {
idx = ((Integer)index).intValue();
}
if(idx < 0) {
return obj;
}
else if(obj instanceof Map) {
Map map = (Map)obj;
Iterator iterator = map.keySet().iterator();
return index(iterator, idx);
}
else if(obj instanceof List) {
return ((List)obj).get(idx);
}
else if(obj instanceof Object[]) {
return ((Object[])obj)[idx];
}
else if(obj instanceof Enumeration) {
Enumeration enumeration = (Enumeration)obj;
while(enumeration.hasMoreElements()) {
idx--;
if(idx == -1) {
return enumeration.nextElement();
} else {
enumeration.nextElement();
}
}
}
else if(obj instanceof Iterator) {
return index((Iterator)obj, idx);
}
else if(obj instanceof Collection) {
Iterator iterator = ((Collection)obj).iterator();
return index(iterator, idx);
}
return obj;
}
private static Object index(Iterator iterator, int idx) {
while(iterator.hasNext()) {
idx--;
if(idx == -1) {
return iterator.next();
} else {
iterator.next();
}
}
return iterator;
}
/**
* Returns an Iterator for the given object. Currently this method can handle
* Iterator, Enumeration, Collection, Map, Object[] or array.
*
* @deprecated use IteratorUtils version instead
*/
public static Iterator getIterator(Object obj) {
if(obj instanceof Iterator) {
return (Iterator)obj;
}
else if(obj instanceof Collection) {
return ((Collection)obj).iterator();
}
else if(obj instanceof Object[]) {
return new ArrayIterator( obj );
}
else if(obj instanceof Enumeration) {
return new EnumerationIterator( (Enumeration)obj );
}
else if(obj instanceof Map) {
return ((Map)obj).values().iterator();
}
else if(obj != null && obj.getClass().isArray()) {
return new ArrayIterator( obj );
}
else{
return null;
}
}
/** Reverses the order of the given array */
public static void reverseArray(Object[] array) {
int i = 0;
int j = array.length - 1;
Object tmp;
while(j>i) {
tmp = array[j];
array[j] = array[i];
array[i] = tmp;
j--;
i++;
}
}
private static final int getFreq(final Object obj, final Map freqMap) {
try {
return ((Integer)(freqMap.get(obj))).intValue();
} catch(NullPointerException e) {
// ignored
} catch(NoSuchElementException e) {
// ignored
}
return 0;
}
/**
* 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:
*
* CollectionWrapper
* PredicatedCollection
* PredicatedSet
* PredicatedList
* PredicatedBag
* PredicatedBuffer
* UnmodifiableCollection
* UnmodifiableBag
* UnmodifiableBuffer
* LazyCollection
* LazyList
* LazyBag
* SynchronizedCollection
* SynchronizedBuffer
* SynchronizedBag
* SynchronizedBuffer
*
*/
static class CollectionWrapper
implements Collection {
protected final Collection collection;
public CollectionWrapper(Collection collection) {
if (collection == null) {
throw new IllegalArgumentException("Collection must not be null");
}
this.collection = collection;
}
public int size() {
return collection.size();
}
public boolean isEmpty() {
return collection.isEmpty();
}
public boolean contains(Object o) {
return collection.contains(o);
}
public Iterator iterator() {
return collection.iterator();
}
public Object[] toArray() {
return collection.toArray();
}
public Object[] toArray(Object[] o) {
return collection.toArray(o);
}
public boolean add(Object o) {
return collection.add(o);
}
public boolean remove(Object o) {
return collection.remove(o);
}
public boolean containsAll(Collection c2) {
return collection.containsAll(c2);
}
public boolean addAll(Collection c2) {
return collection.addAll(c2);
}
public boolean removeAll(Collection c2) {
return collection.removeAll(c2);
}
public boolean retainAll(Collection c2) {
return collection.retainAll(c2);
}
public void clear() {
collection.clear();
}
public boolean equals(Object o) {
if (o == this) return true;
return collection.equals(o);
}
public int hashCode() {
return collection.hashCode();
}
public String toString() {
return collection.toString();
}
}
static class PredicatedCollection
extends CollectionWrapper {
protected final Predicate predicate;
public PredicatedCollection(Collection c, Predicate p) {
super(c);
if (p == null) {
throw new IllegalArgumentException("Predicate must not be null");
}
this.predicate = p;
for (Iterator iter = c.iterator(); iter.hasNext(); ) {
validate(iter.next());
}
}
public boolean add(Object o) {
validate(o);
return collection.add(o);
}
public boolean addAll(Collection c2) {
for (Iterator iter = c2.iterator(); iter.hasNext(); ) {
validate(iter.next());
}
return collection.addAll(c2);
}
protected void validate(Object o) {
if (!predicate.evaluate(o)) {
throw new IllegalArgumentException("Cannot add Object - Predicate rejected it");
}
}
}
static class UnmodifiableCollection
extends CollectionWrapper {
public UnmodifiableCollection(Collection c) {
super(c);
}
public boolean add(Object o) {
throw new UnsupportedOperationException();
}
public boolean addAll(Collection c) {
throw new UnsupportedOperationException();
}
public boolean remove(Object o) {
throw new UnsupportedOperationException();
}
public boolean removeAll(Collection c) {
throw new UnsupportedOperationException();
}
public boolean retainAll(Collection c) {
throw new UnsupportedOperationException();
}
public void clear() {
throw new UnsupportedOperationException();
}
public Iterator iterator() {
return new UnmodifiableIterator(collection.iterator());
}
}
static class SynchronizedCollection {
protected final Collection collection;
public SynchronizedCollection(Collection collection) {
if (collection == null) {
throw new IllegalArgumentException("Collection must not be null");
}
this.collection = collection;
}
public synchronized int size() {
return collection.size();
}
public synchronized boolean isEmpty() {
return collection.isEmpty();
}
public synchronized boolean contains(Object o) {
return collection.contains(o);
}
public Iterator iterator() {
return collection.iterator();
}
public synchronized Object[] toArray() {
return collection.toArray();
}
public synchronized Object[] toArray(Object[] o) {
return collection.toArray(o);
}
public synchronized boolean add(Object o) {
return collection.add(o);
}
public synchronized boolean remove(Object o) {
return collection.remove(o);
}
public synchronized boolean containsAll(Collection c2) {
return collection.containsAll(c2);
}
public synchronized boolean addAll(Collection c2) {
return collection.addAll(c2);
}
public synchronized boolean removeAll(Collection c2) {
return collection.removeAll(c2);
}
public synchronized boolean retainAll(Collection c2) {
return collection.retainAll(c2);
}
public synchronized void clear() {
collection.clear();
}
public synchronized boolean equals(Object o) {
return collection.equals(o);
}
public synchronized int hashCode() {
return collection.hashCode();
}
public synchronized String toString() {
return collection.toString();
}
}
static class UnmodifiableIterator
implements Iterator {
protected final Iterator iterator;
public UnmodifiableIterator(Iterator iterator) {
if (iterator == null) {
throw new IllegalArgumentException("Iterator must not be null");
}
this.iterator = iterator;
}
public boolean hasNext() {
return iterator.hasNext();
}
public Object next() {
return iterator.next();
}
public void remove() {
throw new UnsupportedOperationException();
}
}
/**
* 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 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 collection, Predicate predicate) {
return new PredicatedCollection(collection, predicate);
}
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/IteratorUtils.java 0100644 0001750 0001750 00000056441 10055172376 031752 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.lang.reflect.Array;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Dictionary;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.NoSuchElementException;
import org.apache.commons.collections.iterators.ArrayIterator;
import org.apache.commons.collections.iterators.CollatingIterator;
import org.apache.commons.collections.iterators.EnumerationIterator;
import org.apache.commons.collections.iterators.FilterIterator;
import org.apache.commons.collections.iterators.FilterListIterator;
import org.apache.commons.collections.iterators.IteratorChain;
import org.apache.commons.collections.iterators.IteratorEnumeration;
import org.apache.commons.collections.iterators.ListIteratorWrapper;
import org.apache.commons.collections.iterators.SingletonIterator;
import org.apache.commons.collections.iterators.SingletonListIterator;
import org.apache.commons.collections.iterators.TransformIterator;
/**
* Provides static utility methods and decorators for {@link Iterator}
* instances. The implementations are provided in the
* org.apache.commons.collections.iterators subpackage.
*
* @author Stephen Colebourne
* @version $Id: IteratorUtils.java,v 1.4.2.2 2004/05/22 12:14:01 scolebourne Exp $
* @since 2.1
*/
public class IteratorUtils {
// validation is done in this class in certain cases because the
// public classes allow invalid states
/**
* An iterator over no elements.
* @deprecated Use EmptyIterator.INSTANCE
*/
public static final Iterator EMPTY_ITERATOR = new EmptyIterator();
/**
* A list iterator over no elements
* @deprecated Use EmptyListIterator.INSTANCE
*/
public static final ListIterator EMPTY_LIST_ITERATOR = new EmptyListIterator();
/**
* Prevents instantiation.
*/
private IteratorUtils() {
}
/**
* Gets an empty iterator.
* EmptyIterator.INSTANCE
*/
public static Iterator emptyIterator() {
return EMPTY_ITERATOR;
}
/**
* Gets an empty list iterator.
* EmptyListIterator.INSTANCE
*/
public static ListIterator emptyListIterator() {
return EMPTY_LIST_ITERATOR;
}
/**
* Gets a singleton iterator.
* new SingletonIterator(object)
*/
public static Iterator singletonIterator(Object object) {
return new SingletonIterator(object);
}
/**
* Gets a singleton list iterator.
* new ArrayIterator(array)
*/
public static Iterator arrayIterator(Object[] array) {
return new ArrayIterator(array);
}
/**
* Gets an iterator over the end part of an array.
*
* @param array the array over which to iterate
* @param start the index to start iterating at
* @return an iterator over part of the array
* @throws IllegalArgumentException if array bounds are invalid
* @throws NullPointerException if array is null
* @deprecated Use new ArrayIterator(array,start)
*/
public static Iterator arrayIterator(Object[] array, int start) {
return new ArrayIterator(array, start);
}
/**
* Gets an iterator over part of an array.
*
* @param array the array over which to iterate
* @param start the index to start iterating at
* @param end the index to finish iterating at
* @return an iterator over part of the array
* @throws IllegalArgumentException if array bounds are invalid
* @throws NullPointerException if array is null
* @deprecated Use new ArrayIterator(array,start,end)
*/
public static Iterator arrayIterator(Object[] array, int start, int end) {
return new ArrayIterator(array, start, end);
}
// /**
// * Gets a list iterator over an array.
// *
// * @param array the array over which to iterate
// * @return a list iterator over the array
// * @throws NullPointerException if array is null
// */
// public static ListIterator arrayListIterator(Object[] array) {
// return new ArrayListIterator(array);
// }
//
// /**
// * Gets a list iterator over the end part of an array.
// *
// * @param array the array over which to iterate
// * @param start the index to start iterating at
// * @return a list iterator over part of the array
// * @throws IllegalArgumentException if array bounds are invalid
// * @throws NullPointerException if array is null
// */
// public static ListIterator arrayListIterator(Object[] array, int start) {
// return new ArrayListIterator(array, start);
// }
//
// /**
// * Gets a list iterator over part of an array.
// *
// * @param array the array over which to iterate
// * @param start the index to start iterating at
// * @param end the index to finish iterating at
// * @return a list iterator over part of the array
// * @throws IllegalArgumentException if array bounds are invalid
// * @throws NullPointerException if array is null
// */
// public static ListIterator arrayListIterator(Object[] array, int start, int end) {
// return new ArrayListIterator(array, start, end);
// }
/**
* Gets an iterator that iterates through two {@link Iterator}s
* one after another.
*
* @param iterator1 the first iterators to use, not null
* @param iterator2 the first iterators to use, not null
* @return a combination iterator over the iterators
* @throws NullPointerException if either iterator is null
*/
public static Iterator chainedIterator(Iterator iterator1, Iterator iterator2) {
return new IteratorChain(iterator1, iterator2);
}
/**
* Gets an iterator that iterates through an array of {@link Iterator}s
* one after another.
*
* @param iterators the iterators to use, not null or empty or contain nulls
* @return a combination iterator over the iterators
* @throws NullPointerException if iterators array is null or contains a null
*/
public static Iterator chainedIterator(Iterator[] iterators) {
return new IteratorChain(iterators);
}
/**
* Gets an iterator that iterates through a collections of {@link Iterator}s
* one after another.
*
* @param iterators the iterators to use, not null or empty or contain nulls
* @return a combination iterator over the iterators
* @throws NullPointerException if iterators collection is null or contains a null
* @throws ClassCastException if the iterators collection contains the wrong object type
*/
public static Iterator chainedIterator(Collection iterators) {
return new IteratorChain(iterators);
}
/**
* Gets an iterator that provides an ordered iteration over the elements
* contained in a collection of ordered {@link Iterator}s.
* A and B,
* the {@link Iterator#next()} method will return the lesser of
* A.next() and B.next().
* A and B,
* the {@link Iterator#next()} method will return the lesser of
* A.next() and B.next() and so on.
* A and B,
* the {@link Iterator#next()} method will return the lesser of
* A.next() and B.next() and so on.
*
*
*
* @param obj the object to convert to an iterator
* @return a suitable iterator, never null
*/
public static Iterator getIterator(Object obj) {
if (obj == null) {
return emptyIterator();
} else if (obj instanceof Iterator) {
return (Iterator) obj;
} else if (obj instanceof Collection) {
return ((Collection) obj).iterator();
} else if (obj instanceof Object[]) {
return new ArrayIterator(obj);
} else if (obj instanceof Enumeration) {
return new EnumerationIterator((Enumeration) obj);
} else if (obj instanceof Map) {
return ((Map) obj).values().iterator();
} else if (obj instanceof Dictionary) {
return new EnumerationIterator(((Dictionary) obj).elements());
} else if (obj != null && obj.getClass().isArray()) {
return new ArrayIterator(obj);
} else {
try {
Method method = obj.getClass().getMethod("iterator", null);
if (Iterator.class.isAssignableFrom(method.getReturnType())) {
Iterator it = (Iterator) method.invoke(obj, null);
if (it != null) {
return it;
}
}
} catch (Exception ex) {
// ignore
}
return singletonIterator(obj);
}
}
/**
* EmptyIterator class
*/
static class EmptyIterator implements Iterator {
/**
* @see java.util.Iterator#hasNext()
*/
public boolean hasNext() {
return false;
}
/**
* @see java.util.Iterator#next()
*/
public Object next() {
throw new NoSuchElementException();
}
/**
* @see java.util.Iterator#remove()
*/
public void remove() {
throw new UnsupportedOperationException("remove() not supported for empty Iterator");
}
}
/**
* EmptyListIterator class
*/
static class EmptyListIterator extends EmptyIterator implements ListIterator {
/**
* @see java.util.ListIterator#hasPrevious()
*/
public boolean hasPrevious() {
return false;
}
/**
* @see java.util.ListIterator#previous()
*/
public Object previous() {
throw new NoSuchElementException();
}
/**
* @see java.util.ListIterator#nextIndex()
*/
public int nextIndex() {
return 0;
}
/**
* @see java.util.ListIterator#previousIndex()
*/
public int previousIndex() {
return -1;
}
/**
* @see java.util.ListIterator#add(Object)
*/
public void add(Object o) {
throw new UnsupportedOperationException("add() not supported for empty Iterator");
}
/**
* @see java.util.ListIterator#set(Object)
*/
public void set(Object o) {
throw new UnsupportedOperationException("set() not supported for empty Iterator");
}
}
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/StringStack.java 0100644 0001750 0001750 00000014012 10055172400 031344 0 ustar tora tora /*
* Copyright 2001-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.io.Serializable;
import java.util.Iterator;
import java.util.Stack;
/**
* This class implements a stack for String objects.
* StringUtils class in
* the [lang] project.
* @since 2.0
* @author John D. McNally
* @author Daniel Rall
* @author Stephen Colebourne
* @version $Id: StringStack.java,v 1.3.2.1 2004/05/22 12:14:01 scolebourne Exp $
*/
public class StringStack implements Serializable
{
/**
* The stack of String objects.
*/
private Stack stack = null;
/**
* Creates an empty instance.
*/
public StringStack()
{
stack = new Stack();
}
/**
* Adds the String to the collection if it does not already
* contain it.
*
* @param s The String object to add to this stack
* (if it is not null and doesn't already exist in
* the stack).
* @return A reference to this stack (useful for when this method
* is called repeatedly).
*/
public StringStack add(String s)
{
if (s != null && !contains(s))
{
stack.push(s);
}
return this;
}
/**
* Adds all Strings in the given StringStack to the collection
* (skipping those it already contains)
*
* @param ss The stack of String objects to add to
* this stack (if it is not null and doesn't already
* exist in the stack).
* @return A reference to this stack (useful for when this method
* is called repeatedly).
*/
public StringStack addAll(StringStack ss)
{
Iterator i = ss.stack.iterator();
while (i.hasNext())
{
add((String) i.next());
}
return this;
}
/**
* Clears the stack.
*/
public void clear()
{
stack.clear();
}
/**
* Returns whether this stack contain the specified text.
*
* @param s The text to search for.
* @return Whether the stack contains the text.
*/
public boolean contains(String s)
{
return (stack.search(s) != -1);
}
/**
* Whether the stack is empty.
*
* @return Whether the stack is empty.
*/
public final boolean empty()
{
return stack.empty();
}
/**
* Get a string off the stack at a certain position.
*
* @param i The position.
* @return A the string from the specified position.
*/
public String get(int i)
{
return (String) stack.elementAt(i);
}
/**
* Returns the size of the stack.
*
* @return The size of the stack.
*/
public final int size()
{
return stack.size();
}
/**
* Converts the stack to a single {@link java.lang.String} with no
* separator.
*
* @return The stack elements as a single block of text.
*/
public String toString()
{
return toString("");
}
/**
* Converts the stack to a single {@link java.lang.String}.
*
* @param separator The text to use as glue between elements in
* the stack.
* @return The stack elements--glued together by
* separator--as a single block of text.
*/
public String toString( String separator )
{
String s;
if (size() > 0)
{
if ( separator == null )
{
separator = "";
}
// Determine what size to pre-allocate for the buffer.
int totalSize = 0;
for (int i = 0; i < stack.size(); i++)
{
totalSize += get(i).length();
}
totalSize += (stack.size() - 1) * separator.length();
StringBuffer sb = new StringBuffer(totalSize).append( get(0) );
for (int i = 1; i < stack.size(); i++)
{
sb.append(separator).append(get(i));
}
s = sb.toString();
}
else
{
s = "";
}
return s;
}
/**
* Compares two StringStacks. Considered equal if the
* toString() method returns such.
*/
public boolean equals(Object ssbuf)
{
boolean isEquiv = false;
if ( ssbuf == null || !(ssbuf instanceof StringStack) )
{
isEquiv = false;
}
else if ( ssbuf == this )
{
isEquiv = true;
}
else if ( this.toString().equals(ssbuf.toString()) )
{
isEquiv = true;
}
return isEquiv;
}
/**
* Turns this stack into an array.
*
* @return This stack as an array.
*/
public String[] toStringArray()
{
String[] array = new String[size()];
for (int i = 0; i < size(); i++)
{
array[i] = get(i);
}
return array;
}
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/BinaryHeap.java 0100644 0001750 0001750 00000037317 10055172400 031147 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.AbstractCollection;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Comparator;
/**
* Binary heap implementation of {@link PriorityQueue} and {@link Buffer}.
* isMinHeap flag in the constructors
* can be used to reverse the sort order, in which case {@link #remove()}
* will always remove the last element.) The removal order is
* not the same as the order of iteration; elements are
* returned by the iterator in no particular order.
* BinaryHeap:
*
*
* Buffer heap = BufferUtils.synchronizedBuffer(new BinaryHeap());
*
*
* @author Peter Donald
* @author Ram Chidambaram
* @author Michael A. Smith
* @author Paul Jack
* @author Stephen Colebourne
* @since 1.0
* @version $Id: BinaryHeap.java,v 1.11.2.1 2004/05/22 12:14:02 scolebourne Exp $
*/
public final class BinaryHeap extends AbstractCollection
implements PriorityQueue, Buffer {
/**
* The default capacity for a binary heap.
*/
private final static int DEFAULT_CAPACITY = 13;
/**
* The number of elements currently in this heap.
*/
int m_size; // package scoped for testing
/**
* The elements in this heap.
*/
Object[] m_elements; // package scoped for testing
/**
* If true, the first element as determined by the sort order will
* be returned. If false, the last element as determined by the
* sort order will be returned.
*/
boolean m_isMinHeap; // package scoped for testing
/**
* The comparator used to order the elements
*/
Comparator m_comparator; // package scoped for testing
/**
* Constructs a new minimum binary heap.
*/
public BinaryHeap() {
this(DEFAULT_CAPACITY, true);
}
/**
* Constructs a new BinaryHeap that will use the given
* comparator to order its elements.
*
* @param comparator the comparator used to order the elements, null
* means use natural order
*/
public BinaryHeap(Comparator comparator) {
this();
m_comparator = comparator;
}
/**
* Constructs a new minimum binary heap with the specified initial capacity.
*
* @param capacity The initial capacity for the heap. This value must
* be greater than zero.
* @throws IllegalArgumentException
* if capacity is <= 0
*/
public BinaryHeap(int capacity) {
this(capacity, true);
}
/**
* Constructs a new BinaryHeap.
*
* @param capacity the initial capacity for the heap
* @param comparator the comparator used to order the elements, null
* means use natural order
* @throws IllegalArgumentException
* if capacity is <= 0
*/
public BinaryHeap(int capacity, Comparator comparator) {
this(capacity);
m_comparator = comparator;
}
/**
* Constructs a new minimum or maximum binary heap
*
* @param isMinHeap if true the heap is created as a
* minimum heap; otherwise, the heap is created as a maximum heap
*/
public BinaryHeap(boolean isMinHeap) {
this(DEFAULT_CAPACITY, isMinHeap);
}
/**
* Constructs a new BinaryHeap.
*
* @param isMinHeap true to use the order imposed by the given
* comparator; false to reverse that order
* @param comparator the comparator used to order the elements, null
* means use natural order
*/
public BinaryHeap(boolean isMinHeap, Comparator comparator) {
this(isMinHeap);
m_comparator = comparator;
}
/**
* Constructs a new minimum or maximum binary heap with the specified
* initial capacity.
*
* @param capacity the initial capacity for the heap. This value must
* be greater than zero.
* @param isMinHeap if true the heap is created as a
* minimum heap; otherwise, the heap is created as a maximum heap.
* @throws IllegalArgumentException
* if capacity is <= 0
*/
public BinaryHeap(int capacity, boolean isMinHeap) {
if (capacity <= 0) {
throw new IllegalArgumentException("invalid capacity");
}
m_isMinHeap = isMinHeap;
//+1 as 0 is noop
m_elements = new Object[capacity + 1];
}
/**
* Constructs a new BinaryHeap.
*
* @param capacity the initial capacity for the heap
* @param isMinHeap true to use the order imposed by the given
* comparator; false to reverse that order
* @param comparator the comparator used to order the elements, null
* means use natural order
* @throws IllegalArgumentException
* if capacity is <= 0
*/
public BinaryHeap(int capacity, boolean isMinHeap, Comparator comparator) {
this(capacity, isMinHeap);
m_comparator = comparator;
}
/**
* Clears all elements from queue.
*/
public void clear() {
m_elements = new Object[m_elements.length]; // for gc
m_size = 0;
}
/**
* Tests if queue is empty.
*
* @return true if queue is empty; false
* otherwise.
*/
public boolean isEmpty() {
return m_size == 0;
}
/**
* Tests if queue is full.
*
* @return true if queue is full; false
* otherwise.
*/
public boolean isFull() {
//+1 as element 0 is noop
return m_elements.length == m_size + 1;
}
/**
* Inserts an element into queue.
*
* @param element the element to be inserted
*/
public void insert(Object element) {
if (isFull()) {
grow();
}
//percolate element to it's place in tree
if (m_isMinHeap) {
percolateUpMinHeap(element);
} else {
percolateUpMaxHeap(element);
}
}
/**
* Returns the element on top of heap but don't remove it.
*
* @return the element at top of heap
* @throws NoSuchElementException if isEmpty() == true
*/
public Object peek() throws NoSuchElementException {
if (isEmpty()) {
throw new NoSuchElementException();
} else {
return m_elements[1];
}
}
/**
* Returns the element on top of heap and remove it.
*
* @return the element at top of heap
* @throws NoSuchElementException if isEmpty() == true
*/
public Object pop() throws NoSuchElementException {
final Object result = peek();
m_elements[1] = m_elements[m_size--];
// set the unused element to 'null' so that the garbage collector
// can free the object if not used anywhere else.(remove reference)
m_elements[m_size + 1] = null;
if (m_size != 0) {
// percolate top element to it's place in tree
if (m_isMinHeap) {
percolateDownMinHeap(1);
} else {
percolateDownMaxHeap(1);
}
}
return result;
}
/**
* Percolates element down heap from top.
* Assume it is a maximum heap.
*
* @param index the index for the element
*/
protected void percolateDownMinHeap(final int index) {
final Object element = m_elements[index];
int hole = index;
while ((hole * 2) <= m_size) {
int child = hole * 2;
// if we have a right child and that child can not be percolated
// up then move onto other child
if (child != m_size && compare(m_elements[child + 1], m_elements[child]) < 0) {
child++;
}
// if we found resting place of bubble then terminate search
if (compare(m_elements[child], element) >= 0) {
break;
}
m_elements[hole] = m_elements[child];
hole = child;
}
m_elements[hole] = element;
}
/**
* Percolates element down heap from top.
* Assume it is a maximum heap.
*
* @param index the index of the element
*/
protected void percolateDownMaxHeap(final int index) {
final Object element = m_elements[index];
int hole = index;
while ((hole * 2) <= m_size) {
int child = hole * 2;
// if we have a right child and that child can not be percolated
// up then move onto other child
if (child != m_size && compare(m_elements[child + 1], m_elements[child]) > 0) {
child++;
}
// if we found resting place of bubble then terminate search
if (compare(m_elements[child], element) <= 0) {
break;
}
m_elements[hole] = m_elements[child];
hole = child;
}
m_elements[hole] = element;
}
/**
* Percolates element up heap from bottom.
* Assume it is a maximum heap.
*
* @param element the element
*/
protected void percolateUpMinHeap(final Object element) {
int hole = ++m_size;
m_elements[hole] = element;
while (hole > 1 && compare(element, m_elements[hole / 2]) < 0) {
// save element that is being pushed down
// as the element "bubble" is percolated up
final int next = hole / 2;
m_elements[hole] = m_elements[next];
hole = next;
}
m_elements[hole] = element;
}
/**
* Percolates element up heap from bottom.
* Assume it is a maximum heap.
*
* @param element the element
*/
protected void percolateUpMaxHeap(final Object element) {
int hole = ++m_size;
while (hole > 1 && compare(element, m_elements[hole / 2]) > 0) {
// save element that is being pushed down
// as the element "bubble" is percolated up
final int next = hole / 2;
m_elements[hole] = m_elements[next];
hole = next;
}
m_elements[hole] = element;
}
/**
* Compares two objects using the comparator if specified, or the
* natural order otherwise.
*
* @param a the first object
* @param b the second object
* @return -ve if a less than b, 0 if they are equal, +ve if a greater than b
*/
private int compare(Object a, Object b) {
if (m_comparator != null) {
return m_comparator.compare(a, b);
} else {
return ((Comparable) a).compareTo(b);
}
}
/**
* Increases the size of the heap to support additional elements
*/
protected void grow() {
final Object[] elements = new Object[m_elements.length * 2];
System.arraycopy(m_elements, 0, elements, 0, m_elements.length);
m_elements = elements;
}
/**
* Returns a string representation of this heap. The returned string
* is similar to those produced by standard JDK collections.
*
* @return a string representation of this heap
*/
public String toString() {
final StringBuffer sb = new StringBuffer();
sb.append("[ ");
for (int i = 1; i < m_size + 1; i++) {
if (i != 1) {
sb.append(", ");
}
sb.append(m_elements[i]);
}
sb.append(" ]");
return sb.toString();
}
/**
* Returns an iterator over this heap's elements.
*
* @return an iterator over this heap's elements
*/
public Iterator iterator() {
return new Iterator() {
private int index = 1;
private int lastReturnedIndex = -1;
public boolean hasNext() {
return index <= m_size;
}
public Object next() {
if (!hasNext()) throw new NoSuchElementException();
lastReturnedIndex = index;
index++;
return m_elements[lastReturnedIndex];
}
public void remove() {
if (lastReturnedIndex == -1) throw new IllegalStateException();
m_elements[ lastReturnedIndex ] = m_elements[ m_size ];
m_elements[ m_size ] = null;
m_size--;
if( m_size != 0 )
{
//percolate top element to it's place in tree
if( m_isMinHeap ) percolateDownMinHeap( lastReturnedIndex );
else percolateDownMaxHeap( lastReturnedIndex );
}
index--;
lastReturnedIndex = -1;
}
};
}
/**
* Adds an object to this heap. Same as {@link #insert(Object)}.
*
* @param object the object to add
* @return true, always
*/
public boolean add(Object object) {
insert(object);
return true;
}
/**
* Returns the priority element. Same as {@link #peek()}.
*
* @return the priority element
* @throws BufferUnderflowException if this heap is empty
*/
public Object get() {
try {
return peek();
} catch (NoSuchElementException e) {
throw new BufferUnderflowException();
}
}
/**
* Removes the priority element. Same as {@link #pop()}.
*
* @return the removed priority element
* @throws BufferUnderflowException if this heap is empty
*/
public Object remove() {
try {
return pop();
} catch (NoSuchElementException e) {
throw new BufferUnderflowException();
}
}
/**
* Returns the number of elements in this heap.
*
* @return the number of elements in this heap
*/
public int size() {
return m_size;
}
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/Transformer.java 0100644 0001750 0001750 00000002104 10055172400 031411 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
/** An object capable of transforming an input object into some output object.
*
* @since 1.0
* @author James Strachan
*/
public interface Transformer {
/** Transforms the input object (leaving it unchanged) into some output object.
* @return the transformation of the input object to the output object
*/
public Object transform(Object input);
}
././@LongLink 0000000 0000000 0000000 00000000151 00000000000 011562 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/CursorableLinkedList.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/CursorableLinkedList 0100644 0001750 0001750 00000132124 10055172400 032261 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.Collection;
import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
import java.util.ConcurrentModificationException;
import java.util.NoSuchElementException;
import java.io.Serializable;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.IOException;
import java.lang.reflect.Array;
/**
* A doubly-linked list implementation of the {@link List} interface,
* supporting a {@link ListIterator} that allows concurrent modifications
* to the underlying list.
*
* hashCode = 1;
* Iterator i = list.iterator();
* while (i.hasNext()) {
* Object obj = i.next();
* hashCode = 31*hashCode + (obj==null ? 0 : obj.hashCode());
* }
*
* This ensures that list1.equals(list2) implies that
* list1.hashCode()==list2.hashCode() for any two lists,
* list1 and list2, as required by the general
* contract of Object.hashCode.
*
* @return the hash code value for this list.
* @see Object#hashCode()
* @see Object#equals(Object)
* @see #equals(Object)
*/
public int hashCode() {
int hash = 1;
for(Listable elt = _head.next(), past = null; null != elt && past != _head.prev(); elt = (past = elt).next()) {
hash = 31*hash + (null == elt.value() ? 0 : elt.value().hashCode());
}
return hash;
}
/**
* Returns the index in this list of the first occurrence of the specified
* element, or -1 if this list does not contain this element.
* More formally, returns the lowest index i such that
* (o==null ? get(i)==null : o.equals(get(i))),
* or -1 if there is no such index.
*
* @param o element to search for.
* @return the index in this list of the first occurrence of the specified
* element, or -1 if this list does not contain this element.
*/
public int indexOf(Object o) {
int ndx = 0;
// perform the null check outside of the loop to save checking every
// single time through the loop.
if (null == o) {
for(Listable elt = _head.next(), past = null; null != elt && past != _head.prev(); elt = (past = elt).next()) {
if (null == elt.value()) {
return ndx;
}
ndx++;
}
} else {
for(Listable elt = _head.next(), past = null; null != elt && past != _head.prev(); elt = (past = elt).next()) {
if (o.equals(elt.value())) {
return ndx;
}
ndx++;
}
}
return -1;
}
/**
* Returns true if this list contains no elements.
* @return true if this list contains no elements.
*/
public boolean isEmpty() {
return(0 == _size);
}
/**
* Returns a fail-fast iterator.
* @see List#iterator
*/
public Iterator iterator() {
return listIterator(0);
}
/**
* Returns the index in this list of the last occurrence of the specified
* element, or -1 if this list does not contain this element.
* More formally, returns the highest index i such that
* (o==null ? get(i)==null : o.equals(get(i))),
* or -1 if there is no such index.
*
* @param o element to search for.
* @return the index in this list of the last occurrence of the specified
* element, or -1 if this list does not contain this element.
*/
public int lastIndexOf(Object o) {
int ndx = _size-1;
// perform the null check outside of the loop to save checking every
// single time through the loop.
if (null == o) {
for(Listable elt = _head.prev(), past = null; null != elt && past != _head.next(); elt = (past = elt).prev()) {
if (null == elt.value()) {
return ndx;
}
ndx--;
}
} else {
for(Listable elt = _head.prev(), past = null; null != elt && past != _head.next(); elt = (past = elt).prev()) {
if (o.equals(elt.value())) {
return ndx;
}
ndx--;
}
}
return -1;
}
/**
* Returns a fail-fast ListIterator.
* @see List#listIterator
*/
public ListIterator listIterator() {
return listIterator(0);
}
/**
* Returns a fail-fast ListIterator.
* @see List#listIterator(int)
*/
public ListIterator listIterator(int index) {
if(index<0 || index > _size) {
throw new IndexOutOfBoundsException(index + " < 0 or > " + _size);
}
return new ListIter(index);
}
/**
* Removes the first occurrence in this list of the specified element.
* If this list does not contain the element, it is
* unchanged. More formally, removes the element with the lowest index i
* such that (o==null ? get(i)==null : o.equals(get(i))) (if
* such an element exists).
*
* @param o element to be removed from this list, if present.
* @return true if this list contained the specified element.
*/
public boolean remove(Object o) {
for(Listable elt = _head.next(), past = null; null != elt && past != _head.prev(); elt = (past = elt).next()) {
if(null == o && null == elt.value()) {
removeListable(elt);
return true;
} else if(o != null && o.equals(elt.value())) {
removeListable(elt);
return true;
}
}
return false;
}
/**
* Removes the element at the specified position in this list (optional
* operation). Shifts any subsequent elements to the left (subtracts one
* from their indices). Returns the element that was removed from the
* list.
*
* @param index the index of the element to removed.
* @return the element previously at the specified position.
*
* @throws IndexOutOfBoundsException if the index is out of range (index
* < 0 || index >= size()).
*/
public Object remove(int index) {
Listable elt = getListableAt(index);
Object ret = elt.value();
removeListable(elt);
return ret;
}
/**
* Removes from this list all the elements that are contained in the
* specified collection.
*
* @param c collection that defines which elements will be removed from
* this list.
* @return true if this list changed as a result of the call.
*/
public boolean removeAll(Collection c) {
if(0 == c.size() || 0 == _size) {
return false;
} else {
boolean changed = false;
Iterator it = iterator();
while(it.hasNext()) {
if(c.contains(it.next())) {
it.remove();
changed = true;
}
}
return changed;
}
}
/**
* Removes the first element of this list, if any.
*/
public Object removeFirst() {
if(_head.next() != null) {
Object val = _head.next().value();
removeListable(_head.next());
return val;
} else {
throw new NoSuchElementException();
}
}
/**
* Removes the last element of this list, if any.
*/
public Object removeLast() {
if(_head.prev() != null) {
Object val = _head.prev().value();
removeListable(_head.prev());
return val;
} else {
throw new NoSuchElementException();
}
}
/**
* Retains only the elements in this list that are contained in the
* specified collection. In other words, removes
* from this list all the elements that are not contained in the specified
* collection.
*
* @param c collection that defines which elements this set will retain.
*
* @return true if this list changed as a result of the call.
*/
public boolean retainAll(Collection c) {
boolean changed = false;
Iterator it = iterator();
while(it.hasNext()) {
if(!c.contains(it.next())) {
it.remove();
changed = true;
}
}
return changed;
}
/**
* Replaces the element at the specified position in this list with the
* specified element.
*
* @param index index of element to replace.
* @param element element to be stored at the specified position.
* @return the element previously at the specified position.
*
* @throws ClassCastException if the class of the specified element
* prevents it from being added to this list.
* @throws IllegalArgumentException if some aspect of the specified
* element prevents it from being added to this list.
* @throws IndexOutOfBoundsException if the index is out of range
* (index < 0 || index >= size()).
*/
public Object set(int index, Object element) {
Listable elt = getListableAt(index);
Object val = elt.setValue(element);
broadcastListableChanged(elt);
return val;
}
/**
* Returns the number of elements in this list.
* @return the number of elements in this list.
*/
public int size() {
return _size;
}
/**
* Returns an array containing all of the elements in this list in proper
* sequence. Obeys the general contract of the {@link Collection#toArray} method.
*
* @return an array containing all of the elements in this list in proper
* sequence.
*/
public Object[] toArray() {
Object[] array = new Object[_size];
int i = 0;
for(Listable elt = _head.next(), past = null; null != elt && past != _head.prev(); elt = (past = elt).next()) {
array[i++] = elt.value();
}
return array;
}
/**
* Returns an array containing all of the elements in this list in proper
* sequence; the runtime type of the returned array is that of the
* specified array. Obeys the general contract of the
* {@link Collection#toArray} method.
*
* @param a the array into which the elements of this list are to
* be stored, if it is big enough; otherwise, a new array of the
* same runtime type is allocated for this purpose.
* @return an array containing the elements of this list.
* @exception ArrayStoreException
* if the runtime type of the specified array
* is not a supertype of the runtime type of every element in
* this list.
*/
public Object[] toArray(Object a[]) {
if(a.length < _size) {
a = (Object[])Array.newInstance(a.getClass().getComponentType(), _size);
}
int i = 0;
for(Listable elt = _head.next(), past = null; null != elt && past != _head.prev(); elt = (past = elt).next()) {
a[i++] = elt.value();
}
if(a.length > _size) {
a[_size] = null; // should we null out the rest of the array also? java.util.LinkedList doesn't
}
return a;
}
/**
* Returns a {@link String} representation of this list, suitable for debugging.
* @return a {@link String} representation of this list, suitable for debugging.
*/
public String toString() {
StringBuffer buf = new StringBuffer();
buf.append("[");
for(Listable elt = _head.next(), past = null; null != elt && past != _head.prev(); elt = (past = elt).next()) {
if(_head.next() != elt) {
buf.append(", ");
}
buf.append(elt.value());
}
buf.append("]");
return buf.toString();
}
/**
* Returns a fail-fast sublist.
* @see List#subList(int,int)
*/
public List subList(int i, int j) {
if(i < 0 || j > _size || i > j) {
throw new IndexOutOfBoundsException();
} else if(i == 0 && j == _size) {
return this;
} else {
return new CursorableSubList(this,i,j);
}
}
//--- protected methods ------------------------------------------
/**
* Inserts a new value into my
* list, after the specified before element, and before the
* specified after element
*
* @return the newly created
* {@link org.apache.commons.collections.CursorableLinkedList.Listable}
*/
protected Listable insertListable(Listable before, Listable after, Object value) {
_modCount++;
_size++;
Listable elt = new Listable(before,after,value);
if(null != before) {
before.setNext(elt);
} else {
_head.setNext(elt);
}
if(null != after) {
after.setPrev(elt);
} else {
_head.setPrev(elt);
}
broadcastListableInserted(elt);
return elt;
}
/**
* Removes the given
* {@link org.apache.commons.collections.CursorableLinkedList.Listable}
* from my list.
*/
protected void removeListable(Listable elt) {
_modCount++;
_size--;
if(_head.next() == elt) {
_head.setNext(elt.next());
}
if(null != elt.next()) {
elt.next().setPrev(elt.prev());
}
if(_head.prev() == elt) {
_head.setPrev(elt.prev());
}
if(null != elt.prev()) {
elt.prev().setNext(elt.next());
}
broadcastListableRemoved(elt);
}
/**
* Returns the
* {@link org.apache.commons.collections.CursorableLinkedList.Listable}
* at the specified index.
*
* @throws IndexOutOfBoundsException if index is less than zero or
* greater than or equal to the size of this list.
*/
protected Listable getListableAt(int index) {
if(index < 0 || index >= _size) {
throw new IndexOutOfBoundsException(String.valueOf(index) + " < 0 or " + String.valueOf(index) + " >= " + _size);
}
if(index <=_size/2) {
Listable elt = _head.next();
for(int i = 0; i < index; i++) {
elt = elt.next();
}
return elt;
} else {
Listable elt = _head.prev();
for(int i = (_size-1); i > index; i--) {
elt = elt.prev();
}
return elt;
}
}
/**
* Registers a {@link CursorableLinkedList.Cursor} to be notified
* of changes to this list.
*/
protected void registerCursor(Cursor cur) {
_cursors.add(cur);
}
/**
* Removes a {@link CursorableLinkedList.Cursor} from
* the set of cursors to be notified of changes to this list.
*/
protected void unregisterCursor(Cursor cur) {
_cursors.remove(cur);
}
/**
* Informs all of my registerd cursors that they are now
* invalid.
*/
protected void invalidateCursors() {
Iterator it = _cursors.iterator();
while(it.hasNext()) {
((Cursor)it.next()).invalidate();
it.remove();
}
}
/**
* Informs all of my registerd cursors that the specified
* element was changed.
* @see #set(int,java.lang.Object)
*/
protected void broadcastListableChanged(Listable elt) {
Iterator it = _cursors.iterator();
while(it.hasNext()) {
((Cursor)it.next()).listableChanged(elt);
}
}
/**
* Informs all of my registered cursors tha the specifed
* element was just removed from my list.
*/
protected void broadcastListableRemoved(Listable elt) {
Iterator it = _cursors.iterator();
while(it.hasNext()) {
((Cursor)it.next()).listableRemoved(elt);
}
}
/**
* Informs all of my registered cursors tha the specifed
* element was just added to my list.
*/
protected void broadcastListableInserted(Listable elt) {
Iterator it = _cursors.iterator();
while(it.hasNext()) {
((Cursor)it.next()).listableInserted(elt);
}
}
private void writeObject(ObjectOutputStream out) throws IOException {
out.defaultWriteObject();
out.writeInt(_size);
Listable cur = _head.next();
while(cur != null) {
out.writeObject(cur.value());
cur = cur.next();
}
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
_size = 0;
_head = new Listable(null,null,null);
int size = in.readInt();
for(int i=0;iReferenceMap, you can
* specify what kind of references are used to store the
* map's keys and values. If non-hard references are
* used, then the garbage collector can remove mappings
* if a key or value becomes unreachable, or if the
* JVM's memory is running low. For information on how
* the different reference types behave, see
* {@link Reference}.WeakHashMap. However, you
* can also specify hard keys and weak values, or any other
* combination. The default constructor uses hard keys
* and soft values, providing a memory-sensitive cache.NullPointerException.ReferenceMap.
*
* @author Paul Jack
* @version $Id: ReferenceMap.java,v 1.7.2.1 2004/05/22 12:14:01 scolebourne Exp $
* @since 2.1
* @see java.lang.ref.Reference
*/
public class ReferenceMap extends AbstractMap {
/**
* For serialization.
*/
final private static long serialVersionUID = -3370601314380922368L;
/**
* Constant indicating that hard references should be used.
*/
final public static int HARD = 0;
/**
* Constant indiciating that soft references should be used.
*/
final public static int SOFT = 1;
/**
* Constant indicating that weak references should be used.
*/
final public static int WEAK = 2;
// --- serialized instance variables:
/**
* The reference type for keys. Must be HARD, SOFT, WEAK.
* Note: I originally marked this field as final, but then this class
* didn't compile under JDK1.2.2.
* @serial
*/
private int keyType;
/**
* The reference type for values. Must be HARD, SOFT, WEAK.
* Note: I originally marked this field as final, but then this class
* didn't compile under JDK1.2.2.
* @serial
*/
private int valueType;
/**
* The threshold variable is calculated by multiplying
* table.length and loadFactor.
* Note: I originally marked this field as final, but then this class
* didn't compile under JDK1.2.2.
* @serial
*/
private float loadFactor;
// -- Non-serialized instance variables
/**
* ReferenceQueue used to eliminate stale mappings.
* @see #purge
*/
private transient ReferenceQueue queue = new ReferenceQueue();
/**
* The hash table. Its length is always a power of two.
*/
private transient Entry[] table;
/**
* Number of mappings in this map.
*/
private transient int size;
/**
* When size reaches threshold, the map is resized.
* @see resize
*/
private transient int threshold;
/**
* Number of times this map has been modified.
*/
private transient volatile int modCount;
/**
* Cached key set. May be null if key set is never accessed.
*/
private transient Set keySet;
/**
* Cached entry set. May be null if entry set is never accessed.
*/
private transient Set entrySet;
/**
* Cached values. May be null if values() is never accessed.
*/
private transient Collection values;
/**
* Constructs a new ReferenceMap that will
* use hard references to keys and soft references to values.
*/
public ReferenceMap() {
this(HARD, SOFT);
}
/**
* Constructs a new ReferenceMap that will
* use the specified types of references.
*
* @param keyType the type of reference to use for keys;
* must be {@link #HARD}, {@link #SOFT}, {@link #WEAK}
* @param valueType the type of reference to use for values;
* must be {@link #HARD}, {@link #SOFT}, {@link #WEAK}
*/
public ReferenceMap(int keyType, int valueType) {
this(keyType, valueType, 16, 0.75f);
}
/**
* Constructs a new ReferenceMap with the
* specified reference types, load factor and initial
* capacity.
*
* @param keyType the type of reference to use for keys;
* must be {@link #HARD}, {@link #SOFT}, {@link #WEAK}
* @param valueType the type of reference to use for values;
* must be {@link #HARD}, {@link #SOFT}, {@link #WEAK}
* @param capacity the initial capacity for the map
* @param loadFactor the load factor for the map
*/
public ReferenceMap(int keyType, int valueType, int capacity, float loadFactor) {
super();
verify("keyType", keyType);
verify("valueType", valueType);
if (capacity <= 0) {
throw new IllegalArgumentException("capacity must be positive");
}
if ((loadFactor <= 0.0f) || (loadFactor >= 1.0f)) {
throw new IllegalArgumentException("Load factor must be greater than 0 and less than 1.");
}
this.keyType = keyType;
this.valueType = valueType;
int v = 1;
while (v < capacity) v *= 2;
this.table = new Entry[v];
this.loadFactor = loadFactor;
this.threshold = (int)(v * loadFactor);
}
// used by constructor
private static void verify(String name, int type) {
if ((type < HARD) || (type > WEAK)) {
throw new IllegalArgumentException(name +
" must be HARD, SOFT, WEAK.");
}
}
/**
* Writes this object to the given output stream.
*
* @param out the output stream to write to
* @throws IOException if the stream raises it
*/
private void writeObject(ObjectOutputStream out) throws IOException {
out.defaultWriteObject();
out.writeInt(table.length);
// Have to use null-terminated list because size might shrink
// during iteration
for (Iterator iter = entrySet().iterator(); iter.hasNext();) {
Map.Entry entry = (Map.Entry)iter.next();
out.writeObject(entry.getKey());
out.writeObject(entry.getValue());
}
out.writeObject(null);
}
/**
* Reads the contents of this object from the given input stream.
*
* @param inp the input stream to read from
* @throws IOException if the stream raises it
* @throws ClassNotFoundException if the stream raises it
*/
private void readObject(ObjectInputStream inp) throws IOException, ClassNotFoundException {
inp.defaultReadObject();
table = new Entry[inp.readInt()];
threshold = (int)(table.length * loadFactor);
queue = new ReferenceQueue();
Object key = inp.readObject();
while (key != null) {
Object value = inp.readObject();
put(key, value);
key = inp.readObject();
}
}
/**
* Constructs a reference of the given type to the given
* referent. The reference is registered with the queue
* for later purging.
*
* @param type HARD, SOFT or WEAK
* @param referent the object to refer to
* @param hash the hash code of the key of the mapping;
* this number might be different from referent.hashCode() if
* the referent represents a value and not a key
*/
private Object toReference(int type, Object referent, int hash) {
switch (type) {
case HARD: return referent;
case SOFT: return new SoftRef(hash, referent, queue);
case WEAK: return new WeakRef(hash, referent, queue);
default: throw new Error();
}
}
/**
* Returns the entry associated with the given key.
*
* @param key the key of the entry to look up
* @return the entry associated with that key, or null
* if the key is not in this map
*/
private Entry getEntry(Object key) {
if (key == null) return null;
int hash = key.hashCode();
int index = indexFor(hash);
for (Entry entry = table[index]; entry != null; entry = entry.next) {
if ((entry.hash == hash) && key.equals(entry.getKey())) {
return entry;
}
}
return null;
}
/**
* Converts the given hash code into an index into the
* hash table.
*/
private int indexFor(int hash) {
// mix the bits to avoid bucket collisions...
hash += ~(hash << 15);
hash ^= (hash >>> 10);
hash += (hash << 3);
hash ^= (hash >>> 6);
hash += ~(hash << 11);
hash ^= (hash >>> 16);
return hash & (table.length - 1);
}
/**
* Resizes this hash table by doubling its capacity.
* This is an expensive operation, as entries must
* be copied from the old smaller table to the new
* bigger table.
*/
private void resize() {
Entry[] old = table;
table = new Entry[old.length * 2];
for (int i = 0; i < old.length; i++) {
Entry next = old[i];
while (next != null) {
Entry entry = next;
next = next.next;
int index = indexFor(entry.hash);
entry.next = table[index];
table[index] = entry;
}
old[i] = null;
}
threshold = (int)(table.length * loadFactor);
}
/**
* Purges stale mappings from this map.true if this map is empty.
*
* @return true if this map is empty
*/
public boolean isEmpty() {
purge();
return size == 0;
}
/**
* Returns true if this map contains the given key.
*
* @return true if the given key is in this map
*/
public boolean containsKey(Object key) {
purge();
Entry entry = getEntry(key);
if (entry == null) return false;
return entry.getValue() != null;
}
/**
* Returns the value associated with the given key, if any.
*
* @return the value associated with the given key, or null
* if the key maps to no value
*/
public Object get(Object key) {
purge();
Entry entry = getEntry(key);
if (entry == null) return null;
return entry.getValue();
}
/**
* Associates the given key with the given value.Map wraps another Map
* implementation, using the wrapped instance for its default
* implementation. This class is used as a framework on which to
* build to extensions for its wrapped Map object which
* would be unavailable or inconvenient via sub-classing (but usable
* via composition).Map needs
* synchronization (to make it thread-safe), but the Map
* returned by Collections.synchronizedMap(map)
* hides part of map's public interface.Map used for default implementations.
*/
protected Map map;
/**
* Creates a new instance acting as a representative for the
* specified Map.
*
* @param map The Map to whose operations to wrap.
*/
public ProxyMap(Map map) {
this.map = map;
}
/**
* Invokes the underlying {@link Map#clear()} method.
*/
public void clear() {
map.clear();
}
/**
* Invokes the underlying {@link Map#containsKey(Object)} method.
*/
public boolean containsKey(Object key) {
return map.containsKey(key);
}
/**
* Invokes the underlying {@link Map#containsValue(Object)} method.
*/
public boolean containsValue(Object value) {
return map.containsValue(value);
}
/**
* Invokes the underlying {@link Map#entrySet()} method.
*/
public Set entrySet() {
return map.entrySet();
}
/**
* Invokes the underlying {@link Map#equals(Object)} method.
*/
public boolean equals(Object m) {
return map.equals(m);
}
/**
* Invokes the underlying {@link Map#get(Object)} method.
*/
public Object get(Object key) {
return map.get(key);
}
/**
* Invokes the underlying {@link Map#hashCode()} method.
*/
public int hashCode() {
return map.hashCode();
}
/**
* Invokes the underlying {@link Map#isEmpty()} method.
*/
public boolean isEmpty() {
return map.isEmpty();
}
/**
* Invokes the underlying {@link Map#keySet()} method.
*/
public Set keySet() {
return map.keySet();
}
/**
* Invokes the underlying {@link Map#put(Object,Object)} method.
*/
public Object put(Object key, Object value) {
return map.put(key, value);
}
/**
* Invokes the underlying {@link Map#putAll(Map)} method.
*/
public void putAll(Map t) {
map.putAll(t);
}
/**
* Invokes the underlying {@link Map#remove(Object)} method.
*/
public Object remove(Object key) {
return map.remove(key);
}
/**
* Invokes the underlying {@link Map#size()} method.
*/
public int size() {
return map.size();
}
/**
* Invokes the underlying {@link Map#values()} method.
*/
public Collection values() {
return map.values();
}
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/Bag.java 0100644 0001750 0001750 00000016027 10055172376 027625 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.Collection;
import java.util.Iterator;
import java.util.Set;
/**
* A {@link Collection} that counts the number of times an object appears in
* the collection. Suppose you have a Bag that contains {a, a, b,
* c}. Calling {@link #getCount(Object)} on a would return
* 2, while calling {@link #uniqueSet()} would return {a, b, c}.
*
* true. Since it sometimes returns
* false, this method violates the contract. A future
* version of this method will comply by always returning true.
*
* @return true if the object was not already in the
* uniqueSet
* @see #getCount(Object)
**/
public boolean add(Object o);
/**
* Add i copies of the given object to the bag and
* keep a count.
* @return true if the object was not already in the
* uniqueSet
* @see #add(Object)
* @see #getCount(Object)
**/
public boolean add(Object o, int i);
/**
* (Violation)
* Remove all occurrences of the given object from the bag, and do
* not represent the object in the {@link #uniqueSet()}.
*
* true if this call changed the collection
**/
public boolean remove(Object o);
/**
* Remove the given number of occurrences from the bag. If the bag
* contains i occurrences or less, the item will be
* removed from the {@link #uniqueSet()}.
* @see #getCount(Object)
* @see #remove(Object)
* @return true if this call changed the collection
**/
public boolean remove(Object o, int i);
/**
* The {@link Set} of unique members that represent all members in
* the bag. Uniqueness constraints are the same as those in {@link
* Set}.
**/
public Set uniqueSet();
/**
* Returns the total number of items in the bag across all types.
**/
public int size();
/**
* (Violation)
* Returns true if the bag contains all elements in
* the given collection, respecting cardinality. That is, if the
* given collection C contains n copies
* of a given object, calling {@link #getCount(Object)} on that object must
* be >= n for all n in C.
*
* C contains n copies of a given object,
* the bag will have n fewer copies, assuming the bag
* had at least n copies to begin with.
*
* true if this call changed the collection
**/
public boolean removeAll(Collection c);
/**
* (Violation)
* Remove any members of the bag that are not in the given
* collection, respecting cardinality. That is, if the given
* collection C contains n copies of a
* given object and the bag has m > n copies, then
* delete m - n copies from the bag. In addition, if
* e is an object in the bag but
* !C.contains(e), then remove e and any
* of its copies.
*
* true if this call changed the collection
**/
public boolean retainAll(Collection c);
/**
* Returns an {@link Iterator} over the entire set of members,
* including copies due to cardinality. This iterator is fail-fast
* and will not tolerate concurrent modifications.
**/
public Iterator iterator();
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/DefaultMapBag.java 0100644 0001750 0001750 00000025307 10055172376 031571 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* This class provides a skeletal implementation of the {@link Bag}
* interface to minimize the effort required for target implementations.
* Subclasses need only to call {@link #setMap(Map)} in their constructor
* specifying a map instance that will be used to store the contents of
* the bag.true if the bag contains all elements in
* the given collection, respecting cardinality.
* @see #containsAll(Collection)
**/
public boolean containsAll(Bag other) {
boolean result = true;
Iterator i = other.uniqueSet().iterator();
while (i.hasNext()) {
Object current = i.next();
boolean contains =
getCount(current) >= ((Bag)other).getCount(current);
result = result && contains;
}
return result;
}
/**
* Returns true if the given object is not null, has the precise type
* of this bag, and contains the same number of occurrences of all the
* same elements.
*
* @param o the object to test for equality
* @return true if that object equals this bag
*/
public boolean equals(Object o) {
return (o == this ||
(o != null && o.getClass().equals(this.getClass()) &&
((DefaultMapBag)o)._map.equals(this._map)));
}
/**
* Returns the hash code of the underlying map.
*
* @return the hash code of the underlying map
*/
public int hashCode() {
return _map.hashCode();
}
/**
* Returns true if the underlying map is empty.
*
* @return true if there are no elements in this bag
*/
public boolean isEmpty() {
return _map.isEmpty();
}
public Iterator iterator() {
return new BagIterator(this, extractList().iterator());
}
private class BagIterator implements Iterator {
private DefaultMapBag _parent = null;
private Iterator _support = null;
private Object _current = null;
private int _mods = 0;
public BagIterator(DefaultMapBag parent, Iterator support) {
_parent = parent;
_support = support;
_current = null;
_mods = parent.modCount();
}
public boolean hasNext() {
return _support.hasNext();
}
public Object next() {
if (_parent.modCount() != _mods) {
throw new ConcurrentModificationException();
}
_current = _support.next();
return _current;
}
public void remove() {
if (_parent.modCount() != _mods) {
throw new ConcurrentModificationException();
}
_support.remove();
_parent.remove(_current, 1);
_mods++;
}
}
public boolean remove (Object o) {
return remove(o, getCount(o));
}
public boolean remove (Object o, int i) {
_mods++;
boolean result = false;
int count = getCount(o);
if (i <= 0) {
result = false;
} else if (count > i) {
_map.put(o, new Integer(count - i));
result = true;
_total -= i;
} else { // count > 0 && count <= i
// need to remove all
result = (_map.remove(o) != null);
_total -= count;
}
return result;
}
public boolean removeAll(Collection c) {
boolean result = false;
if (c != null) {
Iterator i = c.iterator();
while (i.hasNext()) {
boolean changed = remove(i.next(), 1);
result = result || changed;
}
}
return result;
}
/**
* Remove any members of the bag that are not in the given
* bag, respecting cardinality.
*
* @return true if this call changed the collection
*/
public boolean retainAll(Collection c) {
return retainAll(new HashBag(c));
}
/**
* Remove any members of the bag that are not in the given
* bag, respecting cardinality.
* @see #retainAll(Collection)
* @return true if this call changed the collection
**/
public boolean retainAll(Bag other) {
boolean result = false;
Bag excess = new HashBag();
Iterator i = uniqueSet().iterator();
while (i.hasNext()) {
Object current = i.next();
int myCount = getCount(current);
int otherCount = other.getCount(current);
if (1 <= otherCount && otherCount <= myCount) {
excess.add(current, myCount - otherCount);
} else {
excess.add(current, myCount);
}
}
if (!excess.isEmpty()) {
result = removeAll(excess);
}
return result;
}
/**
* Returns an array of all of this bag's elements.
*
* @return an array of all of this bag's elements
*/
public Object[] toArray() {
return extractList().toArray();
}
/**
* Returns an array of all of this bag's elements.
*
* @param a the array to populate
* @return an array of all of this bag's elements
*/
public Object[] toArray(Object[] a) {
return extractList().toArray(a);
}
/**
* Returns the number of occurrence of the given element in this bag
* by looking up its count in the underlying map.
*
* @see Bag#getCount(Object)
*/
public int getCount(Object o) {
int result = 0;
Integer count = MapUtils.getInteger(_map, o);
if (count != null) {
result = count.intValue();
}
return result;
}
/**
* Returns an unmodifiable view of the underlying map's key set.
*
* @return the set of unique elements in this bag
*/
public Set uniqueSet() {
return Collections.unmodifiableSet(_map.keySet());
}
/**
* Returns the number of elements in this bag.
*
* @return the number of elements in this bag
*/
public int size() {
return _total;
}
/**
* Actually walks the bag to make sure the count is correct and
* resets the running total
**/
protected int calcTotalSize() {
_total = extractList().size();
return _total;
}
/**
* Utility method for implementations to set the map that backs
* this bag. Not intended for interactive use outside of
* subclasses.
**/
protected void setMap(Map m) {
_map = m;
}
/**
* Utility method for implementations to access the map that backs
* this bag. Not intended for interactive use outside of
* subclasses.
**/
protected Map getMap() {
return _map;
}
/**
* Create a list for use in iteration, etc.
**/
private List extractList() {
List result = new ArrayList();
Iterator i = uniqueSet().iterator();
while (i.hasNext()) {
Object current = i.next();
for (int index = getCount(current); index > 0; index--) {
result.add(current);
}
}
return result;
}
/**
* Return number of modifications for iterator
**/
private int modCount() {
return _mods;
}
/**
* Implement a toString() method suitable for debugging
**/
public String toString() {
StringBuffer buf = new StringBuffer();
buf.append("[");
Iterator i = uniqueSet().iterator();
while(i.hasNext()) {
Object current = i.next();
int count = getCount(current);
buf.append(count);
buf.append(":");
buf.append(current);
if(i.hasNext()) {
buf.append(",");
}
}
buf.append("]");
return buf.toString();
}
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/StaticBucketMap.java 0100644 0001750 0001750 00000047336 10055172400 032152 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.AbstractCollection;
import java.util.AbstractSet;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.ArrayList;
import java.util.NoSuchElementException;
/**
* A StaticBucketMap is an efficient, thread-safe implementation of
* java.util.Map that performs well in in a highly
* thread-contentious environment. The map supports very efficient
* {@link #get(Object) get}, {@link #put(Object,Object) put},
* {@link #remove(Object) remove} and {@link #containsKey(Object) containsKey}
* operations, assuming (approximate) uniform hashing and
* that the number of entries does not exceed the number of buckets. If the
* number of entries exceeds the number of buckets or if the hashcodes of the
* objects are not uniformly distributed, these operations have a worst case
* scenario that is proportional to the number of elements in the map
* (O(n)).
* staticBucketMapInstance.putAll(map);
*
*
* and
*
*
* staticBucketMapInstance.entrySet().removeAll(map.entrySet());
*
*
* then the results are generally random. Those two statement could cancel
* each other out, leaving staticBucketMapInstance essentially
* unchanged, or they could leave some random subset of map in
* staticBucketMapInstance.
* He = |Hk mod n|
*
*
*
* staticBucketMapInstance.atomic(new Runnable() {
* public void run() {
* staticBucketMapInstance.putAll(map);
* }
* });
*
*
* It can also be used if you need a reliable iterator:
*
*
* staticBucketMapInstance.atomic(new Runnable() {
* public void run() {
* Iterator iterator = staticBucketMapInstance.iterator();
* while (iterator.hasNext()) {
* foo(iterator.next();
* }
* }
* });
*
*
* Implementation note: This method requires a lot of time
* and a ton of stack space. Essentially a recursive algorithm is used
* to enter each bucket's monitor. If you have twenty thousand buckets
* in your map, then the recursive method will be invoked twenty thousand
* times. You have been warned.
*
* @param r the code to execute atomicly
*/
public void atomic(Runnable r) {
if (r == null) throw new NullPointerException();
atomic(r, 0);
}
private void atomic(Runnable r, int bucket) {
if (bucket >= m_buckets.length) {
r.run();
return;
}
synchronized (m_locks[bucket]) {
atomic(r, bucket + 1);
}
}
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/BufferUtils.java 0100644 0001750 0001750 00000014245 10055172376 031366 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.Collection;
/**
* Contains static utility methods for operating on {@link Buffer} objects.
*
* @author Paul Jack
* @author Stephen Colebourne
* @version $Id: BufferUtils.java,v 1.9.2.1 2004/05/22 12:14:02 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:
*
*
* Buffer b = BufferUtils.synchronizedBuffer(myBuffer);
* synchronized (b) {
* Iterator i = b.iterator();
* while (i.hasNext()) {
* process (i.next());
* }
* }
*
*
* @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 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
* BufferUnderflowException.
*
* @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 buffer) {
return new SynchronizedBuffer(buffer) {
public synchronized boolean add(Object o) {
boolean r = collection.add(o);
notify();
return r;
}
public synchronized boolean addAll(Collection c) {
boolean r = collection.addAll(c);
notifyAll();
return r;
}
public synchronized Object get() {
while (collection.isEmpty()) {
try {
wait();
} catch (InterruptedException e) {
throw new BufferUnderflowException();
}
}
return ((Buffer)collection).get();
}
public synchronized Object remove() {
while (collection.isEmpty()) {
try {
wait();
} catch (InterruptedException e) {
throw new BufferUnderflowException();
}
}
return ((Buffer)collection).remove();
}
};
}
/**
* Returns an unmodifiable buffer backed by the given 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 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.
*
* @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 buffer, final Predicate predicate) {
return new PredicatedBuffer(buffer, predicate);
}
static class SynchronizedBuffer
extends CollectionUtils.SynchronizedCollection
implements Buffer {
public SynchronizedBuffer(Buffer b) {
super(b);
}
public synchronized Object get() {
return ((Buffer)collection).get();
}
public synchronized Object remove() {
return ((Buffer)collection).remove();
}
}
static class UnmodifiableBuffer
extends CollectionUtils.UnmodifiableCollection
implements Buffer {
public UnmodifiableBuffer(Buffer b) {
super(b);
}
public Object get() {
return ((Buffer)collection).get();
}
public Object remove() {
throw new UnsupportedOperationException();
}
}
static class PredicatedBuffer
extends CollectionUtils.PredicatedCollection
implements Buffer {
public PredicatedBuffer(Buffer b, Predicate p) {
super(b, p);
}
public Object get() {
return ((Buffer)collection).get();
}
public Object remove() {
return ((Buffer)collection).remove();
}
}
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/ArrayIterator.java 0100644 0001750 0001750 00000005723 10055172400 031711 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
/** Implements an {@link java.util.Iterator} over an array of objects.
*
* @since 1.0
* @author James Strachan
* @author Mauricio S. Moura
* @author Michael A. Smith
* @version $Revision: 1.17.2.1 $
* @deprecated this class has been moved to the iterators subpackage
*/
public class ArrayIterator
extends org.apache.commons.collections.iterators.ArrayIterator {
/**
* Construct an ArrayIterator. Using this constructor, the iterator is
* equivalent to an empty iterator until {@link #setArray(Object)} is
* called to establish the array to iterate over.
**/
public ArrayIterator() {
super();
}
/**
* Construct an ArrayIterator that will iterate over the values in the
* specified array.
*
* @param array the array to iterate over.
*
* @exception IllegalArgumentException if array is not an
* array.
*
* @exception NullPointerException
* if array is null
**/
public ArrayIterator(Object array) {
super(array);
}
/**
* Construct an ArrayIterator that will iterate over the values in the
* specified array.
*
* @param array the array to iterate over.
* @param start the index to start iterating at.
*
* @exception IllegalArgumentException if array is not an
* array.
*
* @exception NullPointerException
* if array is null
**/
public ArrayIterator(Object array, int start) {
super(array, start);
}
/**
* Construct an ArrayIterator that will iterate over the values in the
* specified array.
*
* @param array the array to iterate over.
* @param start the index to start iterating at.
* @param end the index to finish iterating at.
*
* @exception IllegalArgumentException if array is not an
* array.
*
* @exception NullPointerException
* if array is null
**/
public ArrayIterator(Object array, int start, int end) {
super(array, start, end);
}
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/ 0040755 0001750 0001750 00000000000 10072637465 030306 5 ustar tora tora ././@LongLink 0000000 0000000 0000000 00000000162 00000000000 011564 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/IteratorEnumeration.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/IteratorEn 0100644 0001750 0001750 00000005273 10055172376 032305 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.iterators;
import java.util.Enumeration;
import java.util.Iterator;
/** Adapter to make an {@link Iterator Iterator} instance appear to be an {@link Enumeration Enumeration} instances
*
* @since 1.0
* @author James Strachan
*/
public class IteratorEnumeration implements Enumeration {
private Iterator iterator;
/**
* Constructs a new IteratorEnumeration that will not
* function until {@link #setIterator(Iterator) setIterator} is
* invoked.
*/
public IteratorEnumeration() {
}
/**
* Constructs a new IteratorEnumeration that will use
* the given iterator.
*
* @param iterator the iterator to use
*/
public IteratorEnumeration( Iterator iterator ) {
this.iterator = iterator;
}
// Iterator interface
//-------------------------------------------------------------------------
/**
* Returns true if the underlying iterator has more elements.
*
* @return true if the underlying iterator has more elements
*/
public boolean hasMoreElements() {
return iterator.hasNext();
}
/**
* Returns the next element from the underlying iterator.
*
* @return the next element from the underlying iterator.
* @throws NoSuchElementException if the underlying iterator has no
* more elements
*/
public Object nextElement() {
return iterator.next();
}
// Properties
//-------------------------------------------------------------------------
/**
* Returns the underlying iterator.
*
* @return the underlying iterator
*/
public Iterator getIterator() {
return iterator;
}
/**
* Sets the underlying iterator.
*
* @param iterator the new underlying iterator
*/
public void setIterator( Iterator iterator ) {
this.iterator = iterator;
}
}
././@LongLink 0000000 0000000 0000000 00000000160 00000000000 011562 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/SingletonIterator.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/SingletonI 0100644 0001750 0001750 00000004754 10055172402 032275 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.iterators;
import java.util.Iterator;
import java.util.NoSuchElementException;
/**
* SingletonIterator is an {@link Iterator} over a single
* object instance.SingletonIterator.
*
* @param object the single object to return from the iterator
*/
public SingletonIterator(Object object) {
super();
this.object = object;
}
/**
* Is another object available from the iterator.
* A and B,
* my {@link #next} method will return the lesser of
* A.next() and B.next().
*
* @since 2.1
* @author Rodney Waldhoff
* @author Stephen Colebourne
* @version $Revision: 1.3.2.1 $ $Date: 2004/05/22 12:14:04 $
*/
public class CollatingIterator implements Iterator {
/** My {@link Comparator}. */
private Comparator comparator = null;
/** My list of {@link Iterator}s. */
private ArrayList iterators = null;
/** {@link Iterator#next Next} objects peeked from each iterator. */
private ArrayList values = null;
/** Whether or not each {@link #values} element has been set. */
private BitSet valueSet = null;
/** Index of the {@link #iterators iterator} from whom the last returned value was obtained. */
private int lastReturned = -1;
// Constructors
// -------------------------------------------------------------------
/**
* Constructs a new CollatingIterator. Natural sort order
* will be used, and child iterators will have to be manually added
* using the {@link #addIterator(Iterator)} method.
*/
public CollatingIterator() {
this(null,2);
}
/**
* Constructs a new CollatingIterator that will used the
* specified comparator for ordering. Child iterators will have to be
* manually added using the {@link #addIterator(Iterator)} method.
*
* @param comp the comparator to use for ordering, or null
* to use natural sort order
*/
public CollatingIterator(Comparator comp) {
this(comp,2);
}
/**
* Constructs a new CollatingIterator that will used the
* specified comparator for ordering and have the specified initial
* capacity. Child iterators will have to be
* manually added using the {@link #addIterator(Iterator)} method.
*
* @param comp the comparator to use for ordering, or null
* to use natural sort order
* @param initIterCapacity the initial capacity for the internal list
* of child iterators
*/
public CollatingIterator(Comparator comp, int initIterCapacity) {
iterators = new ArrayList(initIterCapacity);
setComparator(comp);
}
/**
* Constructs a new CollatingIterator that will use the
* specified comparator to provide ordered iteration over the two
* given iterators.
*
* @param comp the comparator to use to sort, or null to use natural
* sort order
* @param a the first child ordered iterator
* @param b the second child ordered iterator
* @throws NullPointerException if either iterator is null
*/
public CollatingIterator(Comparator comp, Iterator a, Iterator b) {
this(comp,2);
addIterator(a);
addIterator(b);
}
/**
* Constructs a new CollatingIterator that will use the
* specified comparator to provide ordered iteration over the array
* of iterators.
*
* @param comp the comparator to use to sort, or null to use natural
* sort order
* @param iterators the array of iterators
* @throws NullPointerException if iterators array is or contains null
*/
public CollatingIterator(Comparator comp, Iterator[] iterators) {
this(comp, iterators.length);
for (int i = 0; i < iterators.length; i++) {
addIterator(iterators[i]);
}
}
/**
* Constructs a new CollatingIterator that will use the
* specified comparator to provide ordered iteration over the collection
* of iterators.
*
* @param comp the comparator to use to sort, or null to use natural
* sort order
* @param iterators the collection of iterators
* @throws NullPointerException if the iterators collection is or contains null
* @throws ClassCastException if the iterators collection contains an
* element that's not an {@link Iterator}
*/
public CollatingIterator(Comparator comp, Collection iterators) {
this(comp, iterators.size());
for (Iterator it = iterators.iterator(); it.hasNext();) {
Iterator item = (Iterator) it.next();
addIterator(item);
}
}
// Public Methods
// -------------------------------------------------------------------
/**
* Add the given {@link Iterator} to my collection to collate.
* @throws IllegalStateException if I've already started iterating
* @throws NullPointerException if the iterator is null
*/
public void addIterator(Iterator iterator) {
checkNotStarted();
if (iterator == null) {
throw new NullPointerException("Iterator must not be null");
}
iterators.add(iterator);
}
/**
* Set the Iterator at the given index
*
* @param index index of the Iterator to replace
* @param iterator Iterator to place at the given index
* @throws IndexOutOfBoundsException if index < 0 or index > size()
* @throws IllegalStateException if I've already started iterating
* @throws NullPointerException if the iterator is null
*/
public void setIterator(int index, Iterator iterator) throws IndexOutOfBoundsException {
checkNotStarted();
if (iterator == null) {
throw new NullPointerException("Iterator must not be null");
}
iterators.set(index, iterator);
}
/**
* Get the list of Iterators (unmodifiable)
*
* @return the unmodifiable list of iterators added
*/
public List getIterators() {
return Collections.unmodifiableList(iterators);
}
/**
* Set the {@link Comparator} by which I collate.
* @throws IllegalStateException if I've already started iterating
*/
public void setComparator(Comparator comp) {
checkNotStarted();
comparator = comp;
}
/**
* Get the {@link Comparator} by which I collate.
*/
public Comparator getComparator() {
return comparator;
}
// Iterator Methods
// -------------------------------------------------------------------
/**
* Returns true if any child iterator has remaining elements.
*
* @return true if this iterator has remaining elements
*/
public boolean hasNext() {
start();
return anyValueSet(valueSet) || anyHasNext(iterators);
}
/**
* Returns the next ordered element from a child iterator.
*
* @return the next ordered element
* @throws NoSuchElementException if no child iterator has any more
* elements
*/
public Object next() throws NoSuchElementException {
if(!hasNext()) {
throw new NoSuchElementException();
} else {
int leastIndex = least();
if(leastIndex == -1) {
throw new NoSuchElementException();
} else {
Object val = values.get(leastIndex);
clear(leastIndex);
lastReturned = leastIndex;
return val;
}
}
}
/**
* Removes the last returned element from the child iterator that
* produced it.
*
* @throws IllegalStateException if there is no last returned element,
* or if the last returned element has already been removed
*/
public void remove() {
if(-1 == lastReturned) {
throw new NoSuchElementException("No value has been returned yet.");
} else {
Iterator iter = (Iterator)(iterators.get(lastReturned));
iter.remove();
}
}
// Private Methods
// -------------------------------------------------------------------
/** Initialize my collating state if it hasn't been already. */
private void start() {
if(null == values) {
values = new ArrayList(iterators.size());
valueSet = new BitSet(iterators.size());
for(int i=0;itrue.
*/
private boolean anyValueSet(BitSet set) {
for(int i=0;iPredicate evaluates to true are
* returned by the iterator.
*
* @since 2.0
* @version $Revision: 1.1.2.1 $ $Date: 2004/05/22 12:14:04 $
* @author Rodney Waldhoff
*/
public class FilterListIterator extends ProxyListIterator {
// Constructors
//-------------------------------------------------------------------------
/**
* Constructs a new FilterListIterator that will not
* function until
* {@link ProxyListIterator#setListIterator(ListIterator) setListIterator}
* and {@link #setPredicate(Predicate) setPredicate} are invoked.
*/
public FilterListIterator() {
}
/**
* Constructs a new FilterListIterator that will not
* function until {@link #setPredicate(Predicate) setPredicate} is invoked.
*
* @param iterator the iterator to use
*/
public FilterListIterator(ListIterator iterator ) {
super(iterator);
}
/**
* Constructs a new FilterListIterator.
*
* @param iterator the iterator to use
* @param predicate the predicate to use
*/
public FilterListIterator(ListIterator iterator, Predicate predicate) {
super(iterator);
this.predicate = predicate;
}
/**
* Constructs a new FilterListIterator that will not
* function until
* {@link ProxyListIterator#setListIterator(ListIterator) setListIterator}
* is invoked.
*
* @param predicate the predicate to use.
*/
public FilterListIterator(Predicate predicate) {
this.predicate = predicate;
}
// ListIterator interface
//-------------------------------------------------------------------------
/** Not supported. */
public void add(Object o) {
throw new UnsupportedOperationException("FilterListIterator.add(Object) is not supported.");
}
public boolean hasNext() {
if(nextObjectSet) {
return true;
} else {
return setNextObject();
}
}
public boolean hasPrevious() {
if(previousObjectSet) {
return true;
} else {
return setPreviousObject();
}
}
public Object next() {
if(!nextObjectSet) {
if(!setNextObject()) {
throw new NoSuchElementException();
}
}
nextIndex++;
Object temp = nextObject;
clearNextObject();
return temp;
}
public int nextIndex() {
return nextIndex;
}
public Object previous() {
if(!previousObjectSet) {
if(!setPreviousObject()) {
throw new NoSuchElementException();
}
}
nextIndex--;
Object temp = previousObject;
clearPreviousObject();
return temp;
}
public int previousIndex() {
return (nextIndex-1);
}
/** Not supported. */
public void remove() {
throw new UnsupportedOperationException("FilterListIterator.remove() is not supported.");
}
/** Not supported. */
public void set(Object o) {
throw new UnsupportedOperationException("FilterListIterator.set(Object) is not supported.");
}
// Properties
//-------------------------------------------------------------------------
/**
* Getter for the predicate property.
* @return value of the predicate property.
*/
public Predicate getPredicate() {
return predicate;
}
/**
* Setter for the predicate property.
* @param predicate new value for the predicate property.
*/
public void setPredicate(Predicate predicate) {
this.predicate = predicate;
}
// Private Methods
//-------------------------------------------------------------------------
private void clearNextObject() {
nextObject = null;
nextObjectSet = false;
}
private boolean setNextObject() {
ListIterator iterator = getListIterator();
Predicate predicate = getPredicate();
// if previousObjectSet,
// then we've walked back one step in the
// underlying list (due to a hasPrevious() call)
// so skip ahead one matching object
if(previousObjectSet) {
clearPreviousObject();
if(!setNextObject()) {
return false;
} else {
clearNextObject();
}
}
while(iterator.hasNext()) {
Object object = iterator.next();
if(predicate.evaluate(object)) {
nextObject = object;
nextObjectSet = true;
return true;
}
}
return false;
}
private void clearPreviousObject() {
previousObject = null;
previousObjectSet = false;
}
private boolean setPreviousObject() {
ListIterator iterator = getListIterator();
Predicate predicate = getPredicate();
// if nextObjectSet,
// then we've walked back one step in the
// underlying list (due to a hasNext() call)
// so skip ahead one matching object
if(nextObjectSet) {
clearNextObject();
if(!setPreviousObject()) {
return false;
} else {
clearPreviousObject();
}
}
while(iterator.hasPrevious()) {
Object object = iterator.previous();
if(predicate.evaluate(object)) {
previousObject = object;
previousObjectSet = true;
return true;
}
}
return false;
}
// Attributes
//-------------------------------------------------------------------------
/** Holds value of property "predicate". */
private Predicate predicate;
/**
* The value of the next (matching) object, when
* {@link #nextObjectSet} is true.
*/
private Object nextObject;
/**
* Whether or not the {@link #nextObject} has been set
* (possibly to null).
*/
private boolean nextObjectSet = false;
/**
* The value of the previous (matching) object, when
* {@link #previousObjectSet} is true.
*/
private Object previousObject;
/**
* Whether or not the {@link #previousObject} has been set
* (possibly to null).
*/
private boolean previousObjectSet = false;
/**
* The index of the element that would be returned by {@link #next}.
*/
private int nextIndex = 0;
}
././@LongLink 0000000 0000000 0000000 00000000164 00000000000 011566 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/AbstractEmptyIterator.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/AbstractEm 0100644 0001750 0001750 00000003637 10055172400 032244 0 ustar tora tora /*
* Copyright 2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.iterators;
import java.util.NoSuchElementException;
/**
* Provides an implementation of an empty iterator.
*
* @since Commons Collections 2.1.1 and 3.1
* @version $Revision: 1.1.2.2 $ $Date: 2004/05/22 11:54:53 $
*
* @author Stephen Colebourne
*/
abstract class AbstractEmptyIterator {
/**
* Constructor.
*/
protected AbstractEmptyIterator() {
super();
}
public boolean hasNext() {
return false;
}
public Object next() {
throw new NoSuchElementException("Iterator contains no elements");
}
public boolean hasPrevious() {
return false;
}
public Object previous() {
throw new NoSuchElementException("Iterator contains no elements");
}
public int nextIndex() {
return 0;
}
public int previousIndex() {
return -1;
}
public void add(Object obj) {
throw new UnsupportedOperationException("add() not supported for empty Iterator");
}
public void set(Object obj) {
throw new IllegalStateException("Iterator contains no elements");
}
public void remove() {
throw new IllegalStateException("Iterator contains no elements");
}
}
././@LongLink 0000000 0000000 0000000 00000000164 00000000000 011566 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/SingletonListIterator.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/SingletonL 0100644 0001750 0001750 00000010735 10055172400 032272 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.iterators;
import java.util.ListIterator;
import java.util.NoSuchElementException;
/**
* SingletonIterator is an {@link ListIterator} over a single
* object instance.SingletonListIterator.
*
* @param object the single object to return from the iterator
*/
public SingletonListIterator(Object object) {
super();
this.object = object;
}
/**
* Is another object available from the iterator.
* array is not an
* array.
*
* @exception NullPointerException
* if array is null
**/
public ArrayIterator(Object array) {
setArray( array );
}
/**
* Construct an ArrayIterator that will iterate over the values in the
* specified array.
*
* @param array the array to iterate over.
* @param start the index to start iterating at.
*
* @exception IllegalArgumentException if array is not an
* array.
*
* @exception NullPointerException
* if array is null
**/
public ArrayIterator(Object array, int start) {
setArray( array );
checkBound(start, "start");
this.index = start;
}
/**
* Construct an ArrayIterator that will iterate over the values in the
* specified array.
*
* @param array the array to iterate over.
* @param start the index to start iterating at.
* @param end the index to finish iterating at.
*
* @exception IllegalArgumentException if array is not an
* array.
*
* @exception NullPointerException
* if array is null
**/
public ArrayIterator(Object array, int start, int end) {
setArray( array );
checkBound(start, "start");
checkBound(end, "end");
if(end <= start) {
throw new IllegalArgumentException(
"End index must be greater than start index. "
);
}
this.index = start;
this.length = end;
}
private void checkBound(int bound, String type ) {
if(bound > this.length) {
throw new ArrayIndexOutOfBoundsException(
"Attempt to make an ArrayIterator that "+type+
"s beyond the end of the array. "
);
}
if(bound < 0) {
throw new ArrayIndexOutOfBoundsException(
"Attempt to make an ArrayIterator that "+type+
"s before the start of the array. "
);
}
}
// Iterator interface
//-------------------------------------------------------------------------
/**
* Returns true if there are more elements to return from the array.
*
* @return true if there is a next element to return
*/
public boolean hasNext() {
return index < length;
}
/**
* Returns the next element in the array.
*
* @return the next element in the array
* @throws NoSuchElementException if all the elements in the array
* have already been returned
*/
public Object next() {
if(!hasNext()) {
throw new NoSuchElementException();
}
return Array.get( array, index++ );
}
/**
* Throws {@link UnsupportedOperationException}.
*
* @throws UnsupportedOperationException always
*/
public void remove() {
throw new UnsupportedOperationException( "remove() method is not supported" );
}
// Properties
//-------------------------------------------------------------------------
/**
* Retrieves the array that this iterator is iterating over.
*
* @return the array this iterator iterates over, or null if
* the no-arg constructor was used and {@link #setArray(Object)} has never
* been called with a valid array.
**/
public Object getArray() {
return array;
}
/**
* Changes the array that the ArrayIterator should iterate over. If an
* array has previously been set (using the single-arg constructor or this
* method), that array along with the current iterator position within
* that array is discarded in favor of the argument to this method. This
* method can be used in combination with {@link #getArray()} to "reset"
* the iterator to the beginning of the array:
*
*
* ArrayIterator iterator = ...
* ...
* iterator.setArray(iterator.getArray());
*
*
* Note: Using i.setArray(i.getArray()) may throw a NullPointerException
* if no array has ever been set for the iterator (see {@link
* #getArray()})
*
* @param array the array that the iterator should iterate over.
*
* @exception IllegalArgumentException if array is not an
* array.
*
* @exception NullPointerException
* if array is null
**/
public void setArray( Object array ) {
// Array.getLength throws IllegalArgumentException if the object is not
// an array or NullPointerException if the object is null. This call
// is made before saving the array and resetting the index so that the
// array iterator remains in a consistent state if the argument is not
// an array or is null.
this.length = Array.getLength( array );
this.array = array;
this.index = 0;
}
}
././@LongLink 0000000 0000000 0000000 00000000154 00000000000 011565 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/IteratorChain.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/IteratorCh 0100644 0001750 0001750 00000024602 10055172400 032256 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.iterators;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
/**
* IteratorChain over the two
* given iterators.
*
* @param a the first child iterator
* @param b the second child iterator
* @throws NullPointerException if either iterator is null
*/
public IteratorChain(Iterator a, Iterator b) {
super();
addIterator(a);
addIterator(b);
}
/**
* Constructs a new IteratorChain over the array
* of iterators.
*
* @param iterators the array of iterators
* @throws NullPointerException if iterators array is or contains null
*/
public IteratorChain(Iterator[] iterators) {
super();
for (int i = 0; i < iterators.length; i++) {
addIterator(iterators[i]);
}
}
/**
* Constructs a new IteratorChain over the collection
* of iterators.
*
* @param iterators the collection of iterators
* @throws NullPointerException if iterators collection is or contains null
* @throws ClassCastException if iterators collection doesn't contain an iterator
*/
public IteratorChain(Collection iterators) {
super();
for (Iterator it = iterators.iterator(); it.hasNext();) {
Iterator item = (Iterator) it.next();
addIterator(item);
}
}
// Public Methods
// -------------------------------------------------------------------
/**
* Add an Iterator to the end of the chain
*
* @param iterator Iterator to add
* @throws IllegalStateException if I've already started iterating
* @throws NullPointerException if the iterator is null
*/
public void addIterator(Iterator iterator) {
checkLocked();
if (iterator == null) {
throw new NullPointerException("Iterator must not be null");
}
iteratorChain.add(iterator);
}
/**
* Set the Iterator at the given index
*
* @param index index of the Iterator to replace
* @param iterator Iterator to place at the given index
* @throws IndexOutOfBoundsException if index < 0 or index > size()
* @throws IllegalStateException if I've already started iterating
* @throws NullPointerException if the iterator is null
*/
public void setIterator(int index, Iterator iterator) throws IndexOutOfBoundsException {
checkLocked();
if (iterator == null) {
throw new NullPointerException("Iterator must not be null");
}
iteratorChain.set(index, iterator);
}
/**
* Get the list of Iterators (unmodifiable)
*
* @return the unmodifiable list of iterators added
*/
public List getIterators() {
return Collections.unmodifiableList(iteratorChain);
}
/**
* Number of Iterators in the current IteratorChain.
*
* @return Iterator count
*/
public int size() {
return iteratorChain.size();
}
/**
* Determine if modifications can still be made to the
* IteratorChain. IteratorChains cannot be modified
* once they have executed a method from the Iterator
* interface.
*
* @return true = IteratorChain cannot be modified; false =
* IteratorChain can still be modified.
*/
public boolean isLocked() {
return isLocked;
}
// throw an exception if the IteratorChain is locked
private void checkLocked() {
if (isLocked == true) {
throw new UnsupportedOperationException("IteratorChain cannot be changed after the first use of a method from the Iterator interface");
}
}
private void checkChainIntegrity() {
if (iteratorChain.size() == 0) {
throw new UnsupportedOperationException("IteratorChains must contain at least one Iterator");
}
}
// you MUST call this method whenever you call a method in the Iterator interface, because
// this method also assigns the initial value of the currentIterator variable
private void lockChain() {
if (isLocked == false) {
checkChainIntegrity();
isLocked = true;
}
}
// call this before any Iterator method to make sure that the current Iterator
// is not exhausted
protected void updateCurrentIterator() {
if (currentIterator == null) {
currentIterator = (Iterator) iteratorChain.get(0);
// set last used iterator here, in case the user calls remove
// before calling hasNext() or next() (although they shouldn't)
lastUsedIterator = currentIterator;
return;
}
if (currentIteratorIndex == (iteratorChain.size() - 1)) {
return;
}
while (currentIterator.hasNext() == false) {
++currentIteratorIndex;
currentIterator = (Iterator) iteratorChain.get(currentIteratorIndex);
if (currentIteratorIndex == (iteratorChain.size() - 1)) {
return;
}
}
}
/**
* Return true if any Iterator in the IteratorChain has a remaining
* element.
*
* @return true if elements remain
* @exception UnsupportedOperationException
* if the IteratorChain does not contain at least one
* Iterator
*/
public boolean hasNext() throws UnsupportedOperationException {
lockChain();
updateCurrentIterator();
lastUsedIterator = currentIterator;
return currentIterator.hasNext();
}
/**
* Returns the next Object of the current Iterator
*
* @return Object from the current Iterator
* @exception NoSuchElementException
* if all the Iterators are exhausted
* @exception UnsupportedOperationException
* if the IteratorChain does not contain at least one
* Iterator
*/
public Object next() throws NoSuchElementException, UnsupportedOperationException {
lockChain();
updateCurrentIterator();
lastUsedIterator = currentIterator;
return currentIterator.next();
}
/**
* Removes from the underlying collection the last element
* returned by the Iterator. As with next() and hasNext(),
* this method calls remove() on the underlying Iterator.
* Therefore, this method may throw an
* UnsupportedOperationException if the underlying
* Iterator does not support this method.
*
* @exception UnsupportedOperationException
* if the remove operator is not supported by the underlying
* Iterator or if there are no Iterators in the IteratorChain
* @exception IllegalStateException
* if the next method has not yet been called, or the
* remove method has already been called after the last
* call to the next method.
*/
public void remove() throws UnsupportedOperationException, IllegalStateException {
lockChain();
updateCurrentIterator();
lastUsedIterator.remove();
}
}
././@LongLink 0000000 0000000 0000000 00000000160 00000000000 011562 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/EmptyListIterator.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/EmptyListI 0100644 0001750 0001750 00000003017 10055172400 032252 0 ustar tora tora /*
* Copyright 2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.iterators;
import java.util.ListIterator;
/**
* Provides an implementation of an empty list iterator.
* IteratorUtils.
*
* @since Commons Collections 2.1.1 and 3.1
* @version $Revision: 1.1.2.2 $ $Date: 2004/05/22 11:54:53 $
*
* @author Stephen Colebourne
*/
public final class EmptyListIterator extends AbstractEmptyIterator implements ListIterator {
/**
* Singleton instance of the iterator.
* @since Commons Collections 2.1.1 and 3.1
*/
public static final ListIterator INSTANCE = new EmptyListIterator();
/**
* Constructor.
*/
protected EmptyListIterator() {
super();
}
}
././@LongLink 0000000 0000000 0000000 00000000160 00000000000 011562 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/ProxyListIterator.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/ProxyListI 0100644 0001750 0001750 00000011216 10055172376 032311 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.iterators;
import java.util.ListIterator;
/**
* A proxy {@link ListIterator ListIterator} which delegates its
* methods to a proxy instance.
*
* @since 2.0
* @see ProxyIterator
* @version $Revision: 1.1.2.1 $ $Date: 2004/05/22 12:14:04 $
* @author Rodney Waldhoff
*/
public class ProxyListIterator implements ListIterator {
// Constructor
//-------------------------------------------------------------------------
/**
* Constructs a new ProxyListIterator that will not
* function until {@link #setListIterator(ListIterator) setListIterator}
* is invoked.
*/
public ProxyListIterator() {
}
/**
* Constructs a new ProxyListIterator that will use the
* given list iterator.
*
* @param iterator the list iterator to use
*/
public ProxyListIterator(ListIterator iterator) {
this.iterator = iterator;
}
// ListIterator interface
//-------------------------------------------------------------------------
/**
* Invokes the underlying {@link ListIterator#add(Object)} method.
*
* @throws NullPointerException if the underyling iterator is null
*/
public void add(Object o) {
getListIterator().add(o);
}
/**
* Invokes the underlying {@link ListIterator#hasNext()} method.
*
* @throws NullPointerException if the underyling iterator is null
*/
public boolean hasNext() {
return getListIterator().hasNext();
}
/**
* Invokes the underlying {@link ListIterator#hasPrevious()} method.
*
* @throws NullPointerException if the underyling iterator is null
*/
public boolean hasPrevious() {
return getListIterator().hasPrevious();
}
/**
* Invokes the underlying {@link ListIterator#next()} method.
*
* @throws NullPointerException if the underyling iterator is null
*/
public Object next() {
return getListIterator().next();
}
/**
* Invokes the underlying {@link ListIterator#nextIndex()} method.
*
* @throws NullPointerException if the underyling iterator is null
*/
public int nextIndex() {
return getListIterator().nextIndex();
}
/**
* Invokes the underlying {@link ListIterator#previous()} method.
*
* @throws NullPointerException if the underyling iterator is null
*/
public Object previous() {
return getListIterator().previous();
}
/**
* Invokes the underlying {@link ListIterator#previousIndex()} method.
*
* @throws NullPointerException if the underyling iterator is null
*/
public int previousIndex() {
return getListIterator().previousIndex();
}
/**
* Invokes the underlying {@link ListIterator#remove()} method.
*
* @throws NullPointerException if the underyling iterator is null
*/
public void remove() {
getListIterator().remove();
}
/**
* Invokes the underlying {@link ListIterator#set(Object)} method.
*
* @throws NullPointerException if the underyling iterator is null
*/
public void set(Object o) {
getListIterator().set(o);
}
// Properties
//-------------------------------------------------------------------------
/**
* Getter for property iterator.
* @return Value of property iterator.
*/
public ListIterator getListIterator() {
return iterator;
}
/**
* Setter for property iterator.
* @param iterator New value of property iterator.
*/
public void setListIterator(ListIterator iterator) {
this.iterator = iterator;
}
// Attributes
//-------------------------------------------------------------------------
/** Holds value of property "iterator". */
private ListIterator iterator;
}
././@LongLink 0000000 0000000 0000000 00000000160 00000000000 011562 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/TransformIterator.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/TransformI 0100644 0001750 0001750 00000006640 10055172376 032314 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.iterators;
import java.util.Iterator;
import org.apache.commons.collections.Transformer;
/** A Proxy {@link Iterator Iterator} which uses a {@link Transformer Transformer} instance to
* transform the contents of the {@link Iterator Iterator} into some other form
*
* @since 1.0
* @author James Strachan
*/
public class TransformIterator extends ProxyIterator {
/** Holds value of property transformer. */
private Transformer transformer;
/**
* Constructs a new TransformIterator that will not function
* until the {@link #setIterator(Iterator) setIterator} method is
* invoked.
*/
public TransformIterator() {
}
/**
* Constructs a new TransformIterator that won't transform
* elements from the given iterator.
*
* @param iterator the iterator to use
*/
public TransformIterator( Iterator iterator ) {
super( iterator );
}
/**
* Constructs a new TransformIterator that will use the
* given iterator and transformer. If the given transformer is null,
* then objects will not be transformed.
*
* @param iterator the iterator to use
* @param transformer the transformer to use
*/
public TransformIterator( Iterator iterator, Transformer transformer ) {
super( iterator );
this.transformer = transformer;
}
// Iterator interface
//-------------------------------------------------------------------------
public Object next() {
return transform( super.next() );
}
// Properties
//-------------------------------------------------------------------------
/** Getter for property transformer.
* @return Value of property transformer.
*/
public Transformer getTransformer() {
return transformer;
}
/** Setter for property transformer.
* @param transformer New value of property transformer.
*/
public void setTransformer(Transformer transformer) {
this.transformer = transformer;
}
// Implementation methods
//-------------------------------------------------------------------------
/**
* Transforms the given object using the transformer. If the
* transformer is null, the original object is returned as-is.
*
* @param source the object to transform
* @return the transformed object
*/
protected Object transform( Object source ) {
Transformer transformer = getTransformer();
if ( transformer != null ) {
return transformer.transform( source );
}
return source;
}
}
././@LongLink 0000000 0000000 0000000 00000000155 00000000000 011566 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/FilterIterator.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/FilterIter 0100644 0001750 0001750 00000011233 10055172400 032257 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.iterators;
import java.util.Iterator;
import java.util.NoSuchElementException;
import org.apache.commons.collections.Predicate;
/** A Proxy {@link Iterator Iterator} which takes a {@link Predicate Predicate} instance to filter
* out objects from an underlying {@link Iterator Iterator} instance.
* Only objects for which the
* specified Predicate evaluates to true are
* returned.
*
* @since 1.0
* @author James Strachan
* @author Jan Sorensen
*/
public class FilterIterator extends ProxyIterator {
/** Holds value of property predicate. */
private Predicate predicate;
private Object nextObject;
private boolean nextObjectSet = false;
//-------------------------------------------------------------------------
/**
* Constructs a new FilterIterator that will not function
* until {@link #setIterator(Iterator) setIterator} is invoked.
*/
public FilterIterator() {
}
/**
* Constructs a new FilterIterator that will not function
* until {@link #setPredicate(Predicate) setPredicate} is invoked.
*
* @param iterator the iterator to use
*/
public FilterIterator( Iterator iterator ) {
super( iterator );
}
/**
* Constructs a new FilterIterator that will use the
* given iterator and predicate.
*
* @param iterator the iterator to use
* @param predicate the predicate to use
*/
public FilterIterator( Iterator iterator, Predicate predicate ) {
super( iterator );
this.predicate = predicate;
}
// Iterator interface
//-------------------------------------------------------------------------
/**
* Returns true if the underlying iterator contains an object that
* matches the predicate.
*
* @return true if there is another object that matches the predicate
*/
public boolean hasNext() {
if ( nextObjectSet ) {
return true;
} else {
return setNextObject();
}
}
/**
* Returns the next object that matches the predicate.
*
* @return the next object which matches the given predicate
* @throws NoSuchElementException if there are no more elements that
* match the predicate
*/
public Object next() {
if ( !nextObjectSet ) {
if (!setNextObject()) {
throw new NoSuchElementException();
}
}
nextObjectSet = false;
return nextObject;
}
/**
* Always throws UnsupportedOperationException as this class
* does look-ahead with its internal iterator.
*
* @throws UnsupportedOperationException always
*/
public void remove() {
throw new UnsupportedOperationException();
}
// Properties
//-------------------------------------------------------------------------
/** Getter for property predicate.
* @return Value of property predicate.
*/
public Predicate getPredicate() {
return predicate;
}
/** Setter for property predicate.
* @param predicate New value of property predicate.
*/
public void setPredicate(Predicate predicate) {
this.predicate = predicate;
}
/**
* Set nextObject to the next object. If there are no more
* objects then return false. Otherwise, return true.
*/
private boolean setNextObject() {
Iterator iterator = getIterator();
Predicate predicate = getPredicate();
while ( iterator.hasNext() ) {
Object object = iterator.next();
if ( predicate.evaluate( object ) ) {
nextObject = object;
nextObjectSet = true;
return true;
}
}
return false;
}
}
././@LongLink 0000000 0000000 0000000 00000000162 00000000000 011564 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/ListIteratorWrapper.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/ListIterat 0100644 0001750 0001750 00000012365 10055172400 032301 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.iterators;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;
import java.util.NoSuchElementException;
/**
* As the wrapped Iterator is traversed, ListIteratorWrapper
* builds a LinkedList of its values, permitting all required
* operations of ListIterator.
*
* @since 2.1
* @author Morgan Delagrange
* @author Stephen Colebourne
* @version $Id: ListIteratorWrapper.java,v 1.2.2.1 2004/05/22 12:14:04 scolebourne Exp $
*/
public class ListIteratorWrapper implements ListIterator {
/** Holds value of property "iterator" */
private final Iterator iterator;
private final LinkedList list = new LinkedList();
// position of this iterator
private int currentIndex = 0;
// position of the wrapped iterator
// this Iterator should only be used to populate the list
private int wrappedIteratorIndex = 0;
private static final String UNSUPPORTED_OPERATION_MESSAGE =
"ListIteratorWrapper does not support optional operations of ListIterator.";
// Constructor
//-------------------------------------------------------------------------
/**
* Constructs a new ListIteratorWrapper that will wrap
* the given iterator.
*
* @param iterator the iterator to wrap
* @throws NullPointerException if the iterator is null
*/
public ListIteratorWrapper(Iterator iterator) {
if (iterator == null) {
throw new NullPointerException("Iterator must not be null");
}
this.iterator = iterator;
}
// ListIterator interface
//-------------------------------------------------------------------------
/**
* Throws {@link UnsupportedOperationException}.
*
* @param o ignored
* @throws UnsupportedOperationException always
*/
public void add(Object o) throws UnsupportedOperationException {
throw new UnsupportedOperationException(UNSUPPORTED_OPERATION_MESSAGE);
}
/**
* Returns true if there are more elements in the iterator.
*
* @return true if there are more elements
*/
public boolean hasNext() {
if (currentIndex == wrappedIteratorIndex) {
return iterator.hasNext();
}
return true;
}
/**
* Returns true if there are previous elements in the iterator.
*
* @return true if there are previous elements
*/
public boolean hasPrevious() {
if (currentIndex == 0) {
return false;
}
return true;
}
/**
* Returns the next element from the iterator.
*
* @return the next element from the iterator
* @throws NoSuchElementException if there are no more elements
*/
public Object next() throws NoSuchElementException {
if (currentIndex < wrappedIteratorIndex) {
++currentIndex;
return list.get(currentIndex - 1);
}
Object retval = iterator.next();
list.add(retval);
++currentIndex;
++wrappedIteratorIndex;
return retval;
}
/**
* Returns in the index of the next element.
*
* @return the index of the next element
*/
public int nextIndex() {
return currentIndex;
}
/**
* Returns the the previous element.
*
* @return the previous element
* @throws NoSuchElementException if there are no previous elements
*/
public Object previous() throws NoSuchElementException {
if (currentIndex == 0) {
throw new NoSuchElementException();
}
--currentIndex;
return list.get(currentIndex);
}
/**
* Returns the index of the previous element.
*
* @return the index of the previous element
*/
public int previousIndex() {
return currentIndex - 1;
}
/**
* Throws {@link UnsupportedOperationException}.
*
* @throws UnsupportedOperationException always
*/
public void remove() throws UnsupportedOperationException {
throw new UnsupportedOperationException(UNSUPPORTED_OPERATION_MESSAGE);
}
/**
* Throws {@link UnsupportedOperationException}.
*
* @param o ignored
* @throws UnsupportedOperationException always
*/
public void set(Object o) throws UnsupportedOperationException {
throw new UnsupportedOperationException(UNSUPPORTED_OPERATION_MESSAGE);
}
}
././@LongLink 0000000 0000000 0000000 00000000162 00000000000 011564 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/EnumerationIterator.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/Enumeratio 0100644 0001750 0001750 00000010444 10055172400 032321 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.iterators;
import java.util.Collection;
import java.util.Enumeration;
import java.util.Iterator;
/** Adapter to make {@link Enumeration Enumeration} instances appear
* to be {@link Iterator Iterator} instances.
*
* @since 1.0
* @author James Strachan
* @author Daniel Rall
*/
public class EnumerationIterator implements Iterator {
private Collection collection;
private Enumeration enumeration;
private Object last;
/**
* Constructs a new EnumerationIterator that will not
* function until {@link #setEnumeration(Enumeration)} is called.
*/
public EnumerationIterator() {
this(null, null);
}
/**
* Constructs a new EnumerationIterator that provides
* an iterator view of the given enumeration.
*
* @param enumeration the enumeration to use
*/
public EnumerationIterator( Enumeration enumeration ) {
this(enumeration, null);
}
/**
* Constructs a new EnumerationIterator that will remove
* elements from the specified collection.
*
* @param enumeration the enumeration to use
* @param collection the collection to remove elements from
*/
public EnumerationIterator( Enumeration enumeration, Collection collection ) {
this.enumeration = enumeration;
this.collection = collection;
this.last = null;
}
// Iterator interface
//-------------------------------------------------------------------------
/**
* Returns true if the underlying enumeration has more elements.
*
* @return true if the underlying enumeration has more elements
* @throws NullPointerException if the underlying enumeration is null
*/
public boolean hasNext() {
return enumeration.hasMoreElements();
}
/**
* Returns the next object from the enumeration.
*
* @return the next object from the enumeration
* @throws NullPointerException if the enumeration is null
*/
public Object next() {
last = enumeration.nextElement();
return last;
}
/**
* Functions if an associated Collection is known.
* If so, the first occurrence of the last returned object from this
* iterator will be removed from the collection.
*
* @exception IllegalStateException next() not called.
* @exception UnsupportedOperationException No associated
* Collection.
*/
public void remove() {
if (collection != null) {
if (last != null) {
collection.remove(last);
}
else {
throw new IllegalStateException
("next() must have been called for remove() to function");
}
}
else {
throw new UnsupportedOperationException
("No Collection associated with this Iterator");
}
}
// Properties
//-------------------------------------------------------------------------
/**
* Returns the underlying enumeration.
*
* @return the underlying enumeration
*/
public Enumeration getEnumeration() {
return enumeration;
}
/**
* Sets the underlying enumeration.
*
* @param enumeration the new underlying enumeration
*/
public void setEnumeration( Enumeration enumeration ) {
this.enumeration = enumeration;
}
}
././@LongLink 0000000 0000000 0000000 00000000154 00000000000 011565 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/EmptyIterator.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/EmptyItera 0100644 0001750 0001750 00000002755 10055172400 032302 0 ustar tora tora /*
* Copyright 2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.iterators;
import java.util.Iterator;
/**
* Provides an implementation of an empty iterator.
* IteratorUtils.
*
* @since Commons Collections 2.1.1 and 3.1
* @version $Revision: 1.1.2.2 $ $Date: 2004/05/22 11:54:53 $
*
* @author Stephen Colebourne
*/
public final class EmptyIterator extends AbstractEmptyIterator implements Iterator {
/**
* Singleton instance of the iterator.
* @since Commons Collections 2.1.1 and 3.1
*/
public static final Iterator INSTANCE = new EmptyIterator();
/**
* Constructor.
*/
protected EmptyIterator() {
super();
}
}
././@LongLink 0000000 0000000 0000000 00000000154 00000000000 011565 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/ProxyIterator.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/ProxyItera 0100644 0001750 0001750 00000005622 10055172376 032335 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.iterators;
import java.util.Iterator;
/** A Proxy {@link Iterator Iterator} which delegates its methods to a proxy instance.
*
* @since 1.0
* @see ProxyListIterator
* @version $Revision: 1.1.2.1 $ $Date: 2004/05/22 12:14:04 $
*
* @author James Strachan
*/
public class ProxyIterator implements Iterator {
/** Holds value of property iterator. */
private Iterator iterator;
/**
* Constructs a new ProxyIterator that will not function
* until {@link #setIterator(Iterator)} is called.
*/
public ProxyIterator() {
}
/**
* Constructs a new ProxyIterator that will use the
* given iterator.
*
* @param iterator the underyling iterator
*/
public ProxyIterator( Iterator iterator ) {
this.iterator = iterator;
}
// Iterator interface
//-------------------------------------------------------------------------
/**
* Returns true if the underlying iterator has more elements.
*
* @return true if the underlying iterator has more elements
*/
public boolean hasNext() {
return getIterator().hasNext();
}
/**
* Returns the next element from the underlying iterator.
*
* @return the next element from the underlying iterator
* @throws NoSuchElementException if the underlying iterator
* raises it because it has no more elements
*/
public Object next() {
return getIterator().next();
}
/**
* Removes the last returned element from the collection that spawned
* the underlying iterator.
*/
public void remove() {
getIterator().remove();
}
// Properties
//-------------------------------------------------------------------------
/** Getter for property iterator.
* @return Value of property iterator.
*/
public Iterator getIterator() {
return iterator;
}
/** Setter for property iterator.
* @param iterator New value of property iterator.
*/
public void setIterator(Iterator iterator) {
this.iterator = iterator;
}
}
././@LongLink 0000000 0000000 0000000 00000000146 00000000000 011566 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/package.html libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/iterators/package.ht 0100644 0001750 0001750 00000000453 10055172400 032215 0 ustar tora tora UniqueFilterIterator.
*
* @param iterator the iterator to use
*/
public UniqueFilterIterator( Iterator iterator ) {
super( iterator, new UniquePredicate() );
}
private static class UniquePredicate implements Predicate {
HashSet set = new HashSet();
public boolean evaluate(Object object) {
return set.add(object);
}
}
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/ListUtils.java 0100644 0001750 0001750 00000034150 10055172376 031065 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.ArrayList;
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.
*
* @since 1.0
* @author Federico Barbieri
* @author Peter Donald
* @author Paul Jack
* @author Stephen Colebourne
*/
public class ListUtils {
/**
* Please don't ever instantiate a ListUtils.
*/
public ListUtils() {
}
/**
* 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
*/
public static List intersection(final List list1, final List list2) {
final ArrayList result = new ArrayList();
final Iterator iterator = list2.iterator();
while (iterator.hasNext()) {
final Object o = iterator.next();
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 list1 contains two
* occurrences of null and list2 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
*/
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());
}
return result;
}
/**
* 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
*/
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.
*
* @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);
return result;
}
static class ListIteratorWrapper
implements ListIterator {
final protected ListIterator iterator;
public ListIteratorWrapper(ListIterator iterator) {
this.iterator = iterator;
}
public boolean hasNext() {
return iterator.hasNext();
}
public Object next() {
return iterator.next();
}
public boolean hasPrevious() {
return iterator.hasPrevious();
}
public Object previous() {
return iterator.previous();
}
public int nextIndex() {
return iterator.nextIndex();
}
public int previousIndex() {
return iterator.previousIndex();
}
public void remove() {
iterator.remove();
}
public void set(Object o) {
iterator.set(o);
}
public void add(Object o) {
iterator.add(o);
}
}
static class PredicatedList
extends CollectionUtils.PredicatedCollection
implements List {
public PredicatedList(List list, Predicate p) {
super(list, p);
}
public boolean addAll(int i, Collection c) {
for (Iterator iter = c.iterator(); iter.hasNext(); ) {
validate(iter.next());
}
return getList().addAll(i, c);
}
public Object get(int i) {
return getList().get(i);
}
public Object set(int i, Object o) {
validate(o);
return getList().set(i, o);
}
public void add(int i, Object o) {
validate(o);
getList().add(i, o);
}
public Object remove(int i) {
return getList().remove(i);
}
public int indexOf(Object o) {
return getList().indexOf(o);
}
public int lastIndexOf(Object o) {
return getList().lastIndexOf(o);
}
public ListIterator listIterator() {
return listIterator(0);
}
public ListIterator listIterator(int i) {
return new ListIteratorWrapper(getList().listIterator(i)) {
public void add(Object o) {
validate(o);
iterator.add(o);
}
public void set(Object o) {
validate(o);
iterator.set(o);
}
};
}
public List subList(int i1, int i2) {
List sub = getList().subList(i1, i2);
return new PredicatedList(sub, predicate);
}
private List getList() {
return (List)collection;
}
}
static class FixedSizeList
extends CollectionUtils.UnmodifiableCollection
implements List {
public FixedSizeList(List list) {
super(list);
}
public boolean addAll(int i, Collection c) {
throw new UnsupportedOperationException();
}
public Object get(int i) {
return getList().get(i);
}
public Object set(int i, Object o) {
return getList().set(i, o);
}
public void add(int i, Object o) {
throw new UnsupportedOperationException();
}
public Object remove(int i) {
throw new UnsupportedOperationException();
}
public int indexOf(Object o) {
return getList().indexOf(o);
}
public int lastIndexOf(Object o) {
return getList().lastIndexOf(o);
}
public ListIterator listIterator() {
return listIterator(0);
}
public ListIterator listIterator(int i) {
return new ListIteratorWrapper(getList().listIterator(i)) {
public void remove() {
throw new UnsupportedOperationException();
}
public void add(Object o) {
throw new UnsupportedOperationException();
}
public void remove(Object o) {
throw new UnsupportedOperationException();
}
};
}
public List subList(int i1, int i2) {
List sub = getList().subList(i1, i2);
return new FixedSizeList(sub);
}
private List getList() {
return (List)collection;
}
}
static class LazyList
extends CollectionUtils.CollectionWrapper
implements List {
protected final Factory factory;
public LazyList(List list, Factory factory) {
super(list);
if (factory == null) {
throw new IllegalArgumentException("Factory must not be null");
}
this.factory = factory;
}
/* Proxy method to the impl's get method. With the exception that if it's out
* of bounds, then the collection will grow, leaving place-holders in its
* wake, so that an item can be set at any given index. Later the
* place-holders are removed to return to a pure collection.
*
* If there's a place-holder at the index, then it's replaced with a proper
* object to be used.
*/
public Object get(int index) {
Object obj;
if (index < (getList().size())) {
/* within bounds, get the object */
obj = getList().get(index);
if (obj == null) {
/* item is a place holder, create new one, set and return */
obj = this.factory.create();
this.getList().set(index, obj);
return obj;
} else {
/* good and ready to go */
return obj;
}
} else {
/* we have to grow the list */
for (int i = getList().size(); i < index; i++) {
getList().add(null);
}
/* create our last object, set and return */
obj = this.factory.create();
getList().add(obj);
return obj;
}
}
/* proxy the call to the provided list implementation. */
public List subList(int fromIndex, int toIndex) {
/* wrap the returned sublist so it can continue the functionality */
return new LazyList(getList().subList(fromIndex, toIndex), factory);
}
public boolean addAll(int i, Collection c) {
return getList().addAll(i, c);
}
public Object set(int i, Object o) {
return getList().set(i, o);
}
public void add(int i, Object o) {
getList().add(i, o);
}
public Object remove(int i) {
return getList().remove(i);
}
public int indexOf(Object o) {
return getList().indexOf(o);
}
public int lastIndexOf(Object o) {
return getList().lastIndexOf(o);
}
public ListIterator listIterator() {
return getList().listIterator();
}
public ListIterator listIterator(int i) {
return getList().listIterator(i);
}
private List getList() {
return (List)collection;
}
}
/**
* 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, 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 predicate) {
return new PredicatedList(list, predicate);
}
/**
* Returns a "lazy" list whose elements will be created on demand.
* Factory factory = new Factory() {
* public Object create() {
* return new Date();
* }
* }
* List lazy = ListUtils.lazyList(new ArrayList(), factory);
* Object obj = lazy.get(3);
*
*
* After the above code is executed, obj will contain
* a new Date instance. Furthermore, that Date
* instance is the fourth element in the list. The first, second,
* and third element are all set to null.
*
* @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).
*
* @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);
}
}
././@LongLink 0000000 0000000 0000000 00000000145 00000000000 011565 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/SequencedHashMap.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/SequencedHashMap.jav 0100644 0001750 0001750 00000100102 10055172400 032121 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.io.Externalizable;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.io.IOException;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.AbstractCollection;
import java.util.AbstractSet;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.NoSuchElementException;
import java.util.ConcurrentModificationException;
/**
* A map of objects whose mapping entries are sequenced based on the order in
* which they were added. This data structure has fast O(1) search
* time, deletion time, and insertion time.
*
* null
* key and value.
**/
private static final Entry createSentinel() {
Entry s = new Entry(null, null);
s.prev = s;
s.next = s;
return s;
}
/**
* Sentinel used to hold the head and tail of the list of entries.
**/
private Entry sentinel;
/**
* Map of keys to entries
**/
private HashMap entries;
/**
* Holds the number of modifications that have occurred to the map,
* excluding modifications made through a collection view's iterator
* (e.g. entrySet().iterator().remove()). This is used to create a
* fail-fast behavior with the iterators.
**/
private transient long modCount = 0;
/**
* Construct a new sequenced hash map with default initial size and load
* factor.
**/
public SequencedHashMap() {
sentinel = createSentinel();
entries = new HashMap();
}
/**
* Construct a new sequenced hash map with the specified initial size and
* default load factor.
*
* @param initialSize the initial size for the hash table
*
* @see HashMap#HashMap(int)
**/
public SequencedHashMap(int initialSize) {
sentinel = createSentinel();
entries = new HashMap(initialSize);
}
/**
* Construct a new sequenced hash map with the specified initial size and
* load factor.
*
* @param initialSize the initial size for the hash table
*
* @param loadFactor the load factor for the hash table.
*
* @see HashMap#HashMap(int,float)
**/
public SequencedHashMap(int initialSize, float loadFactor) {
sentinel = createSentinel();
entries = new HashMap(initialSize, loadFactor);
}
/**
* Construct a new sequenced hash map and add all the elements in the
* specified map. The order in which the mappings in the specified map are
* added is defined by {@link #putAll(Map)}.
**/
public SequencedHashMap(Map m) {
this();
putAll(m);
}
/**
* Removes an internal entry from the linked list. This does not remove
* it from the underlying map.
**/
private void removeEntry(Entry entry) {
entry.next.prev = entry.prev;
entry.prev.next = entry.next;
}
/**
* Inserts a new internal entry to the tail of the linked list. This does
* not add the entry to the underlying map.
**/
private void insertEntry(Entry entry) {
entry.next = sentinel;
entry.prev = sentinel.prev;
sentinel.prev.next = entry;
sentinel.prev = entry;
}
// per Map.size()
/**
* Implements {@link Map#size()}.
*/
public int size() {
// use the underlying Map's size since size is not maintained here.
return entries.size();
}
/**
* Implements {@link Map#isEmpty()}.
*/
public boolean isEmpty() {
// for quick check whether the map is entry, we can check the linked list
// and see if there's anything in it.
return sentinel.next == sentinel;
}
/**
* Implements {@link Map#containsKey(Object)}.
*/
public boolean containsKey(Object key) {
// pass on to underlying map implementation
return entries.containsKey(key);
}
/**
* Implements {@link Map#containsValue(Object)}.
*/
public boolean containsValue(Object value) {
// unfortunately, we cannot just pass this call to the underlying map
// because we are mapping keys to entries, not keys to values. The
// underlying map doesn't have an efficient implementation anyway, so this
// isn't a big deal.
// do null comparison outside loop so we only need to do it once. This
// provides a tighter, more efficient loop at the expense of slight
// code duplication.
if(value == null) {
for(Entry pos = sentinel.next; pos != sentinel; pos = pos.next) {
if(pos.getValue() == null) return true;
}
} else {
for(Entry pos = sentinel.next; pos != sentinel; pos = pos.next) {
if(value.equals(pos.getValue())) return true;
}
}
return false;
}
/**
* Implements {@link Map#get(Object)}.
*/
public Object get(Object o) {
// find entry for the specified key object
Entry entry = (Entry)entries.get(o);
if(entry == null) return null;
return entry.getValue();
}
/**
* Return the entry for the "oldest" mapping. That is, return the Map.Entry
* for the key-value pair that was first put into the map when compared to
* all the other pairings in the map. This behavior is equivalent to using
* entrySet().iterator().next(), but this method provides an
* optimized implementation.
*
* @return The first entry in the sequence, or null if the
* map is empty.
**/
public Map.Entry getFirst() {
// sentinel.next points to the "first" element of the sequence -- the head
// of the list, which is exactly the entry we need to return. We must test
// for an empty list though because we don't want to return the sentinel!
return (isEmpty()) ? null : sentinel.next;
}
/**
* Return the key for the "oldest" mapping. That is, return the key for the
* mapping that was first put into the map when compared to all the other
* objects in the map. This behavior is equivalent to using
* getFirst().getKey(), but this method provides a slightly
* optimized implementation.
*
* @return The first key in the sequence, or null if the
* map is empty.
**/
public Object getFirstKey() {
// sentinel.next points to the "first" element of the sequence -- the head
// of the list -- and the requisite key is returned from it. An empty list
// does not need to be tested. In cases where the list is empty,
// sentinel.next will point to the sentinel itself which has a null key,
// which is exactly what we would want to return if the list is empty (a
// nice convient way to avoid test for an empty list)
return sentinel.next.getKey();
}
/**
* Return the value for the "oldest" mapping. That is, return the value for
* the mapping that was first put into the map when compared to all the
* other objects in the map. This behavior is equivalent to using
* getFirst().getValue(), but this method provides a slightly
* optimized implementation.
*
* @return The first value in the sequence, or null if the
* map is empty.
**/
public Object getFirstValue() {
// sentinel.next points to the "first" element of the sequence -- the head
// of the list -- and the requisite value is returned from it. An empty
// list does not need to be tested. In cases where the list is empty,
// sentinel.next will point to the sentinel itself which has a null value,
// which is exactly what we would want to return if the list is empty (a
// nice convient way to avoid test for an empty list)
return sentinel.next.getValue();
}
/**
* Return the entry for the "newest" mapping. That is, return the Map.Entry
* for the key-value pair that was first put into the map when compared to
* all the other pairings in the map. The behavior is equivalent to:
*
*
* Object obj = null;
* Iterator iter = entrySet().iterator();
* while(iter.hasNext()) {
* obj = iter.next();
* }
* return (Map.Entry)obj;
*
*
* However, the implementation of this method ensures an O(1) lookup of the
* last key rather than O(n).
*
* @return The last entry in the sequence, or null if the map
* is empty.
**/
public Map.Entry getLast() {
// sentinel.prev points to the "last" element of the sequence -- the tail
// of the list, which is exactly the entry we need to return. We must test
// for an empty list though because we don't want to return the sentinel!
return (isEmpty()) ? null : sentinel.prev;
}
/**
* Return the key for the "newest" mapping. That is, return the key for the
* mapping that was last put into the map when compared to all the other
* objects in the map. This behavior is equivalent to using
* getLast().getKey(), but this method provides a slightly
* optimized implementation.
*
* @return The last key in the sequence, or null if the map is
* empty.
**/
public Object getLastKey() {
// sentinel.prev points to the "last" element of the sequence -- the tail
// of the list -- and the requisite key is returned from it. An empty list
// does not need to be tested. In cases where the list is empty,
// sentinel.prev will point to the sentinel itself which has a null key,
// which is exactly what we would want to return if the list is empty (a
// nice convient way to avoid test for an empty list)
return sentinel.prev.getKey();
}
/**
* Return the value for the "newest" mapping. That is, return the value for
* the mapping that was last put into the map when compared to all the other
* objects in the map. This behavior is equivalent to using
* getLast().getValue(), but this method provides a slightly
* optimized implementation.
*
* @return The last value in the sequence, or null if the map
* is empty.
**/
public Object getLastValue() {
// sentinel.prev points to the "last" element of the sequence -- the tail
// of the list -- and the requisite value is returned from it. An empty
// list does not need to be tested. In cases where the list is empty,
// sentinel.prev will point to the sentinel itself which has a null value,
// which is exactly what we would want to return if the list is empty (a
// nice convient way to avoid test for an empty list)
return sentinel.prev.getValue();
}
/**
* Implements {@link Map#put(Object, Object)}.
*/
public Object put(Object key, Object value) {
modCount++;
Object oldValue = null;
// lookup the entry for the specified key
Entry e = (Entry)entries.get(key);
// check to see if it already exists
if(e != null) {
// remove from list so the entry gets "moved" to the end of list
removeEntry(e);
// update value in map
oldValue = e.setValue(value);
// Note: We do not update the key here because its unnecessary. We only
// do comparisons using equals(Object) and we know the specified key and
// that in the map are equal in that sense. This may cause a problem if
// someone does not implement their hashCode() and/or equals(Object)
// method properly and then use it as a key in this map.
} else {
// add new entry
e = new Entry(key, value);
entries.put(key, e);
}
// assert(entry in map, but not list)
// add to list
insertEntry(e);
return oldValue;
}
/**
* Implements {@link Map#remove(Object)}.
*/
public Object remove(Object key) {
Entry e = removeImpl(key);
return (e == null) ? null : e.getValue();
}
/**
* Fully remove an entry from the map, returning the old entry or null if
* there was no such entry with the specified key.
**/
private Entry removeImpl(Object key) {
Entry e = (Entry)entries.remove(key);
if(e == null) return null;
modCount++;
removeEntry(e);
return e;
}
/**
* Adds all the mappings in the specified map to this map, replacing any
* mappings that already exist (as per {@link Map#putAll(Map)}). The order
* in which the entries are added is determined by the iterator returned
* from {@link Map#entrySet()} for the specified map.
*
* @param t the mappings that should be added to this map.
*
* @exception NullPointerException if t is null
**/
public void putAll(Map t) {
Iterator iter = t.entrySet().iterator();
while(iter.hasNext()) {
Map.Entry entry = (Map.Entry)iter.next();
put(entry.getKey(), entry.getValue());
}
}
/**
* Implements {@link Map#clear()}.
*/
public void clear() {
modCount++;
// remove all from the underlying map
entries.clear();
// and the list
sentinel.next = sentinel;
sentinel.prev = sentinel;
}
/**
* Implements {@link Map#equals(Object)}.
*/
public boolean equals(Object obj) {
if(obj == null) return false;
if(obj == this) return true;
if(!(obj instanceof Map)) return false;
return entrySet().equals(((Map)obj).entrySet());
}
/**
* Implements {@link Map#hashCode()}.
*/
public int hashCode() {
return entrySet().hashCode();
}
/**
* Provides a string representation of the entries within the map. The
* format of the returned string may change with different releases, so this
* method is suitable for debugging purposes only. If a specific format is
* required, use {@link #entrySet()}.{@link Set#iterator() iterator()} and
* iterate over the entries in the map formatting them as appropriate.
**/
public String toString() {
StringBuffer buf = new StringBuffer();
buf.append('[');
for(Entry pos = sentinel.next; pos != sentinel; pos = pos.next) {
buf.append(pos.getKey());
buf.append('=');
buf.append(pos.getValue());
if(pos.next != sentinel) {
buf.append(',');
}
}
buf.append(']');
return buf.toString();
}
/**
* Implements {@link Map#keySet()}.
*/
public Set keySet() {
return new AbstractSet() {
// required impls
public Iterator iterator() { return new OrderedIterator(KEY); }
public boolean remove(Object o) {
Entry e = SequencedHashMap.this.removeImpl(o);
return (e != null);
}
// more efficient impls than abstract set
public void clear() {
SequencedHashMap.this.clear();
}
public int size() {
return SequencedHashMap.this.size();
}
public boolean isEmpty() {
return SequencedHashMap.this.isEmpty();
}
public boolean contains(Object o) {
return SequencedHashMap.this.containsKey(o);
}
};
}
/**
* Implements {@link Map#values()}.
*/
public Collection values() {
return new AbstractCollection() {
// required impl
public Iterator iterator() { return new OrderedIterator(VALUE); }
public boolean remove(Object value) {
// do null comparison outside loop so we only need to do it once. This
// provides a tighter, more efficient loop at the expense of slight
// code duplication.
if(value == null) {
for(Entry pos = sentinel.next; pos != sentinel; pos = pos.next) {
if(pos.getValue() == null) {
SequencedHashMap.this.removeImpl(pos.getKey());
return true;
}
}
} else {
for(Entry pos = sentinel.next; pos != sentinel; pos = pos.next) {
if(value.equals(pos.getValue())) {
SequencedHashMap.this.removeImpl(pos.getKey());
return true;
}
}
}
return false;
}
// more efficient impls than abstract collection
public void clear() {
SequencedHashMap.this.clear();
}
public int size() {
return SequencedHashMap.this.size();
}
public boolean isEmpty() {
return SequencedHashMap.this.isEmpty();
}
public boolean contains(Object o) {
return SequencedHashMap.this.containsValue(o);
}
};
}
/**
* Implements {@link Map#entrySet()}.
*/
public Set entrySet() {
return new AbstractSet() {
// helper
private Entry findEntry(Object o) {
if(o == null) return null;
if(!(o instanceof Map.Entry)) return null;
Map.Entry e = (Map.Entry)o;
Entry entry = (Entry)entries.get(e.getKey());
if(entry != null && entry.equals(e)) return entry;
else return null;
}
// required impl
public Iterator iterator() {
return new OrderedIterator(ENTRY);
}
public boolean remove(Object o) {
Entry e = findEntry(o);
if(e == null) return false;
return SequencedHashMap.this.removeImpl(e.getKey()) != null;
}
// more efficient impls than abstract collection
public void clear() {
SequencedHashMap.this.clear();
}
public int size() {
return SequencedHashMap.this.size();
}
public boolean isEmpty() {
return SequencedHashMap.this.isEmpty();
}
public boolean contains(Object o) {
return findEntry(o) != null;
}
};
}
// constants to define what the iterator should return on "next"
private static final int KEY = 0;
private static final int VALUE = 1;
private static final int ENTRY = 2;
private static final int REMOVED_MASK = 0x80000000;
private class OrderedIterator implements Iterator {
/**
* Holds the type that should be returned from the iterator. The value
* should be either {@link #KEY}, {@link #VALUE}, or {@link #ENTRY}. To
* save a tiny bit of memory, this field is also used as a marker for when
* remove has been called on the current object to prevent a second remove
* on the same element. Essientially, if this value is negative (i.e. the
* bit specified by {@link #REMOVED_MASK} is set), the current position
* has been removed. If positive, remove can still be called.
**/
private int returnType;
/**
* Holds the "current" position in the iterator. When pos.next is the
* sentinel, we've reached the end of the list.
**/
private Entry pos = sentinel;
/**
* Holds the expected modification count. If the actual modification
* count of the map differs from this value, then a concurrent
* modification has occurred.
**/
private transient long expectedModCount = modCount;
/**
* Construct an iterator over the sequenced elements in the order in which
* they were added. The {@link #next()} method returns the type specified
* by returnType which must be either {@link #KEY}, {@link
* #VALUE}, or {@link #ENTRY}.
**/
public OrderedIterator(int returnType) {
//// Since this is a private inner class, nothing else should have
//// access to the constructor. Since we know the rest of the outer
//// class uses the iterator correctly, we can leave of the following
//// check:
//if(returnType >= 0 && returnType <= 2) {
// throw new IllegalArgumentException("Invalid iterator type");
//}
// Set the "removed" bit so that the iterator starts in a state where
// "next" must be called before "remove" will succeed.
this.returnType = returnType | REMOVED_MASK;
}
/**
* Returns whether there is any additional elements in the iterator to be
* returned.
*
* @return true if there are more elements left to be
* returned from the iterator; false otherwise.
**/
public boolean hasNext() {
return pos.next != sentinel;
}
/**
* Returns the next element from the iterator.
*
* @return the next element from the iterator.
*
* @exception NoSuchElementException if there are no more elements in the
* iterator.
*
* @exception ConcurrentModificationException if a modification occurs in
* the underlying map.
**/
public Object next() {
if(modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
if(pos.next == sentinel) {
throw new NoSuchElementException();
}
// clear the "removed" flag
returnType = returnType & ~REMOVED_MASK;
pos = pos.next;
switch(returnType) {
case KEY:
return pos.getKey();
case VALUE:
return pos.getValue();
case ENTRY:
return pos;
default:
// should never happen
throw new Error("bad iterator type: " + returnType);
}
}
/**
* Removes the last element returned from the {@link #next()} method from
* the sequenced map.
*
* @exception IllegalStateException if there isn't a "last element" to be
* removed. That is, if {@link #next()} has never been called, or if
* {@link #remove()} was already called on the element.
*
* @exception ConcurrentModificationException if a modification occurs in
* the underlying map.
**/
public void remove() {
if((returnType & REMOVED_MASK) != 0) {
throw new IllegalStateException("remove() must follow next()");
}
if(modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
SequencedHashMap.this.removeImpl(pos.getKey());
// update the expected mod count for the remove operation
expectedModCount++;
// set the removed flag
returnType = returnType | REMOVED_MASK;
}
}
// APIs maintained from previous version of SequencedHashMap for backwards
// compatibility
/**
* Creates a shallow copy of this object, preserving the internal structure
* by copying only references. The keys and values themselves are not
* clone()'d. The cloned object maintains the same sequence.
*
* @return A clone of this instance.
*
* @exception CloneNotSupportedException if clone is not supported by a
* subclass.
*/
public Object clone () throws CloneNotSupportedException {
// yes, calling super.clone() silly since we're just blowing away all
// the stuff that super might be doing anyway, but for motivations on
// this, see:
// http://www.javaworld.com/javaworld/jw-01-1999/jw-01-object.html
SequencedHashMap map = (SequencedHashMap)super.clone();
// create new, empty sentinel
map.sentinel = createSentinel();
// create a new, empty entry map
// note: this does not preserve the initial capacity and load factor.
map.entries = new HashMap();
// add all the mappings
map.putAll(this);
// Note: We cannot just clone the hashmap and sentinel because we must
// duplicate our internal structures. Cloning those two will not clone all
// the other entries they reference, and so the cloned hash map will not be
// able to maintain internal consistency because there are two objects with
// the same entries. See discussion in the Entry implementation on why we
// cannot implement a clone of the Entry (and thus why we need to recreate
// everything).
return map;
}
/**
* Returns the Map.Entry at the specified index
*
* @exception ArrayIndexOutOfBoundsException if the specified index is
* < 0 or > the size of the map.
**/
private Map.Entry getEntry(int index) {
Entry pos = sentinel;
if(index < 0) {
throw new ArrayIndexOutOfBoundsException(index + " < 0");
}
// loop to one before the position
int i = -1;
while(i < (index-1) && pos.next != sentinel) {
i++;
pos = pos.next;
}
// pos.next is the requested position
// if sentinel is next, past end of list
if(pos.next == sentinel) {
throw new ArrayIndexOutOfBoundsException(index + " >= " + (i + 1));
}
return pos.next;
}
/**
* Returns the key at the specified index.
*
* @exception ArrayIndexOutOfBoundsException if the index is
* < 0 or > the size of the map.
*/
public Object get (int index)
{
return getEntry(index).getKey();
}
/**
* Returns the value at the specified index.
*
* @exception ArrayIndexOutOfBoundsException if the index is
* < 0 or > the size of the map.
*/
public Object getValue (int index)
{
return getEntry(index).getValue();
}
/**
* Returns the index of the specified key.
*/
public int indexOf (Object key)
{
Entry e = (Entry)entries.get(key);
int pos = 0;
while(e.prev != sentinel) {
pos++;
e = e.prev;
}
return pos;
}
/**
* Returns a key iterator.
*/
public Iterator iterator ()
{
return keySet().iterator();
}
/**
* Returns the last index of the specified key.
*/
public int lastIndexOf (Object key)
{
// keys in a map are guarunteed to be unique
return indexOf(key);
}
/**
* Returns a List view of the keys rather than a set view. The returned
* list is unmodifiable. This is required because changes to the values of
* the list (using {@link java.util.ListIterator#set(Object)}) will
* effectively remove the value from the list and reinsert that value at
* the end of the list, which is an unexpected side effect of changing the
* value of a list. This occurs because changing the key, changes when the
* mapping is added to the map and thus where it appears in the list.
*
* key, or
* null if none existed.
*
* @exception ArrayIndexOutOfBoundsException if the index is
* < 0 or > the size of the map.
*/
public Object remove (int index)
{
return remove(get(index));
}
// per Externalizable.readExternal(ObjectInput)
/**
* Deserializes this map from the given stream.
*
* @param in the stream to deserialize from
* @throws IOException if the stream raises it
* @throws ClassNotFoundException if the stream raises it
*/
public void readExternal( ObjectInput in )
throws IOException, ClassNotFoundException
{
int size = in.readInt();
for(int i = 0; i < size; i++) {
Object key = in.readObject();
Object value = in.readObject();
put(key, value);
}
}
/**
* Serializes this map to the given stream.
*
* @param out the stream to serialize to
* @throws IOException if the stream raises it
*/
public void writeExternal( ObjectOutput out ) throws IOException {
out.writeInt(size());
for(Entry pos = sentinel.next; pos != sentinel; pos = pos.next) {
out.writeObject(pos.getKey());
out.writeObject(pos.getValue());
}
}
// add a serial version uid, so that if we change things in the future
// without changing the format, we can still deserialize properly.
private static final long serialVersionUID = 3380552487888102930L;
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/SortedBag.java 0100644 0001750 0001750 00000002326 10055172400 030767 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.Comparator;
/**
* A type of {@link Bag} that maintains order among its unique
* representative members.
*
* @since 2.0
* @author Chuck Burdick
**/
public interface SortedBag extends Bag {
/**
* Returns the comparator associated with this sorted set, or null
* if it uses its elements' natural ordering.
**/
public Comparator comparator();
/**
* Returns the first (lowest) member.
**/
public Object first();
/**
* Returns the last (highest) member.
**/
public Object last();
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/BagUtils.java 0100644 0001750 0001750 00000023173 10055172400 030632 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.Comparator;
import java.util.Set;
/**
* Provides utility methods and decorators for {@link Bag}
* and {@link SortedBag} instances.
* Bag bag = BagUtils.synchronizedBag(new HashBag());
* ...
* synchronized(bag) {
* Iterator i = bag.iterator(); // Must be in synchronized block
* while (i.hasNext())
* foo(i.next());
* }
* }
*
*
* Failure to follow this advice may result in non-deterministic
* behavior.
*
* @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 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.
*
* @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 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}.
*
* @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 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.
*
* SortedBag bag = BagUtils.synchronizedSortedBag(new TreeBag());
* ...
* synchronized(bag) {
* Iterator i = bag.iterator(); // Must be in synchronized block
* while (i.hasNext())
* foo(i.next());
* }
* }
*
*
* Failure to follow this advice may result in non-deterministic
* behavior.
*
* @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 bag) {
return new SynchronizedSortedBag(bag);
}
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/ComparatorUtils.java 0100644 0001750 0001750 00000020451 10055172376 032260 0 ustar tora tora /*
* Copyright 2001-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.Collection;
import java.util.Comparator;
import org.apache.commons.collections.comparators.ComparableComparator;
import org.apache.commons.collections.comparators.ComparatorChain;
import org.apache.commons.collections.comparators.NullComparator;
import org.apache.commons.collections.comparators.ReverseComparator;
import org.apache.commons.collections.comparators.TransformingComparator;
/**
* Provides convenient static utility methods for Comparator
* objects.
* comparators package. This class merely provides a
* convenient central place if you have use for more than one class
* in the comparators subpackage.
* null instead of a comparator, in which case
* {@link #NATURAL_COMPARATOR} will be used.
*
* @since 2.1
* @author Paul Jack
* @author Stephen Colebourne
* @version $Id: $
*/
public class ComparatorUtils {
/**
* Restrictive constructor
*/
private ComparatorUtils() {
}
/**
* Comparator for natural sort order.
*
* @see ComparableComparator#getInstance
*/
public static final Comparator NATURAL_COMPARATOR = ComparableComparator.getInstance();
/**
* Gets a comparator that uses the natural order of the objects.
*
* @return a comparator which uses natural order
*/
public static Comparator naturalComparator() {
return NATURAL_COMPARATOR;
}
/**
* Gets a comparator that compares using two {@link Comparator}s.
* null values.
* null values.
* ProxyListIterator that will not
* function until {@link #setListIterator(ListIterator) setListIterator}
* is invoked.
*/
public ProxyListIterator() {
super();
}
/**
* Constructs a new ProxyListIterator that will use the
* given list iterator.
*
* @param iterator the list iterator to use
*/
public ProxyListIterator(ListIterator iterator) {
super(iterator);
}
}
././@LongLink 0000000 0000000 0000000 00000000155 00000000000 011566 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/BufferUnderflowException.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/BufferUnderflowExcep 0100644 0001750 0001750 00000004151 10055172376 032273 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
/**
* The BufferUnderflowException is used when the buffer is already empty
*
* @author Avalon
* @author Berin Loritsch
* @author Jeff Turner
* @author Paul Jack
* @author Stephen Colebourne
* @since 2.1
* @version $Id: BufferUnderflowException.java,v 1.5.2.1 2004/05/22 12:14:02 scolebourne Exp $
*/
public class BufferUnderflowException extends RuntimeException {
private final Throwable m_throwable;
/**
* Constructs a new BufferUnderflowException.
*/
public BufferUnderflowException() {
super();
m_throwable = null;
}
/**
* Construct a new BufferUnderflowException.
*
* @param message the detail message for this exception
*/
public BufferUnderflowException(String message) {
this(message, null);
}
/**
* Construct a new BufferUnderflowException.
*
* @param message the detail message for this exception
* @param throwable the root cause of the exception
*/
public BufferUnderflowException(String message, Throwable exception) {
super(message);
m_throwable = exception;
}
/**
* Gets the root cause of the exception.
*
* @return the root cause
*/
public final Throwable getCause() {
return m_throwable;
}
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/BeanMap.java 0100644 0001750 0001750 00000065766 10055172400 030441 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.AbstractMap;
import java.util.AbstractSet;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
/** An implementation of Map for JavaBeans which uses introspection to
* get and put properties in the bean.
*
* If an exception occurs during attempts to get or set a property then the
* property is considered non existent in the Map
*
* @since 1.0
* @author James Strachan
*/
public class BeanMap extends AbstractMap implements Cloneable {
private transient Object bean;
private transient HashMap readMethods = new HashMap();
private transient HashMap writeMethods = new HashMap();
private transient HashMap types = new HashMap();
/**
* An empty array. Used to invoke accessors via reflection.
*/
public static final Object[] NULL_ARGUMENTS = {};
/**
* Maps primitive Class types to transformers. The transformer
* transform strings into the appropriate primitive wrapper.
*/
public static HashMap defaultTransformers = new HashMap();
static {
defaultTransformers.put(
Boolean.TYPE,
new Transformer() {
public Object transform( Object input ) {
return Boolean.valueOf( input.toString() );
}
}
);
defaultTransformers.put(
Character.TYPE,
new Transformer() {
public Object transform( Object input ) {
return new Character( input.toString().charAt( 0 ) );
}
}
);
defaultTransformers.put(
Byte.TYPE,
new Transformer() {
public Object transform( Object input ) {
return Byte.valueOf( input.toString() );
}
}
);
defaultTransformers.put(
Short.TYPE,
new Transformer() {
public Object transform( Object input ) {
return Short.valueOf( input.toString() );
}
}
);
defaultTransformers.put(
Integer.TYPE,
new Transformer() {
public Object transform( Object input ) {
return Integer.valueOf( input.toString() );
}
}
);
defaultTransformers.put(
Long.TYPE,
new Transformer() {
public Object transform( Object input ) {
return Long.valueOf( input.toString() );
}
}
);
defaultTransformers.put(
Float.TYPE,
new Transformer() {
public Object transform( Object input ) {
return Float.valueOf( input.toString() );
}
}
);
defaultTransformers.put(
Double.TYPE,
new Transformer() {
public Object transform( Object input ) {
return Double.valueOf( input.toString() );
}
}
);
}
// Constructors
//-------------------------------------------------------------------------
/**
* Constructs a new empty BeanMap.
*/
public BeanMap() {
}
/**
* Constructs a new BeanMap that operates on the
* specified bean. If the given bean is null, then
* this map will be empty.
*
* @param bean the bean for this map to operate on
*/
public BeanMap(Object bean) {
this.bean = bean;
initialise();
}
// Map interface
//-------------------------------------------------------------------------
/**
* Clone this bean map using the following process:
*
*
*
**/
public Object clone() throws CloneNotSupportedException {
BeanMap newMap = (BeanMap)super.clone();
if(bean == null) {
// no bean, just an empty bean map at the moment. return a newly
// cloned and empty bean map.
return newMap;
}
Object newBean = null;
Class beanClass = null;
try {
beanClass = bean.getClass();
newBean = beanClass.newInstance();
} catch (Exception e) {
// unable to instantiate
throw new CloneNotSupportedException
("Unable to instantiate the underlying bean \"" +
beanClass.getName() + "\": " + e);
}
try {
newMap.setBean(newBean);
} catch (Exception exception) {
throw new CloneNotSupportedException
("Unable to set bean in the cloned bean map: " +
exception);
}
try {
// copy only properties that are readable and writable. If its
// not readable, we can't get the value from the old map. If
// its not writable, we can't write a value into the new map.
Iterator readableKeys = readMethods.keySet().iterator();
while(readableKeys.hasNext()) {
Object key = readableKeys.next();
if(getWriteMethod(key) != null) {
newMap.put(key, get(key));
}
}
} catch (Exception exception) {
throw new CloneNotSupportedException
("Unable to copy bean values to cloned bean map: " +
exception);
}
return newMap;
}
/**
* Puts all of the writeable properties from the given BeanMap into this
* BeanMap. Read-only properties will be ignored.
*
* @param map the BeanMap whose properties to put
*/
public void putAllWriteable(BeanMap map) {
Iterator readableKeys = map.readMethods.keySet().iterator();
while(readableKeys.hasNext()) {
Object key = readableKeys.next();
if(getWriteMethod(key) != null) {
this.put(key, map.get(key));
}
}
}
/**
* This method reinitializes the bean map to have default values for the
* bean's properties. This is accomplished by constructing a new instance
* of the bean which the map uses as its underlying data source. This
* behavior for
clear() differs from the Map contract in that
* the mappings are not actually removed from the map (the mappings for a
* BeanMap are fixed).
**/
public void clear() {
if(bean == null) return;
Class beanClass = null;
try {
beanClass = bean.getClass();
bean = beanClass.newInstance();
}
catch (Exception e) {
throw new UnsupportedOperationException( "Could not create new instance of class: " + beanClass );
}
}
/**
* Returns true if the bean defines a property with the given name.
* The given name must be a String; if not, this method
* returns false. This method will also return false if the bean
* does not define a property with that name.
*
* @param name the name of the property to check
* @return false if the given name is null or is not a String;
* false if the bean does not define a property with that name; or
* true if the bean does define a property with that name
*/
public boolean containsKey(Object name) {
Method method = getReadMethod( name );
return method != null;
}
/**
* Returns true if the bean defines a property whose current value is
* the given object.
*
* @param value the value to check
* @return false true if the bean has at least one property whose
* current value is that object, false otherwise
*/
public boolean containsValue(Object value) {
// use default implementation
return super.containsValue( value );
}
/**
* Returns the value of the bean's property with the given name.
* The given name must be a {@link String} and must not be
* null; otherwise, this method returns null.
* If the bean defines a property with the given name, the value of
* that property is returned. Otherwise, null is
* returned.
*
* @param name the name of the property whose value to return
* @return the value of the property with that name
*/
public Object get(Object name) {
if ( bean != null ) {
Method method = getReadMethod( name );
if ( method != null ) {
try {
return method.invoke( bean, NULL_ARGUMENTS );
}
catch ( IllegalAccessException e ) {
logWarn( e );
}
catch ( IllegalArgumentException e ) {
logWarn( e );
}
catch ( InvocationTargetException e ) {
logWarn( e );
}
catch ( NullPointerException e ) {
logWarn( e );
}
}
}
return null;
}
/**
* Sets the bean property with the given name to the given value.
*
* @param name the name of the property to set
* @param value the value to set that property to
* @return the previous value of that property
* @throws IllegalArgumentException if the given name is null;
* if the given name is not a {@link String}; if the bean doesn't
* define a property with that name; or if the bean property with
* that name is read-only
*/
public Object put(Object name, Object value) throws IllegalArgumentException, ClassCastException {
if ( bean != null ) {
Object oldValue = get( name );
Method method = getWriteMethod( name );
if ( method == null ) {
throw new IllegalArgumentException( "The bean of type: "+ bean.getClass().getName() + " has no property called: " + name );
}
try {
Object[] arguments = createWriteMethodArguments( method, value );
method.invoke( bean, arguments );
Object newValue = get( name );
firePropertyChange( name, oldValue, newValue );
}
catch ( InvocationTargetException e ) {
logInfo( e );
throw new IllegalArgumentException( e.getMessage() );
}
catch ( IllegalAccessException e ) {
logInfo( e );
throw new IllegalArgumentException( e.getMessage() );
}
return oldValue;
}
return null;
}
/**
* Returns the number of properties defined by the bean.
*
* @return the number of properties defined by the bean
*/
public int size() {
return readMethods.size();
}
/**
* Get the keys for this BeanMap.
*
* @return BeanMap keys. The Set returned by this method is not
* modifiable.
*/
public Set keySet() {
return Collections.unmodifiableSet(readMethods.keySet());
}
/**
* Get the mappings for this BeanMap
*
* @return BeanMap mappings. The Set returned by this method
* is not modifiable.
*/
public Set entrySet() {
return Collections.unmodifiableSet(new AbstractSet() {
public Iterator iterator() {
return new Iterator() {
Iterator methodIter =
BeanMap.this.readMethods.keySet().iterator();
public boolean hasNext() {
return methodIter.hasNext();
}
public Object next() {
Object key = (Object)methodIter.next();
return new DefaultMapEntry(key, get(key));
}
public void remove() {
throw new UnsupportedOperationException
("remove() not supported from BeanMap.entrySet()");
}
};
}
public int size() {
return BeanMap.this.readMethods.size();
}
});
}
/**
* Returns the values for the BeanMap.
*
* @return values for the BeanMap. The returned collection is not
* modifiable.
*/
public Collection values() {
ArrayList answer = new ArrayList( readMethods.size() );
for ( Iterator iter = valueIterator(); iter.hasNext(); ) {
answer.add( iter.next() );
}
return Collections.unmodifiableList(answer);
}
// Helper methods
//-------------------------------------------------------------------------
/**
* Returns the type of the property with the given name.
*
* @param name the name of the property
* @return the type of the property, or null if no such
* property exists
*/
public Class getType(String name) {
return (Class) types.get( name );
}
/**
* Convenience method for getting an iterator over the keys.
*
* @return an iterator over the keys
*/
public Iterator keyIterator() {
return readMethods.keySet().iterator();
}
/**
* Convenience method for getting an iterator over the values.
*
* @return an iterator over the values
*/
public Iterator valueIterator() {
final Iterator iter = keyIterator();
return new Iterator() {
public boolean hasNext() {
return iter.hasNext();
}
public Object next() {
Object key = iter.next();
return get( (String) key );
}
public void remove() {
throw new UnsupportedOperationException( "remove() not supported for BeanMap" );
}
};
}
/**
* Convenience method for getting an iterator over the entries.
*
* @return an iterator over the entries
*/
public Iterator entryIterator() {
final Iterator iter = keyIterator();
return new Iterator() {
public boolean hasNext() {
return iter.hasNext();
}
public Object next() {
Object key = iter.next();
Object value = get( (String) key );
return new MyMapEntry( BeanMap.this, key, value );
}
public void remove() {
throw new UnsupportedOperationException( "remove() not supported for BeanMap" );
}
};
}
// Properties
//-------------------------------------------------------------------------
/**
* Returns the bean currently being operated on. The return value may
* be null if this map is empty.
*
* @return the bean being operated on by this map
*/
public Object getBean() {
return bean;
}
/**
* Sets the bean to be operated on by this map. The given value may
* be null, in which case this map will be empty.
*
* @param newBean the new bean to operate on
*/
public void setBean( Object newBean ) {
bean = newBean;
reinitialise();
}
// Implementation methods
//-------------------------------------------------------------------------
/**
* Returns the accessor for the property with the given name.
*
* @param name the name of the property
* @return null if the name is null; null if the name is not a
* {@link String}; null if no such property exists; or the accessor
* method for that property
*/
protected Method getReadMethod( Object name ) {
return (Method) readMethods.get( name );
}
/**
* Returns the mutator for the property with the given name.
*
* @param name the name of the
* @return null if the name is null; null if the name is not a
* {@link String}; null if no such property exists; null if the
* property is read-only; or the mutator method for that property
*/
protected Method getWriteMethod( Object name ) {
return (Method) writeMethods.get( name );
}
/**
* Reinitializes this bean. Called during {@link #setBean(Object)}.
* Does introspection to find properties.
*/
protected void reinitialise() {
readMethods.clear();
writeMethods.clear();
types.clear();
initialise();
}
private void initialise() {
if(getBean() == null) return;
Class beanClass = getBean().getClass();
try {
//BeanInfo beanInfo = Introspector.getBeanInfo( bean, null );
BeanInfo beanInfo = Introspector.getBeanInfo( beanClass );
PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
if ( propertyDescriptors != null ) {
for ( int i = 0; i < propertyDescriptors.length; i++ ) {
PropertyDescriptor propertyDescriptor = propertyDescriptors[i];
if ( propertyDescriptor != null ) {
String name = propertyDescriptor.getName();
Method readMethod = propertyDescriptor.getReadMethod();
Method writeMethod = propertyDescriptor.getWriteMethod();
Class aType = propertyDescriptor.getPropertyType();
if ( readMethod != null ) {
readMethods.put( name, readMethod );
}
if ( writeMethods != null ) {
writeMethods.put( name, writeMethod );
}
types.put( name, aType );
}
}
}
}
catch ( IntrospectionException e ) {
logWarn( e );
}
}
/**
* Called during a successful {@link #put(Object,Object)} operation.
* Default implementation does nothing. Override to be notified of
* property changes in the bean caused by this map.
*
* @param key the name of the property that changed
* @param oldValue the old value for that property
* @param newValue the new value for that property
*/
protected void firePropertyChange( Object key, Object oldValue, Object newValue ) {
}
// Implementation classes
//-------------------------------------------------------------------------
/**
* Map entry used by {@link BeanMap}.
*/
protected static class MyMapEntry extends DefaultMapEntry {
private BeanMap owner;
/**
* Constructs a new MyMapEntry.
*
* @param owner the BeanMap this entry belongs to
* @param key the key for this entry
* @param value the value for this entry
*/
protected MyMapEntry( BeanMap owner, Object key, Object value ) {
super( key, value );
this.owner = owner;
}
/**
* Sets the value.
*
* @param value the new value for the entry
* @return the old value for the entry
*/
public Object setValue(Object value) {
Object key = getKey();
Object oldValue = owner.get( key );
owner.put( key, value );
Object newValue = owner.get( key );
super.setValue( newValue );
return oldValue;
}
}
/**
* Creates an array of parameters to pass to the given mutator method.
* If the given object is not the right type to pass to the method
* directly, it will be converted using {@link #convertType(Class,Object)}.
*
* @param method the mutator method
* @param value the value to pass to the mutator method
* @return an array containing one object that is either the given value
* or a transformed value
* @throws IllegalAccessException if {@link #convertType(Class,Object)}
* raises it
* @throws IllegalArgumentException if any other exception is raised
* by {@link #convertType(Class,Object)}
*/
protected Object[] createWriteMethodArguments( Method method, Object value ) throws IllegalAccessException, ClassCastException {
try {
if ( value != null ) {
Class[] types = method.getParameterTypes();
if ( types != null && types.length > 0 ) {
Class paramType = types[0];
if ( ! paramType.isAssignableFrom( value.getClass() ) ) {
value = convertType( paramType, value );
}
}
}
Object[] answer = { value };
return answer;
}
catch ( InvocationTargetException e ) {
logInfo( e );
throw new IllegalArgumentException( e.getMessage() );
}
catch ( InstantiationException e ) {
logInfo( e );
throw new IllegalArgumentException( e.getMessage() );
}
}
/**
* Converts the given value to the given type. First, reflection is
* is used to find a public constructor declared by the given class
* that takes one argument, which must be the precise type of the
* given value. If such a constructor is found, a new object is
* created by passing the given value to that constructor, and the
* newly constructed object is returned.int.System.out. Used to display
* warnings while accessing/mutating the bean.
*
* @param e the exception to log
*/
protected void logInfo(Exception e) {
// XXXX: should probably use log4j here instead...
System.out.println( "INFO: Exception: " + e );
}
/**
* Logs the given exception to System.err. Used to display
* errors while accessing/mutating the bean.
*
* @param e the exception to log
*/
protected void logWarn(Exception e) {
// XXXX: should probably use log4j here instead...
System.out.println( "WARN: Exception: " + e );
e.printStackTrace();
}
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/MultiMap.java 0100644 0001750 0001750 00000002324 10055172402 030645 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.Map;
/**
* This is simply 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.
* Thus, this is simply a tag interface.
*
* @since 2.0
* @author Christopher Berry
* @author James Strachan
*/
public interface MultiMap extends Map {
public Object remove( Object key, Object item );
}
././@LongLink 0000000 0000000 0000000 00000000146 00000000000 011566 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/TransformIterator.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/TransformIterator.ja 0100644 0001750 0001750 00000004134 10055172376 032266 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.Iterator;
/** A Proxy {@link Iterator Iterator} which uses a {@link Transformer Transformer} instance to
* transform the contents of the {@link Iterator Iterator} into some other form
*
* @since 1.0
* @author James Strachan
* @deprecated this class has been moved to the iterators subpackage
*/
public class TransformIterator
extends org.apache.commons.collections.iterators.TransformIterator {
/**
* Constructs a new TransformIterator that will not function
* until the {@link #setIterator(Iterator) setIterator} method is
* invoked.
*/
public TransformIterator() {
super();
}
/**
* Constructs a new TransformIterator that won't transform
* elements from the given iterator.
*
* @param iterator the iterator to use
*/
public TransformIterator( Iterator iterator ) {
super( iterator );
}
/**
* Constructs a new TransformIterator that will use the
* given iterator and transformer. If the given transformer is null,
* then objects will not be transformed.
*
* @param iterator the iterator to use
* @param transformer the transformer to use
*/
public TransformIterator( Iterator iterator, Transformer transformer ) {
super( iterator, transformer );
}
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/FilterIterator.java 0100644 0001750 0001750 00000004170 10055172400 032053 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.Iterator;
/** A Proxy {@link Iterator Iterator} which takes a {@link Predicate Predicate} instance to filter
* out objects from an underlying {@link Iterator Iterator} instance.
* Only objects for which the
* specified Predicate evaluates to true are
* returned.
*
* @since 1.0
* @author James Strachan
* @author Jan Sorensen
* @deprecated this class has been moved to the iterators subpackage
*/
public class FilterIterator
extends org.apache.commons.collections.iterators.FilterIterator {
/**
* Constructs a new FilterIterator that will not function
* until {@link #setIterator(Iterator) setIterator} is invoked.
*/
public FilterIterator() {
super();
}
/**
* Constructs a new FilterIterator that will not function
* until {@link #setPredicate(Predicate) setPredicate} is invoked.
*
* @param iterator the iterator to use
*/
public FilterIterator( Iterator iterator ) {
super( iterator );
}
/**
* Constructs a new FilterIterator that will use the
* given iterator and predicate.
*
* @param iterator the iterator to use
* @param predicate the predicate to use
*/
public FilterIterator( Iterator iterator, Predicate predicate ) {
super( iterator, predicate );
}
}
././@LongLink 0000000 0000000 0000000 00000000145 00000000000 011565 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/DoubleOrderedMap.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/DoubleOrderedMap.jav 0100644 0001750 0001750 00000205255 10055172376 032153 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.AbstractCollection;
import java.util.AbstractMap;
import java.util.AbstractSet;
import java.util.Collection;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;
/**
* Red-Black tree-based implementation of Map. This class guarantees
* that the map will be in both ascending key order and ascending
* value order, sorted according to the natural order for the key's
* and value's classes.TreeBag.
*/
public TreeBag() {
setMap(new TreeMap());
}
/**
* New {@link Bag} that maintains order on its unique
* representative members according to the given {@link
* Comparator}.
**/
public TreeBag(Comparator c) {
setMap(new TreeMap(c));
}
/**
* New {@link Bag} containing all the members of the given
* collection.
* @see #addAll
**/
public TreeBag(Collection c) {
this();
addAll(c);
}
public Object first() {
return ((SortedMap)getMap()).firstKey();
}
public Object last() {
return ((SortedMap)getMap()).lastKey();
}
public Comparator comparator() {
return ((SortedMap)getMap()).comparator();
}
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/MapUtils.java 0100644 0001750 0001750 00000116311 10055172400 030653 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.io.*;
import java.text.*;
import java.text.NumberFormat;
import java.util.*;
/**
* A helper class for using {@link Map Map} instances.
*
*
* @since 1.0
* @author James Strachan
* @author Nissim Karpenstein
* @author Kasper Nielsen
* @author Paul Jack
* @author Stephen Colebourne
*/
public class MapUtils {
private static int debugIndent = 0;
/**
* Please don't instantiate a MapUtils.
*/
public MapUtils() {
}
// Type safe getters
//-------------------------------------------------------------------------
/**
* Synonym for {@link Map#get(Object)}.
*
* @param map the map whose value to look up
* @param key the key whose value to look up in that map
* @return null if the map is null; or the result of
* map.get(key)
*/
public static Object getObject( Map map, Object key ) {
if ( map != null ) {
return map.get( key );
}
return null;
}
/**
* Looks up the given key in the given map, converting the result into
* a string.
*
* @param map the map whose value to look up
* @param key the key whose value to look up in that map
* @return null if the map is null; null if the value mapped by that
* key is null; or the toString()
* result of the value for that key
*/
public static String getString( Map map, Object key ) {
if ( map != null ) {
Object answer = map.get( key );
if ( answer != null ) {
return answer.toString();
}
}
return null;
}
/**
* Looks up the given key in the given map, converting the result into
* a {@link Boolean}. If the map is null, this method returns null.
* If the value mapped by the given key is a
* {@link Boolean}, then it is returned as-is. Otherwise, if the value
* is a string, then if that string ignoring case equals "true", then
* a true {@link Boolean} is returned. Any other string value will
* result in a false {@link Boolean} being returned. OR, if the value
* is a {@link Number}, and that {@link Number} is 0, then a false
* {@link Boolean} is returned. Any other {@link Number} value results
* in a true {@link Boolean} being returned.System.out.
*
* @param e the exception to log
*/
protected static void logInfo(Exception e) {
// mapX: should probably use log4j here instead...
System.out.println( "INFO: Exception: " + e );
}
/**
* Nice method for adding data to a map in such a way
* as to not get NPE's. The point being that if the
* value is null, map.put() will throw an exception.
* That blows in the case of this class cause you may want to
* essentially treat put("Not Null", null ) == put("Not Null", "")
* We will still throw a NPE if the key is null cause that should
* never happen.
*/
public static final void safeAddToMap(Map map, Object key, Object value)
throws NullPointerException
{
if (value == null)
{
map.put ( key, "" );
}
else
{
map.put ( key, value );
}
}
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 must not be null");
}
if (keyPred == null) {
throw new IllegalArgumentException("Key Predicate must not be null");
}
if (valuePred == null) {
throw new IllegalArgumentException("Value Predicate must not be null");
}
this.keyPredicate = keyPred;
this.valuePredicate = valuePred;
Iterator iter = map.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry entry = (Map.Entry)iter.next();
Object key = entry.getKey();
Object value = entry.getValue();
validate(key, value);
}
}
public Object put(Object key, Object value) {
validate(key, value);
return map.put(key, value);
}
public void putAll(Map m) {
Iterator iter = m.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry entry = (Map.Entry)iter.next();
Object key = entry.getKey();
Object value = entry.getValue();
validate(key, value);
}
map.putAll(m);
}
public Set entrySet() {
return new PredicatedMapEntrySet(map.entrySet(), valuePredicate);
}
private void validate(Object key, Object value) {
if (!keyPredicate.evaluate(key)) {
throw new IllegalArgumentException("Cannot add key - Predicate rejected it");
}
if (!valuePredicate.evaluate(value)) {
throw new IllegalArgumentException("Cannot add value - Predicate rejected it");
}
}
}
static class PredicatedMapEntrySet
extends CollectionUtils.CollectionWrapper
implements Set {
private final Predicate predicate;
public PredicatedMapEntrySet(Set set, Predicate p) {
super(set);
this.predicate = p;
}
public Iterator iterator() {
final Iterator iterator = collection.iterator();
return new Iterator() {
public boolean hasNext() {
return iterator.hasNext();
}
public Object next() {
Map.Entry entry = (Map.Entry)iterator.next();
return new PredicatedMapEntry(entry, predicate);
}
public void remove() {
iterator.remove();
}
};
}
}
static class PredicatedMapEntry
implements Map.Entry {
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;
}
public boolean equals(Object o) {
return entry.equals(o);
}
public int hashCode() {
return entry.hashCode();
}
public String toString() {
return entry.toString();
}
public Object getKey() {
return entry.getKey();
}
public Object getValue() {
return entry.getValue();
}
public Object setValue(Object o) {
if (!predicate.evaluate(o)) {
throw new IllegalArgumentException("Cannot set value - Predicate rejected it");
}
return entry.setValue(o);
}
}
static class FixedSizeMap
extends ProxyMap {
public FixedSizeMap(Map map) {
super(map);
if (map == null) {
throw new IllegalArgumentException("Map must not be null");
}
}
public Object put(Object key, Object value) {
if (!map.containsKey(key)) {
throw new IllegalArgumentException("Cannot put new key/value pair - List is fixed size");
}
return map.put(key, value);
}
public void putAll(Map m) {
for (Iterator iter = m.keySet().iterator(); iter.hasNext(); ) {
if (!map.containsKey(iter.next())) {
throw new IllegalArgumentException("Cannot put new key/value pair - List is fixed size");
}
}
map.putAll(m);
}
}
static class LazyMap
extends ProxyMap {
protected final Factory factory;
public LazyMap(Map map, Factory factory) {
super(map);
if (map == null) {
throw new IllegalArgumentException("Map must not be null");
}
if (factory == null) {
throw new IllegalArgumentException("Factory must not be null");
}
this.factory = factory;
}
public Object get(Object key) {
if (!map.containsKey(key)) {
Object value = factory.create();
map.put(key, value);
return value;
}
return map.get(key);
}
}
static class PredicatedSortedMap
extends PredicatedMap
implements SortedMap {
public PredicatedSortedMap(SortedMap map, Predicate k, Predicate v) {
super(map, k, v);
}
public Object firstKey() {
return getSortedMap().firstKey();
}
public Object lastKey() {
return getSortedMap().lastKey();
}
public Comparator comparator() {
return getSortedMap().comparator();
}
public SortedMap subMap(Object o1, Object o2) {
SortedMap sub = getSortedMap().subMap(o1, o2);
return new PredicatedSortedMap(sub, keyPredicate, valuePredicate);
}
public SortedMap headMap(Object o1) {
SortedMap sub = getSortedMap().headMap(o1);
return new PredicatedSortedMap(sub, keyPredicate, valuePredicate);
}
public SortedMap tailMap(Object o1) {
SortedMap sub = getSortedMap().tailMap(o1);
return new PredicatedSortedMap(sub, keyPredicate, valuePredicate);
}
private SortedMap getSortedMap() {
return (SortedMap)map;
}
}
static class FixedSizeSortedMap
extends FixedSizeMap
implements SortedMap {
public FixedSizeSortedMap(SortedMap m) {
super(m);
}
public Object firstKey() {
return getSortedMap().firstKey();
}
public Object lastKey() {
return getSortedMap().lastKey();
}
public Comparator comparator() {
return getSortedMap().comparator();
}
public SortedMap subMap(Object o1, Object o2) {
return new FixedSizeSortedMap(getSortedMap().subMap(o1, o2));
}
public SortedMap headMap(Object o1) {
return new FixedSizeSortedMap(getSortedMap().headMap(o1));
}
public SortedMap tailMap(Object o1) {
return new FixedSizeSortedMap(getSortedMap().tailMap(o1));
}
private SortedMap getSortedMap() {
return (SortedMap)map;
}
}
static class LazySortedMap
extends LazyMap
implements SortedMap {
public LazySortedMap(SortedMap m, Factory factory) {
super(m, factory);
}
public Object firstKey() {
return getSortedMap().firstKey();
}
public Object lastKey() {
return getSortedMap().lastKey();
}
public Comparator comparator() {
return getSortedMap().comparator();
}
public SortedMap subMap(Object o1, Object o2) {
return new LazySortedMap(getSortedMap().subMap(o1, o2), factory);
}
public SortedMap headMap(Object o1) {
return new LazySortedMap(getSortedMap().headMap(o1), factory);
}
public SortedMap tailMap(Object o1) {
return new LazySortedMap(getSortedMap().tailMap(o1), factory);
}
private SortedMap getSortedMap() {
return (SortedMap)map;
}
}
/**
* 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, 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).
*
* @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.
* Factory factory = new Factory() {
* public Object create() {
* return new Date();
* }
* }
* Map lazy = MapUtils.lazyMap(new HashMap(), factory);
* Object obj = lazy.get("test");
*
*
* After the above code is executed, obj will contain
* a new Date instance. Furthermore, that Date
* instance is the value for the test key.
*
* @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.
*
* @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).
*
* @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.
*
* Factory factory = new Factory() {
* public Object create() {
* return new Date();
* }
* }
* SortedMap lazy = MapUtils.lazySortedMap(new TreeMap(), factory);
* Object obj = lazy.get("test");
*
*
* After the above code is executed, obj will contain
* a new Date instance. Furthermore, that Date
* instance is the value for the test key.
*
* @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);
}
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/DefaultMapEntry.java 0100644 0001750 0001750 00000006703 10055172400 032164 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.Map;
/** A default implementation of {@link java.util.Map.Entry}
*
* @since 1.0
* @author James Strachan
* @author Michael A. Smith
*/
public class DefaultMapEntry implements Map.Entry {
private Object key;
private Object value;
/**
* Constructs a new DefaultMapEntry with a null key
* and null value.
*/
public DefaultMapEntry() {
}
/**
* Constructs a new DefaultMapEntry with the given
* key and given value.
*
* @param key the key for the entry, may be null
* @param value the value for the entyr, may be null
*/
public DefaultMapEntry(Object key, Object value) {
this.key = key;
this.value = value;
}
/**
* Implemented per API documentation of
* {@link java.util.Map.Entry#equals(Object)}
**/
public boolean equals(Object o) {
if( o == null ) return false;
if( o == this ) return true;
if ( ! (o instanceof Map.Entry ) )
return false;
Map.Entry e2 = (Map.Entry)o;
return ((getKey() == null ?
e2.getKey() == null : getKey().equals(e2.getKey())) &&
(getValue() == null ?
e2.getValue() == null : getValue().equals(e2.getValue())));
}
/**
* Implemented per API documentation of
* {@link java.util.Map.Entry#hashCode()}
**/
public int hashCode() {
return ( ( getKey() == null ? 0 : getKey().hashCode() ) ^
( getValue() == null ? 0 : getValue().hashCode() ) );
}
// Map.Entry interface
//-------------------------------------------------------------------------
/**
* Returns the key.
*
* @return the key
*/
public Object getKey() {
return key;
}
/**
* Returns the value.
*
* @return the value
*/
public Object getValue() {
return value;
}
// Properties
//-------------------------------------------------------------------------
/**
* Sets the key. This method does not modify any map.
*
* @param key the new key
*/
public void setKey(Object key) {
this.key = key;
}
/** Note that this method only sets the local reference inside this object and
* does not modify the original Map.
*
* @return the old value of the value
* @param value the new value
*/
public Object setValue(Object value) {
Object answer = this.value;
this.value = value;
return answer;
}
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/HashBag.java 0100644 0001750 0001750 00000002340 10055172376 030422 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.Collection;
import java.util.HashMap;
/**
* An implementation of {@link Bag} that is backed by a {@link
* HashMap}.
*
* @since 2.0
* @author Chuck Burdick
**/
public class HashBag extends DefaultMapBag implements Bag {
/**
* Constructs a new empty HashBag.
*/
public HashBag() {
setMap(new HashMap());
}
/**
* New {@link Bag} containing all the members of the given
* collection.
* @see #addAll
**/
public HashBag(Collection c) {
this();
addAll(c);
}
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/FastTreeMap.java 0100644 0001750 0001750 00000054317 10055172376 031313 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.Collection;
import java.util.Comparator;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;
/**
* java.util.TreeMap designed
* to operate in a multithreaded environment where the large majority of
* method calls are read-only, instead of structural changes. When operating
* in "fast" mode, read calls are non-synchronized and write calls perform the
* following steps:
*
* setFast(true)) after initialization
* is complete.TreeMap only within a single thread, you should use
* java.util.TreeMap directly (with no synchronization), for
* maximum performance.FastTreeMap instance.
* The keys and values themselves are not copied.
*/
public Object clone() {
FastTreeMap results = null;
if (fast) {
results = new FastTreeMap(map);
} else {
synchronized (map) {
results = new FastTreeMap(map);
}
}
results.setFast(getFast());
return (results);
}
/**
* Return the comparator used to order this map, or null
* if this map uses its keys' natural order.
*/
public Comparator comparator() {
if (fast) {
return (map.comparator());
} else {
synchronized (map) {
return (map.comparator());
}
}
}
/**
* Return true if this map contains a mapping for the
* specified key.
*
* @param key Key to be searched for
*/
public boolean containsKey(Object key) {
if (fast) {
return (map.containsKey(key));
} else {
synchronized (map) {
return (map.containsKey(key));
}
}
}
/**
* Return true if this map contains one or more keys mapping
* to the specified value.
*
* @param value Value to be searched for
*/
public boolean containsValue(Object value) {
if (fast) {
return (map.containsValue(value));
} else {
synchronized (map) {
return (map.containsValue(value));
}
}
}
/**
* Return a collection view of the mappings contained in this map. Each
* element in the returned collection is a Map.Entry.
*/
public Set entrySet() {
return new EntrySet();
}
/**
* Compare the specified object with this list for equality. This
* implementation uses exactly the code that is used to define the
* list equals function in the documentation for the
* Map.equals method.
*
* @param o Object to be compared to this list
*/
public boolean equals(Object o) {
// Simple tests that require no synchronization
if (o == this)
return (true);
else if (!(o instanceof Map))
return (false);
Map mo = (Map) o;
// Compare the two maps for equality
if (fast) {
if (mo.size() != map.size())
return (false);
java.util.Iterator i = map.entrySet().iterator();
while (i.hasNext()) {
Map.Entry e = (Map.Entry) i.next();
Object key = e.getKey();
Object value = e.getValue();
if (value == null) {
if (!(mo.get(key) == null && mo.containsKey(key)))
return (false);
} else {
if (!value.equals(mo.get(key)))
return (false);
}
}
return (true);
} else {
synchronized (map) {
if (mo.size() != map.size())
return (false);
java.util.Iterator i = map.entrySet().iterator();
while (i.hasNext()) {
Map.Entry e = (Map.Entry) i.next();
Object key = e.getKey();
Object value = e.getValue();
if (value == null) {
if (!(mo.get(key) == null && mo.containsKey(key)))
return (false);
} else {
if (!value.equals(mo.get(key)))
return (false);
}
}
return (true);
}
}
}
/**
* Return the first (lowest) key currently in this sorted map.
*/
public Object firstKey() {
if (fast) {
return (map.firstKey());
} else {
synchronized (map) {
return (map.firstKey());
}
}
}
/**
* Return the value to which this map maps the specified key. Returns
* null if the map contains no mapping for this key, or if
* there is a mapping with a value of null. Use the
* containsKey() method to disambiguate these cases.
*
* @param key Key whose value is to be returned
*/
public Object get(Object key) {
if (fast) {
return (map.get(key));
} else {
synchronized (map) {
return (map.get(key));
}
}
}
/**
* Return the hash code value for this map. This implementation uses
* exactly the code that is used to define the list hash function in the
* documentation for the Map.hashCode method.
*/
public int hashCode() {
if (fast) {
int h = 0;
java.util.Iterator i = map.entrySet().iterator();
while (i.hasNext())
h += i.next().hashCode();
return (h);
} else {
synchronized (map) {
int h = 0;
java.util.Iterator i = map.entrySet().iterator();
while (i.hasNext())
h += i.next().hashCode();
return (h);
}
}
}
/**
* Return a view of the portion of this map whose keys are strictly
* less than the specified key.
*
* @param key Key higher than any in the returned map
*/
public SortedMap headMap(Object key) {
if (fast) {
return (map.headMap(key));
} else {
synchronized (map) {
return (map.headMap(key));
}
}
}
/**
* Test if this list has no elements.
*/
public boolean isEmpty() {
if (fast) {
return (map.isEmpty());
} else {
synchronized (map) {
return (map.isEmpty());
}
}
}
/**
* Return a set view of the keys contained in this map.
*/
public Set keySet() {
return new KeySet();
}
/**
* Return the last (highest) key currently in this sorted map.
*/
public Object lastKey() {
if (fast) {
return (map.lastKey());
} else {
synchronized (map) {
return (map.lastKey());
}
}
}
/**
* Associate the specified value with the specified key in this map.
* If the map previously contained a mapping for this key, the old
* value is replaced and returned.
*
* @param key The key with which the value is to be associated
* @param value The value to be associated with this key
*/
public Object put(Object key, Object value) {
if (fast) {
synchronized (this) {
TreeMap temp = (TreeMap) map.clone();
Object result = temp.put(key, value);
map = temp;
return (result);
}
} else {
synchronized (map) {
return (map.put(key, value));
}
}
}
/**
* Copy all of the mappings from the specified map to this one, replacing
* any mappings with the same keys.
*
* @param in Map whose mappings are to be copied
*/
public void putAll(Map in) {
if (fast) {
synchronized (this) {
TreeMap temp = (TreeMap) map.clone();
temp.putAll(in);
map = temp;
}
} else {
synchronized (map) {
map.putAll(in);
}
}
}
/**
* Remove any mapping for this key, and return any previously
* mapped value.
*
* @param key Key whose mapping is to be removed
*/
public Object remove(Object key) {
if (fast) {
synchronized (this) {
TreeMap temp = (TreeMap) map.clone();
Object result = temp.remove(key);
map = temp;
return (result);
}
} else {
synchronized (map) {
return (map.remove(key));
}
}
}
/**
* Return the number of key-value mappings in this map.
*/
public int size() {
if (fast) {
return (map.size());
} else {
synchronized (map) {
return (map.size());
}
}
}
/**
* Return a view of the portion of this map whose keys are in the
* range fromKey (inclusive) to toKey (exclusive).
*
* @param fromKey Lower limit of keys for the returned map
* @param toKey Upper limit of keys for the returned map
*/
public SortedMap subMap(Object fromKey, Object toKey) {
if (fast) {
return (map.subMap(fromKey, toKey));
} else {
synchronized (map) {
return (map.subMap(fromKey, toKey));
}
}
}
/**
* Return a view of the portion of this map whose keys are greater than
* or equal to the specified key.
*
* @param key Key less than or equal to any in the returned map
*/
public SortedMap tailMap(Object key) {
if (fast) {
return (map.tailMap(key));
} else {
synchronized (map) {
return (map.tailMap(key));
}
}
}
/**
* Return a collection view of the values contained in this map.
*/
public Collection values() {
return new Values();
}
private abstract class CollectionView implements Collection {
public CollectionView() {
}
protected abstract Collection get(Map map);
protected abstract Object iteratorNext(Map.Entry entry);
public void clear() {
if (fast) {
synchronized (FastTreeMap.this) {
TreeMap temp = (TreeMap) map.clone();
get(temp).clear();
map = temp;
}
} else {
synchronized (map) {
get(map).clear();
}
}
}
public boolean remove(Object o) {
if (fast) {
synchronized (FastTreeMap.this) {
TreeMap temp = (TreeMap) map.clone();
boolean r = get(temp).remove(o);
map = temp;
return r;
}
} else {
synchronized (map) {
return get(map).remove(o);
}
}
}
public boolean removeAll(Collection o) {
if (fast) {
synchronized (FastTreeMap.this) {
TreeMap temp = (TreeMap) map.clone();
boolean r = get(temp).removeAll(o);
map = temp;
return r;
}
} else {
synchronized (map) {
return get(map).removeAll(o);
}
}
}
public boolean retainAll(Collection o) {
if (fast) {
synchronized (FastTreeMap.this) {
TreeMap temp = (TreeMap) map.clone();
boolean r = get(temp).retainAll(o);
map = temp;
return r;
}
} else {
synchronized (map) {
return get(map).retainAll(o);
}
}
}
public int size() {
if (fast) {
return get(map).size();
} else {
synchronized (map) {
return get(map).size();
}
}
}
public boolean isEmpty() {
if (fast) {
return get(map).isEmpty();
} else {
synchronized (map) {
return get(map).isEmpty();
}
}
}
public boolean contains(Object o) {
if (fast) {
return get(map).contains(o);
} else {
synchronized (map) {
return get(map).contains(o);
}
}
}
public boolean containsAll(Collection o) {
if (fast) {
return get(map).containsAll(o);
} else {
synchronized (map) {
return get(map).containsAll(o);
}
}
}
public Object[] toArray(Object[] o) {
if (fast) {
return get(map).toArray(o);
} else {
synchronized (map) {
return get(map).toArray(o);
}
}
}
public Object[] toArray() {
if (fast) {
return get(map).toArray();
} else {
synchronized (map) {
return get(map).toArray();
}
}
}
public boolean equals(Object o) {
if (o == this) return true;
if (fast) {
return get(map).equals(o);
} else {
synchronized (map) {
return get(map).equals(o);
}
}
}
public int hashCode() {
if (fast) {
return get(map).hashCode();
} else {
synchronized (map) {
return get(map).hashCode();
}
}
}
public boolean add(Object o) {
throw new UnsupportedOperationException();
}
public boolean addAll(Collection c) {
throw new UnsupportedOperationException();
}
public Iterator iterator() {
return new CollectionViewIterator();
}
private class CollectionViewIterator implements Iterator {
private Map expected;
private Map.Entry lastReturned = null;
private Iterator iterator;
public CollectionViewIterator() {
this.expected = map;
this.iterator = expected.entrySet().iterator();
}
public boolean hasNext() {
if (expected != map) {
throw new ConcurrentModificationException();
}
return iterator.hasNext();
}
public Object next() {
if (expected != map) {
throw new ConcurrentModificationException();
}
lastReturned = (Map.Entry)iterator.next();
return iteratorNext(lastReturned);
}
public void remove() {
if (lastReturned == null) {
throw new IllegalStateException();
}
if (fast) {
synchronized (FastTreeMap.this) {
if (expected != map) {
throw new ConcurrentModificationException();
}
FastTreeMap.this.remove(lastReturned.getKey());
lastReturned = null;
expected = map;
}
} else {
iterator.remove();
lastReturned = null;
}
}
}
}
private class KeySet extends CollectionView implements Set {
protected Collection get(Map map) {
return map.keySet();
}
protected Object iteratorNext(Map.Entry entry) {
return entry.getKey();
}
}
private class Values extends CollectionView {
protected Collection get(Map map) {
return map.values();
}
protected Object iteratorNext(Map.Entry entry) {
return entry.getValue();
}
}
private class EntrySet extends CollectionView implements Set {
protected Collection get(Map map) {
return map.entrySet();
}
protected Object iteratorNext(Map.Entry entry) {
return entry;
}
}
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/Closure.java 0100644 0001750 0001750 00000002053 10055172400 030526 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
/** An interface to represent some Closure, a block of code which is executed
* from inside some block, function or iteration which operates on an input
* object.
*
* @since 1.0
* @author James Strachan
*/
public interface Closure {
/** Performs some operation on the input object
*/
public void execute(Object input);
}
././@LongLink 0000000 0000000 0000000 00000000154 00000000000 011565 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/BufferOverflowException.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/BufferOverflowExcept 0100644 0001750 0001750 00000004161 10055172376 032316 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
/**
* The BufferOverflowException is used when the buffer's capacity has been
* exceeded.
*
* @author Avalon
* @author Berin Loritsch
* @author Jeff Turner
* @author Paul Jack
* @author Stephen Colebourne
* @since 2.1
* @version $Id: BufferOverflowException.java,v 1.4.2.1 2004/05/22 12:14:02 scolebourne Exp $
*/
public class BufferOverflowException extends RuntimeException {
private final Throwable m_throwable;
/**
* Constructs a new BufferOverflowException.
*/
public BufferOverflowException() {
super();
m_throwable = null;
}
/**
* Construct a new BufferOverflowException.
*
* @param message the detail message for this exception
*/
public BufferOverflowException(String message) {
this(message, null);
}
/**
* Construct a new BufferOverflowException.
*
* @param message the detail message for this exception
* @param throwable the root cause of the exception
*/
public BufferOverflowException(String message, Throwable exception) {
super(message);
m_throwable = exception;
}
/**
* Gets the root cause of the exception.
*
* @return the root cause
*/
public final Throwable getCause() {
return m_throwable;
}
}
././@LongLink 0000000 0000000 0000000 00000000150 00000000000 011561 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/EnumerationIterator.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/EnumerationIterator. 0100644 0001750 0001750 00000004131 10055172402 032251 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.Collection;
import java.util.Enumeration;
/** Adapter to make {@link Enumeration Enumeration} instances appear
* to be {@link java.util.Iterator Iterator} instances.
*
* @since 1.0
* @author James Strachan
* @author Daniel Rall
* @deprecated this class has been moved to the iterators subpackage
*/
public class EnumerationIterator
extends org.apache.commons.collections.iterators.EnumerationIterator {
/**
* Constructs a new EnumerationIterator that will not
* function until {@link #setEnumeration(Enumeration)} is called.
*/
public EnumerationIterator() {
super();
}
/**
* Constructs a new EnumerationIterator that provides
* an iterator view of the given enumeration.
*
* @param enumeration the enumeration to use
*/
public EnumerationIterator( Enumeration enumeration ) {
super(enumeration);
}
/**
* Constructs a new EnumerationIterator that will remove
* elements from the specified collection.
*
* @param enumeration the enumeration to use
* @param collection the collection to remove elements from
*/
public EnumerationIterator( Enumeration enumeration, Collection collection ) {
super(enumeration, collection);
}
}
././@LongLink 0000000 0000000 0000000 00000000156 00000000000 011567 L ustar root root libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/SynchronizedPriorityQueue.java libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/SynchronizedPriority 0100644 0001750 0001750 00000005547 10055172376 032442 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.NoSuchElementException;
/**
* A thread safe version of the PriorityQueue.
* Provides synchronized wrapper methods for all the methods
* defined in the PriorityQueue interface.
*
* @since 1.0
* @author Ram Chidambaram
*/
public final class SynchronizedPriorityQueue
implements PriorityQueue
{
/**
* The underlying priority queue.
*/
protected final PriorityQueue m_priorityQueue;
/**
* Constructs a new synchronized priority queue.
*
* @param priorityQueue the priority queue to synchronize
*/
public SynchronizedPriorityQueue( final PriorityQueue priorityQueue )
{
m_priorityQueue = priorityQueue;
}
/**
* Clear all elements from queue.
*/
public synchronized void clear()
{
m_priorityQueue.clear();
}
/**
* Test if queue is empty.
*
* @return true if queue is empty else false.
*/
public synchronized boolean isEmpty()
{
return m_priorityQueue.isEmpty();
}
/**
* Insert an element into queue.
*
* @param element the element to be inserted
*/
public synchronized void insert( final Object element )
{
m_priorityQueue.insert( element );
}
/**
* Return element on top of heap but don't remove it.
*
* @return the element at top of heap
* @exception NoSuchElementException if isEmpty() == true
*/
public synchronized Object peek() throws NoSuchElementException
{
return m_priorityQueue.peek();
}
/**
* Return element on top of heap and remove it.
*
* @return the element at top of heap
* @exception NoSuchElementException if isEmpty() == true
*/
public synchronized Object pop() throws NoSuchElementException
{
return m_priorityQueue.pop();
}
/**
* Returns a string representation of the underlying queue.
*
* @return a string representation of the underlying queue
*/
public synchronized String toString()
{
return m_priorityQueue.toString();
}
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/ProxyIterator.java 0100644 0001750 0001750 00000003141 10055172400 031744 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.Iterator;
/** A Proxy {@link Iterator Iterator} which delegates its methods to a proxy instance.
*
* @since 1.0
* @see ProxyListIterator
* @version $Revision: 1.6.2.1 $ $Date: 2004/05/22 12:14:02 $
*
* @author James Strachan
* @deprecated this class has been moved to the iterators subpackage
*/
public class ProxyIterator
extends org.apache.commons.collections.iterators.ProxyIterator {
/**
* Constructs a new ProxyIterator that will not function
* until {@link #setIterator(Iterator)} is called.
*/
public ProxyIterator() {
super();
}
/**
* Constructs a new ProxyIterator that will use the
* given iterator.
*
* @param iterator the underyling iterator
*/
public ProxyIterator( Iterator iterator ) {
super(iterator);
}
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/FastHashMap.java 0100644 0001750 0001750 00000047356 10055172400 031270 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.Collection;
import java.util.ConcurrentModificationException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/**
* java.util.HashMap designed
* to operate in a multithreaded environment where the large majority of
* method calls are read-only, instead of structural changes. When operating
* in "fast" mode, read calls are non-synchronized and write calls perform the
* following steps:
*
* setFast(true)) after initialization
* is complete.HashMap only within a single thread, you should use
* java.util.HashMap directly (with no synchronization), for
* maximum performance.FastHashMap instance.
* The keys and values themselves are not copied.
*/
public Object clone() {
FastHashMap results = null;
if (fast) {
results = new FastHashMap(map);
} else {
synchronized (map) {
results = new FastHashMap(map);
}
}
results.setFast(getFast());
return (results);
}
/**
* Return true if this map contains a mapping for the
* specified key.
*
* @param key Key to be searched for
*/
public boolean containsKey(Object key) {
if (fast) {
return (map.containsKey(key));
} else {
synchronized (map) {
return (map.containsKey(key));
}
}
}
/**
* Return true if this map contains one or more keys mapping
* to the specified value.
*
* @param value Value to be searched for
*/
public boolean containsValue(Object value) {
if (fast) {
return (map.containsValue(value));
} else {
synchronized (map) {
return (map.containsValue(value));
}
}
}
/**
* Return a collection view of the mappings contained in this map. Each
* element in the returned collection is a Map.Entry.
*/
public Set entrySet() {
return new EntrySet();
}
/**
* Compare the specified object with this list for equality. This
* implementation uses exactly the code that is used to define the
* list equals function in the documentation for the
* Map.equals method.
*
* @param o Object to be compared to this list
*/
public boolean equals(Object o) {
// Simple tests that require no synchronization
if (o == this)
return (true);
else if (!(o instanceof Map))
return (false);
Map mo = (Map) o;
// Compare the two maps for equality
if (fast) {
if (mo.size() != map.size())
return (false);
java.util.Iterator i = map.entrySet().iterator();
while (i.hasNext()) {
Map.Entry e = (Map.Entry) i.next();
Object key = e.getKey();
Object value = e.getValue();
if (value == null) {
if (!(mo.get(key) == null && mo.containsKey(key)))
return (false);
} else {
if (!value.equals(mo.get(key)))
return (false);
}
}
return (true);
} else {
synchronized (map) {
if (mo.size() != map.size())
return (false);
java.util.Iterator i = map.entrySet().iterator();
while (i.hasNext()) {
Map.Entry e = (Map.Entry) i.next();
Object key = e.getKey();
Object value = e.getValue();
if (value == null) {
if (!(mo.get(key) == null && mo.containsKey(key)))
return (false);
} else {
if (!value.equals(mo.get(key)))
return (false);
}
}
return (true);
}
}
}
/**
* Return the value to which this map maps the specified key. Returns
* null if the map contains no mapping for this key, or if
* there is a mapping with a value of null. Use the
* containsKey() method to disambiguate these cases.
*
* @param key Key whose value is to be returned
*/
public Object get(Object key) {
if (fast) {
return (map.get(key));
} else {
synchronized (map) {
return (map.get(key));
}
}
}
/**
* Return the hash code value for this map. This implementation uses
* exactly the code that is used to define the list hash function in the
* documentation for the Map.hashCode method.
*/
public int hashCode() {
if (fast) {
int h = 0;
java.util.Iterator i = map.entrySet().iterator();
while (i.hasNext())
h += i.next().hashCode();
return (h);
} else {
synchronized (map) {
int h = 0;
java.util.Iterator i = map.entrySet().iterator();
while (i.hasNext())
h += i.next().hashCode();
return (h);
}
}
}
/**
* Return true if this map contains no mappings.
*/
public boolean isEmpty() {
if (fast) {
return (map.isEmpty());
} else {
synchronized (map) {
return (map.isEmpty());
}
}
}
/**
* Return a set view of the keys contained in this map.
*/
public Set keySet() {
return new KeySet();
}
/**
* Associate the specified value with the specified key in this map.
* If the map previously contained a mapping for this key, the old
* value is replaced and returned.
*
* @param key The key with which the value is to be associated
* @param value The value to be associated with this key
*/
public Object put(Object key, Object value) {
if (fast) {
synchronized (this) {
HashMap temp = (HashMap) map.clone();
Object result = temp.put(key, value);
map = temp;
return (result);
}
} else {
synchronized (map) {
return (map.put(key, value));
}
}
}
/**
* Copy all of the mappings from the specified map to this one, replacing
* any mappings with the same keys.
*
* @param in Map whose mappings are to be copied
*/
public void putAll(Map in) {
if (fast) {
synchronized (this) {
HashMap temp = (HashMap) map.clone();
temp.putAll(in);
map = temp;
}
} else {
synchronized (map) {
map.putAll(in);
}
}
}
/**
* Remove any mapping for this key, and return any previously
* mapped value.
*
* @param key Key whose mapping is to be removed
*/
public Object remove(Object key) {
if (fast) {
synchronized (this) {
HashMap temp = (HashMap) map.clone();
Object result = temp.remove(key);
map = temp;
return (result);
}
} else {
synchronized (map) {
return (map.remove(key));
}
}
}
/**
* Return the number of key-value mappings in this map.
*/
public int size() {
if (fast) {
return (map.size());
} else {
synchronized (map) {
return (map.size());
}
}
}
/**
* Return a collection view of the values contained in this map.
*/
public Collection values() {
return new Values();
}
private abstract class CollectionView implements Collection {
public CollectionView() {
}
protected abstract Collection get(Map map);
protected abstract Object iteratorNext(Map.Entry entry);
public void clear() {
if (fast) {
synchronized (FastHashMap.this) {
HashMap temp = (HashMap) map.clone();
get(temp).clear();
map = temp;
}
} else {
synchronized (map) {
get(map).clear();
}
}
}
public boolean remove(Object o) {
if (fast) {
synchronized (FastHashMap.this) {
HashMap temp = (HashMap) map.clone();
boolean r = get(temp).remove(o);
map = temp;
return r;
}
} else {
synchronized (map) {
return get(map).remove(o);
}
}
}
public boolean removeAll(Collection o) {
if (fast) {
synchronized (FastHashMap.this) {
HashMap temp = (HashMap) map.clone();
boolean r = get(temp).removeAll(o);
map = temp;
return r;
}
} else {
synchronized (map) {
return get(map).removeAll(o);
}
}
}
public boolean retainAll(Collection o) {
if (fast) {
synchronized (FastHashMap.this) {
HashMap temp = (HashMap) map.clone();
boolean r = get(temp).retainAll(o);
map = temp;
return r;
}
} else {
synchronized (map) {
return get(map).retainAll(o);
}
}
}
public int size() {
if (fast) {
return get(map).size();
} else {
synchronized (map) {
return get(map).size();
}
}
}
public boolean isEmpty() {
if (fast) {
return get(map).isEmpty();
} else {
synchronized (map) {
return get(map).isEmpty();
}
}
}
public boolean contains(Object o) {
if (fast) {
return get(map).contains(o);
} else {
synchronized (map) {
return get(map).contains(o);
}
}
}
public boolean containsAll(Collection o) {
if (fast) {
return get(map).containsAll(o);
} else {
synchronized (map) {
return get(map).containsAll(o);
}
}
}
public Object[] toArray(Object[] o) {
if (fast) {
return get(map).toArray(o);
} else {
synchronized (map) {
return get(map).toArray(o);
}
}
}
public Object[] toArray() {
if (fast) {
return get(map).toArray();
} else {
synchronized (map) {
return get(map).toArray();
}
}
}
public boolean equals(Object o) {
if (o == this) return true;
if (fast) {
return get(map).equals(o);
} else {
synchronized (map) {
return get(map).equals(o);
}
}
}
public int hashCode() {
if (fast) {
return get(map).hashCode();
} else {
synchronized (map) {
return get(map).hashCode();
}
}
}
public boolean add(Object o) {
throw new UnsupportedOperationException();
}
public boolean addAll(Collection c) {
throw new UnsupportedOperationException();
}
public Iterator iterator() {
return new CollectionViewIterator();
}
private class CollectionViewIterator implements Iterator {
private Map expected;
private Map.Entry lastReturned = null;
private Iterator iterator;
public CollectionViewIterator() {
this.expected = map;
this.iterator = expected.entrySet().iterator();
}
public boolean hasNext() {
if (expected != map) {
throw new ConcurrentModificationException();
}
return iterator.hasNext();
}
public Object next() {
if (expected != map) {
throw new ConcurrentModificationException();
}
lastReturned = (Map.Entry)iterator.next();
return iteratorNext(lastReturned);
}
public void remove() {
if (lastReturned == null) {
throw new IllegalStateException();
}
if (fast) {
synchronized (FastHashMap.this) {
if (expected != map) {
throw new ConcurrentModificationException();
}
FastHashMap.this.remove(lastReturned.getKey());
lastReturned = null;
expected = map;
}
} else {
iterator.remove();
lastReturned = null;
}
}
}
}
private class KeySet extends CollectionView implements Set {
protected Collection get(Map map) {
return map.keySet();
}
protected Object iteratorNext(Map.Entry entry) {
return entry.getKey();
}
}
private class Values extends CollectionView {
protected Collection get(Map map) {
return map.values();
}
protected Object iteratorNext(Map.Entry entry) {
return entry.getValue();
}
}
private class EntrySet extends CollectionView implements Set {
protected Collection get(Map map) {
return map.entrySet();
}
protected Object iteratorNext(Map.Entry entry) {
return entry;
}
}
}
libcommons-collections-java-2.1.1.orig/src/java/org/apache/commons/collections/package.html 0100644 0001750 0001750 00000011663 10055172400 030537 0 ustar tora tora
libcommons-collections-java-2.1.1.orig/src/test/ 0040755 0001750 0001750 00000000000 10055172376 020323 5 ustar tora tora libcommons-collections-java-2.1.1.orig/src/test/org/ 0040755 0001750 0001750 00000000000 10055172376 021112 5 ustar tora tora libcommons-collections-java-2.1.1.orig/src/test/org/apache/ 0040755 0001750 0001750 00000000000 10055172376 022333 5 ustar tora tora libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/ 0040755 0001750 0001750 00000000000 10055172376 024006 5 ustar tora tora libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/ 0040755 0001750 0001750 00000000000 10072637470 026324 5 ustar tora tora libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestList.java 0100644 0001750 0001750 00000103434 10055172400 030730 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.io.IOException;
import java.io.Serializable;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.AbstractCollection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.NoSuchElementException;
/**
* Tests base {@link java.util.List} methods and contracts.
*
Category Classes Comments
List Implementations
{@link org.apache.commons.collections.CursorableLinkedList}
{@link org.apache.commons.collections.FastArrayList}
Special-purpose implementations of the {@link
java.util.List} interface.
Map Implementations
{@link org.apache.commons.collections.BeanMap}
{@link org.apache.commons.collections.DoubleOrderedMap}
{@link org.apache.commons.collections.ExtendedProperties}
{@link org.apache.commons.collections.FastHashMap}
{@link org.apache.commons.collections.FastTreeMap}
{@link org.apache.commons.collections.LRUMap}
{@link org.apache.commons.collections.MultiHashMap}
{@link org.apache.commons.collections.ProxyMap}
{@link org.apache.commons.collections.ReferenceMap}
{@link org.apache.commons.collections.SequencedHashMap}
{@link org.apache.commons.collections.SoftRefHashMap}
{@link org.apache.commons.collections.StaticBucketMap}
Special-purpose implementations of the {@link
java.util.Map} interface and associated classes.
Buffer Interface and Implementations
{@link org.apache.commons.collections.ArrayStack}
{@link org.apache.commons.collections.BinaryHeap}
{@link org.apache.commons.collections.BoundedFifoBuffer}
{@link org.apache.commons.collections.Buffer}
{@link org.apache.commons.collections.PriorityQueue}
{@link org.apache.commons.collections.SynchronizedPriorityQueue}
{@link org.apache.commons.collections.UnboundedFifoBuffer}
New collection interface that specifies a removal order for
the collection, used to implement queues and queue-like things.
Bag Interface and Implementations
{@link org.apache.commons.collections.Bag}
{@link org.apache.commons.collections.DefaultMapBag}
{@link org.apache.commons.collections.HashBag}
{@link org.apache.commons.collections.SortedBag}
{@link org.apache.commons.collections.TreeBag}
New collections interface that keeps a count of its members.
Utilities
{@link org.apache.commons.collections.BagUtils}
{@link org.apache.commons.collections.BufferUtils}
{@link org.apache.commons.collections.CollectionUtils}
{@link org.apache.commons.collections.ComparatorUtils}
{@link org.apache.commons.collections.ListUtils}
{@link org.apache.commons.collections.MapUtils}
{@link org.apache.commons.collections.SetUtils}
Manipulate collection objects, determine set theoretic
properties, ensure type-safety, provide decorators, etc.
Functor Interfaces
{@link org.apache.commons.collections.Factory}
{@link org.apache.commons.collections.Predicate}
{@link org.apache.commons.collections.Closure}
{@link org.apache.commons.collections.Transformer}
Create views or functors on a collection. If your collection
represents X, these allow you to define and look at
f(X).
Miscellaneous
{@link org.apache.commons.collections.StringStack}
{@link org.apache.commons.collections.DefaultMapEntry}
A stack of strings; and the trivial implementation of
{@link java.util.Map.Entry}.
TestList
* method, including another bulkTestSubList.
* Sublists are tested until the size of the sublist is less than 10.
* Each sublist is 6 elements smaller than its parent list.
* (By default this means that two rounds of sublists will be tested).
* The verify() method is overloaded to test that the original list is
* modified when the sublist is.
*/
public BulkTest bulkTestSubList() {
if (getFullElements().length - 6 < 10) return null;
return new BulkTestSubList(this);
}
static class BulkTestSubList extends TestList {
private TestList outer;
BulkTestSubList(TestList outer) {
super("");
this.outer = outer;
}
protected Object[] getFullElements() {
List l = Arrays.asList(outer.getFullElements());
return l.subList(3, l.size() - 3).toArray();
}
protected Object[] getOtherElements() {
return outer.getOtherElements();
}
protected boolean isAddSupported() {
return outer.isAddSupported();
}
protected boolean isRemoveSupported() {
return outer.isRemoveSupported();
}
protected List makeEmptyList() {
return outer.makeFullList().subList(4, 4);
}
protected List makeFullList() {
int size = getFullElements().length;
return outer.makeFullList().subList(3, size - 3);
}
protected void resetEmpty() {
outer.resetFull();
this.collection = outer.getList().subList(4, 4);
this.confirmed = outer.getConfirmedList().subList(4, 4);
}
protected void resetFull() {
outer.resetFull();
int size = outer.confirmed.size();
this.collection = outer.getList().subList(3, size - 3);
this.confirmed = outer.getConfirmedList().subList(3, size - 3);
}
protected void verify() {
super.verify();
outer.verify();
}
}
/**
* Tests that a sublist raises a {@link java.util.ConcurrentModificationException ConcurrentModificationException}
* if elements are added to the original list.
*/
public void testListSubListFailFastOnAdd() {
if (!isAddSupported()) return;
resetFull();
int size = collection.size();
List sub = getList().subList(1, size);
getList().add(getOtherElements()[0]);
failFastAll(sub);
resetFull();
sub = getList().subList(1, size);
getList().add(0, getOtherElements()[0]);
failFastAll(sub);
resetFull();
sub = getList().subList(1, size);
getList().addAll(Arrays.asList(getOtherElements()));
failFastAll(sub);
resetFull();
sub = getList().subList(1, size);
getList().addAll(0, Arrays.asList(getOtherElements()));
failFastAll(sub);
}
/**
* Tests that a sublist raises a {@link java.util.ConcurrentModificationException ConcurrentModificationException}
* if elements are removed from the original list.
*/
public void testListSubListFailFastOnRemove() {
if (!isRemoveSupported()) return;
resetFull();
int size = collection.size();
List sub = getList().subList(1, size);
getList().remove(0);
failFastAll(sub);
resetFull();
sub = getList().subList(1, size);
getList().remove(getFullElements()[2]);
failFastAll(sub);
resetFull();
sub = getList().subList(1, size);
getList().removeAll(Arrays.asList(getFullElements()));
failFastAll(sub);
resetFull();
sub = getList().subList(1, size);
getList().retainAll(Arrays.asList(getOtherElements()));
failFastAll(sub);
resetFull();
sub = getList().subList(1, size);
getList().clear();
failFastAll(sub);
}
/**
* Invokes all the methods on the given sublist to make sure they raise
* a {@link java.util.ConcurrentModificationException ConcurrentModificationException}.
*/
protected void failFastAll(List list) {
Method[] methods = List.class.getMethods();
for (int i = 0; i < methods.length; i++) {
failFastMethod(list, methods[i]);
}
}
/**
* Invokes the given method on the given sublist to make sure it raises
* a {@link java.util.ConcurrentModificationException ConcurrentModificationException}.
*
* Unless the method happens to be the equals() method, in which case
* the test is skipped. There seems to be a bug in
* java.util.AbstractList.subList(int,int).equals(Object) -- it never
* raises a ConcurrentModificationException.
*
* @param list the sublist to test
* @param m the method to invoke
*/
protected void failFastMethod(List list, Method m) {
if (m.getName().equals("equals")) return;
Object element = getOtherElements()[0];
Collection c = Collections.singleton(element);
Class[] types = m.getParameterTypes();
Object[] params = new Object[types.length];
for (int i = 0; i < params.length; i++) {
if (types[i] == Integer.TYPE) params[i] = new Integer(0);
else if (types[i] == Collection.class) params[i] = c;
else if (types[i] == Object.class) params[i] = element;
else if (types[i] == Object[].class) params[i] = new Object[0];
}
try {
m.invoke(list, params);
fail(m.getName() + " should raise ConcurrentModification");
} catch (IllegalAccessException e) {
// impossible
} catch (InvocationTargetException e) {
Throwable t = e.getTargetException();
if (t instanceof ConcurrentModificationException) {
// expected
return;
} else {
fail(m.getName() + " raised unexpected " + e);
}
}
}
}
libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestBinaryHeap.java 0100644 0001750 0001750 00000016552 10055172376 032057 0 ustar tora tora /*
* Copyright 2002-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.NoSuchElementException;
import junit.framework.Test;
import junit.framework.TestSuite;
import org.apache.commons.collections.comparators.ComparableComparator;
import org.apache.commons.collections.comparators.ReverseComparator;
/**
* Tests the BinaryHeap.
*
* @author Michael A. Smith
* @version $Id: TestBinaryHeap.java,v 1.7.2.1 2004/05/22 12:14:05 scolebourne Exp $
*/
public class TestBinaryHeap extends TestCollection {
public static Test suite() {
return new TestSuite(TestBinaryHeap.class);
}
public TestBinaryHeap(String testName) {
super(testName);
}
/**
* Return a new, empty {@link Object} to used for testing.
*/
public Collection makeCollection() {
return new BinaryHeap();
}
public Collection makeConfirmedCollection() {
return new ArrayList();
}
public Collection makeConfirmedFullCollection() {
ArrayList list = new ArrayList();
list.addAll(Arrays.asList(getFullElements()));
return list;
}
public Object[] getFullElements() {
return getFullNonNullStringElements();
}
public Object[] getOtherElements() {
return getOtherNonNullStringElements();
}
public void testCollectionIteratorFailFast() {
}
public void testBasicOps() {
BinaryHeap heap = new BinaryHeap();
assertTrue("heap should be empty after create", heap.isEmpty());
try {
heap.peek();
fail("NoSuchElementException should be thrown if peek is called " +
"before any elements are inserted");
} catch (NoSuchElementException e) {
// expected
}
try {
heap.pop();
fail("NoSuchElementException should be thrown if pop is called " +
"before any elements are inserted");
} catch (NoSuchElementException e) {
// expected
}
heap.insert("a");
heap.insert("c");
heap.insert("e");
heap.insert("b");
heap.insert("d");
heap.insert("n");
heap.insert("m");
heap.insert("l");
heap.insert("k");
heap.insert("j");
heap.insert("i");
heap.insert("h");
heap.insert("g");
heap.insert("f");
assertTrue("heap should not be empty after inserts", !heap.isEmpty());
for(int i = 0; i < 14; i++) {
assertEquals("peek using default constructor should return " +
"minimum value in the binary heap",
String.valueOf((char)('a' + i)), heap.peek());
assertEquals("pop using default constructor should return minimum " +
"value in the binary heap",
String.valueOf((char)('a' + i)), heap.pop());
if(i + 1 < 14) {
assertTrue("heap should not be empty before all elements are popped",
!heap.isEmpty());
} else {
assertTrue("heap should be empty after all elements are popped",
heap.isEmpty());
}
}
try {
heap.peek();
fail("NoSuchElementException should be thrown if peek is called " +
"after all elements are popped");
} catch (NoSuchElementException e) {
// expected
}
try {
heap.pop();
fail("NoSuchElementException should be thrown if pop is called " +
"after all elements are popped");
} catch (NoSuchElementException e) {
// expected
}
}
public void testBasicComparatorOps() {
BinaryHeap heap =
new BinaryHeap(new ReverseComparator(new ComparableComparator()));
assertTrue("heap should be empty after create", heap.isEmpty());
try {
heap.peek();
fail("NoSuchElementException should be thrown if peek is called " +
"before any elements are inserted");
} catch (NoSuchElementException e) {
// expected
}
try {
heap.pop();
fail("NoSuchElementException should be thrown if pop is called " +
"before any elements are inserted");
} catch (NoSuchElementException e) {
// expected
}
heap.insert("a");
heap.insert("c");
heap.insert("e");
heap.insert("b");
heap.insert("d");
heap.insert("n");
heap.insert("m");
heap.insert("l");
heap.insert("k");
heap.insert("j");
heap.insert("i");
heap.insert("h");
heap.insert("g");
heap.insert("f");
assertTrue("heap should not be empty after inserts", !heap.isEmpty());
for(int i = 0; i < 14; i++) {
// note: since we're using a comparator that reverses items, the
// "minimum" item is "n", and the "maximum" item is "a".
assertEquals("peek using default constructor should return " +
"minimum value in the binary heap",
String.valueOf((char)('n' - i)), heap.peek());
assertEquals("pop using default constructor should return minimum " +
"value in the binary heap",
String.valueOf((char)('n' - i)), heap.pop());
if(i + 1 < 14) {
assertTrue("heap should not be empty before all elements are popped",
!heap.isEmpty());
} else {
assertTrue("heap should be empty after all elements are popped",
heap.isEmpty());
}
}
try {
heap.peek();
fail("NoSuchElementException should be thrown if peek is called " +
"after all elements are popped");
} catch (NoSuchElementException e) {
// expected
}
try {
heap.pop();
fail("NoSuchElementException should be thrown if pop is called " +
"after all elements are popped");
} catch (NoSuchElementException e) {
// expected
}
}
public void verify() {
super.verify();
BinaryHeap heap = (BinaryHeap)collection;
Comparator c = heap.m_comparator;
if (c == null) c = ComparatorUtils.naturalComparator();
if (!heap.m_isMinHeap) c = ComparatorUtils.reversedComparator(c);
Object[] tree = heap.m_elements;
for (int i = 1; i <= heap.m_size; i++) {
Object parent = tree[i];
if (i * 2 <= heap.m_size) {
assertTrue("Parent is less than or equal to its left child",
c.compare(parent, tree[i * 2]) <= 0);
}
if (i * 2 + 1 < heap.m_size) {
assertTrue("Parent is less than or equal to its right child",
c.compare(parent, tree[i * 2 + 1]) <= 0);
}
}
}
}
././@LongLink 0000000 0000000 0000000 00000000145 00000000000 011565 L ustar root root libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestFastTreeMap1.java libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestFastTreeMap1.jav 0100644 0001750 0001750 00000003153 10055172376 032121 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.Map;
import java.util.TreeMap;
import junit.framework.Test;
/**
* Test FastTreeMap in fast mode.
*
* @author Jason van Zyl
* @version $Id: TestFastTreeMap1.java,v 1.5.2.1 2004/05/22 12:14:05 scolebourne Exp $
*/
public class TestFastTreeMap1 extends TestFastTreeMap
{
public TestFastTreeMap1(String testName)
{
super(testName);
}
public static Test suite()
{
return BulkTest.makeSuite(TestFastTreeMap1.class);
}
public static void main(String args[])
{
String[] testCaseName = { TestFastTreeMap1.class.getName() };
junit.textui.TestRunner.main(testCaseName);
}
public Map makeEmptyMap() {
FastTreeMap ftm = new FastTreeMap();
ftm.setFast(true);
return (ftm);
}
public void setUp()
{
map = (TreeMap) makeEmptyMap();
}
}
././@LongLink 0000000 0000000 0000000 00000000151 00000000000 011562 L ustar root root libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestSequencedHashMap.java libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestSequencedHashMap 0100644 0001750 0001750 00000015107 10055172400 032252 0 ustar tora tora /*
* Copyright 2001-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.io.IOException;
import java.io.Serializable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import junit.framework.Test;
/**
* Unit tests
* {@link org.apache.commons.collections.SequencedHashMap}.
* Be sure to use the "labRat" instance whenever possible,
* so that subclasses will be tested correctly.
*
* @author Morgan Delagrange
* @author Daniel Rall
* @author Henning P. Schmiedehausen
* @author James Strachan
*/
public class TestSequencedHashMap extends TestMap {
/**
* The instance to experiment on.
*/
protected SequencedHashMap labRat;
public TestSequencedHashMap(String name) {
super(name);
}
public static Test suite() {
return BulkTest.makeSuite(TestSequencedHashMap.class);
}
// current versions of SequencedHashMap and subclasses are not
// compatible with Collections 1.x
public int getCompatibilityVersion() {
return 2;
}
public static void main(String[] args[]) {
String[] testCaseName = { TestSequencedHashMap.class.getName() };
junit.textui.TestRunner.main(testCaseName);
}
public void setUp() throws Exception {
super.setUp();
// use makeMap and cast the result to a SeqHashMap
// so that subclasses of SeqHashMap can share these tests
labRat = (SequencedHashMap) makeEmptyMap();
}
public Map makeEmptyMap() {
return new SequencedHashMap();
}
protected Object[] getKeys() {
return new Object[] { "foo", "baz", "eek" };
}
protected Object[] getValues() {
return new Object[] { "bar", "frob", new Object() };
}
public void testSequenceMap() throws Throwable {
Object[] keys = getKeys();
int expectedSize = keys.length;
Object[] values = getValues();
for (int i = 0; i < expectedSize; i++) {
labRat.put(keys[i], values[i]);
}
// Test size().
assertEquals("size() does not match expected size",
expectedSize, labRat.size());
// Test clone(), iterator(), and get(Object).
SequencedHashMap clone = (SequencedHashMap) labRat.clone();
assertEquals("Size of clone does not match original",
labRat.size(), clone.size());
Iterator origEntries = labRat.entrySet().iterator();
Iterator copiedEntries = clone.entrySet().iterator();
while (origEntries.hasNext()) {
Map.Entry origEntry = (Map.Entry)origEntries.next();
Map.Entry copiedEntry = (Map.Entry)copiedEntries.next();
assertEquals("Cloned key does not match original",
origEntry.getKey(), copiedEntry.getKey());
assertEquals("Cloned value does not match original",
origEntry.getValue(), copiedEntry.getValue());
assertEquals("Cloned entry does not match orginal",
origEntry, copiedEntry);
}
assertTrue("iterator() returned different number of elements than keys()",
!copiedEntries.hasNext());
// Test sequence()
List seq = labRat.sequence();
assertEquals("sequence() returns more keys than in the Map",
expectedSize, seq.size());
for (int i = 0; i < seq.size(); i++) {
assertEquals("Key " + i + " is not the same as the key in the Map",
keys[i], seq.get(i));
}
}
public void testYoungest() {
labRat.put(new Integer(1),"foo");
labRat.put(new Integer(2),"bar");
assertTrue("first key is correct",labRat.get(0).equals(new Integer(1)));
labRat.put(new Integer(1),"boo");
assertTrue("second key is reassigned to first",labRat.get(0).equals(new Integer(2)));
}
public void testYoungestReplaceNullWithValue() {
labRat.put(new Integer(1),null);
labRat.put(new Integer(2),"foo");
assertTrue("first key is correct",labRat.get(0).equals(new Integer(1)));
labRat.put(new Integer(1),"bar");
assertTrue("second key is reassigned to first",labRat.get(0).equals(new Integer(2)));
}
public void testYoungestReplaceValueWithNull() {
labRat.put(new Integer(1),"bar");
labRat.put(new Integer(2),"foo");
assertTrue("first key is correct",labRat.get(0).equals(new Integer(1)));
labRat.put(new Integer(1),null);
assertTrue("second key is reassigned to first",labRat.get(0).equals(new Integer(2)));
}
// override TestMap method with more specific tests
public void testFullMapSerialization()
throws IOException, ClassNotFoundException {
SequencedHashMap map = (SequencedHashMap) makeFullMap();
if (!(map instanceof Serializable)) return;
byte[] objekt = writeExternalFormToBytes((Serializable) map);
SequencedHashMap map2 = (SequencedHashMap) readExternalFormFromBytes(objekt);
assertEquals("Both maps are same size",map.size(), getSampleKeys().length);
assertEquals("Both maps are same size",map2.size(),getSampleKeys().length);
assertEquals("Both maps have the same first key",
map.getFirstKey(),getSampleKeys()[0]);
assertEquals("Both maps have the same first key",
map2.getFirstKey(),getSampleKeys()[0]);
assertEquals("Both maps have the same last key",
map.getLastKey(),getSampleKeys()[getSampleKeys().length - 1]);
assertEquals("Both maps have the same last key",
map2.getLastKey(),getSampleKeys()[getSampleKeys().length - 1]);
}
protected void tearDown() {
labRat = null;
}
}
libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestCollection.java 0100644 0001750 0001750 00000130752 10055172400 032113 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.ConcurrentModificationException;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
/**
* Tests base {@link java.util.Collection} methods and contracts.
* null is not permitted):
*
*
*
* Supported Operation Methods
*
*
* Fixture Methodsjava.util.ArrayList, which is
* known to conform exactly to its collection interface's contract. After the
* operation takes place on both your collection implementation and the
* confirmed collection implementation, the two collections are compared to see
* if their state is identical. The comparison is usually much more involved
* than a simple equals test. This verification is used to ensure
* proper modifications are made along with ensuring that the collection does
* not change when read-only modifications are made.
*
*
* Those methods should provide a confirmed collection implementation
* that's compatible with your collection implementation.add and addAll
* operations.remove, removeAll,
* retainAll, clear and
* iterator().remove() methods.
* Default implementation returns true. Override if your collection
* class does not support removal operations.
*/
protected boolean isRemoveSupported() {
return true;
}
/**
* Returns an array of objects that are contained in a collection
* produced by {@link #makeFullCollection()}. Every element in the
* returned array must be an element in a full collection.addAll on an empty collection with
* the results of {@link #getFullElements()}. Override this default
* if your collection doesn't support addAll.
*/
protected Collection makeFullCollection() {
Collection c = makeCollection();
c.addAll(Arrays.asList(getFullElements()));
return c;
}
/**
* Returns an empty collection for Object tests.
*/
public Object makeObject() {
return makeCollection();
}
/**
* Tests {@link Collection#add(Object)}.
*/
public void testCollectionAdd() {
if (!isAddSupported()) return;
Object[] elements = getFullElements();
for (int i = 0; i < elements.length; i++) {
resetEmpty();
boolean r = collection.add(elements[i]);
confirmed.add(elements[i]);
verify();
assertTrue("Empty collection changed after add", r);
assertTrue("Collection size is 1 after first add",
collection.size() == 1);
}
resetEmpty();
int size = 0;
for (int i = 0; i < elements.length; i++) {
boolean r = collection.add(elements[i]);
confirmed.add(elements[i]);
verify();
if (r) size++;
assertEquals("Collection size should grow after add",
size, collection.size());
assertTrue("Collection should contain added element",
collection.contains(elements[i]));
}
}
/**
* Tests {@link Collection#addAll(Collection)}.
*/
public void testCollectionAddAll() {
if (!isAddSupported()) return;
resetEmpty();
Object[] elements = getFullElements();
boolean r = collection.addAll(Arrays.asList(elements));
confirmed.addAll(Arrays.asList(elements));
verify();
assertTrue("Empty collection should change after addAll", r);
for (int i = 0; i < elements.length; i++) {
assertTrue("Collection should contain added element",
collection.contains(elements[i]));
}
resetFull();
int size = collection.size();
elements = getOtherElements();
r = collection.addAll(Arrays.asList(elements));
confirmed.addAll(Arrays.asList(elements));
verify();
assertTrue("Full collection should change after addAll", r);
for (int i = 0; i < elements.length; i++) {
assertTrue("Full collection should contain added element",
collection.contains(elements[i]));
}
assertEquals("Size should increase after addAll",
size + elements.length, collection.size());
resetFull();
size = collection.size();
r = collection.addAll(Arrays.asList(getFullElements()));
confirmed.addAll(Arrays.asList(getFullElements()));
verify();
if (r) {
assertTrue("Size should increase if addAll returns true",
size < collection.size());
} else {
assertEquals("Size should not change if addAll returns false",
size, collection.size());
}
}
/**
* If {@link #isAddSupported()} returns false, tests that add operations
* raise UnsupportedOperationException.
*/
public void testUnsupportedAdd() {
if (isAddSupported()) return;
resetEmpty();
try {
collection.add(new Object());
fail("Emtpy collection should not support add.");
} catch (UnsupportedOperationException e) {
// expected
}
// make sure things didn't change even if the expected exception was
// thrown.
verify();
try {
collection.addAll(Arrays.asList(getFullElements()));
fail("Emtpy collection should not support addAll.");
} catch (UnsupportedOperationException e) {
// expected
}
// make sure things didn't change even if the expected exception was
// thrown.
verify();
resetFull();
try {
collection.add(new Object());
fail("Full collection should not support add.");
} catch (UnsupportedOperationException e) {
// expected
}
// make sure things didn't change even if the expected exception was
// thrown.
verify();
try {
collection.addAll(Arrays.asList(getOtherElements()));
fail("Full collection should not support addAll.");
} catch (UnsupportedOperationException e) {
// expected
}
// make sure things didn't change even if the expected exception was
// thrown.
verify();
}
/**
* Test {@link Collection#clear()}.
*/
public void testCollectionClear() {
if (!isRemoveSupported()) return;
resetEmpty();
collection.clear(); // just to make sure it doesn't raise anything
verify();
resetFull();
collection.clear();
confirmed.clear();
verify();
}
/**
* Tests {@link Collection#contains(Object)}.
*/
public void testCollectionContains() {
Object[] elements;
resetEmpty();
elements = getFullElements();
for(int i = 0; i < elements.length; i++) {
assertTrue("Empty collection shouldn'y contain element",
!collection.contains(elements[i]));
}
// make sure calls to "contains" don't change anything
verify();
elements = getOtherElements();
for(int i = 0; i < elements.length; i++) {
assertTrue("Empty collection shouldn'y contain element",
!collection.contains(elements[i]));
}
// make sure calls to "contains" don't change anything
verify();
resetFull();
elements = getFullElements();
for(int i = 0; i < elements.length; i++) {
assertTrue("Full collection should contain element.",
collection.contains(elements[i]));
}
// make sure calls to "contains" don't change anything
verify();
resetFull();
elements = getOtherElements();
for(int i = 0; i < elements.length; i++) {
assertTrue("Full collection shouldn't contain element",
!collection.contains(elements[i]));
}
}
/**
* Tests {@link Collection#containsAll(Collection)}.
*/
public void testCollectionContainsAll() {
resetEmpty();
Collection col = new HashSet();
assertTrue("Every Collection should contain all elements of an " +
"empty Collection.", collection.containsAll(col));
col.addAll(Arrays.asList(getOtherElements()));
assertTrue("Empty Collection shouldn't contain all elements of " +
"a non-empty Collection.", !collection.containsAll(col));
// make sure calls to "containsAll" don't change anything
verify();
resetFull();
assertTrue("Full collection shouldn't contain other elements",
!collection.containsAll(col));
col.clear();
col.addAll(Arrays.asList(getFullElements()));
assertTrue("Full collection should containAll full elements",
collection.containsAll(col));
// make sure calls to "containsAll" don't change anything
verify();
col = Arrays.asList(getFullElements()).subList(2, 5);
assertTrue("Full collection should containAll partial full " +
"elements", collection.containsAll(col));
assertTrue("Full collection should containAll itself",
collection.containsAll(collection));
// make sure calls to "containsAll" don't change anything
verify();
col = new ArrayList();
col.addAll(Arrays.asList(getFullElements()));
col.addAll(Arrays.asList(getFullElements()));
assertTrue("Full collection should containAll duplicate full " +
"elements", collection.containsAll(col));
// make sure calls to "containsAll" don't change anything
verify();
}
/**
* Tests {@link Collection#isEmpty()}.
*/
public void testCollectionIsEmpty() {
resetEmpty();
assertEquals("New Collection should be empty.",
true, collection.isEmpty());
// make sure calls to "isEmpty() don't change anything
verify();
resetFull();
assertEquals("Full collection shouldn't be empty",
false, collection.isEmpty());
// make sure calls to "isEmpty() don't change anything
verify();
}
/**
* Tests the read-only functionality of {@link Collection#iterator()}.
*/
public void testCollectionIterator() {
resetEmpty();
Iterator it1 = collection.iterator();
assertEquals("Iterator for empty Collection shouldn't have next.",
false, it1.hasNext());
try {
it1.next();
fail("Iterator at end of Collection should throw " +
"NoSuchElementException when next is called.");
} catch(NoSuchElementException e) {
// expected
}
// make sure nothing has changed after non-modification
verify();
resetFull();
it1 = collection.iterator();
for (int i = 0; i < collection.size(); i++) {
assertTrue("Iterator for full collection should haveNext",
it1.hasNext());
it1.next();
}
assertTrue("Iterator should be finished", !it1.hasNext());
ArrayList list = new ArrayList();
it1 = collection.iterator();
for (int i = 0; i < collection.size(); i++) {
Object next = it1.next();
assertTrue("Collection should contain element returned by " +
"its iterator", collection.contains(next));
list.add(next);
}
try {
it1.next();
fail("iterator.next() should raise NoSuchElementException " +
"after it finishes");
} catch (NoSuchElementException e) {
// expected
}
// make sure nothing has changed after non-modification
verify();
}
/**
* Tests removals from {@link Collection#iterator()}.
*/
public void testCollectionIteratorRemove() {
if (!isRemoveSupported()) return;
resetEmpty();
try {
collection.iterator().remove();
fail("New iterator.remove should raise IllegalState");
} catch (IllegalStateException e) {
// expected
}
verify();
try {
Iterator iter = collection.iterator();
iter.hasNext();
iter.remove();
fail("New iterator.remove should raise IllegalState " +
"even after hasNext");
} catch (IllegalStateException e) {
// expected
}
verify();
resetFull();
int size = collection.size();
Iterator iter = collection.iterator();
while (iter.hasNext()) {
Object o = iter.next();
iter.remove();
// if the elements aren't distinguishable, we can just remove a
// matching element from the confirmed collection and verify
// contents are still the same. Otherwise, we don't have the
// ability to distinguish the elements and determine which to
// remove from the confirmed collection (in which case, we don't
// verify because we don't know how).
//
// see areEqualElementsDistinguishable()
if(!areEqualElementsDistinguishable()) {
confirmed.remove(o);
verify();
}
size--;
assertEquals("Collection should shrink by one after " +
"iterator.remove", size, collection.size());
}
assertTrue("Collection should be empty after iterator purge",
collection.isEmpty());
resetFull();
iter = collection.iterator();
iter.next();
iter.remove();
try {
iter.remove();
fail("Second iter.remove should raise IllegalState");
} catch (IllegalStateException e) {
// expected
}
}
/**
* Tests {@link Collection#remove(Object)}.
*/
public void testCollectionRemove() {
if (!isRemoveSupported()) return;
resetEmpty();
Object[] elements = getFullElements();
for (int i = 0; i < elements.length; i++) {
assertTrue("Shouldn't remove nonexistent element",
!collection.remove(elements[i]));
verify();
}
Object[] other = getOtherElements();
resetFull();
for (int i = 0; i < other.length; i++) {
assertTrue("Shouldn't remove nonexistent other element",
!collection.remove(other[i]));
verify();
}
int size = collection.size();
for (int i = 0; i < elements.length; i++) {
resetFull();
assertTrue("Collection should remove extant element",
collection.remove(elements[i]));
// if the elements aren't distinguishable, we can just remove a
// matching element from the confirmed collection and verify
// contents are still the same. Otherwise, we don't have the
// ability to distinguish the elements and determine which to
// remove from the confirmed collection (in which case, we don't
// verify because we don't know how).
//
// see areEqualElementsDistinguishable()
if(!areEqualElementsDistinguishable()) {
confirmed.remove(elements[i]);
verify();
}
assertEquals("Collection should shrink after remove",
size - 1, collection.size());
}
}
/**
* Tests {@link Collection#removeAll(Collection)}.
*/
public void testCollectionRemoveAll() {
if (!isRemoveSupported()) return;
resetEmpty();
assertTrue("Emtpy collection removeAll should return false for " +
"empty input",
!collection.removeAll(Collections.EMPTY_SET));
verify();
assertTrue("Emtpy collection removeAll should return false for " +
"nonempty input",
!collection.removeAll(new ArrayList(collection)));
verify();
resetFull();
assertTrue("Full collection removeAll should return false for " +
"empty input",
!collection.removeAll(Collections.EMPTY_SET));
verify();
assertTrue("Full collection removeAll should return false for " +
"other elements",
!collection.removeAll(Arrays.asList(getOtherElements())));
verify();
assertTrue("Full collection removeAll should return true for " +
"full elements",
collection.removeAll(new HashSet(collection)));
confirmed.removeAll(new HashSet(confirmed));
verify();
resetFull();
int size = collection.size();
Collection all = Arrays.asList(getFullElements()).subList(2, 5);
assertTrue("Full collection removeAll should work",
collection.removeAll(all));
confirmed.removeAll(all);
verify();
assertTrue("Collection should shrink after removeAll",
collection.size() < size);
Iterator iter = all.iterator();
while (iter.hasNext()) {
assertTrue("Collection shouldn't contain removed element",
!collection.contains(iter.next()));
}
}
/**
* Tests {@link Collection#retainAll(Collection)}.
*/
public void testCollectionRetainAll() {
if (!isRemoveSupported()) return;
resetEmpty();
List elements = Arrays.asList(getFullElements());
List other = Arrays.asList(getOtherElements());
assertTrue("Empty retainAll() should return false",
!collection.retainAll(Collections.EMPTY_SET));
verify();
assertTrue("Empty retainAll() should return false",
!collection.retainAll(elements));
verify();
resetFull();
assertTrue("Collection should change from retainAll empty",
collection.retainAll(Collections.EMPTY_SET));
confirmed.retainAll(Collections.EMPTY_SET);
verify();
resetFull();
assertTrue("Collection changed from retainAll other",
collection.retainAll(other));
confirmed.retainAll(other);
verify();
resetFull();
int size = collection.size();
assertTrue("Collection shouldn't change from retainAll elements",
!collection.retainAll(elements));
verify();
assertEquals("Collection size shouldn't change", size,
collection.size());
resetFull();
size = collection.size();
assertTrue("Collection should changed by partial retainAll",
collection.retainAll(elements.subList(2, 5)));
confirmed.retainAll(elements.subList(2, 5));
verify();
Iterator iter = collection.iterator();
while (iter.hasNext()) {
assertTrue("Collection only contains retained element",
elements.subList(2, 5).contains(iter.next()));
}
resetFull();
HashSet set = new HashSet(elements);
size = collection.size();
assertTrue("Collection shouldn't change from retainAll without " +
"duplicate elements", !collection.retainAll(set));
verify();
assertEquals("Collection size didn't change from nonduplicate " +
"retainAll", size, collection.size());
}
/**
* Tests {@link Collection#size()}.
*/
public void testCollectionSize() {
resetEmpty();
assertEquals("Size of new Collection is 0.", 0, collection.size());
resetFull();
assertTrue("Size of full collection should be greater than zero",
collection.size() > 0);
}
/**
* Tests {@link Collection#toArray()}.
*/
public void testCollectionToArray() {
resetEmpty();
assertEquals("Empty Collection should return empty array for toArray",
0, collection.toArray().length);
resetFull();
Object[] array = collection.toArray();
assertEquals("Full collection toArray should be same size as " +
"collection", array.length, collection.size());
Object[] confirmedArray = confirmed.toArray();
assertEquals("length of array from confirmed collection should " +
"match the length of the collection's array",
confirmedArray.length, array.length);
boolean[] matched = new boolean[array.length];
for (int i = 0; i < array.length; i++) {
assertTrue("Collection should contain element in toArray",
collection.contains(array[i]));
boolean match = false;
// find a match in the confirmed array
for(int j = 0; j < array.length; j++) {
// skip already matched
if(matched[j]) continue;
if(array[i] == confirmedArray[j] ||
(array[i] != null && array[i].equals(confirmedArray[j]))) {
matched[j] = true;
match = true;
break;
}
}
if(!match) {
fail("element " + i + " in returned array should be found " +
"in the confirmed collection's array");
}
}
for(int i = 0; i < matched.length; i++) {
assertEquals("Collection should return all its elements in " +
"toArray", true, matched[i]);
}
}
/**
* Tests {@link Collection.toArray(Object[])}.
*/
public void testCollectionToArray2() {
resetEmpty();
Object[] a = new Object[] { new Object(), null, null };
Object[] array = collection.toArray(a);
assertEquals("Given array shouldn't shrink", array, a);
assertEquals("Last element should be set to null", a[0], null);
verify();
resetFull();
try {
array = collection.toArray(new Void[0]);
fail("toArray(new Void[0]) should raise ArrayStore");
} catch (ArrayStoreException e) {
// expected
}
verify();
try {
array = collection.toArray(null);
fail("toArray(null) should raise NPE");
} catch (NullPointerException e) {
// expected
}
verify();
array = collection.toArray(new Object[0]);
a = collection.toArray();
assertEquals("toArrays should be equal",
Arrays.asList(array), Arrays.asList(a));
// Figure out if they're all the same class
// TODO: It'd be nicer to detect a common superclass
HashSet classes = new HashSet();
for (int i = 0; i < array.length; i++) {
classes.add((array[i] == null) ? null : array[i].getClass());
}
if (classes.size() > 1) return;
Class cl = (Class)classes.iterator().next();
a = (Object[])Array.newInstance(cl, 0);
array = collection.toArray(a);
assertEquals("toArray(Object[]) should return correct array type",
a.getClass(), array.getClass());
assertEquals("type-specific toArrays should be equal",
Arrays.asList(array),
Arrays.asList(collection.toArray()));
verify();
}
/**
* Tests toString on a collection.
*/
public void testCollectionToString() {
resetEmpty();
assertTrue("toString shouldn't return null",
collection.toString() != null);
resetFull();
assertTrue("toString shouldn't return null",
collection.toString() != null);
}
/**
* If isRemoveSupported() returns false, tests to see that remove
* operations raise an UnsupportedOperationException.
*/
public void testUnsupportedRemove() {
if (isRemoveSupported()) return;
resetEmpty();
try {
collection.clear();
fail("clear should raise UnsupportedOperationException");
} catch (UnsupportedOperationException e) {
// expected
}
verify();
try {
collection.remove(null);
fail("remove should raise UnsupportedOperationException");
} catch (UnsupportedOperationException e) {
// expected
}
verify();
try {
collection.removeAll(null);
fail("removeAll should raise UnsupportedOperationException");
} catch (UnsupportedOperationException e) {
// expected
}
verify();
try {
collection.retainAll(null);
fail("removeAll should raise UnsupportedOperationException");
} catch (UnsupportedOperationException e) {
// expected
}
verify();
resetFull();
try {
Iterator iterator = collection.iterator();
iterator.next();
iterator.remove();
fail("iterator.remove should raise UnsupportedOperationException");
} catch (UnsupportedOperationException e) {
// expected
}
verify();
}
/**
* Tests that the collection's iterator is fail-fast.
*/
public void testCollectionIteratorFailFast() {
if (isAddSupported()) {
resetFull();
try {
Iterator iter = collection.iterator();
Object o = getOtherElements()[0];
collection.add(o);
confirmed.add(o);
iter.next();
fail("next after add should raise ConcurrentModification");
} catch (ConcurrentModificationException e) {
// expected
}
verify();
resetFull();
try {
Iterator iter = collection.iterator();
collection.addAll(Arrays.asList(getOtherElements()));
confirmed.addAll(Arrays.asList(getOtherElements()));
iter.next();
fail("next after addAll should raise ConcurrentModification");
} catch (ConcurrentModificationException e) {
// expected
}
verify();
}
if (!isRemoveSupported()) return;
resetFull();
try {
Iterator iter = collection.iterator();
collection.clear();
iter.next();
fail("next after clear should raise ConcurrentModification");
} catch (ConcurrentModificationException e) {
// expected
} catch (NoSuchElementException e) {
// (also legal given spec)
}
resetFull();
try {
Iterator iter = collection.iterator();
collection.remove(getFullElements()[0]);
iter.next();
fail("next after remove should raise ConcurrentModification");
} catch (ConcurrentModificationException e) {
// expected
}
resetFull();
try {
Iterator iter = collection.iterator();
List sublist = Arrays.asList(getFullElements()).subList(2,5);
collection.removeAll(sublist);
iter.next();
fail("next after removeAll should raise ConcurrentModification");
} catch (ConcurrentModificationException e) {
// expected
}
resetFull();
try {
Iterator iter = collection.iterator();
List sublist = Arrays.asList(getFullElements()).subList(2,5);
collection.retainAll(sublist);
iter.next();
fail("next after retainAll should raise ConcurrentModification");
} catch (ConcurrentModificationException e) {
// expected
}
}
/**
* Returns a list of elements suitable for return by
* {@link getFullElements()}. The array returned by this method
* does not include null, but does include a variety of objects
* of different types. Override getFullElements to return
* the results of this method if your collection does not support
* the null element.
*/
public static Object[] getFullNonNullElements() {
return new Object[] {
new String(""),
new String("One"),
new Integer(2),
"Three",
new Integer(4),
"One",
new Double(5),
new Float(6),
"Seven",
"Eight",
new String("Nine"),
new Integer(10),
new Short((short)11),
new Long(12),
"Thirteen",
"14",
"15",
new Byte((byte)16)
};
}
/**
* Returns the default list of objects returned by
* {@link getOtherElements()}. Includes many objects
* of different types.
*/
public static Object[] getOtherNonNullElements() {
return new Object[] {
new Integer(0),
new Float(0),
new Double(0),
"Zero",
new Short((short)0),
new Byte((byte)0),
new Long(0),
new Character('\u0000'),
"0"
};
}
/**
* Returns a list of string elements suitable for return by
* {@link getFullElements()}. Override getFullElements to return
* the results of this method if your collection does not support
* heterogenous elements or the null element.
*/
public static Object[] getFullNonNullStringElements() {
return new Object[] {
"If","the","dull","substance","of","my","flesh","were","thought",
"Injurious","distance","could","not","stop","my","way",
};
}
/**
* Returns a list of string elements suitable for return by
* {@link getOtherElements()}. Override getOtherElements to return
* the results of this method if your collection does not support
* heterogenous elements or the null element.
*/
public static Object[] getOtherNonNullStringElements() {
return new Object[] {
"For","then","despite",/* of */"space","I","would","be","brought",
"From","limits","far","remote","where","thou","dost","stay"
};
}
}
././@LongLink 0000000 0000000 0000000 00000000146 00000000000 011566 L ustar root root libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestIteratorUtils.java libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestIteratorUtils.ja 0100644 0001750 0001750 00000003556 10055172400 032304 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import junit.framework.Test;
/**
* Tests for IteratorUtils.
*/
public class TestIteratorUtils extends BulkTest {
public TestIteratorUtils(String name) {
super(name);
}
public static Test suite() {
return BulkTest.makeSuite(TestIteratorUtils.class);
}
public void testToList() {
List list = new ArrayList();
list.add(new Integer(1));
list.add("Two");
list.add(null);
List result = IteratorUtils.toList(list.iterator());
assertEquals(list, result);
}
public void testToArray() {
List list = new ArrayList();
list.add(new Integer(1));
list.add("Two");
list.add(null);
Object[] result = IteratorUtils.toArray(list.iterator());
assertEquals(list, Arrays.asList(result));
}
public void testToArray2() {
List list = new ArrayList();
list.add("One");
list.add("Two");
list.add(null);
String[] result = (String[]) IteratorUtils.toArray(list.iterator(), String.class);
assertEquals(list, Arrays.asList(result));
}
}
libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/comparators/ 0040755 0001750 0001750 00000000000 10072637466 030663 5 ustar tora tora ././@LongLink 0000000 0000000 0000000 00000000164 00000000000 011566 L ustar root root libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/comparators/TestComparatorChain.java libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/comparators/TestComp 0100644 0001750 0001750 00000012560 10055172376 032340 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.comparators;
import java.io.Serializable;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import junit.framework.Test;
import junit.framework.TestSuite;
public class TestComparatorChain extends TestComparator {
public TestComparatorChain(String testName) {
super(testName);
}
public static Test suite() {
return new TestSuite(TestComparatorChain.class);
}
/**
*
* @return
*/
public Comparator makeComparator() {
ComparatorChain chain = new ComparatorChain(new ColumnComparator(0));
chain.addComparator(new ColumnComparator(1),true); // reverse the second column
chain.addComparator(new ColumnComparator(2),false);
return chain;
}
public void testNoopComparatorChain() {
ComparatorChain chain = new ComparatorChain();
Integer i1 = new Integer(4);
Integer i2 = new Integer(6);
chain.addComparator(new ComparableComparator());
int correctValue = i1.compareTo(i2);
assertTrue("Comparison returns the right order",chain.compare(i1,i2) == correctValue);
}
public void testBadNoopComparatorChain() {
ComparatorChain chain = new ComparatorChain();
Integer i1 = new Integer(4);
Integer i2 = new Integer(6);
try {
chain.compare(i1,i2);
fail("An exception should be thrown when a chain contains zero comparators.");
} catch (UnsupportedOperationException e) {
}
}
public void testListComparatorChain() {
List list = new LinkedList();
list.add(new ComparableComparator());
ComparatorChain chain = new ComparatorChain(list);
Integer i1 = new Integer(4);
Integer i2 = new Integer(6);
int correctValue = i1.compareTo(i2);
assertTrue("Comparison returns the right order",chain.compare(i1,i2) == correctValue);
}
public void testBadListComparatorChain() {
List list = new LinkedList();
ComparatorChain chain = new ComparatorChain(list);
Integer i1 = new Integer(4);
Integer i2 = new Integer(6);
try {
chain.compare(i1,i2);
fail("An exception should be thrown when a chain contains zero comparators.");
} catch (UnsupportedOperationException e) {
}
}
public List getComparableObjectsOrdered() {
List list = new LinkedList();
// this is the correct order assuming a
// "0th forward, 1st reverse, 2nd forward" sort
list.add(new PseudoRow(1,2,3));
list.add(new PseudoRow(2,3,5));
list.add(new PseudoRow(2,2,4));
list.add(new PseudoRow(2,2,8));
list.add(new PseudoRow(3,1,0));
list.add(new PseudoRow(4,4,4));
list.add(new PseudoRow(4,4,7));
return list;
}
public static class PseudoRow implements Serializable {
public int cols[] = new int[3];
public PseudoRow(int col1, int col2, int col3) {
cols[0] = col1;
cols[1] = col2;
cols[2] = col3;
}
public int getColumn(int colIndex) {
return cols[colIndex];
}
public String toString() {
StringBuffer buf = new StringBuffer();
buf.append("[");
buf.append(cols[0]);
buf.append(",");
buf.append(cols[1]);
buf.append(",");
buf.append(cols[2]);
buf.append("]");
return buf.toString();
}
public boolean equals(Object o) {
if (!(o instanceof PseudoRow)) {
return false;
}
PseudoRow row = (PseudoRow) o;
if (getColumn(0) != row.getColumn(0)) {
return false;
}
if (getColumn(1) != row.getColumn(1)) {
return false;
}
if (getColumn(2) != row.getColumn(2)) {
return false;
}
return true;
}
}
public static class ColumnComparator implements Comparator,Serializable {
protected int colIndex = 0;
public ColumnComparator(int colIndex) {
this.colIndex = colIndex;
}
public int compare(Object o1, Object o2) {
int col1 = ( (PseudoRow) o1).getColumn(colIndex);
int col2 = ( (PseudoRow) o2).getColumn(colIndex);
if (col1 > col2) {
return 1;
} else if (col1 < col2) {
return -1;
}
return 0;
}
}
}
././@LongLink 0000000 0000000 0000000 00000000166 00000000000 011570 L ustar root root libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/comparators/TestReverseComparator.java libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/comparators/TestReve 0100644 0001750 0001750 00000003645 10055172400 032333 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.comparators;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import junit.framework.Test;
import junit.framework.TestSuite;
public class TestReverseComparator extends TestComparator {
public TestReverseComparator(String testName) {
super(testName);
}
public static Test suite() {
return new TestSuite(TestReverseComparator.class);
}
/**
* For the purposes of this test, return a
* ReverseComparator that wraps the java.util.Collections.reverseOrder()
* Comparator. The resulting comparator shouls
* sort according to natural Order. (Note: we wrap
* a Comparator taken from the JDK so that we can
* save a "canonical" form in CVS.
*
* @return Comparator that returns "natural" order
*/
public Comparator makeComparator() {
return new ReverseComparator(Collections.reverseOrder());
}
public List getComparableObjectsOrdered() {
List list = new LinkedList();
list.add(new Integer(1));
list.add(new Integer(2));
list.add(new Integer(3));
list.add(new Integer(4));
list.add(new Integer(5));
return list;
}
}
././@LongLink 0000000 0000000 0000000 00000000171 00000000000 011564 L ustar root root libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/comparators/TestComparableComparator.java libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/comparators/TestComp 0100644 0001750 0001750 00000002731 10055172400 032323 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.comparators;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import junit.framework.Test;
import junit.framework.TestSuite;
public class TestComparableComparator extends TestComparator {
public TestComparableComparator(String testName) {
super(testName);
}
public static Test suite() {
return new TestSuite(TestComparableComparator.class);
}
public Comparator makeComparator() {
return new ComparableComparator();
}
public List getComparableObjectsOrdered() {
List list = new LinkedList();
list.add(new Integer(1));
list.add(new Integer(2));
list.add(new Integer(3));
list.add(new Integer(4));
list.add(new Integer(5));
return list;
}
}
././@LongLink 0000000 0000000 0000000 00000000163 00000000000 011565 L ustar root root libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/comparators/TestNullComparator.java libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/comparators/TestNull 0100644 0001750 0001750 00000005620 10055172400 032337 0 ustar tora tora /*
* Copyright 2001-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.comparators;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import junit.framework.Test;
import junit.framework.TestSuite;
/**
* Test the NullComparator
*
* @author Michael A. Smith
* @version $Id: TestNullComparator.java,v 1.3.2.1 2004/05/22 12:14:03 scolebourne Exp $
**/
public abstract class TestNullComparator extends TestComparator {
public TestNullComparator(String testName) {
super(testName);
}
public static Test suite() {
TestSuite suite = new TestSuite(TestNullComparator.class.getName());
suite.addTest(new TestSuite(TestNullComparator1.class));
suite.addTest(new TestSuite(TestNullComparator2.class));
return suite;
}
/**
* Test the NullComparator with nulls high, using comparable comparator
**/
public static class TestNullComparator1 extends TestNullComparator {
public TestNullComparator1(String testName) {
super(testName);
}
public Comparator makeComparator() {
return new NullComparator();
}
public List getComparableObjectsOrdered() {
List list = new LinkedList();
list.add(new Integer(1));
list.add(new Integer(2));
list.add(new Integer(3));
list.add(new Integer(4));
list.add(new Integer(5));
list.add(null);
return list;
}
public String getCanonicalComparatorName(Object object) {
return super.getCanonicalComparatorName(object) + "1";
}
}
/**
* Test the NullComparator with nulls low using the comparable comparator
**/
public static class TestNullComparator2 extends TestNullComparator {
public TestNullComparator2(String testName) {
super(testName);
}
public Comparator makeComparator() {
return new NullComparator(false);
}
public List getComparableObjectsOrdered() {
List list = new LinkedList();
list.add(null);
list.add(new Integer(1));
list.add(new Integer(2));
list.add(new Integer(3));
list.add(new Integer(4));
list.add(new Integer(5));
return list;
}
public String getCanonicalComparatorName(Object object) {
return super.getCanonicalComparatorName(object) + "2";
}
}
}
././@LongLink 0000000 0000000 0000000 00000000150 00000000000 011561 L ustar root root libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/comparators/TestAll.java libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/comparators/TestAll. 0100644 0001750 0001750 00000003060 10055172400 032207 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.comparators;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
/**
* Entry point for all Comparator Collections tests.
* @author Stephen Colebourne
* @version $Id: TestAll.java,v 1.1.2.1 2004/05/22 12:14:03 scolebourne Exp $
*/
public class TestAll extends TestCase {
public TestAll(String testName) {
super(testName);
}
public static Test suite() {
TestSuite suite = new TestSuite();
suite.addTest(TestComparableComparator.suite());
suite.addTest(TestComparatorChain.suite());
suite.addTest(TestNullComparator.suite());
suite.addTest(TestReverseComparator.suite());
return suite;
}
public static void main(String args[]) {
String[] testCaseName = { TestAll.class.getName() };
junit.textui.TestRunner.main(testCaseName);
}
}
././@LongLink 0000000 0000000 0000000 00000000157 00000000000 011570 L ustar root root libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/comparators/TestComparator.java libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/comparators/TestComp 0100644 0001750 0001750 00000013027 10055172376 032337 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections.comparators;
import java.io.IOException;
import java.io.FileNotFoundException;
import java.io.Serializable;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import org.apache.commons.collections.TestObject;
public abstract class TestComparator extends TestObject {
public TestComparator(String testName) {
super(testName);
}
public abstract Comparator makeComparator();
public abstract List getComparableObjectsOrdered();
public Object makeObject() {
return makeComparator();
}
/**
* There were no Comparators in version 1.x.
*
* @return 2
*/
public int getCompatibilityVersion() {
return 2;
}
public void reverseObjects(List list) {
Collections.reverse(list);
}
public void randomizeObjects(List list) {
Collections.shuffle(list);
}
/**
* Sort object according to the given Comparator.
*
* @param list List to sort
* @param comparator sorting comparator
*/
public void sortObjects(List list, Comparator comparator) {
Collections.sort(list,comparator);
}
public boolean supportsEmptyCollections() {
return false;
}
public boolean supportsFullCollections() {
return false;
}
public void testEmptyListSort() {
List list = new LinkedList();
sortObjects(list,makeComparator());
List list2 = new LinkedList();
assertTrue("Comparator cannot sort empty lists",
list2.equals(list));
}
public void testReverseListSort() {
Comparator comparator = makeComparator();
List randomList = getComparableObjectsOrdered();
reverseObjects(randomList);
sortObjects(randomList,comparator);
List orderedList = getComparableObjectsOrdered();
assertTrue("Comparator did not reorder the List correctly",
orderedList.equals(randomList));
}
public void testRandomListSort() {
Comparator comparator = makeComparator();
List randomList = getComparableObjectsOrdered();
randomizeObjects(randomList);
sortObjects(randomList,comparator);
List orderedList = getComparableObjectsOrdered();
/* debug
Iterator i = randomList.iterator();
while (i.hasNext()) {
System.out.println(i.next());
}
*/
assertTrue("Comparator did not reorder the List correctly",
orderedList.equals(randomList));
}
/**
* Nearly all Comparators should be Serializable.
*/
public void testComparatorIsSerializable() {
Comparator comparator = makeComparator();
assertTrue("This comparator should be Serializable.",
comparator instanceof Serializable);
}
public String getCanonicalComparatorName(Object object) {
StringBuffer retval = new StringBuffer();
retval.append("data/test/");
String colName = object.getClass().getName();
colName = colName.substring(colName.lastIndexOf(".")+1,colName.length());
retval.append(colName);
retval.append(".version");
retval.append(getCompatibilityVersion());
retval.append(".obj");
return retval.toString();
}
/**
* Compare the current serialized form of the Comparator
* against the canonical version in CVS.
*/
public void testComparatorCompatibility() throws IOException, ClassNotFoundException {
Comparator comparator = null;
// test to make sure the canonical form has been preserved
try {
comparator =
(Comparator) readExternalFormFromDisk
(getCanonicalComparatorName(makeComparator()));
} catch (FileNotFoundException exception) {
boolean autoCreateSerialized = false;
if(autoCreateSerialized) {
comparator = makeComparator();
String fileName = getCanonicalComparatorName(comparator);
writeExternalFormToDisk((Serializable) comparator, fileName);
fail("Serialized form could not be found. A serialized version " +
"has now been written (and should be added to CVS): " + fileName);
} else {
fail("The Serialized form could be located to test serialization " +
"compatibility: " + exception.getMessage());
}
}
// make sure the canonical form produces the ordering we currently
// expect
List randomList = getComparableObjectsOrdered();
reverseObjects(randomList);
sortObjects(randomList,comparator);
List orderedList = getComparableObjectsOrdered();
assertTrue("Comparator did not reorder the List correctly",
orderedList.equals(randomList));
}
}
libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestSetUtils.java 0100644 0001750 0001750 00000003622 10055172400 031567 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import junit.framework.Test;
import java.util.Collection;
import java.util.Set;
import java.util.HashSet;
/**
* Tests for SetUtils.
*/
public class TestSetUtils extends BulkTest {
public TestSetUtils(String name) {
super(name);
}
public static Test suite() {
return BulkTest.makeSuite(TestSetUtils.class);
}
public void testNothing() {
}
public BulkTest bulkTestPredicatedSet() {
return new TestPredicatedCollection("") {
public Collection predicatedCollection() {
Predicate p = getPredicate();
return SetUtils.predicatedSet(new HashSet(), p);
}
public BulkTest bulkTestAll() {
return new TestSet("") {
public Set makeEmptySet() {
return (Set)predicatedCollection();
}
public Object[] getFullElements() {
return getFullNonNullStringElements();
}
public Object[] getOtherElements() {
return getOtherNonNullStringElements();
}
};
}
};
}
}
libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestLRUMap.java 0100644 0001750 0001750 00000014660 10055172376 031133 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import junit.framework.Test;
/**
*
* @author James Strachan
* @author Morgan Delagrange
* @version $Id: TestLRUMap.java,v 1.23.2.1 2004/05/22 12:14:05 scolebourne Exp $
*/
public class TestLRUMap extends TestSequencedHashMap
{
public TestLRUMap(String testName) {
super(testName);
}
public static Test suite() {
return BulkTest.makeSuite(TestLRUMap.class);
}
public static void main(String args[]) {
String[] testCaseName = { TestLRUMap.class.getName() };
junit.textui.TestRunner.main(testCaseName);
}
public Map makeEmptyMap() {
LRUMap map = new LRUMap();
return map;
}
public void testRemoveLRU() {
LRUMap map2 = new LRUMap(3);
map2.put(new Integer(1),"foo");
map2.put(new Integer(2),"foo");
map2.put(new Integer(3),"foo");
map2.put(new Integer(4),"foo"); // removes 1 since max size exceeded
map2.removeLRU(); // should be Integer(2)
assertTrue("Second to last value should exist",map2.get(new Integer(3)).equals("foo"));
assertTrue("First value inserted should not exist", map2.get(new Integer(1)) == null);
}
public void testMultiplePuts() {
LRUMap map2 = new LRUMap(2);
map2.put(new Integer(1),"foo");
map2.put(new Integer(2),"bar");
map2.put(new Integer(3),"foo");
map2.put(new Integer(4),"bar");
assertTrue("last value should exist",map2.get(new Integer(4)).equals("bar"));
assertTrue("LRU should not exist", map2.get(new Integer(1)) == null);
}
/**
* Confirm that putAll(Map) does not cause the LRUMap
* to exceed its maxiumum size.
*/
public void testPutAll() {
LRUMap map2 = new LRUMap(3);
map2.put(new Integer(1),"foo");
map2.put(new Integer(2),"foo");
map2.put(new Integer(3),"foo");
HashMap hashMap = new HashMap();
hashMap.put(new Integer(4),"foo");
map2.putAll(hashMap);
assertTrue("max size is 3, but actual size is " + map2.size(),
map2.size() == 3);
assertTrue("map should contain the Integer(4) object",
map2.containsKey(new Integer(4)));
}
/**
* Test that the size of the map is reduced immediately
* when setMaximumSize(int) is called
*/
public void testSetMaximumSize() {
LRUMap map = new LRUMap(6);
map.put("1","1");
map.put("2","2");
map.put("3","3");
map.put("4","4");
map.put("5","5");
map.put("6","6");
map.setMaximumSize(3);
assertTrue("map should have size = 3, but actually = " + map.size(),
map.size() == 3);
}
public void testGetPromotion() {
LRUMap map = new LRUMap(3);
map.put("1","1");
map.put("2","2");
map.put("3","3");
// LRU is now 1 (then 2 then 3)
// promote 1 to top
// eviction order is now 2,3,1
map.get("1");
// add another value, forcing a remove
// 2 should be evicted (then 3,1,4)
map.put("4","4");
Iterator keyIterator = map.keySet().iterator();
Object[] keys = new Object[3];
for (int i = 0; keyIterator.hasNext() ; ++i) {
keys[i] = keyIterator.next();
}
assertTrue("first evicted should be 3, was " + keys[0], keys[0].equals("3"));
assertTrue("second evicted should be 1, was " + keys[1], keys[1].equals("1"));
assertTrue("third evicted should be 4, was " + keys[2], keys[2].equals("4"));
}
/**
* You should be able to subclass LRUMap and perform a
* custom action when items are removed automatically
* by the LRU algorithm (the removeLRU() method).
*/
public void testLRUSubclass() {
LRUCounter counter = new LRUCounter(3);
// oldest <--> newest
// 1
counter.put("1","foo");
// 1 2
counter.put("2","foo");
// 1 2 3
counter.put("3","foo");
// 2 3 1
counter.put("1","foo");
// 3 1 4 (2 goes out)
counter.put("4","foo");
// 1 4 5 (3 goes out)
counter.put("5","foo");
// 4 5 2 (1 goes out)
counter.put("2","foo");
// 4 2
counter.remove("5");
assertTrue("size should be 2, but was " + counter.size(), counter.size() == 2);
assertTrue("removedCount should be 3 but was " + counter.removedCount,
counter.removedCount == 3);
assertTrue("first removed was '2'",counter.list.get(0).equals("2"));
assertTrue("second removed was '3'",counter.list.get(1).equals("3"));
assertTrue("third removed was '1'",counter.list.get(2).equals("1"));
assertTrue("oldest key is '4'",counter.get(0).equals("4"));
assertTrue("newest key is '2'",counter.get(1).equals("2"));
}
protected void entrySetEqualsMap(Set set, Map m) {
// Overridden because LRUMap.get(Object) actually alters the map,
// so there's no way to verify that the entry set and map contain
// the same entries
}
private class LRUCounter extends LRUMap {
int removedCount = 0;
ArrayList list = new ArrayList(3);
LRUCounter(int i) {
super(i);
}
protected void processRemovedLRU(Object key, Object value) {
++removedCount;
list.add(key);
}
}
}
libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestMap.java 0100644 0001750 0001750 00000114076 10055172376 030552 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.io.IOException;
import java.io.Serializable;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/**
* Tests base {@link java.util.Map} methods and contracts.
*
*
*
* Supported Operation Methods
*
*
* Fixture Methodsjava.util.HashMap, which is known to conform
* exactly to the {@link Map} contract. After the modification takes place
* on both your map implementation and the confirmed map implementation, the
* two maps are compared to see if their state is identical. The comparison
* also compares the collection views to make sure they're still the same.false
*
* @author Michael Smith
* @author Rodney Waldhoff
* @author Paul Jack
* @version $Id: TestMap.java,v 1.20.2.1 2004/05/22 12:14:05 scolebourne Exp $
*/
public abstract class TestMap extends TestObject {
// These instance variables are initialized with the reset method.
// Tests for map methods that alter the map (put, putAll, remove)
// first call reset() to create the map and its views; then perform
// the modification on the map; perform the same modification on the
// confirmed; and then call verify() to ensure that the map is equal
// to the confirmed, that the already-constructed collection views
// are still equal to the confirmed's collection views.
/** Map created by reset(). */
protected Map map;
/** Entry set of map created by reset(). */
protected Set entrySet;
/** Key set of map created by reset(). */
protected Set keySet;
/** Values collection of map created by reset(). */
protected Collection values;
/** HashMap created by reset(). */
protected Map confirmed;
public TestMap(String testName) {
super(testName);
}
/**
* Override if your map does not allow a null key. The
* default implementation returns true
**/
protected boolean useNullKey() {
return true;
}
/**
* Override if your map does not allow null values. The
* default implementation returns true.
**/
protected boolean useNullValue() {
return true;
}
/**
* Override if your map does not allow duplicate values. The default
* implementation returns true.
**/
protected boolean useDuplicateValues() {
return true;
}
/**
* Override if your map allows its mappings to be changed to new values.
* The default implementation returns true.
**/
protected boolean isChangeable() {
return true;
}
/**
* Override if your map does not allow add/remove modifications. The
* default implementation returns true.
**/
protected boolean isAddRemoveModifiable() {
return true;
}
/**
* Returns the set of keys in the mappings used to test the map. This
* method must return an array with the same length as {@link
* #getSampleValues()} and all array elements must be different. The
* default implementation constructs a set of String keys, and includes a
* single null key if {@link #useNullKey()} returns true.
**/
protected Object[] getSampleKeys() {
Object[] result = new Object[] {
"blah", "foo", "bar", "baz", "tmp", "gosh", "golly", "gee",
"hello", "goodbye", "we'll", "see", "you", "all", "again",
"key",
"key2",
(useNullKey()) ? null : "nonnullkey"
};
return result;
}
protected Object[] getOtherKeys() {
return TestCollection.getOtherNonNullStringElements();
}
protected Object[] getOtherValues() {
return TestCollection.getOtherNonNullStringElements();
}
/**
* Returns the set of values in the mappings used to test the map. This
* method must return an array with the same length as {@link
* #getSampleKeys()}. The default implementation contructs a set of
* String values and includes a single null value if {@link
* #useNullValue()} returns true, and includes two values
* that are the same if {@link #useDuplicateValues()} returns
* true.
**/
protected Object[] getSampleValues() {
Object[] result = new Object[] {
"blahv", "foov", "barv", "bazv", "tmpv", "goshv", "gollyv", "geev",
"hellov", "goodbyev", "we'llv", "seev", "youv", "allv", "againv",
(useNullValue()) ? null : "nonnullvalue",
"value",
(useDuplicateValues()) ? "value" : "value2",
};
return result;
}
/**
* Returns a the set of values that can be used to replace the values
* returned from {@link #getSampleValues()}. This method must return an
* array with the same length as {@link #getSampleValues()}. The values
* returned from this method should not be the same as those returned from
* {@link #getSampleValues()}. The default implementation constructs a
* set of String values and includes a single null value if {@link
* #useNullValue()} returns true, and includes two values
* that are the same if {@link #useDuplicateValues()} returns
* true.
**/
protected Object[] getNewSampleValues() {
Object[] result = new Object[] {
(useNullValue()) ? null : "newnonnullvalue",
"newvalue",
(useDuplicateValues()) ? "newvalue" : "newvalue2",
"newblahv", "newfoov", "newbarv", "newbazv", "newtmpv", "newgoshv",
"newgollyv", "newgeev", "newhellov", "newgoodbyev", "newwe'llv",
"newseev", "newyouv", "newallv", "newagainv",
};
return result;
}
/**
* Helper method to add all the mappings described by {@link
* #getSampleKeys()} and {@link #getSampleValues()}.
**/
protected void addSampleMappings(Map m) {
Object[] keys = getSampleKeys();
Object[] values = getSampleValues();
for(int i = 0; i < keys.length; i++) {
try {
m.put(keys[i], values[i]);
} catch (NullPointerException exception) {
assertTrue("NullPointerException only allowed to be thrown " +
"if either the key or value is null.",
keys[i] == null || values[i] == null);
assertTrue("NullPointerException on null key, but " +
"useNullKey is not overridden to return false.",
keys[i] == null || !useNullKey());
assertTrue("NullPointerException on null value, but " +
"useNullValue is not overridden to return false.",
values[i] == null || !useNullValue());
assertTrue("Unknown reason for NullPointer.", false);
}
}
assertEquals("size must reflect number of mappings added.",
keys.length, m.size());
}
/**
* Return a new, empty {@link Map} to be used for testing.
*/
protected abstract Map makeEmptyMap();
/**
* Return a new, populated map. The mappings in the map should match the
* keys and values returned from {@link #getSampleKeys()} and {@link
* #getSampleValues()}. The default implementation uses makeEmptyMap()
* and calls {@link #addSampleMappings()} to add all the mappings to the
* map.
**/
protected Map makeFullMap() {
Map m = makeEmptyMap();
addSampleMappings(m);
return m;
}
public Object makeObject() {
return makeEmptyMap();
}
/**
* Test to ensure the test setup is working properly. This method checks
* to ensure that the getSampleKeys and getSampleValues methods are
* returning results that look appropriate. That is, they both return a
* non-null array of equal length. The keys array must not have any
* duplicate values, and may only contain a (single) null key if
* useNullKey() returns true. The values array must only have a null
* value if useNullValue() is true and may only have duplicate values if
* useDuplicateValues() returns true.
**/
public void testSampleMappings() {
Object[] keys = getSampleKeys();
Object[] values = getSampleValues();
Object[] newValues = getNewSampleValues();
assertTrue("failure in test: Must have keys returned from " +
"getSampleKeys.", keys != null);
assertTrue("failure in test: Must have values returned from " +
"getSampleValues.", values != null);
// verify keys and values have equivalent lengths (in case getSampleX are
// overridden)
assertEquals("failure in test: not the same number of sample " +
"keys and values.", keys.length, values.length);
assertEquals("failure in test: not the same number of values and new values.",
values.length, newValues.length);
// verify there aren't duplicate keys, and check values
for(int i = 0; i < keys.length - 1; i++) {
for(int j = i + 1; j < keys.length; j++) {
assertTrue("failure in test: duplicate null keys.",
(keys[i] != null || keys[j] != null));
assertTrue("failure in test: duplicate non-null key.",
(keys[i] == null || keys[j] == null ||
(!keys[i].equals(keys[j]) &&
!keys[j].equals(keys[i]))));
}
assertTrue("failure in test: found null key, but useNullKey " +
"is false.", keys[i] != null || useNullKey());
assertTrue("failure in test: found null value, but useNullValue " +
"is false.", values[i] != null || useNullValue());
assertTrue("failure in test: found null new value, but useNullValue " +
"is false.", newValues[i] != null || useNullValue());
assertTrue("failure in test: values should not be the same as new value",
values[i] != newValues[i] &&
(values[i] == null || !values[i].equals(newValues[i])));
}
}
// tests begin here. Each test adds a little bit of tested functionality.
// Many methods assume previous methods passed. That is, they do not
// exhaustively recheck things that have already been checked in a previous
// test methods.
/**
* Test to ensure that makeEmptyMap and makeFull returns a new non-null
* map with each invocation.
**/
public void testMakeMap() {
Map em = makeEmptyMap();
assertTrue("failure in test: makeEmptyMap must return a non-null map.",
em != null);
Map em2 = makeEmptyMap();
assertTrue("failure in test: makeEmptyMap must return a non-null map.",
em != null);
assertTrue("failure in test: makeEmptyMap must return a new map " +
"with each invocation.", em != em2);
Map fm = makeFullMap();
assertTrue("failure in test: makeFullMap must return a non-null map.",
fm != null);
Map fm2 = makeFullMap();
assertTrue("failure in test: makeFullMap must return a non-null map.",
fm != null);
assertTrue("failure in test: makeFullMap must return a new map " +
"with each invocation.", fm != fm2);
}
/**
* Tests Map.isEmpty()
**/
public void testMapIsEmpty() {
resetEmpty();
assertEquals("Map.isEmpty() should return true with an empty map",
true, map.isEmpty());
verify();
resetFull();
assertEquals("Map.isEmpty() should return false with a non-empty map",
false, map.isEmpty());
verify();
}
/**
* Tests Map.size()
**/
public void testMapSize() {
resetEmpty();
assertEquals("Map.size() should be 0 with an empty map",
0, map.size());
verify();
resetFull();
assertEquals("Map.size() should equal the number of entries " +
"in the map", getSampleKeys().length, map.size());
verify();
}
/**
* Tests {@link Map#clear()}. If the map {@link #isAddRemoveModifiable()
* can add and remove elements}, then {@link Map#size()} and {@link
* Map#isEmpty()} are used to ensure that map has no elements after a call
* to clear. If the map does not support adding and removing elements,
* this method checks to ensure clear throws an
* UnsupportedOperationException.
**/
public void testMapClear() {
if (!isAddRemoveModifiable()) return;
resetEmpty();
map.clear();
confirmed.clear();
verify();
resetFull();
map.clear();
confirmed.clear();
verify();
}
/**
* Tests Map.containsKey(Object) by verifying it returns false for all
* sample keys on a map created using an empty map and returns true for
* all sample keys returned on a full map.
**/
public void testMapContainsKey() {
Object[] keys = getSampleKeys();
resetEmpty();
for(int i = 0; i < keys.length; i++) {
assertTrue("Map must not contain key when map is empty",
!map.containsKey(keys[i]));
}
verify();
resetFull();
for(int i = 0; i < keys.length; i++) {
assertTrue("Map must contain key for a mapping in the map. " +
"Missing: " + keys[i], map.containsKey(keys[i]));
}
verify();
}
/**
* Tests Map.containsValue(Object) by verifying it returns false for all
* sample values on an empty map and returns true for all sample values on
* a full map.
**/
public void testMapContainsValue() {
Object[] values = getSampleValues();
resetEmpty();
for(int i = 0; i < values.length; i++) {
assertTrue("Empty map must not contain value",
!map.containsValue(values[i]));
}
verify();
resetFull();
for(int i = 0; i < values.length; i++) {
assertTrue("Map must contain value for a mapping in the map.",
map.containsValue(values[i]));
}
verify();
}
/**
* Tests Map.equals(Object)
**/
public void testMapEquals() {
resetEmpty();
assertTrue("Empty maps unequal.", map.equals(confirmed));
verify();
resetFull();
assertTrue("Full maps unequal.", map.equals(confirmed));
verify();
resetFull();
// modify the HashMap created from the full map and make sure this
// change results in map.equals() to return false.
Iterator iter = confirmed.keySet().iterator();
iter.next();
iter.remove();
assertTrue("Different maps equal.", !map.equals(confirmed));
resetFull();
assertTrue("equals(null) returned true.", !map.equals(null));
assertTrue("equals(new Object()) returned true.",
!map.equals(new Object()));
verify();
}
/**
* Tests Map.get(Object)
**/
public void testMapGet() {
resetEmpty();
Object[] keys = getSampleKeys();
Object[] values = getSampleValues();
for (int i = 0; i < keys.length; i++) {
assertTrue("Empty map.get() should return null.",
map.get(keys[i]) == null);
}
verify();
resetFull();
for (int i = 0; i < keys.length; i++) {
assertEquals("Full map.get() should return value from mapping.",
values[i], map.get(keys[i]));
}
}
/**
* Tests Map.hashCode()
**/
public void testMapHashCode() {
resetEmpty();
assertTrue("Empty maps have different hashCodes.",
map.hashCode() == confirmed.hashCode());
resetFull();
assertTrue("Equal maps have different hashCodes.",
map.hashCode() == confirmed.hashCode());
}
/**
* Tests Map.toString(). Since the format of the string returned by the
* toString() method is not defined in the Map interface, there is no
* common way to test the results of the toString() method. Thereforce,
* it is encouraged that Map implementations override this test with one
* that checks the format matches any format defined in its API. This
* default implementation just verifies that the toString() method does
* not return null.
**/
public void testMapToString() {
resetEmpty();
assertTrue("Empty map toString() should not return null",
map.toString() != null);
verify();
resetFull();
assertTrue("Empty map toString() should not return null",
map.toString() != null);
verify();
}
/**
* Compare the current serialized form of the Map
* against the canonical version in CVS.
*/
public void testEmptyMapCompatibility() throws IOException, ClassNotFoundException {
/**
* Create canonical objects with this code
Map map = makeEmptyMap();
if (!(map instanceof Serializable)) return;
writeExternalFormToDisk((Serializable) map, getCanonicalEmptyCollectionName(map));
*/
// test to make sure the canonical form has been preserved
if (!(makeEmptyMap() instanceof Serializable)) return;
Map map = (Map) readExternalFormFromDisk(getCanonicalEmptyCollectionName(makeEmptyMap()));
assertTrue("Map is empty",map.isEmpty() == true);
}
/**
* Compare the current serialized form of the Map
* against the canonical version in CVS.
*/
public void testFullMapCompatibility() throws IOException, ClassNotFoundException {
/**
* Create canonical objects with this code
Map map = makeFullMap();
if (!(map instanceof Serializable)) return;
writeExternalFormToDisk((Serializable) map, getCanonicalFullCollectionName(map));
*/
// test to make sure the canonical form has been preserved
if (!(makeFullMap() instanceof Serializable)) return;
Map map = (Map) readExternalFormFromDisk(getCanonicalFullCollectionName(makeFullMap()));
assertEquals("Map is the right size",map.size(), getSampleKeys().length);
}
/**
* Tests Map.put(Object, Object)
**/
public void testMapPut() {
if (!isAddRemoveModifiable()) return;
resetEmpty();
Object[] keys = getSampleKeys();
Object[] values = getSampleValues();
Object[] newValues = getNewSampleValues();
for(int i = 0; i < keys.length; i++) {
Object o = map.put(keys[i], values[i]);
confirmed.put(keys[i], values[i]);
verify();
assertTrue("First map.put should return null", o == null);
assertTrue("Map should contain key after put",
map.containsKey(keys[i]));
assertTrue("Map should contain value after put",
map.containsValue(values[i]));
}
for(int i = 0; i < keys.length; i++) {
Object o = map.put(keys[i], newValues[i]);
confirmed.put(keys[i], newValues[i]);
verify();
assertEquals("Second map.put should return previous value",
values[i], o);
assertTrue("Map should still contain key after put",
map.containsKey(keys[i]));
assertTrue("Map should contain new value after put",
map.containsValue(newValues[i]));
// if duplicates are allowed, we're not guarunteed that the value
// no longer exists, so don't try checking that.
if(!useDuplicateValues()) {
assertTrue("Map should not contain old value after second put",
!map.containsValue(values[i]));
}
}
}
/**
* Tests Map.putAll(Collection)
**/
public void testMapPutAll() {
if (!isAddRemoveModifiable()) return;
resetEmpty();
Map m2 = makeFullMap();
map.putAll(m2);
confirmed.putAll(m2);
verify();
resetEmpty();
m2 = new HashMap();
Object[] keys = getSampleKeys();
Object[] values = getSampleValues();
for(int i = 0; i < keys.length; i++) {
m2.put(keys[i], values[i]);
}
map.putAll(m2);
confirmed.putAll(m2);
verify();
}
/**
* Tests Map.remove(Object)
**/
public void testMapRemove() {
if (!isAddRemoveModifiable()) return;
resetEmpty();
Object[] keys = getSampleKeys();
Object[] values = getSampleValues();
for(int i = 0; i < keys.length; i++) {
Object o = map.remove(keys[i]);
assertTrue("First map.remove should return null", o == null);
}
verify();
resetFull();
for(int i = 0; i < keys.length; i++) {
Object o = map.remove(keys[i]);
confirmed.remove(keys[i]);
verify();
assertEquals("map.remove with valid key should return value",
values[i], o);
}
Object[] other = getOtherKeys();
resetFull();
int size = map.size();
for (int i = 0; i < other.length; i++) {
Object o = map.remove(other[i]);
assertEquals("map.remove for nonexistent key should return null",
o, null);
assertEquals("map.remove for nonexistent key should not " +
"shrink map", size, map.size());
}
verify();
}
/**
* Utility methods to create an array of Map.Entry objects
* out of the given key and value arrays.equals test
* is done on the maps and their collection views; their size and
* isEmpty results are compared; their hashCodes are
* compared; and containsAll tests are run on the
* collection views.
*/
protected void verify() {
verifyMap();
verifyEntrySet();
verifyKeySet();
verifyValues();
}
protected void verifyMap() {
int size = confirmed.size();
boolean empty = confirmed.isEmpty();
assertEquals("Map should be same size as HashMap",
size, map.size());
assertEquals("Map should be empty if HashMap is",
empty, map.isEmpty());
assertEquals("hashCodes should be the same",
confirmed.hashCode(), map.hashCode());
// this fails for LRUMap because confirmed.equals() somehow modifies
// map, causing concurrent modification exceptions.
//assertEquals("Map should still equal HashMap", confirmed, map);
// this works though and performs the same verification:
assertTrue("Map should still equal HashMap", map.equals(confirmed));
// TODO: this should really be rexamined to figure out why LRU map
// behaves like it does (the equals shouldn't modify since all accesses
// by the confirmed collection should be through an iterator, thus not
// causing LRUMap to change).
}
protected void verifyEntrySet() {
int size = confirmed.size();
boolean empty = confirmed.isEmpty();
assertEquals("entrySet should be same size as HashMap's",
size, entrySet.size());
assertEquals("entrySet should be empty if HashMap is",
empty, entrySet.isEmpty());
assertTrue("entrySet should contain all HashMap's elements",
entrySet.containsAll(confirmed.entrySet()));
assertEquals("entrySet hashCodes should be the same",
confirmed.entrySet().hashCode(), entrySet.hashCode());
assertEquals("Map's entry set should still equal HashMap's",
confirmed.entrySet(), entrySet);
}
protected void verifyKeySet() {
int size = confirmed.size();
boolean empty = confirmed.isEmpty();
assertEquals("keySet should be same size as HashMap's",
size, keySet.size());
assertEquals("keySet should be empty if HashMap is",
empty, keySet.isEmpty());
assertTrue("keySet should contain all HashMap's elements",
keySet.containsAll(confirmed.keySet()));
assertEquals("keySet hashCodes should be the same",
confirmed.keySet().hashCode(), keySet.hashCode());
assertEquals("Map's key set should still equal HashMap's",
confirmed.keySet(), keySet);
}
protected void verifyValues() {
Bag bag1 = new HashBag(confirmed.values());
Bag bag2 = new HashBag(values);
int size = confirmed.size();
boolean empty = confirmed.isEmpty();
assertEquals("values should be same size as HashMap's",
size, values.size());
assertEquals("values should be empty if HashMap is",
empty, values.isEmpty());
assertTrue("values should contain all HashMap's elements",
values.containsAll(confirmed.values()));
assertEquals("Map's values should still equal HashMap's",
bag1, bag2);
}
/**
* Erases any leftover instance variables by setting them to null.
*/
protected void tearDown() {
map = null;
keySet = null;
entrySet = null;
values = null;
confirmed = null;
}
}
libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/LocalTestNode.java 0100644 0001750 0001750 00000005321 10055172376 031665 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
/**
* Class LocalTestNode
*
* a helper class for TestDoubleOrderedMap
*
* @author Marc Johnson (marcj at users dot sourceforge dot net)
*/
class LocalTestNode implements Comparable {
private Comparable key;
private Comparable value;
/**
* construct a LocalTestNode
*
* @param key value used to create the key and value
*/
LocalTestNode(final int key) {
this.key = new Integer(key);
this.value = String.valueOf(key);
}
/**
* @param key the unique key associated with the current node.
*/
void setKey(Comparable key) {
this.key = key;
}
/**
* @return the unique key associated with the current node
*/
Comparable getKey() {
return key;
}
/**
* @param value the unique value associated with the current node.
*/
void setValue(Comparable value) {
this.value = value;
}
/**
* @return the unique value associated with the current node
*/
Comparable getValue() {
return value;
}
/**
* Method compareTo
*
* @param o
*
* @return
*/
public int compareTo(Object o) {
LocalTestNode other = (LocalTestNode) o;
int rval = getKey().compareTo(other.getKey());
if (rval == 0) {
rval = getValue().compareTo(other.getValue());
}
return rval;
}
/**
* Method equals
*
* @param o
*
* @return true if equal
*/
public boolean equals(Object o) {
if (o == null) {
return false;
}
if (!(o.getClass().equals(this.getClass()))) {
return false;
}
LocalTestNode node = (LocalTestNode) o;
return (getKey().equals(node.getKey())
&& getValue().equals(node.getValue()));
}
/**
* @return hash code
*/
public int hashCode() {
return getKey().hashCode() ^ getValue().hashCode();
}
}
././@LongLink 0000000 0000000 0000000 00000000151 00000000000 011562 L ustar root root libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestDoubleOrderedMap.java libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestDoubleOrderedMap 0100644 0001750 0001750 00000224563 10055172376 032275 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import junit.framework.*;
import java.util.*;
/**
* Class TestDoubleOrderedMap
*
* Test cases for DoubleOrderedMap. This class cannot
* implement TestMap.SupportsPut, because it is a special
* Map that does not support duplicate keys, duplicate
* values, or null values.
*
* @author Marc Johnson (marcj at users dot sourceforge dot net)
*/
public class TestDoubleOrderedMap extends TestMap {
/**
* constructor
*
* @param name
*/
public TestDoubleOrderedMap(final String name) {
super(name);
}
/**
* create a suite of the tests in this class
*
* @return the test suite
*/
public static Test suite() {
return BulkTest.makeSuite(TestDoubleOrderedMap.class);
}
/**
* The default comparator in double ordered map does not allow null keys.
**/
public boolean useNullKey() {
return false;
}
/**
* The default comparator in double ordered map does not allow null keys,
* and values are keys in this map.
**/
public boolean useNullValue() {
return false;
}
/**
* Double ordered map does not support duplicate values
**/
public boolean useDuplicateValues() {
return false;
}
public Map makeEmptyMap() {
return new DoubleOrderedMap();
}
public Map makeMap() {
return new DoubleOrderedMap();
}
/**
* test size() method
*/
public void testSize() {
Map m = makeMap();
assertEquals(0, m.size());
LocalTestNode nodes[] = makeLocalNodes();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k].getValue());
assertEquals(k + 1, m.size());
}
int count = m.size();
for (int k = 0; k < nodes.length; k++) {
m.remove(nodes[k].getKey());
--count;
assertEquals(count, m.size());
// failed remove should not affect size
m.remove(nodes[k].getKey());
assertEquals(count, m.size());
}
}
/**
* test IsEmpty() method
*/
public void testIsEmpty() {
Map m = makeMap();
assertTrue(m.isEmpty());
LocalTestNode nodes[] = makeLocalNodes();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k].getValue());
assertTrue(!m.isEmpty());
}
int count = m.size();
for (int k = 0; k < nodes.length; k++) {
m.remove(nodes[k].getKey());
--count;
if (count == 0) {
assertTrue(m.isEmpty());
} else {
assertTrue(!m.isEmpty());
}
// failed remove should not affect emptiness
m.remove(nodes[k].getKey());
if (count == 0) {
assertTrue(m.isEmpty());
} else {
assertTrue(!m.isEmpty());
}
}
}
/**
* test containsKey() method
*/
public void testContainsKey() {
Map m = makeMap();
try {
m.containsKey(new Object());
fail("should have caught ClassCastException");
} catch (ClassCastException ignored) {}
try {
m.containsKey(null);
fail("should have caught NullPointerException");
} catch (NullPointerException ignored) {}
assertTrue(!m.containsKey("foo"));
LocalTestNode nodes[] = makeLocalNodes();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
assertTrue(m.containsKey(nodes[k].getKey()));
}
assertTrue(!m.containsKey(new Integer(-1)));
try {
m.containsKey("foo");
fail("Should have caught ClassCastException");
} catch (ClassCastException ignored) {}
for (int k = 0; k < nodes.length; k++) {
m.remove(nodes[k].getKey());
assertTrue(!m.containsKey(nodes[k].getKey()));
}
}
/**
* test containsValue() method
*/
public void testContainsValue() {
Map m = (DoubleOrderedMap) makeMap();
LocalTestNode nodes[] = makeLocalNodes();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
assertTrue(m.containsValue(nodes[k]));
}
for (int k = 0; k < nodes.length; k++) {
m.remove(nodes[k].getKey());
assertTrue(!m.containsValue(nodes[k]));
}
}
/**
* test get() method
*/
public void testGet() {
Map m = makeMap();
try {
m.get(new Object());
fail("should have caught ClassCastException");
} catch (ClassCastException ignored) {}
try {
m.get(null);
fail("should have caught NullPointerException");
} catch (NullPointerException ignored) {}
assertNull(m.get("foo"));
LocalTestNode nodes[] = makeLocalNodes();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
assertSame(m.get(nodes[k].getKey()), nodes[k]);
}
assertNull(m.get(new Integer(-1)));
try {
m.get("foo");
fail("Should have caught ClassCastException");
} catch (ClassCastException ignored) {}
for (int k = 0; k < nodes.length; k++) {
assertNotNull(m.get(nodes[k].getKey()));
m.remove(nodes[k].getKey());
assertNull(m.get(nodes[k].getKey()));
}
}
/**
* test put() method
*/
public void testPut() {
Map m = makeMap();
try {
m.put(new Object(), "foo");
fail("should have caught ClassCastException");
} catch (ClassCastException ignored) {}
try {
m.put(null, "foo");
fail("should have caught NullPointerException");
} catch (NullPointerException ignored) {}
try {
m.put("foo", null);
fail("should have caught NullPointerException");
} catch (NullPointerException ignored) {}
try {
m.put("foo", new Object());
fail("should have caught ClassCastException");
} catch (ClassCastException ignored) {}
LocalTestNode[] nodes = makeLocalNodes();
for (int k = 0; k < nodes.length; k++) {
assertNull(m.put(nodes[k].getKey(), nodes[k].getValue()));
try {
m.put(nodes[k].getKey(), "foo");
} catch (IllegalArgumentException ignored) {}
}
}
/**
* test remove() method
*/
public void testRemove() {
DoubleOrderedMap m = (DoubleOrderedMap) makeMap();
LocalTestNode nodes[] = makeLocalNodes();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
try {
m.remove(null);
fail("should have caught NullPointerException");
} catch (NullPointerException ignored) {}
try {
m.remove(new Object());
fail("should have caught ClassCastException");
} catch (ClassCastException ignored) {}
assertNull(m.remove(new Integer(-1)));
try {
m.remove("foo");
fail("should have caught ClassCastException");
} catch (ClassCastException ignored) {}
for (int k = 0; k < nodes.length; k += 2) {
Comparable key = nodes[k].getKey();
assertNotNull(m.get(key));
assertSame(nodes[k], m.remove(key));
assertNull(m.remove(key));
assertNull(m.get(key));
}
for (int k = 1; k < nodes.length; k += 2) {
Comparable key = nodes[k].getKey();
assertNotNull(m.get(key));
assertSame(nodes[k], m.remove(key));
assertNull(m.remove(key));
assertNull(m.get(key));
}
assertTrue(m.isEmpty());
}
/**
* Method testPutAll
*/
public void testPutAll() {
Map m = (DoubleOrderedMap) makeMap();
LocalTestNode nodes[] = makeLocalNodes();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
Map m1 = new HashMap();
m1.put(null, "foo");
try {
m.putAll(m1);
fail("Should have caught NullPointerException");
} catch (NullPointerException ignored) {}
m1 = new HashMap();
m1.put(new Object(), "bar");
try {
m.putAll(m1);
fail("Should have caught ClassCastException");
} catch (ClassCastException ignored) {}
m1 = new HashMap();
m1.put("fubar", null);
try {
m.putAll(m1);
fail("Should have caught NullPointerException");
} catch (NullPointerException ignored) {}
m1 = new HashMap();
m1.put("fubar", new Object());
try {
m.putAll(m1);
fail("Should have caught ClassCastException");
} catch (ClassCastException ignored) {}
assertEquals(nodes.length, m.size());
m = (DoubleOrderedMap) makeMap();
m1 = new HashMap();
for (int k = 0; k < nodes.length; k++) {
m1.put(nodes[k].getKey(), nodes[k].getValue());
}
m.putAll(m1);
assertEquals(nodes.length, m.size());
for (int k = 0; k < nodes.length; k++) {
assertSame(nodes[k].getValue(), m.get(nodes[k].getKey()));
}
}
/**
* test clear() method
*/
public void testClear() {
Map m = (DoubleOrderedMap) makeMap();
LocalTestNode nodes[] = makeLocalNodes();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k].getValue());
assertTrue(!m.isEmpty());
}
assertTrue(!m.isEmpty());
for (int k = 0; k < nodes.length; k++) {
assertTrue(m.containsKey(nodes[k].getKey()));
assertTrue(m.containsValue(nodes[k].getValue()));
}
m.clear();
assertTrue(m.isEmpty());
for (int k = 0; k < nodes.length; k++) {
assertTrue(!m.containsKey(nodes[k].getKey()));
assertTrue(!m.containsValue(nodes[k].getValue()));
}
}
/**
* test keySet() method
*/
public void testKeySet() {
testKeySet((DoubleOrderedMap) makeMap());
Map m = (DoubleOrderedMap) makeMap();
LocalTestNode nodes[] = makeLocalNodes();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
testKeySet(m);
m = (DoubleOrderedMap) makeMap();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
int count = m.size();
for (Iterator iter = m.keySet().iterator(); iter.hasNext(); ) {
iter.next();
iter.remove();
--count;
assertEquals(count, m.size());
}
assertTrue(m.isEmpty());
m = (DoubleOrderedMap) makeMap();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
Set s = m.keySet();
try {
s.remove(null);
fail("should have caught NullPointerException");
} catch (NullPointerException ignored) {}
try {
s.remove(new Object());
fail("should have caught ClassCastException");
} catch (ClassCastException ignored) {}
for (int k = 0; k < nodes.length; k++) {
Comparable key = nodes[k].getKey();
assertTrue(s.remove(key));
assertTrue(!s.contains(key));
assertTrue(!m.containsKey(key));
assertTrue(!m.containsValue(nodes[k]));
}
assertTrue(m.isEmpty());
m = (DoubleOrderedMap) makeMap();
Collection c1 = new LinkedList();
Collection c2 = new LinkedList();
c2.add(new Integer(-99));
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
c1.add(nodes[k].getKey());
c2.add(nodes[k].getKey());
}
assertTrue(m.keySet().containsAll(c1));
assertTrue(!m.keySet().containsAll(c2));
m = (DoubleOrderedMap) makeMap();
c1 = new LinkedList();
c1.add(new Integer(-55));
try {
m.keySet().addAll(c1);
fail("should have caught exception of addAll()");
} catch (UnsupportedOperationException ignored) {}
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
c1.add(nodes[k].getKey());
}
assertTrue(!m.keySet().retainAll(c1));
assertEquals(nodes.length, m.size());
m = (DoubleOrderedMap) makeMap();
c1 = new LinkedList();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
if (k % 2 == 1) {
c1.add(nodes[k].getKey());
}
}
assertTrue(m.keySet().retainAll(c1));
assertEquals(nodes.length / 2, m.size());
m = (DoubleOrderedMap) makeMap();
c1 = new LinkedList();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
assertTrue(m.keySet().retainAll(c1));
assertEquals(0, m.size());
m = (DoubleOrderedMap) makeMap();
c1 = new LinkedList();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
assertTrue(!m.keySet().removeAll(c1));
assertEquals(nodes.length, m.size());
m = (DoubleOrderedMap) makeMap();
c1 = new LinkedList();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
if (k % 2 == 0) {
c1.add(nodes[k].getKey());
}
}
assertTrue(m.keySet().removeAll(c1));
assertEquals(nodes.length / 2, m.size());
m = (DoubleOrderedMap) makeMap();
c1 = new LinkedList();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
c1.add(nodes[k].getKey());
}
assertTrue(m.keySet().removeAll(c1));
assertEquals(0, m.size());
m = (DoubleOrderedMap) makeMap();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
m.keySet().clear();
assertEquals(0, m.size());
}
/**
* test values() method
*/
public void testValues() {
testValues((DoubleOrderedMap) makeMap());
Map m = (DoubleOrderedMap) makeMap();
LocalTestNode nodes[] = makeLocalNodes();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
testValues(m);
m = (DoubleOrderedMap) makeMap();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
int count = m.size();
for (Iterator iter = m.values().iterator(); iter.hasNext(); ) {
iter.next();
iter.remove();
--count;
assertEquals(count, m.size());
}
assertTrue(m.isEmpty());
m = (DoubleOrderedMap) makeMap();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
count = m.size();
Collection s = m.values();
for (int k = 0; k < count; k++) {
assertTrue(s.remove(nodes[k]));
assertTrue(!s.contains(nodes[k]));
assertTrue(!m.containsKey(nodes[k].getKey()));
assertTrue(!m.containsValue(nodes[k]));
}
assertTrue(m.isEmpty());
m = (DoubleOrderedMap) makeMap();
Collection c1 = new LinkedList();
Collection c2 = new LinkedList();
c2.add(new LocalTestNode(-123));
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
c1.add(nodes[k]);
c2.add(nodes[k]);
}
assertTrue(m.values().containsAll(c1));
assertTrue(!m.values().containsAll(c2));
m = (DoubleOrderedMap) makeMap();
c1 = new LinkedList();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
c1.add(nodes[k]);
}
try {
m.values().addAll(c1);
fail("should have caught exception of addAll()");
} catch (UnsupportedOperationException ignored) {}
m = (DoubleOrderedMap) makeMap();
c1 = new LinkedList();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
c1.add(nodes[k]);
}
assertTrue(!m.values().retainAll(c1));
assertEquals(nodes.length, m.size());
m = (DoubleOrderedMap) makeMap();
c1 = new LinkedList();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
if (k % 2 == 1) {
c1.add(nodes[k]);
}
}
assertTrue(m.values().retainAll(c1));
assertEquals(nodes.length / 2, m.size());
m = (DoubleOrderedMap) makeMap();
c1 = new LinkedList();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
assertTrue(m.values().retainAll(c1));
assertEquals(0, m.size());
m = (DoubleOrderedMap) makeMap();
c1 = new LinkedList();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
assertTrue(!m.values().removeAll(c1));
assertEquals(nodes.length, m.size());
m = (DoubleOrderedMap) makeMap();
c1 = new LinkedList();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
if (k % 2 == 0) {
c1.add(nodes[k]);
}
}
assertTrue(m.values().removeAll(c1));
assertEquals(nodes.length / 2, m.size());
m = (DoubleOrderedMap) makeMap();
c1 = new LinkedList();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
c1.add(nodes[k]);
}
assertTrue(m.values().removeAll(c1));
assertEquals(0, m.size());
m = (DoubleOrderedMap) makeMap();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
m.values().clear();
assertEquals(0, m.size());
}
/**
* test entrySet() method
*/
public void testEntrySet() {
testEntrySet((DoubleOrderedMap) makeMap());
Map m = (DoubleOrderedMap) makeMap();
LocalTestNode nodes[] = makeLocalNodes();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
testEntrySet(m);
m = (DoubleOrderedMap) makeMap();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
try {
((Map.Entry) m.entrySet().iterator().next())
.setValue(new LocalTestNode(-1));
fail("Should have caught UnsupportedOperationException");
} catch (UnsupportedOperationException ignored) {}
int count = m.size();
for (Iterator iter = m.entrySet().iterator(); iter.hasNext(); ) {
iter.next();
iter.remove();
--count;
assertEquals(count, m.size());
}
assertTrue(m.isEmpty());
m = (DoubleOrderedMap) makeMap();
Collection c1 = new LinkedList();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
c1.add(nodes[k].getKey());
}
try {
m.entrySet().addAll(c1);
fail("should have caught exception of addAll()");
} catch (UnsupportedOperationException ignored) {}
m = (DoubleOrderedMap) makeMap();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
m.entrySet().clear();
assertEquals(0, m.size());
m = (DoubleOrderedMap) makeMap();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
int x = 0;
for (Iterator iter = m.entrySet().iterator(); iter.hasNext(); ) {
Map.Entry entry = (Map.Entry) iter.next();
assertSame(entry.getKey(), nodes[x].getKey());
assertSame(entry.getValue(), nodes[x]);
x++;
}
}
/**
* Method testEquals
*/
public void testEquals() {
Map m = (DoubleOrderedMap) makeMap();
LocalTestNode nodes[] = makeLocalNodes();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
assertTrue(!m.equals(null));
assertEquals(m, m);
Map m1 = new HashMap();
for (int k = 0; k < nodes.length; k++) {
m1.put(nodes[k].getKey(), nodes[k]);
}
assertEquals(m, m1);
m1 = (DoubleOrderedMap) makeMap();
for (int k = 0; k < (nodes.length - 1); k++) {
m1.put(nodes[k].getKey(), nodes[k]);
}
assertTrue(!m.equals(m1));
m1 = (DoubleOrderedMap) makeMap();
for (int k = 0; k < nodes.length; k++) {
m1.put(nodes[k].getKey(), nodes[k]);
}
LocalTestNode node1 = new LocalTestNode(-1000);
m1.put(node1.getKey(), node1);
assertTrue(!m.equals(m1));
m1 = (DoubleOrderedMap) makeMap();
for (int k = 0; k < nodes.length; k++) {
m1.put(nodes[k].getKey(), nodes[nodes.length - (k + 1)]);
}
assertTrue(!m.equals(m1));
m1 = (DoubleOrderedMap) makeMap();
for (int k = nodes.length - 1; k >= 0; k--) {
m1.put(nodes[k].getKey(), nodes[k]);
}
assertEquals(m, m1);
}
/**
* test hashCode() method
*/
public void testHashCode() {
Map m = (DoubleOrderedMap) makeMap();
LocalTestNode nodes[] = makeLocalNodes();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
Map m1 = (DoubleOrderedMap) makeMap();
for (int k = nodes.length - 1; k >= 0; k--) {
m1.put(nodes[k].getKey(), nodes[k]);
}
assertEquals(m.hashCode(), m1.hashCode());
}
/**
* test constructors
*/
public void testConstructors() {
DoubleOrderedMap m = (DoubleOrderedMap) makeMap();
assertTrue(m.isEmpty());
DoubleOrderedMap m1 = new DoubleOrderedMap(m);
assertTrue(m1.isEmpty());
m1 = (DoubleOrderedMap) makeMap();
LocalTestNode nodes[] = makeLocalNodes();
for (int k = 0; k < nodes.length; k++) {
m1.put(nodes[k].getKey(), nodes[k]);
}
m = new DoubleOrderedMap(m1);
assertEquals(m, m1);
Map m2 = new HashMap();
for (int k = 0; k < nodes.length; k++) {
m2.put(nodes[k].getKey(), nodes[k]);
}
m = new DoubleOrderedMap(m2);
assertEquals(m, m2);
// reject duplicated values
m2 = new HashMap();
m2.put("1", "foo");
m2.put("2", "foo");
try {
m = new DoubleOrderedMap(m2);
fail("Should have caught IllegalArgumentException");
} catch (IllegalArgumentException ignored) {}
// reject null values
m2.put("2", null);
try {
m = new DoubleOrderedMap(m2);
fail("Should have caught NullPointerException");
} catch (NullPointerException ignored) {}
// reject non-Comparable values
m2.put("2", new Object());
try {
m = new DoubleOrderedMap(m2);
fail("Should have caught ClassCastException");
} catch (ClassCastException ignored) {}
// reject incompatible values
m2.put("2", new Integer(2));
try {
m = new DoubleOrderedMap(m2);
fail("Should have caught ClassCastException");
} catch (ClassCastException ignored) {}
// reject incompatible keys
m2.remove("2");
m2.put(new Integer(2), "bad key");
try {
m = new DoubleOrderedMap(m2);
fail("Should have caught ClassCastException");
} catch (ClassCastException ignored) {}
// reject non-Comparable keys
m2.clear();
m2.put("1", "foo");
m2.put(new Object(), "bad key");
try {
m = new DoubleOrderedMap(m2);
fail("Should have caught ClassCastException");
} catch (ClassCastException ignored) {}
}
/**
* test getKeyForValue() method
*/
public void testGetKeyForValue() {
DoubleOrderedMap m = (DoubleOrderedMap) makeMap();
try {
m.getKeyForValue(new Object());
fail("should have caught ClassCastException");
} catch (ClassCastException ignored) {}
try {
m.getKeyForValue(null);
fail("should have caught NullPointerException");
} catch (NullPointerException ignored) {}
assertNull(m.getKeyForValue("foo"));
LocalTestNode nodes[] = makeLocalNodes();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
assertSame(m.getKeyForValue(nodes[k]), nodes[k].getKey());
}
assertNull(m.getKeyForValue(new LocalTestNode(-1)));
try {
m.getKeyForValue("foo");
fail("Should have caught ClassCastException");
} catch (ClassCastException ignored) {}
for (int k = 0; k < nodes.length; k++) {
assertNotNull(m.getKeyForValue(nodes[k]));
m.remove(nodes[k].getKey());
assertNull(m.getKeyForValue(nodes[k]));
}
}
/**
* test removeValue() method
*/
public void testRemoveValue() {
DoubleOrderedMap m = (DoubleOrderedMap) makeMap();
LocalTestNode nodes[] = makeLocalNodes();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
try {
m.removeValue(null);
fail("should have caught NullPointerException");
} catch (NullPointerException ignored) {}
try {
m.removeValue(new Object());
fail("should have caught ClassCastException");
} catch (ClassCastException ignored) {}
assertNull(m.remove(new Integer(-1)));
try {
m.removeValue("foo");
fail("should have caught ClassCastException");
} catch (ClassCastException ignored) {}
for (int k = 0; k < nodes.length; k += 2) {
assertNotNull(m.getKeyForValue(nodes[k]));
assertSame(nodes[k].getKey(), m.removeValue(nodes[k]));
assertNull(m.removeValue(nodes[k]));
assertNull(m.getKeyForValue(nodes[k]));
}
for (int k = 1; k < nodes.length; k += 2) {
assertNotNull(m.getKeyForValue(nodes[k]));
assertSame(nodes[k].getKey(), m.removeValue(nodes[k]));
assertNull(m.removeValue(nodes[k]));
assertNull(m.getKeyForValue(nodes[k]));
}
assertTrue(m.isEmpty());
}
/**
* test entrySetByValue() method
*/
public void testEntrySetByValue() {
testEntrySetByValue((DoubleOrderedMap) makeMap());
DoubleOrderedMap m = (DoubleOrderedMap) makeMap();
LocalTestNode nodes[] = makeLocalNodes();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
testEntrySetByValue(m);
m = (DoubleOrderedMap) makeMap();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
try {
((Map.Entry) m.entrySetByValue().iterator().next())
.setValue(new LocalTestNode(-1));
fail("Should have caught UnsupportedOperationException");
} catch (UnsupportedOperationException ignored) {}
int count = m.size();
for (Iterator iter = m.entrySetByValue().iterator();
iter.hasNext(); ) {
iter.next();
iter.remove();
--count;
assertEquals(count, m.size());
}
assertTrue(m.isEmpty());
m = (DoubleOrderedMap) makeMap();
Collection c1 = new LinkedList();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
c1.add(nodes[k].getKey());
}
try {
m.entrySetByValue().addAll(c1);
fail("should have caught exception of addAll()");
} catch (UnsupportedOperationException ignored) {}
m = (DoubleOrderedMap) makeMap();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
m.entrySetByValue().clear();
assertEquals(0, m.size());
m = (DoubleOrderedMap) makeMap();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
int x = 0;
for (Iterator iter = m.entrySetByValue().iterator();
iter.hasNext(); ) {
Map.Entry entry = (Map.Entry) iter.next();
assertSame(entry.getKey(), nodes[x].getKey());
assertSame(entry.getValue(), nodes[x]);
x++;
}
}
/**
* test keySetByValue() method
*/
public void testKeySetByValue() {
testKeySetByValue((DoubleOrderedMap) makeMap());
DoubleOrderedMap m = (DoubleOrderedMap) makeMap();
LocalTestNode nodes[] = makeLocalNodes();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
testKeySetByValue(m);
m = (DoubleOrderedMap) makeMap();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
int count = m.size();
for (Iterator iter = m.keySetByValue().iterator(); iter.hasNext(); )
{
iter.next();
iter.remove();
--count;
assertEquals(count, m.size());
}
assertTrue(m.isEmpty());
m = (DoubleOrderedMap) makeMap();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
Set s = m.keySetByValue();
try {
s.remove(null);
fail("should have caught NullPointerException");
} catch (NullPointerException ignored) {}
try {
s.remove(new Object());
fail("should have caught ClassCastException");
} catch (ClassCastException ignored) {}
for (int k = 0; k < nodes.length; k++) {
Comparable key = nodes[k].getKey();
assertTrue(s.remove(key));
assertTrue(!s.contains(key));
assertTrue(!m.containsKey(key));
assertTrue(!m.containsValue(nodes[k]));
}
assertTrue(m.isEmpty());
m = (DoubleOrderedMap) makeMap();
Collection c1 = new LinkedList();
Collection c2 = new LinkedList();
c2.add(new Integer(-99));
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
c1.add(nodes[k].getKey());
c2.add(nodes[k].getKey());
}
assertTrue(m.keySetByValue().containsAll(c1));
assertTrue(!m.keySetByValue().containsAll(c2));
m = (DoubleOrderedMap) makeMap();
c1 = new LinkedList();
c1.add(new Integer(-55));
try {
m.keySetByValue().addAll(c1);
fail("should have caught exception of addAll()");
} catch (UnsupportedOperationException ignored) {}
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
c1.add(nodes[k].getKey());
}
assertTrue(!m.keySetByValue().retainAll(c1));
assertEquals(nodes.length, m.size());
m = (DoubleOrderedMap) makeMap();
c1 = new LinkedList();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
if (k % 2 == 1) {
c1.add(nodes[k].getKey());
}
}
assertTrue(m.keySetByValue().retainAll(c1));
assertEquals(nodes.length / 2, m.size());
m = (DoubleOrderedMap) makeMap();
c1 = new LinkedList();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
assertTrue(m.keySetByValue().retainAll(c1));
assertEquals(0, m.size());
m = (DoubleOrderedMap) makeMap();
c1 = new LinkedList();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
assertTrue(!m.keySetByValue().removeAll(c1));
assertEquals(nodes.length, m.size());
m = (DoubleOrderedMap) makeMap();
c1 = new LinkedList();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
if (k % 2 == 0) {
c1.add(nodes[k].getKey());
}
}
assertTrue(m.keySetByValue().removeAll(c1));
assertEquals(nodes.length / 2, m.size());
m = (DoubleOrderedMap) makeMap();
c1 = new LinkedList();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
c1.add(nodes[k].getKey());
}
assertTrue(m.keySetByValue().removeAll(c1));
assertEquals(0, m.size());
m = (DoubleOrderedMap) makeMap();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
m.keySetByValue().clear();
assertEquals(0, m.size());
}
/**
* test valuesByValue() method
*/
public void testValuesByValue() {
testValuesByValue((DoubleOrderedMap) makeMap());
DoubleOrderedMap m = (DoubleOrderedMap) makeMap();
LocalTestNode nodes[] = makeLocalNodes();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
testValuesByValue(m);
m = (DoubleOrderedMap) makeMap();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
int count = m.size();
for (Iterator iter = m.valuesByValue().iterator(); iter.hasNext(); )
{
iter.next();
iter.remove();
--count;
assertEquals(count, m.size());
}
assertTrue(m.isEmpty());
m = (DoubleOrderedMap) makeMap();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
count = m.size();
Collection s = m.valuesByValue();
for (int k = 0; k < count; k++) {
assertTrue(s.remove(nodes[k]));
assertTrue(!s.contains(nodes[k]));
assertTrue(!m.containsKey(nodes[k].getKey()));
assertTrue(!m.containsValue(nodes[k]));
}
assertTrue(m.isEmpty());
m = (DoubleOrderedMap) makeMap();
Collection c1 = new LinkedList();
Collection c2 = new LinkedList();
c2.add(new LocalTestNode(-123));
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
c1.add(nodes[k]);
c2.add(nodes[k]);
}
assertTrue(m.valuesByValue().containsAll(c1));
assertTrue(!m.valuesByValue().containsAll(c2));
m = (DoubleOrderedMap) makeMap();
c1 = new LinkedList();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
c1.add(nodes[k]);
}
try {
m.valuesByValue().addAll(c1);
fail("should have caught exception of addAll()");
} catch (UnsupportedOperationException ignored) {}
m = (DoubleOrderedMap) makeMap();
c1 = new LinkedList();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
c1.add(nodes[k]);
}
assertTrue(!m.valuesByValue().retainAll(c1));
assertEquals(nodes.length, m.size());
m = (DoubleOrderedMap) makeMap();
c1 = new LinkedList();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
if (k % 2 == 1) {
c1.add(nodes[k]);
}
}
assertTrue(m.valuesByValue().retainAll(c1));
assertEquals(nodes.length / 2, m.size());
m = (DoubleOrderedMap) makeMap();
c1 = new LinkedList();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
assertTrue(m.valuesByValue().retainAll(c1));
assertEquals(0, m.size());
m = (DoubleOrderedMap) makeMap();
c1 = new LinkedList();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
assertTrue(!m.valuesByValue().removeAll(c1));
assertEquals(nodes.length, m.size());
m = (DoubleOrderedMap) makeMap();
c1 = new LinkedList();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
if (k % 2 == 0) {
c1.add(nodes[k]);
}
}
assertTrue(m.valuesByValue().removeAll(c1));
assertEquals(nodes.length / 2, m.size());
m = (DoubleOrderedMap) makeMap();
c1 = new LinkedList();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
c1.add(nodes[k]);
}
assertTrue(m.valuesByValue().removeAll(c1));
assertEquals(0, m.size());
m = (DoubleOrderedMap) makeMap();
for (int k = 0; k < nodes.length; k++) {
m.put(nodes[k].getKey(), nodes[k]);
}
m.valuesByValue().clear();
assertEquals(0, m.size());
}
/* ********** START helper methods ********** */
private void testKeySet(final Map m) {
Set s = m.keySet();
assertEquals(m.size(), s.size());
assertEquals(m.isEmpty(), s.isEmpty());
LocalTestNode node = new LocalTestNode(-1);
m.put(node.getKey(), node);
assertTrue(s.contains(node.getKey()));
assertEquals(m.size(), s.size());
assertEquals(m.isEmpty(), s.isEmpty());
m.remove(node.getKey());
assertTrue(!s.contains(node.getKey()));
assertEquals(m.size(), s.size());
assertEquals(m.isEmpty(), s.isEmpty());
try {
s.contains(null);
fail("should have caught NullPointerException");
} catch (NullPointerException ignored) {}
try {
s.contains(new Object());
fail("should have caught ClassCastException");
} catch (ClassCastException ignored) {}
for (int k = 0; k < m.size(); k++) {
assertTrue(s.contains(new Integer(k)));
}
int count = 0;
for (Iterator iter = s.iterator(); iter.hasNext(); ) {
iter.next();
++count;
}
assertEquals(count, s.size());
// force the map to have some content
m.put(node.getKey(), node);
Iterator iter = m.keySet().iterator();
LocalTestNode node2 = new LocalTestNode(-2);
m.put(node2.getKey(), node2);
try {
iter.next();
fail("next() should have thrown an exception after a put");
} catch (ConcurrentModificationException ignored) {}
m.remove(node2.getKey());
iter = s.iterator();
m.remove(node.getKey());
try {
iter.next();
fail("next() should have thrown an exception after a Map remove");
} catch (ConcurrentModificationException ignored) {}
m.put(node.getKey(), node);
iter = s.iterator();
s.remove(node.getKey());
try {
iter.next();
fail("next() should have thrown an exception after a Set remove");
} catch (ConcurrentModificationException ignored) {}
iter = s.iterator();
count = 0;
boolean terminated = false;
try {
while (true) {
iter.next();
++count;
}
} catch (NoSuchElementException ignored) {
terminated = true;
}
assertTrue(terminated);
assertEquals(m.size(), count);
iter = s.iterator();
try {
iter.remove();
fail("Should have thrown exception");
} catch (IllegalStateException ignored) {}
m.put(node.getKey(), node);
iter = s.iterator();
iter.next();
m.put(node2.getKey(), node2);
try {
iter.remove();
fail("should have thrown exception");
} catch (ConcurrentModificationException ignored) {}
Iterator iter2 = s.iterator();
iter2.next();
LocalTestNode node3 = new LocalTestNode(-3);
m.put(node3.getKey(), node3);
try {
iter2.remove();
fail("should have thrown exception");
} catch (ConcurrentModificationException ignored) {}
int removalCount = 0;
for (iter = s.iterator(); iter.hasNext(); ) {
if (iter.next().equals(node.getKey())) {
try {
iter.remove();
++removalCount;
iter.remove();
fail("2nd remove should have failed");
} catch (IllegalStateException ignored) {
assertEquals(1, removalCount);
}
}
}
assertEquals(1, removalCount);
assertTrue(!s.contains(node.getKey()));
removalCount = 0;
m.put(node.getKey(), node);
Object[] a1 = s.toArray();
assertEquals(s.size(), a1.length);
if (a1.length > 1) {
Comparable first = (Comparable) a1[0];
for (int k = 1; k < a1.length; k++) {
Comparable second = (Comparable) a1[k];
assertTrue(first.compareTo(second) < 0);
first = second;
}
iter = s.iterator();
first = (Comparable) iter.next();
for (; iter.hasNext(); ) {
Comparable second = (Comparable) iter.next();
assertTrue(first.compareTo(second) < 0);
first = second;
}
}
try {
String array2[] = (String[]) s.toArray(new String[0]);
if (s.size() != 0) {
fail("should have caught exception creating an invalid array");
}
} catch (ArrayStoreException ignored) {}
Comparable array2[] = (Comparable[]) s.toArray(new Comparable[0]);
Integer array3[] = (Integer[]) s.toArray(new Integer[s.size()]);
if (array3.length > 1) {
Integer first = array3[0];
for (int k = 1; k < array3.length; k++) {
Integer second = array3[k];
assertTrue(first.compareTo(second) < 0);
first = second;
}
}
try {
s.add("foo");
fail("should have thrown an exception");
} catch (UnsupportedOperationException ignored) {}
assertTrue(!s.equals(null));
assertEquals(s, s);
Set hs = new HashSet(s);
assertEquals(s, hs);
assertEquals(hs, s);
assertEquals(s.hashCode(), hs.hashCode());
}
private void testKeySetByValue(final DoubleOrderedMap m) {
Set s = m.keySetByValue();
assertEquals(m.size(), s.size());
assertEquals(m.isEmpty(), s.isEmpty());
LocalTestNode node = new LocalTestNode(-1);
m.put(node.getKey(), node);
assertTrue(s.contains(node.getKey()));
assertEquals(m.size(), s.size());
assertEquals(m.isEmpty(), s.isEmpty());
m.remove(node.getKey());
assertTrue(!s.contains(node.getKey()));
assertEquals(m.size(), s.size());
assertEquals(m.isEmpty(), s.isEmpty());
try {
s.contains(null);
fail("should have caught NullPointerException");
} catch (NullPointerException ignored) {}
try {
s.contains(new Object());
fail("should have caught ClassCastException");
} catch (ClassCastException ignored) {}
for (int k = 0; k < m.size(); k++) {
assertTrue(s.contains(new Integer(k)));
}
int count = 0;
for (Iterator iter = s.iterator(); iter.hasNext(); ) {
iter.next();
++count;
}
assertEquals(count, s.size());
// force the map to have some content
m.put(node.getKey(), node);
Iterator iter = m.keySetByValue().iterator();
LocalTestNode node2 = new LocalTestNode(-2);
m.put(node2.getKey(), node2);
try {
iter.next();
fail("next() should have thrown an exception after a put");
} catch (ConcurrentModificationException ignored) {}
m.remove(node2.getKey());
iter = s.iterator();
m.remove(node.getKey());
try {
iter.next();
fail("next() should have thrown an exception after a Map remove");
} catch (ConcurrentModificationException ignored) {}
m.put(node.getKey(), node);
iter = s.iterator();
s.remove(node.getKey());
try {
iter.next();
fail("next() should have thrown an exception after a Set remove");
} catch (ConcurrentModificationException ignored) {}
iter = s.iterator();
count = 0;
boolean terminated = false;
try {
while (true) {
iter.next();
++count;
}
} catch (NoSuchElementException ignored) {
terminated = true;
}
assertTrue(terminated);
assertEquals(m.size(), count);
iter = s.iterator();
try {
iter.remove();
fail("Should have thrown exception");
} catch (IllegalStateException ignored) {}
m.put(node.getKey(), node);
iter = s.iterator();
iter.next();
m.put(node2.getKey(), node2);
try {
iter.remove();
fail("should have thrown exception");
} catch (ConcurrentModificationException ignored) {}
Iterator iter2 = s.iterator();
iter2.next();
LocalTestNode node3 = new LocalTestNode(-3);
m.put(node3.getKey(), node3);
try {
iter2.remove();
fail("should have thrown exception");
} catch (ConcurrentModificationException ignored) {}
int removalCount = 0;
for (iter = s.iterator(); iter.hasNext(); ) {
if (iter.next().equals(node.getKey())) {
try {
iter.remove();
++removalCount;
iter.remove();
fail("2nd remove should have failed");
} catch (IllegalStateException ignored) {
assertEquals(1, removalCount);
}
}
}
assertEquals(1, removalCount);
assertTrue(!s.contains(node.getKey()));
removalCount = 0;
m.put(node.getKey(), node);
Object[] a1 = s.toArray();
assertEquals(s.size(), a1.length);
// if (a1.length > 1)
// {
// Comparable first = ( Comparable ) a1[ 0 ];
// for (int k = 1; k < a1.length; k++)
// {
// Comparable second = ( Comparable ) a1[ k ];
// assertTrue(first.compareTo(second) < 0);
// first = second;
// }
// iter = s.iterator();
// first = ( Comparable ) iter.next();
// for (; iter.hasNext(); )
// {
// Comparable second = ( Comparable ) iter.next();
// assertTrue(first.compareTo(second) < 0);
// first = second;
// }
// }
try {
String array2[] = (String[]) s.toArray(new String[0]);
if (s.size() != 0) {
fail("should have caught exception creating an invalid array");
}
} catch (ArrayStoreException ignored) {}
Comparable array2[] = (Comparable[]) s.toArray(new Comparable[0]);
Integer array3[] = (Integer[]) s.toArray(new Integer[s.size()]);
// if (array3.length > 1)
// {
// Integer first = array3[ 0 ];
// for (int k = 1; k < array3.length; k++)
// {
// Integer second = array3[ k ];
// assertTrue(first.compareTo(second) < 0);
// first = second;
// }
// }
try {
s.add("foo");
fail("should have thrown an exception");
} catch (UnsupportedOperationException ignored) {}
assertTrue(!s.equals(null));
assertEquals(s, s);
Set hs = new HashSet(s);
assertEquals(s, hs);
assertEquals(hs, s);
assertEquals(s.hashCode(), hs.hashCode());
}
private void testValues(Map m) {
Collection s = m.values();
assertEquals(m.size(), s.size());
assertEquals(m.isEmpty(), s.isEmpty());
LocalTestNode node = new LocalTestNode(-1);
m.put(node.getKey(), node);
assertEquals(m.size(), s.size());
assertEquals(m.isEmpty(), s.isEmpty());
m.remove(node.getKey());
assertEquals(m.size(), s.size());
assertEquals(m.isEmpty(), s.isEmpty());
assertTrue(!s.contains(node));
for (int k = 0; k < m.size(); k++) {
assertTrue(s.contains(new LocalTestNode(k)));
}
m.put(node.getKey(), node);
assertTrue(s.contains(node));
m.remove(node.getKey());
assertTrue(!s.contains(node));
int count = 0;
for (Iterator iter = s.iterator(); iter.hasNext(); ) {
iter.next();
++count;
}
assertEquals(s.size(), count);
LocalTestNode node4 = new LocalTestNode(-4);
m.put(node4.getKey(), node4);
Iterator iter = s.iterator();
m.put(node.getKey(), node);
try {
iter.next();
fail("next() should have thrown an exception after a put");
} catch (ConcurrentModificationException ignored) {}
iter = s.iterator();
m.remove(node.getKey());
try {
iter.next();
fail("next() should have thrown an exception after a Map remove");
} catch (ConcurrentModificationException ignored) {}
m.put(node.getKey(), node);
iter = s.iterator();
s.remove(node);
try {
iter.next();
fail("next() should have thrown an exception after a Set remove");
} catch (ConcurrentModificationException ignored) {}
iter = s.iterator();
count = 0;
boolean terminated = false;
try {
while (true) {
iter.next();
++count;
}
} catch (NoSuchElementException ignored) {
terminated = true;
}
assertTrue(terminated);
assertEquals(m.size(), count);
iter = s.iterator();
try {
iter.remove();
fail("Should have thrown exception");
} catch (IllegalStateException ignored) {}
Iterator iter2 = s.iterator();
try {
iter2.remove();
fail("Should have thrown exception");
} catch (IllegalStateException ignored) {}
m.put(node.getKey(), node);
iter = s.iterator();
iter.next();
LocalTestNode node2 = new LocalTestNode(-2);
m.put(node2.getKey(), node2);
try {
iter.remove();
fail("should have thrown exception");
} catch (ConcurrentModificationException ignored) {}
LocalTestNode node3 = new LocalTestNode(-3);
m.put(node3.getKey(), node3);
iter2 = s.iterator();
while (iter2.hasNext()) {
iter2.next();
}
int removalCount = 0;
for (iter = s.iterator(); iter.hasNext(); ) {
if (iter.next().equals(node3)) {
try {
iter.remove();
++removalCount;
iter.remove();
fail("2nd remove should have failed");
} catch (IllegalStateException ignored) {
assertEquals(1, removalCount);
}
}
}
assertEquals(1, removalCount);
assertTrue(!s.contains(node3));
Object[] a1 = s.toArray();
assertEquals(s.size(), a1.length);
if (a1.length > 1) {
Comparable first = (Comparable) a1[0];
for (int k = 1; k < a1.length; k++) {
Comparable second = (Comparable) a1[k];
assertTrue(first.compareTo(second) < 0);
first = second;
}
iter = s.iterator();
first = (Comparable) iter.next();
for (; iter.hasNext(); ) {
Comparable second = (Comparable) iter.next();
assertTrue(first.compareTo(second) < 0);
first = second;
}
}
try {
String array2[] = (String[]) s.toArray(new String[0]);
if (s.size() != 0) {
fail("should have caught exception creating an invalid array");
}
} catch (ArrayStoreException ignored) {}
m.remove(node.getKey());
m.remove(node2.getKey());
m.remove(node3.getKey());
LocalTestNode array2[] =
(LocalTestNode[]) s.toArray(new LocalTestNode[0]);
LocalTestNode array3[] =
(LocalTestNode[]) s.toArray(new LocalTestNode[s.size()]);
if (array3.length > 1) {
LocalTestNode first = array3[0];
for (int k = 1; k < array3.length; k++) {
LocalTestNode second = array3[k];
assertTrue(first.compareTo(second) < 0);
first = second;
}
}
try {
s.add(node.getKey());
fail("should have thrown an exception");
} catch (UnsupportedOperationException ignored) {}
assertTrue(!s.equals(null));
assertEquals(s, s);
Set hs = new HashSet(s);
assertTrue(!s.equals(hs));
assertTrue(!hs.equals(s));
}
private void testValuesByValue(DoubleOrderedMap m) {
Collection s = m.valuesByValue();
assertEquals(m.size(), s.size());
assertEquals(m.isEmpty(), s.isEmpty());
LocalTestNode node = new LocalTestNode(-1);
m.put(node.getKey(), node);
assertEquals(m.size(), s.size());
assertEquals(m.isEmpty(), s.isEmpty());
m.remove(node.getKey());
assertEquals(m.size(), s.size());
assertEquals(m.isEmpty(), s.isEmpty());
assertTrue(!s.contains(node));
for (int k = 0; k < m.size(); k++) {
assertTrue(s.contains(new LocalTestNode(k)));
}
m.put(node.getKey(), node);
assertTrue(s.contains(node));
m.remove(node.getKey());
assertTrue(!s.contains(node));
int count = 0;
for (Iterator iter = s.iterator(); iter.hasNext(); ) {
iter.next();
++count;
}
assertEquals(s.size(), count);
LocalTestNode node4 = new LocalTestNode(-4);
m.put(node4.getKey(), node4);
Iterator iter = s.iterator();
m.put(node.getKey(), node);
try {
iter.next();
fail("next() should have thrown an exception after a put");
} catch (ConcurrentModificationException ignored) {}
iter = s.iterator();
m.remove(node.getKey());
try {
iter.next();
fail("next() should have thrown an exception after a Map remove");
} catch (ConcurrentModificationException ignored) {}
m.put(node.getKey(), node);
iter = s.iterator();
s.remove(node);
try {
iter.next();
fail("next() should have thrown an exception after a Set remove");
} catch (ConcurrentModificationException ignored) {}
iter = s.iterator();
count = 0;
boolean terminated = false;
try {
while (true) {
iter.next();
++count;
}
} catch (NoSuchElementException ignored) {
terminated = true;
}
assertTrue(terminated);
assertEquals(m.size(), count);
iter = s.iterator();
try {
iter.remove();
fail("Should have thrown exception");
} catch (IllegalStateException ignored) {}
Iterator iter2 = s.iterator();
try {
iter2.remove();
fail("Should have thrown exception");
} catch (IllegalStateException ignored) {}
m.put(node.getKey(), node);
iter = s.iterator();
iter.next();
LocalTestNode node2 = new LocalTestNode(-2);
m.put(node2.getKey(), node2);
try {
iter.remove();
fail("should have thrown exception");
} catch (ConcurrentModificationException ignored) {}
LocalTestNode node3 = new LocalTestNode(-3);
m.put(node3.getKey(), node3);
iter2 = s.iterator();
while (iter2.hasNext()) {
iter2.next();
}
int removalCount = 0;
for (iter = s.iterator(); iter.hasNext(); ) {
if (iter.next().equals(node3)) {
try {
iter.remove();
++removalCount;
iter.remove();
fail("2nd remove should have failed");
} catch (IllegalStateException ignored) {
assertEquals(1, removalCount);
}
}
}
assertEquals(1, removalCount);
assertTrue(!s.contains(node3));
Object[] a1 = s.toArray();
assertEquals(s.size(), a1.length);
try {
String array2[] = (String[]) s.toArray(new String[0]);
if (s.size() != 0) {
fail("should have caught exception creating an invalid array");
}
} catch (ArrayStoreException ignored) {}
m.remove(node.getKey());
m.remove(node2.getKey());
m.remove(node3.getKey());
LocalTestNode array2[] =
(LocalTestNode[]) s.toArray(new LocalTestNode[0]);
LocalTestNode array3[] =
(LocalTestNode[]) s.toArray(new LocalTestNode[s.size()]);
try {
s.add(node.getKey());
fail("should have thrown an exception");
} catch (UnsupportedOperationException ignored) {}
assertTrue(!s.equals(null));
assertEquals(s, s);
Set hs = new HashSet(s);
assertTrue(!s.equals(hs));
assertTrue(!hs.equals(s));
}
private void testEntrySet(Map m) {
Set s = m.entrySet();
assertEquals(m.size(), s.size());
assertEquals(m.isEmpty(), s.isEmpty());
LocalTestNode node = new LocalTestNode(-1);
m.put(node.getKey(), node);
assertEquals(m.size(), s.size());
assertEquals(m.isEmpty(), s.isEmpty());
m.remove(node.getKey());
assertEquals(m.size(), s.size());
assertEquals(m.isEmpty(), s.isEmpty());
int count = 0;
for (Iterator iter = s.iterator(); iter.hasNext(); ) {
iter.next();
++count;
}
assertEquals(s.size(), count);
LocalTestNode node2 = new LocalTestNode(-2);
if (m.size() == 0) {
m.put(node2.getKey(), node2);
}
Iterator iter = s.iterator();
m.put(node.getKey(), node);
try {
iter.next();
fail("next() should have thrown an exception after a put");
} catch (ConcurrentModificationException ignored) {}
m.remove(node2.getKey());
iter = s.iterator();
m.remove(node.getKey());
try {
iter.next();
fail("next() should have thrown an exception after a Map remove");
} catch (ConcurrentModificationException ignored) {}
m.put(node.getKey(), node);
iter = s.iterator();
count = 0;
boolean terminated = false;
try {
while (true) {
iter.next();
++count;
}
} catch (NoSuchElementException ignored) {
terminated = true;
}
assertTrue(terminated);
assertEquals(m.size(), count);
iter = s.iterator();
try {
iter.remove();
fail("Should have thrown exception");
} catch (IllegalStateException ignored) {}
iter = s.iterator();
iter.next();
LocalTestNode node3 = new LocalTestNode(-3);
m.put(node3.getKey(), node3);
try {
iter.remove();
fail("should have thrown exception");
} catch (ConcurrentModificationException ignored) {}
int removalCount = 0;
int when = m.size() / 2;
int timer = 0;
for (iter = s.iterator(); iter.hasNext(); ) {
iter.next();
if (timer == when) {
try {
iter.remove();
++removalCount;
iter.remove();
fail("2nd remove should have failed");
} catch (IllegalStateException ignored) {
assertEquals(1, removalCount);
}
}
timer++;
}
assertEquals(1, removalCount);
Iterator iter2 = s.iterator();
try {
iter2.remove();
fail("Should have thrown exception");
} catch (IllegalStateException ignored) {}
iter2 = s.iterator();
while (iter2.hasNext()) {
iter2.next();
}
LocalTestNode node4 = new LocalTestNode(-4);
m.put(node4.getKey(), node4);
try {
iter2.remove();
fail("should have thrown exception");
} catch (ConcurrentModificationException ignored) {}
Object[] a1 = s.toArray();
assertEquals(s.size(), a1.length);
if (a1.length > 1) {
Map.Entry first = (Map.Entry) a1[0];
for (int k = 1; k < a1.length; k++) {
Map.Entry second = (Map.Entry) a1[k];
assertTrue(((Comparable) first.getKey())
.compareTo((Comparable) second.getKey()) < 0);
first = second;
}
iter = s.iterator();
first = (Map.Entry) iter.next();
for (; iter.hasNext(); ) {
Map.Entry second = (Map.Entry) iter.next();
assertTrue(((Comparable) first.getKey())
.compareTo((Comparable) second.getKey()) < 0);
first = second;
}
}
try {
Integer array2[] = (Integer[]) s.toArray(new Integer[0]);
if (s.size() != 0) {
fail("should have caught exception creating an invalid array");
}
} catch (ArrayStoreException ignored) {}
Map.Entry array2[] = (Map.Entry[]) s.toArray(new Map.Entry[0]);
Map.Entry array3[] = (Map.Entry[]) s.toArray(new Map.Entry[s.size()]);
if (array3.length > 1) {
Comparable first = (Comparable) ((Map.Entry) array3[0]).getKey();
for (int k = 1; k < array3.length; k++) {
Comparable second =
(Comparable) ((Map.Entry) array3[k]).getKey();
assertTrue(first.compareTo(second) < 0);
first = second;
}
}
try {
s.add(node.getKey());
fail("should have thrown an exception");
} catch (UnsupportedOperationException ignored) {}
assertTrue(!s.equals(null));
assertEquals("SetEquality 1", s, s);
Set hs = new HashSet(s);
assertEquals("SetEquality 2", s, hs);
assertEquals("SetEquality 3", hs, s);
assertEquals(s.hashCode(), hs.hashCode());
}
private void testEntrySetByValue(DoubleOrderedMap m) {
Set s = m.entrySetByValue();
assertEquals(m.size(), s.size());
assertEquals(m.isEmpty(), s.isEmpty());
LocalTestNode node = new LocalTestNode(-1);
m.put(node.getKey(), node);
assertEquals(m.size(), s.size());
assertEquals(m.isEmpty(), s.isEmpty());
m.remove(node.getKey());
assertEquals(m.size(), s.size());
assertEquals(m.isEmpty(), s.isEmpty());
int count = 0;
for (Iterator iter = s.iterator(); iter.hasNext(); ) {
iter.next();
++count;
}
assertEquals(s.size(), count);
LocalTestNode node2 = new LocalTestNode(-2);
if (m.size() == 0) {
m.put(node2.getKey(), node2);
}
Iterator iter = s.iterator();
m.put(node.getKey(), node);
try {
iter.next();
fail("next() should have thrown an exception after a put");
} catch (ConcurrentModificationException ignored) {}
m.remove(node2.getKey());
iter = s.iterator();
m.remove(node.getKey());
try {
iter.next();
fail("next() should have thrown an exception after a Map remove");
} catch (ConcurrentModificationException ignored) {}
m.put(node.getKey(), node);
iter = s.iterator();
count = 0;
boolean terminated = false;
try {
while (true) {
iter.next();
++count;
}
} catch (NoSuchElementException ignored) {
terminated = true;
}
assertTrue(terminated);
assertEquals(m.size(), count);
iter = s.iterator();
try {
iter.remove();
fail("Should have thrown exception");
} catch (IllegalStateException ignored) {}
iter = s.iterator();
iter.next();
LocalTestNode node3 = new LocalTestNode(-3);
m.put(node3.getKey(), node3);
try {
iter.remove();
fail("should have thrown exception");
} catch (ConcurrentModificationException ignored) {}
int removalCount = 0;
int when = m.size() / 2;
int timer = 0;
for (iter = s.iterator(); iter.hasNext(); ) {
iter.next();
if (timer == when) {
try {
iter.remove();
++removalCount;
iter.remove();
fail("2nd remove should have failed");
} catch (IllegalStateException ignored) {
assertEquals(1, removalCount);
}
}
timer++;
}
assertEquals(1, removalCount);
Iterator iter2 = s.iterator();
try {
iter2.remove();
fail("Should have thrown exception");
} catch (IllegalStateException ignored) {}
iter2 = s.iterator();
while (iter2.hasNext()) {
iter2.next();
}
LocalTestNode node4 = new LocalTestNode(-4);
m.put(node4.getKey(), node4);
try {
iter2.remove();
fail("should have thrown exception");
} catch (ConcurrentModificationException ignored) {}
Object[] a1 = s.toArray();
assertEquals(s.size(), a1.length);
if (a1.length > 1) {
Map.Entry first = (Map.Entry) a1[0];
for (int k = 1; k < a1.length; k++) {
Map.Entry second = (Map.Entry) a1[k];
assertTrue(((Comparable) first.getKey())
.compareTo((Comparable) second.getKey()) < 0);
first = second;
}
iter = s.iterator();
first = (Map.Entry) iter.next();
for (; iter.hasNext(); ) {
Map.Entry second = (Map.Entry) iter.next();
assertTrue(((Comparable) first.getKey())
.compareTo((Comparable) second.getKey()) < 0);
first = second;
}
}
try {
Integer array2[] = (Integer[]) s.toArray(new Integer[0]);
if (s.size() != 0) {
fail("should have caught exception creating an invalid array");
}
} catch (ArrayStoreException ignored) {}
Map.Entry array2[] = (Map.Entry[]) s.toArray(new Map.Entry[0]);
Map.Entry array3[] = (Map.Entry[]) s.toArray(new Map.Entry[s.size()]);
if (array3.length > 1) {
Comparable first =
(Comparable) ((Map.Entry) array3[0]).getValue();
for (int k = 1; k < array3.length; k++) {
Comparable second =
(Comparable) ((Map.Entry) array3[k]).getValue();
assertTrue(first.compareTo(second) < 0);
first = second;
}
}
try {
s.add(node.getKey());
fail("should have thrown an exception");
} catch (UnsupportedOperationException ignored) {}
assertTrue(!s.equals(null));
assertEquals("SetEquality 1", s, s);
Set hs = new HashSet(s);
assertEquals("SetEquality 2", s, hs);
assertEquals("SetEquality 3", hs, s);
assertEquals(s.hashCode(), hs.hashCode());
}
private LocalTestNode[] makeLocalNodes() {
LocalTestNode nodes[] = new LocalTestNode[1023];
for (int k = 0; k < nodes.length; k++) {
nodes[k] = new LocalTestNode(k);
}
return nodes;
}
/* ********** END helper methods ********** */
/**
* Method main
*
* @param unusedArgs
*/
public static void main(final String unusedArgs[]) {
junit.textui.TestRunner.run(TestDoubleOrderedMap.class);
}
/**
* Override the Map.put() test because it tries put with the same key
* which is invalid in the modified double ordered map contract. (The
* DoubleOrderedMap documentation states that an IllegalArgumentException
* is thrown when a key is tried to be put into the map again. This
* differs from the standard Map contract which would replace the value
* for that key and return it.
**/
public void testMapPut() {
}
}
././@LongLink 0000000 0000000 0000000 00000000155 00000000000 011566 L ustar root root libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestPredicatedCollection.java libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestPredicatedCollec 0100644 0001750 0001750 00000004665 10055172400 032271 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public abstract class TestPredicatedCollection extends BulkTest {
public TestPredicatedCollection(String name) {
super(name);
}
protected abstract Collection predicatedCollection();
protected Predicate getPredicate() {
return new Predicate() {
public boolean evaluate(Object o) {
return o instanceof String;
}
};
}
public void testIllegalAdd() {
Collection c = predicatedCollection();
Integer i = new Integer(3);
try {
c.add(i);
fail("Integer should fail string predicate.");
} catch (IllegalArgumentException e) {
// expected
}
assertTrue("Collection shouldn't contain illegal element",
!c.contains(i));
}
public void testIllegalAddAll() {
Collection c = predicatedCollection();
List elements = new ArrayList();
elements.add("one");
elements.add("two");
elements.add(new Integer(3));
elements.add("four");
try {
c.addAll(elements);
fail("Integer should fail string predicate.");
} catch (IllegalArgumentException e) {
// expected
}
assertTrue("Collection shouldn't contain illegal element",
!c.contains("one"));
assertTrue("Collection shouldn't contain illegal element",
!c.contains("two"));
assertTrue("Collection shouldn't contain illegal element",
!c.contains(new Integer(3)));
assertTrue("Collection shouldn't contain illegal element",
!c.contains("four"));
}
}
libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestMapUtils.java 0100644 0001750 0001750 00000006043 10055172400 031551 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import junit.framework.Test;
/**
* Tests for MapUtils.
*/
public class TestMapUtils extends BulkTest {
public TestMapUtils(String name) {
super(name);
}
public static Test suite() {
return BulkTest.makeSuite(TestMapUtils.class);
}
public Predicate getPredicate() {
return new Predicate() {
public boolean evaluate(Object o) {
return o instanceof String;
}
};
}
public void testPredicatedMapIllegalPut() {
Predicate p = getPredicate();
Map map = MapUtils.predicatedMap(new HashMap(), p, p);
try {
map.put("Hi", new Integer(3));
fail("Illegal value should raise IllegalArgument");
} catch (IllegalArgumentException e) {
// expected
}
try {
map.put(new Integer(3), "Hi");
fail("Illegal key should raise IllegalArgument");
} catch (IllegalArgumentException e) {
// expected
}
assertTrue(!map.containsKey(new Integer(3)));
assertTrue(!map.containsValue(new Integer(3)));
Map map2 = new HashMap();
map2.put("A", "a");
map2.put("B", "b");
map2.put("C", "c");
map2.put("c", new Integer(3));
try {
map.putAll(map2);
fail("Illegal value should raise IllegalArgument");
} catch (IllegalArgumentException e) {
// expected
}
map.put("E", "e");
Iterator iterator = map.entrySet().iterator();
try {
Map.Entry entry = (Map.Entry)iterator.next();
entry.setValue(new Integer(3));
fail("Illegal value should raise IllegalArgument");
} catch (IllegalArgumentException e) {
// expected
}
}
public BulkTest bulkTestPredicatedMap() {
return new TestMap("") {
public boolean useNullKey() {
return false;
}
public boolean useNullValue() {
return false;
}
public Map makeEmptyMap() {
Predicate p = getPredicate();
return MapUtils.predicatedMap(new HashMap(), p, p);
}
};
}
}
libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestObject.java 0100644 0001750 0001750 00000022622 10055172400 031222 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.Serializable;
/**
* Tests base {@link java.lang.Object} methods and contracts.
* MultiHashMap.
*
*/
public class TestMultiHashMap extends TestMap
{
public TestMultiHashMap(String testName)
{
super(testName);
}
public static Test suite()
{
return new TestSuite(TestMultiHashMap.class);
}
public static void main(String args[])
{
String[] testCaseName = { TestMultiHashMap.class.getName() };
junit.textui.TestRunner.main(testCaseName);
}
// MutltiHashMap was introduced in Collections 2.x
public int getCompatibilityVersion() {
return 2;
}
public Map makeEmptyMap() {
return new MultiHashMap();
}
//----------------------------
// Tests
//----------------------------
public void testPutNGet()
{
MultiHashMap map = new MultiHashMap();
loadMap( map );
checkMap( map );
assertTrue( map.get(new Integer(99)) == null );
map.clear();
assertTrue( map.size() == 0 );
}
public void testContainsValue()
{
MultiHashMap map = new MultiHashMap();
loadMap( map );
assertTrue( map.containsValue( "uno" ) );
assertTrue( map.containsValue( "quatro" ) );
assertTrue( map.containsValue( "two" ) );
assertTrue( ! map.containsValue( "uggaBugga" ) );
map.clear();
}
public void testValues()
{
MultiHashMap map = new MultiHashMap();
loadMap( map );
Collection vals = map.values();
assertTrue( vals.size() == getFullSize() );
map.clear();
}
static private class MapPair
{
MapPair( int key, String val )
{
mKey = new Integer( key );
mValue = val;
}
Integer mKey = null;
String mValue = null;
}
static private MapPair[][] sMapPairs =
{
{new MapPair(0,"zero")},
{new MapPair(1,"one"), new MapPair(1,"ONE"), new MapPair(1,"uno")},
{new MapPair(2,"two"), new MapPair(2,"two") },
{new MapPair(3,"three"), new MapPair(3,"THREE"), new MapPair(3,"tres")},
{new MapPair(4,"four"), new MapPair(4,"quatro")}
};
private void loadMap( MultiHashMap map )
{
// Set up so that we load the keys "randomly"
// (i.e. we don't want to load int row-order, so that all like keys
// load together. We want to mix it up...)
int numRows = sMapPairs.length;
int maxCols = 0;
for( int ii=0; ii < sMapPairs.length; ii++ ){
if ( sMapPairs[ii].length > maxCols )
maxCols = sMapPairs[ii].length;
}
for( int ii=0; ii < maxCols; ii++ ){
for( int jj=0; jj < numRows; jj++ ){
if ( ii < sMapPairs[jj].length ) {
map.put( sMapPairs[jj][ii].mKey, sMapPairs[jj][ii].mValue);
//---------------------------------------------------------
}
}
}
assertTrue( map.size() == sMapPairs.length );
}
private void checkMap( MultiHashMap map )
{
for( int ii=0; ii < sMapPairs.length; ii++ ){
checkKeyList( map, ii );
}
}
private void checkKeyList( MultiHashMap map, int index )
{
assertTrue( index < sMapPairs.length );
Integer key = sMapPairs[index][0].mKey ;
Object obj = map.get( key );
//--------------------------
assertTrue( obj != null );
assertTrue( obj instanceof Collection );
Collection keyList = (Collection)obj;
assertTrue( keyList.size() == sMapPairs[index].length );
Iterator iter = keyList.iterator();
while ( iter.hasNext() ) {
Object oval = iter.next();
assertTrue( oval != null );
assertTrue( oval instanceof String );
String val = (String)oval;
boolean foundIt = false;
for( int ii=0; ii < sMapPairs[index].length; ii++ ){
if( val.equals( sMapPairs[index][ii].mValue ) )
foundIt = true;
}
assertTrue( foundIt );
}
}
public int getFullSize()
{
int len = 0;
for( int ii=0; ii < sMapPairs.length; ii++ ){
len += sMapPairs[ii].length;
}
return len;
}
public void testEntrySetIterator() {
}
public void testEntrySetContainsProperMappings() {
}
public void testEntrySetIteratorHasProperMappings() {
// override and ignore test -- it will fail when verifying the iterator for
// the set contains the right value -- we're not returning the value, we're
// returning a collection.
// TODO: re-implement this test to ensure the values of the iterator match
// the proper collection rather than the value the superclass is checking
// for.
return;
}
// Next methods are overriden because MultiHashMap values are always a
// collection, and deviate from the Map contract because of this.
// TODO: implement the tests to ensure that Map.get(Object) returns the
// appropriate collection of values
public void testMapGet() {
}
public void testMapPut() {
}
public void testMapPutAll() {
}
public void testMapRemove() {
}
public void testMapEquals() {
}
public void testMapHashCode() {
}
// The verification for the map and its entry set must also be overridden
// because the values are not going to be the same as the values in the
// confirmed map (they're going to be collections of values instead).
public void verifyMap() {
// TODO: implement test to ensure that map is the same as confirmed if
// its values were converted into collections.
}
public void verifyEntrySet() {
// TODO: implement test to ensure that each entry is the same as one in
// the confirmed map, but with the value wrapped in a collection.
}
// The verification method must be overridden because MultiHashMap's
// values() is not properly backed by the map (Bug 9573).
public void verifyValues() {
// update the values view to the latest version, then proceed to verify
// as usual.
values = map.values();
super.verifyValues();
}
}
libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestBufferUtils.java 0100644 0001750 0001750 00000006511 10055172402 032247 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.Arrays;
import java.util.Collection;
import junit.framework.Test;
/**
* Tests for BufferUtils.
*/
public class TestBufferUtils extends BulkTest {
public TestBufferUtils(String name) {
super(name);
}
public static Test suite() {
return BulkTest.makeSuite(TestBufferUtils.class);
}
public void testNothing() {
}
public BulkTest bulkTestPredicatedBuffer() {
return new TestPredicatedCollection("") {
public Collection predicatedCollection() {
Predicate p = getPredicate();
return BufferUtils.predicatedBuffer(new ArrayStack(), p);
}
public BulkTest bulkTestAll() {
return new TestCollection("") {
public Collection makeCollection() {
return predicatedCollection();
}
public Collection makeConfirmedCollection() {
return new ArrayStack();
}
public Collection makeConfirmedFullCollection() {
ArrayStack list = new ArrayStack();
list.addAll(java.util.Arrays.asList(getFullElements()));
return list;
}
public Object[] getFullElements() {
return getFullNonNullStringElements();
}
public Object[] getOtherElements() {
return getOtherNonNullStringElements();
}
};
}
};
}
public BulkTest bulkTestUnmodifiableBuffer() {
return new TestCollection("") {
public boolean isAddSupported() {
return false;
}
public boolean isRemoveSupported() {
return false;
}
public Collection makeCollection() {
return BufferUtils.unmodifiableBuffer(new ArrayStack());
}
public Collection makeFullCollection() {
ArrayStack a = new ArrayStack();
a.addAll(Arrays.asList(getFullElements()));
return BufferUtils.unmodifiableBuffer(a);
}
public Collection makeConfirmedCollection() {
return new ArrayStack();
}
public Collection makeConfirmedFullCollection() {
ArrayStack a = new ArrayStack();
a.addAll(Arrays.asList(getFullElements()));
return a;
}
};
}
}
././@LongLink 0000000 0000000 0000000 00000000150 00000000000 011561 L ustar root root libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestCollectionUtils.java libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestCollectionUtils. 0100644 0001750 0001750 00000037162 10055172400 032273 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import junit.framework.*;
import java.util.*;
/**
* @author Rodney Waldhoff
* @version $Id: TestCollectionUtils.java,v 1.6.2.1 2004/05/22 12:14:05 scolebourne Exp $
*/
public class TestCollectionUtils extends TestCase {
public TestCollectionUtils(String testName) {
super(testName);
}
public static Test suite() {
return new TestSuite(TestCollectionUtils.class);
}
public static void main(String args[]) {
String[] testCaseName = { TestCollectionUtils.class.getName() };
junit.textui.TestRunner.main(testCaseName);
}
private Collection _a = null;
private Collection _b = null;
public void setUp() {
_a = new ArrayList();
_a.add("a");
_a.add("b");
_a.add("b");
_a.add("c");
_a.add("c");
_a.add("c");
_a.add("d");
_a.add("d");
_a.add("d");
_a.add("d");
_b = new LinkedList();
_b.add("e");
_b.add("d");
_b.add("d");
_b.add("c");
_b.add("c");
_b.add("c");
_b.add("b");
_b.add("b");
_b.add("b");
_b.add("b");
}
public void testGetCardinalityMap() {
Map freq = CollectionUtils.getCardinalityMap(_a);
assertEquals(new Integer(1),freq.get("a"));
assertEquals(new Integer(2),freq.get("b"));
assertEquals(new Integer(3),freq.get("c"));
assertEquals(new Integer(4),freq.get("d"));
assertTrue(null == freq.get("e"));
freq = CollectionUtils.getCardinalityMap(_b);
assertTrue(null == freq.get("a"));
assertEquals(new Integer(4),freq.get("b"));
assertEquals(new Integer(3),freq.get("c"));
assertEquals(new Integer(2),freq.get("d"));
assertEquals(new Integer(1),freq.get("e"));
}
public void testCardinality() {
assertEquals(1,CollectionUtils.cardinality("a",_a));
assertEquals(2,CollectionUtils.cardinality("b",_a));
assertEquals(3,CollectionUtils.cardinality("c",_a));
assertEquals(4,CollectionUtils.cardinality("d",_a));
assertEquals(0,CollectionUtils.cardinality("e",_a));
assertEquals(0,CollectionUtils.cardinality("a",_b));
assertEquals(4,CollectionUtils.cardinality("b",_b));
assertEquals(3,CollectionUtils.cardinality("c",_b));
assertEquals(2,CollectionUtils.cardinality("d",_b));
assertEquals(1,CollectionUtils.cardinality("e",_b));
}
public void testContainsAny() {
Collection empty = new ArrayList(0);
Collection one = new ArrayList(1);
one.add("1");
Collection two = new ArrayList(1);
two.add("2");
Collection three = new ArrayList(1);
three.add("3");
Collection odds = new ArrayList(2);
odds.add("1");
odds.add("3");
assertTrue("containsAny({1},{1,3}) should return true.",
CollectionUtils.containsAny(one,odds));
assertTrue("containsAny({1,3},{1}) should return true.",
CollectionUtils.containsAny(odds,one));
assertTrue("containsAny({3},{1,3}) should return true.",
CollectionUtils.containsAny(three,odds));
assertTrue("containsAny({1,3},{3}) should return true.",
CollectionUtils.containsAny(odds,three));
assertTrue("containsAny({2},{2}) should return true.",
CollectionUtils.containsAny(two,two));
assertTrue("containsAny({1,3},{1,3}) should return true.",
CollectionUtils.containsAny(odds,odds));
assertTrue("containsAny({2},{1,3}) should return false.",
!CollectionUtils.containsAny(two,odds));
assertTrue("containsAny({1,3},{2}) should return false.",
!CollectionUtils.containsAny(odds,two));
assertTrue("containsAny({1},{3}) should return false.",
!CollectionUtils.containsAny(one,three));
assertTrue("containsAny({3},{1}) should return false.",
!CollectionUtils.containsAny(three,one));
assertTrue("containsAny({1,3},{}) should return false.",
!CollectionUtils.containsAny(odds,empty));
assertTrue("containsAny({},{1,3}) should return false.",
!CollectionUtils.containsAny(empty,odds));
assertTrue("containsAny({},{}) should return false.",
!CollectionUtils.containsAny(empty,empty));
}
public void testUnion() {
Collection col = CollectionUtils.union(_a,_b);
Map freq = CollectionUtils.getCardinalityMap(col);
assertEquals(new Integer(1),freq.get("a"));
assertEquals(new Integer(4),freq.get("b"));
assertEquals(new Integer(3),freq.get("c"));
assertEquals(new Integer(4),freq.get("d"));
assertEquals(new Integer(1),freq.get("e"));
Collection col2 = CollectionUtils.union(_b,_a);
Map freq2 = CollectionUtils.getCardinalityMap(col2);
assertEquals(new Integer(1),freq2.get("a"));
assertEquals(new Integer(4),freq2.get("b"));
assertEquals(new Integer(3),freq2.get("c"));
assertEquals(new Integer(4),freq2.get("d"));
assertEquals(new Integer(1),freq2.get("e"));
}
public void testIntersection() {
Collection col = CollectionUtils.intersection(_a,_b);
Map freq = CollectionUtils.getCardinalityMap(col);
assertTrue(null == freq.get("a"));
assertEquals(new Integer(2),freq.get("b"));
assertEquals(new Integer(3),freq.get("c"));
assertEquals(new Integer(2),freq.get("d"));
assertTrue(null == freq.get("e"));
Collection col2 = CollectionUtils.intersection(_b,_a);
Map freq2 = CollectionUtils.getCardinalityMap(col2);
assertTrue(null == freq2.get("a"));
assertEquals(new Integer(2),freq2.get("b"));
assertEquals(new Integer(3),freq2.get("c"));
assertEquals(new Integer(2),freq2.get("d"));
assertTrue(null == freq2.get("e"));
}
public void testDisjunction() {
Collection col = CollectionUtils.disjunction(_a,_b);
Map freq = CollectionUtils.getCardinalityMap(col);
assertEquals(new Integer(1),freq.get("a"));
assertEquals(new Integer(2),freq.get("b"));
assertTrue(null == freq.get("c"));
assertEquals(new Integer(2),freq.get("d"));
assertEquals(new Integer(1),freq.get("e"));
Collection col2 = CollectionUtils.disjunction(_b,_a);
Map freq2 = CollectionUtils.getCardinalityMap(col2);
assertEquals(new Integer(1),freq2.get("a"));
assertEquals(new Integer(2),freq2.get("b"));
assertTrue(null == freq2.get("c"));
assertEquals(new Integer(2),freq2.get("d"));
assertEquals(new Integer(1),freq2.get("e"));
}
public void testDisjunctionAsUnionMinusIntersection() {
Collection dis = CollectionUtils.disjunction(_a,_b);
Collection un = CollectionUtils.union(_a,_b);
Collection inter = CollectionUtils.intersection(_a,_b);
assertTrue(CollectionUtils.isEqualCollection(dis,CollectionUtils.subtract(un,inter)));
}
public void testDisjunctionAsSymmetricDifference() {
Collection dis = CollectionUtils.disjunction(_a,_b);
Collection amb = CollectionUtils.subtract(_a,_b);
Collection bma = CollectionUtils.subtract(_b,_a);
assertTrue(CollectionUtils.isEqualCollection(dis,CollectionUtils.union(amb,bma)));
}
public void testSubtract() {
Collection col = CollectionUtils.subtract(_a,_b);
Map freq = CollectionUtils.getCardinalityMap(col);
assertEquals(new Integer(1),freq.get("a"));
assertTrue(null == freq.get("b"));
assertTrue(null == freq.get("c"));
assertEquals(new Integer(2),freq.get("d"));
assertTrue(null == freq.get("e"));
Collection col2 = CollectionUtils.subtract(_b,_a);
Map freq2 = CollectionUtils.getCardinalityMap(col2);
assertEquals(new Integer(1),freq2.get("e"));
assertTrue(null == freq2.get("d"));
assertTrue(null == freq2.get("c"));
assertEquals(new Integer(2),freq2.get("b"));
assertTrue(null == freq2.get("a"));
}
public void testIsSubCollectionOfSelf() {
assertTrue(CollectionUtils.isSubCollection(_a,_a));
assertTrue(CollectionUtils.isSubCollection(_b,_b));
}
public void testIsSubCollection() {
assertTrue(!CollectionUtils.isSubCollection(_a,_b));
assertTrue(!CollectionUtils.isSubCollection(_b,_a));
}
public void testIsSubCollection2() {
Collection c = new ArrayList();
assertTrue(CollectionUtils.isSubCollection(c,_a));
assertTrue(!CollectionUtils.isSubCollection(_a,c));
c.add("a");
assertTrue(CollectionUtils.isSubCollection(c,_a));
assertTrue(!CollectionUtils.isSubCollection(_a,c));
c.add("b");
assertTrue(CollectionUtils.isSubCollection(c,_a));
assertTrue(!CollectionUtils.isSubCollection(_a,c));
c.add("b");
assertTrue(CollectionUtils.isSubCollection(c,_a));
assertTrue(!CollectionUtils.isSubCollection(_a,c));
c.add("c");
assertTrue(CollectionUtils.isSubCollection(c,_a));
assertTrue(!CollectionUtils.isSubCollection(_a,c));
c.add("c");
assertTrue(CollectionUtils.isSubCollection(c,_a));
assertTrue(!CollectionUtils.isSubCollection(_a,c));
c.add("c");
assertTrue(CollectionUtils.isSubCollection(c,_a));
assertTrue(!CollectionUtils.isSubCollection(_a,c));
c.add("d");
assertTrue(CollectionUtils.isSubCollection(c,_a));
assertTrue(!CollectionUtils.isSubCollection(_a,c));
c.add("d");
assertTrue(CollectionUtils.isSubCollection(c,_a));
assertTrue(!CollectionUtils.isSubCollection(_a,c));
c.add("d");
assertTrue(CollectionUtils.isSubCollection(c,_a));
assertTrue(!CollectionUtils.isSubCollection(_a,c));
c.add("d");
assertTrue(CollectionUtils.isSubCollection(c,_a));
assertTrue(CollectionUtils.isSubCollection(_a,c));
c.add("e");
assertTrue(!CollectionUtils.isSubCollection(c,_a));
assertTrue(CollectionUtils.isSubCollection(_a,c));
}
public void testIsEqualCollectionToSelf() {
assertTrue(CollectionUtils.isEqualCollection(_a,_a));
assertTrue(CollectionUtils.isEqualCollection(_b,_b));
}
public void testIsEqualCollection() {
assertTrue(!CollectionUtils.isEqualCollection(_a,_b));
assertTrue(!CollectionUtils.isEqualCollection(_b,_a));
}
public void testIsEqualCollection2() {
Collection a = new ArrayList();
Collection b = new ArrayList();
assertTrue(CollectionUtils.isEqualCollection(a,b));
assertTrue(CollectionUtils.isEqualCollection(b,a));
a.add("1");
assertTrue(!CollectionUtils.isEqualCollection(a,b));
assertTrue(!CollectionUtils.isEqualCollection(b,a));
b.add("1");
assertTrue(CollectionUtils.isEqualCollection(a,b));
assertTrue(CollectionUtils.isEqualCollection(b,a));
a.add("2");
assertTrue(!CollectionUtils.isEqualCollection(a,b));
assertTrue(!CollectionUtils.isEqualCollection(b,a));
b.add("2");
assertTrue(CollectionUtils.isEqualCollection(a,b));
assertTrue(CollectionUtils.isEqualCollection(b,a));
a.add("1");
assertTrue(!CollectionUtils.isEqualCollection(a,b));
assertTrue(!CollectionUtils.isEqualCollection(b,a));
b.add("1");
assertTrue(CollectionUtils.isEqualCollection(a,b));
assertTrue(CollectionUtils.isEqualCollection(b,a));
}
public void testIndex() {
Map map = new HashMap();
map.put(new Integer(0), "element");
Object test = CollectionUtils.index(map, 0);
assertTrue(test.equals("element"));
List list = new ArrayList();
list.add("element");
test = CollectionUtils.index(list, 0);
assertTrue(test.equals("element"));
Bag bag = new HashBag();
bag.add("element", 1);
test = CollectionUtils.index(bag, 0);
assertTrue(test.equals("element"));
}
public void testFilter() {
List list = new ArrayList();
list.add("One");
list.add("Two");
list.add("Three");
list.add("Four");
CollectionUtils.filter(list, new Predicate() {
public boolean evaluate(Object input) {
return (input.equals("Two"));
}
});
assertEquals(1, list.size());
assertEquals("Two", list.get(0));
}
public void testTransform1() {
List list = new ArrayList();
list.add("1");
list.add("2");
list.add("3");
CollectionUtils.transform(list, new Transformer() {
public Object transform(Object input) {
return new Integer((String) input);
}
});
assertEquals(3, list.size());
assertEquals(new Integer(1), list.get(0));
assertEquals(new Integer(2), list.get(1));
assertEquals(new Integer(3), list.get(2));
}
public void testTransform2() {
Set set = new HashSet();
set.add("1");
set.add("2");
set.add("3");
CollectionUtils.transform(set, new Transformer() {
public Object transform(Object input) {
return new Integer(4);
}
});
assertEquals(1, set.size());
assertEquals(new Integer(4), set.iterator().next());
}
public BulkTest bulkTestPredicatedCollection1() {
return new TestPredicatedCollection("") {
public Collection predicatedCollection() {
Predicate p = getPredicate();
return CollectionUtils.predicatedCollection(new ArrayList(), p);
}
public BulkTest bulkTestAll() {
return new TestCollection("") {
public Collection makeCollection() {
return predicatedCollection();
}
public Collection makeConfirmedCollection() {
return new ArrayList();
}
public Collection makeConfirmedFullCollection() {
ArrayList list = new ArrayList();
list.addAll(java.util.Arrays.asList(getFullElements()));
return list;
}
public Object[] getFullElements() {
return getFullNonNullStringElements();
}
public Object[] getOtherElements() {
return getOtherNonNullStringElements();
}
};
}
};
}
}
././@LongLink 0000000 0000000 0000000 00000000153 00000000000 011564 L ustar root root libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestBoundedFifoBuffer2.java libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestBoundedFifoBuffe 0100644 0001750 0001750 00000005035 10055172376 032243 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.Arrays;
import java.util.Collection;
import junit.framework.Test;
/**
* Runs tests against a full BoundedFifoBuffer, since many of the algorithms
* differ depending on whether the fifo is full or not.
*/
public class TestBoundedFifoBuffer2 extends TestBoundedFifoBuffer {
public TestBoundedFifoBuffer2(String n) {
super(n);
}
public static Test suite() {
return BulkTest.makeSuite(TestBoundedFifoBuffer2.class);
}
/**
* Returns a BoundedFifoBuffer that's filled to capacity.
* Any attempt to add to the returned buffer will result in a
* BufferOverflowException.
*
* @return a full BoundedFifoBuffer
*/
public Collection makeFullCollection() {
return new BoundedFifoBuffer(Arrays.asList(getFullElements()));
}
/**
* Overridden to skip the add tests. All of them would fail with a
* BufferOverflowException.
*
* @return false
*/
public boolean isAddSupported() {
return false;
}
/**
* Overridden because the add operations raise BufferOverflowException
* instead of UnsupportedOperationException.
*/
public void testUnsupportedAdd() {
}
/**
* Tests to make sure the add operations raise BufferOverflowException.
*/
public void testBufferOverflow() {
resetFull();
try {
collection.add(getOtherElements()[0]);
fail("add should raise BufferOverflow.");
} catch (BufferOverflowException e) {
// expected
}
verify();
try {
collection.addAll(Arrays.asList(getOtherElements()));
fail("addAll should raise BufferOverflow.");
} catch (BufferOverflowException e) {
// expected
}
verify();
}
}
libcommons-collections-java-2.1.1.orig/src/test/org/apache/commons/collections/TestBag.java 0100644 0001750 0001750 00000016117 10055172400 030507 0 ustar tora tora /*
* Copyright 1999-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.util.ArrayList;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.List;
/**
* Tests base {@link Bag} methods and contracts.
* BulkTest;
* a subsequent call to {@link TestCase#run} will run that simple test.BulkTest, which can itself define new simple and bulk
* test methods. By using the {@link #makeSuite} method, you can
* automatically create a hierarchal suite of tests and child bulk tests.
* public class TestSet extends BulkTest {
*
* private Set set;
*
* public TestSet(Set set) {
* this.set = set;
* }
*
* public void testContains() {
* boolean r = set.contains(set.iterator().next()));
* assertTrue("Set should contain first element, r);
* }
*
* public void testClear() {
* set.clear();
* assertTrue("Set should be empty after clear", set.isEmpty());
* }
* }
*
*
* public class TestHashMap extends BulkTest {
*
* private Map makeFullMap() {
* HashMap result = new HashMap();
* result.put("1", "One");
* result.put("2", "Two");
* return result;
* }
*
* public void testClear() {
* Map map = makeFullMap();
* map.clear();
* assertTrue("Map empty after clear", map.isEmpty());
* }
*
* public BulkTest bulkTestKeySet() {
* return new TestSet(makeFullMap().keySet());
* }
*
* public BulkTest bulkTestEntrySet() {
* return new TestSet(makeFullMap().entrySet());
* }
* }
*
*
* In the above examples, TestSet defines two
* simple test methods and no bulk test methods; TestHashMap
* defines one simple test method and two bulk test methods. When
* makeSuite(TestHashMap.class).run is executed,
* five simple test methods will be run, in this order:
*
*
* In the graphical junit test runners, the tests would be displayed in
* the following tree:
*
*
* A subclass can override a superclass's bulk test by
* returning
*
*
*
*
*
* null from the bulk test method. If you only
* want to override specific simple tests within a bulk test, use the
* {@link #ignoredSimpleTests} method.suite() method to use {@link #makeSuite}.
* The ordinary {@link TestSuite} constructor doesn't know how to
* interpret bulk test methods.
*
* @author Paul Jack
* @version $Id: BulkTest.java,v 1.2.2.1 2004/05/22 12:14:05 scolebourne Exp $
*/
public class BulkTest extends TestCase implements Cloneable {
// Note: BulkTest is Cloneable to make it easier to construct
// BulkTest instances for simple test methods that are defined in
// anonymous inner classes. Basically we don't have to worry about
// finding wierd constructors. (And even if we found them, techinically
// it'd be illegal for anyone but the outer class to invoke them).
// Given one BulkTest instance, we can just clone it and reset the
// method name for every simple test it defines.
/**
* The full name of this bulk test instance. This is the full name
* that is compared to {@link #ignoredSimpleTests} to see if this
* test should be ignored. It's also displayed in the text runner
* to ease debugging.
*/
String verboseName;
/**
* Constructs a new BulkTest instance that will run the
* specified simple test.
*
* @param name the name of the simple test method to run
*/
public BulkTest(String name) {
super(name);
this.verboseName = getClass().getName();
}
/**
* Creates a clone of this BulkTest.BulkTest
*/
public Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException e) {
throw new Error(); // should never happen
}
}
/**
* Returns an array of simple test names to ignore.BulkTest or
* by one of its bulk test methods has a name that's in the returned
* array, then that simple test will not be executed.BulkTest, eliminating the package name, then
* appending the names of any bulk test methods that were invoked
* to get to the simple test, and then appending the simple test
* method name. The method names are delimited by periods:
*
*
* TestHashMap.bulkTestEntrySet.testClear
*
*
* is the name of one of the simple tests defined in the sample classes
* described above. If the sample TestHashMap class
* included this method:
*
*
* public String[] ignoredSimpleTests() {
* return new String[] { "TestHashMap.bulkTestEntrySet.testClear" };
* }
*
*
* then the entry set's clear method wouldn't be tested, but the key
* set's clear method would.
*
* @return an array of the names of simple tests to ignore, or null if
* no tests should be ignored
*/
public String[] ignoredSimpleTests() {
return null;
}
/**
* Returns the display name of this BulkTest.
*
* @return the display name of this BulkTest
*/
public String toString() {
return getName() + "(" + verboseName + ") ";
}
/**
* Returns a {@link TestSuite} for testing all of the simple tests
* and all the bulk tests defined by the given class.BulkTest and must
* not be abstract.
The Jakarta Commons Collections Package
$Id: STATUS.html,v 1.19 2002/10/21 02:03:29 bayard Exp $
[Introduction]
[Dependencies]
[Release Info]
[Committers]
[Action Items]
1. INTRODUCTION
hashCode to check for equality. Suppose
you have a Bag that contains {a, a, b, c}. Calling
getCount on a would return 2, while calling
uniqueSet would return {a, b, c}. Note: this is an
interface with several implementations.Map wraps another Map
implementation, using the wrapped instance for its default
implementation. This class is used as a framework on which to
build to extensions for its wrapped Map object which
would be unavailable or inconvenient via sub-classing (but usable
via composition).
Iterator which takes a
Predicate
instance to filter out objects from an underlying Iterator instance.
Only objects for which the
specified Predicate evaluates to true are
returned.ListIterator which
takes a Predicate instance to filter
out objects from an underlying ListIterator
instance. Only objects for which the specified
Predicate evaluates to true are
returned by the iterator.2. DEPENDENCIES
3. RELEASE INFO
4. COMMITTERS
5. ACTION ITEMS
libcommons-collections-java-2.1.1.orig/build.properties.sample 0100644 0001750 0001750 00000000274 10055172400 023236 0 ustar tora tora # junit.jar - JUnit 3.2+ Classpath
junit.jar=/java/junit/junit.jar
# optional variable, used for creating source distributions
cvs.root=:pserver:anoncvs@cvs.apache.org:/home/cvspublic
libcommons-collections-java-2.1.1.orig/LICENSE.txt 0100644 0001750 0001750 00000026450 10055172400 020370 0 ustar tora tora
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
libcommons-collections-java-2.1.1.orig/RELEASE-NOTES-2.0.html 0100644 0001750 0001750 00000020726 10055172400 021676 0 ustar tora tora
Action Item
Volunteer
Additional Contributions. Other collection
or collection-related classes or decorators.
Primitive subpackage. Complete implementations of
a collections system based on primitives.
MultiMap ideas. Updates to MultiMap, maybe based on
this library.
Additional Documentation. Create simple
User's Guide, examples, or other documentation for this package.
Serializable Collections. All of the concrete
Collection and Map implementations should be properly Serializable
across all versions of the JDK. Also, decorators should be
Serializable if the underlying instance is.
Fail-Fast Iterators. All concrete Collection and
Map implementations that can have fail-fast iterators should have
them. Some classes, like StaticBucketMap, cannot possibly have
fail-fast iterators, but otherwise everything else should.
Standard Constructors. All concrete Collection and
Map implementations should have the standard copy and no-argument
constructors.
Additional Unit Tests. Create generic unit tests
for SortedSet and SortedMap.
RELEASE NOTES: COLLECTIONS 2.0
NEW COLLECTIONS AND COMPARATORS
{a, a, b, c}. Calling
getCount on a would return 2, while calling
uniqueSet would return {a, b, c}. Note: this is an
interface with several implementations.ListIterator which
takes a Predicate instance to filter
out objects from an underlying ListIterator
instance. Only objects for which the specified
Predicate evaluates to true are
returned by the iterator.Map wraps another Map
implementation, using the wrapped instance for its default
implementation. This class is used as a framework on which to
build to extensions for its wrapped Map object which
would be unavailable or inconvenient via sub-classing (but usable
via composition).
CHANGED COLLECTIONS
libcommons-collections-java-2.1.1.orig/RELEASE-NOTES-2.1.1.html 0100644 0001750 0001750 00000004024 10055172400 022027 0 ustar tora tora RELEASE NOTES: COLLECTIONS 2.1.1
IteratorUtils class. We apologise for this error.
IteratorUtils.arrayIterator(...) -
use new ArrayIterator(...) insteadIteratorUtils.singletonIterator(...) -
use new SingletonIterator(...) insteadIteratorUtils.emptyIterator() -
use EmptyIterator.INSTANCE insteadIteratorUtils.emptyListIterator() -
use EmptyListIterator.INSTANCE insteadIteratorUtils.EMPTY_ITERATOR -
use EmptyIterator.INSTANCE insteadIteratorUtils.EMPTY_LIST_ITERATOR -
use EmptyIterator.INSTANCE insteadEmptyIteratorEmptyListIteratorRELEASE NOTES: COLLECTIONS 2.1
XxxUtils where Xxx is the
collection type. The decorators are:
Collections.Collections.Predicate.Factory.IteratorUtils and ComparatorUtils.
NEW COLLECTIONS, COMPARATORS, ITERATORS AND UTILITY CLASSES
CHANGED CLASSES
REFACTORING
The Jakarta Commons Collections Package
Developers Guide
$Id: DEVELOPERS-GUIDE.html,v 1.2 2002/07/03 02:34:09 mas Exp $
[Introduction]
[Collection Interfaces]
[Collection Implementations]
[Utility Classes]
1. INTRODUCTION
2. COLLECTION INTERFACES
Bag and SortedBag. These interfaces
shall:
3. COLLECTION IMPLEMENTATIONS
DoubleOrderedMap and DefaultMapBag.
These interfaces shall:
4. UTILITY CLASSES
ListUtils and
BagUtils. Variations on a theme (SortedBag as opposed
to Bag) will be dealt with in one Utils class. Each Utils class
shall:
synchronizedMap(Map) or predicatedSet(Set).
Occasionally, such construct is awkward and a more suitable adjective can be
used instead. For example, lazyList,
unmodifiableList.Proposal for Collections Package
(0) Rationale
(1) Scope of the Package
(1.5) Interaction With Other Packages
(2) Initial Source of the Package
org.apache.commons.collections.(3) Required Jakarta-Commons Resources
collections in the
jakarta-commons CVS repository. All initial committers
are already committers on jakarta-commons, so no
additional user setups are required.(4) Initial Committers