procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

[multiple changes]

Browse source 
2001-10-15  Bryce McKinlay  <bryce@waitaki.otago.ac.nz>

	* java/util/HashMap.java (HashEntry.clone): Removed.
	(HashMap(Map)): Use putAllInternal.
	(clone): Likewise.
	(putAllInternal): New method. Efficient counterpart to putAll which
	does not call put().
	* java/util/LinkedHashMap.java (rethread): Removed.
	(putAllInternal): New method. Clear "head" and "tail".
	(addEntry): New argument "callRemove". Don't call removeEldestEntry()
	if callRemove == false.

	* Makefile.am: Add new classes RandomAccess and LinkedHashMap.
	* Makefile.in: Rebuilt.

2001-10-15  Eric Blake  <ebb9@email.byu.edu>

	* java/util/Collection.java: Updated javadoc.
	* java/util/Comparator.java: Updated javadoc.
	* java/util/Enumeration.java: Updated javadoc.
	* java/util/Iterator.java: Updated javadoc.
	* java/util/List.java: Updated javadoc.
	* java/util/ListIterator.java: Updated javadoc.
	* java/util/Map.java: Updated javadoc.
	* java/util/RandomAccess.java: New file.
	* java/util/Set.java: Updated javadoc.
	* java/util/SortedMap.java: Updated javadoc.
	* java/util/SortedSet.java: Updated javadoc.

From-SVN: r46277
This commit is contained in:
Bryce McKinlay 2001-10-16 06:47:01 +01:00
parent ffb5e2e21f
commit 41878ce27e
16 changed files with 2218 additions and 1757 deletions
Download patch file Download diff file Expand all files Collapse all files

191
libjava/java/util/Set.java
View file

@ -1,5 +1,5 @@
/* Set.java -- A collection that prohibits duplicates
Copyright (C) 1998 Free Software Foundation, Inc.
Copyright (C) 1998, 2001 Free Software Foundation, Inc.
This file is part of GNU Classpath.
@ -25,25 +25,208 @@ This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */
// TO DO:
// ~ Doc comments for everything.
package java.util;
/**
* A collection that contains no duplicates. In other words, for two set
* elements e1 and e2, <code>e1.equals(e2)</code> returns false. There
* are additional stipulations on <code>add</code>, <code>equals</code>
* and <code>hashCode</code>, as well as the requirements that constructors
* do not permit duplicate elements. The Set interface is incompatible with
* List; you cannot implement both simultaneously.
* <p>
*
* Note: Be careful about using mutable objects in sets. In particular,
* if a mutable object changes to become equal to another set element, you
* have violated the contract. As a special case of this, a Set is not
* allowed to be an element of itself, without risking undefined behavior.
*
* @author Original author unknown
* @author Eric Blake <ebb9@email.byu.edu>
* @see Collection
* @see List
* @see SortedSet
* @see HashSet
* @see TreeSet
* @see LinkedHashSet
* @see AbstractSet
* @see Collections#singleton(Object)
* @see Collections#EMPTY_SET
* @since 1.2
* @status updated to 1.4
*/
public interface Set extends Collection
{
/**
* Adds the specified element to the set if it is not already present
* (optional operation). In particular, the comparison algorithm is
* <code>o == null ? e == null : o.equals(e)</code>. Sets need not permit
* all values, and may document what exceptions will be thrown if
* a value is not permitted.
*
* @param o the object to add
* @return true if the object was not previously in the set
* @throws UnsupportedOperationException if this operation is not allowed
* @throws ClassCastException if the class of o prevents it from being added
* @throws IllegalArgumentException if some aspect of o prevents it from
* being added
* @throws NullPointerException if null is not permitted in this set
*/
boolean add(Object o);
/**
* Adds all of the elements of the given collection to this set (optional
* operation). If the argument is also a Set, this returns the mathematical
* <i>union</i> of the two. The behavior is unspecified if the set is
* modified while this is taking place.
*
* @param c the collection to add
* @return true if the set changed as a result
* @throws UnsupportedOperationException if this operation is not allowed
* @throws ClassCastException if the class of an element prevents it from
* being added
* @throws IllegalArgumentException if something about an element prevents
* it from being added
* @throws NullPointerException if null is not permitted in this set, or
* if the argument c is null
* @see #add(Object)
*/
boolean addAll(Collection c);
/**
* Removes all elements from this set (optional operation). This set will
* be empty afterwords, unless an exception occurs.
*
* @throws UnsupportedOperationException if this operation is not allowed
*/
void clear();
/**
* Returns true if the set contains the specified element. In other words,
* this looks for <code>o == null ? e == null : o.equals(e)</code>.
*
* @param o the object to look for
* @return true if it is found in the set
*/
boolean contains(Object o);
/**
* Returns true if this set contains all elements in the specified
* collection. If the argument is also a set, this is the <i>subset</i>
* relationship.
*
* @param c the collection to check membership in
* @return true if all elements in this set are in c
* @throws NullPointerException if c is null
* @see #contains(Object)
*/
boolean containsAll(Collection c);
/**
* Compares the specified object to this for equality. For sets, the object
* must be a set, the two must have the same size, and every element in
* one must be in the other.
*
* @param o the object to compare to
* @return true if it is an equal set
*/
boolean equals(Object o);
/**
* Returns the hash code for this set. In order to satisfy the contract of
* equals, this is the sum of the hashcode of all elements in the set.
*
* @return the sum of the hashcodes of all set elements
*/
int hashCode();
/**
* Returns true if the set contains no elements.
*
* @return true if the set is empty
*/
boolean isEmpty();
/**
* Returns an iterator over the set. The iterator has no specific order,
* unless further specified.
*
* @return a set iterator
*/
Iterator iterator();
/**
* Removes the specified element from this set (optional operation). If
* an element e exists, <code>o == null ? e == null : o.equals(e)</code>,
* it is removed from the set.
*
* @param o the object to remove
* @return true if the set changed (an object was removed)
* @throws UnsupportedOperationException if this operation is not allowed
*/
boolean remove(Object o);
/**
* Removes from this set all elements contained in the specified collection
* (optional operation). If the argument is a set, this returns the
* <i>asymmetric set difference</i> of the two sets.
*
* @param c the collection to remove from this set
* @return true if this set changed as a result
* @throws UnsupportedOperationException if this operation is not allowed
* @throws NullPointerException if c is null
* @see #remove(Object)
*/
boolean removeAll(Collection c);
/**
* Retains only the elements in this set that are also in the specified
* collection (optional operation). If the argument is also a set, this
* performs the <i>intersection</i> of the two sets.
*
* @param c the collection to keep
* @return true if this set was modified
* @throws UnsupportedOperationException if this operation is not allowed
* @throws NullPointerException if c is null
* @see #remove(Object)
*/
boolean retainAll(Collection c);
/**
* Returns the number of elements in the set. If there are more
* than Integer.MAX_VALUE mappings, return Integer.MAX_VALUE. This is
* the <i>cardinality</i> of the set.
*
* @return the number of elements
*/
int size();
/**
* Returns an array containing the elements of this set. If the set
* makes a guarantee about iteration order, the array has the same
* order. The array is distinct from the set; modifying one does not
* affect the other.
*
* @return an array of this set's elements
* @see #toArray(Object[])
*/
Object[] toArray();
/**
* Returns an array containing the elements of this set, of the same runtime
* type of the argument. If the given set is large enough, it is reused,
* and null is inserted in the first unused slot. Otherwise, reflection
* is used to build a new array. If the set makes a guarantee about iteration
* order, the array has the same order. The array is distinct from the set;
* modifying one does not affect the other.
*
* @param a the array to determine the return type; if it is big enough
* it is used and returned
* @return an array holding the elements of the set
* @throws ArrayStoreException if the runtime type of a is not a supertype
* of all elements in the set
* @throws NullPointerException if a is null
* @see #toArray()
*/
Object[] toArray(Object[] a);
}