From 54b0bc0008d05bb93fd3b1608c616299724fc942 Mon Sep 17 00:00:00 2001 From: Andrew John Hughes Date: Thu, 30 Aug 2007 19:57:30 +0000 Subject: EnumSet.java: Documented. 2007-08-22 Andrew John Hughes * java/util/EnumSet.java: Documented. (complementOf(EnumSet)): Fixed to flip only the bits used by the enumset. From-SVN: r127938 --- libjava/classpath/ChangeLog | 7 ++ libjava/classpath/java/util/EnumSet.java | 170 ++++++++++++++++++++++++++++++- 2 files changed, 175 insertions(+), 2 deletions(-) (limited to 'libjava/classpath') diff --git a/libjava/classpath/ChangeLog b/libjava/classpath/ChangeLog index cb34d1d..15342ac 100644 --- a/libjava/classpath/ChangeLog +++ b/libjava/classpath/ChangeLog @@ -1,3 +1,10 @@ +2007-08-22 Andrew John Hughes + + * java/util/EnumSet.java: + Documented. + (complementOf(EnumSet)): Fixed to flip only + the bits used by the enumset. + 2007-07-31 Dalibor Topic PR 32844 diff --git a/libjava/classpath/java/util/EnumSet.java b/libjava/classpath/java/util/EnumSet.java index 543df0c..31b0368 100644 --- a/libjava/classpath/java/util/EnumSet.java +++ b/libjava/classpath/java/util/EnumSet.java @@ -41,6 +41,38 @@ package java.util; import java.io.Serializable; /** + *

+ * Provides an efficient mechanism for recording a set of enumeration + * constants. As enumerations have a known set of possible values, certain + * assumptions can be made when creating a set of constants. The maximum + * size of the set will always be equal to the number of constants, and each + * value will always be one of these constants. As a result, the set only needs + * to store whether a particular constant is present or not rather than the + * values themselves. Each constant can thus be represented by a single bit. + *

+ *

+ * This class is designed to provide an alternative to using integer bit flags + * by providing a typesafe {@link Collection} interface with an underlying + * implementation that utilises the assumptions above to give an equivalent level + * of efficiency. The values in a {@link EnumSet} must all be from the same + * {@link Enum} type, which allows the contents to be packed into a bit vector. + * A containment test is then simply a matter of inspecting the appropriate bit, while + * addition involves setting the same. Such basic operations take place in constant + * time. + *

+ *

+ * The {@link Iterator} implementation traverses the values in the natural order + * of the enumeration provided by each constant's {@link Enum#ordinal()}. It is + * weakly consistent and will not throw a {@link ConcurrentModificationException}. + * This means that concurrent changes to the set may or may not be noticeable during + * traversal. + *

+ *

+ * As is usual with most collections, the set is not synchronized by default. This + * can be remedied by using the {@link Collections#synchronizedSet(Set)} method. Null + * elements are not supported and attempts to add one will throw a {@link NullPointerException}. + *

+ * * @author Tom Tromey (tromey@redhat.com) * @author Andrew John Hughes (gnu_andrew@member.fsf.org) * @author Dalibor Topic (robilad@kaffe.org) @@ -57,14 +89,35 @@ public abstract class EnumSet> // These fields could go into the anonymous inner class in of(E), // complementOf would need to be refactored then, though. + /** + * The store which maintains the bits used to represent + * the enumeration constants. + */ BitSet store; + + /** + * The cardinality of the set (the current number + * of bits set). + */ int cardinality; + + /** + * The enumeration used by this set. + */ Class enumClass; + /** + * Empty package-private constructor + */ EnumSet() { } + /** + * Returns a clone of the set. + * + * @return a clone of the set. + */ public EnumSet clone() { EnumSet r; @@ -82,22 +135,56 @@ public abstract class EnumSet> return r; } + /** + * Returns a set for the given enumeration type where + * all the constants are present. + * + * @param eltType the type of enumeration to use for the set. + * @return an {@link EnumSet} with all the bits set. + * @throws NullPointerException if the element type is null. + */ public static > EnumSet allOf(Class eltType) { // create an EnumSet from the list of values of the type return copyOf(Arrays.asList(eltType.getEnumConstants())); } + /** + * Returns a set for the given enumeration type where + * none of the constants are present. + * + * @param eltType the type of enumeration to use for the set. + * @return an {@link EnumSet} with none of the bits set. + * @throws NullPointerException if the element type is null. + */ public static > EnumSet noneOf(Class eltType) { return complementOf(allOf(eltType)); } + /** + * Returns a clone of the given set. + * + * @param other the set to clone. + * @return an {@link EnumSet} that is a clone of the given set. + * @throws NullPointerException if other is null. + */ public static > EnumSet copyOf(EnumSet other) { return other.clone(); } + /** + * Creates an {@link EnumSet} using the contents of the given collection. + * If the collection is also an {@link EnumSet}, this method works the + * same as {@link #copyOf(EnumSet)}. Otherwise, the elements of the collection + * are inspected and used to populate the new set. + * + * @param other the collection to use to populate the new set. + * @return an {@link EnumSet} containing elements from the given collection. + * @throws NullPointerException if other is null. + * @throws IllegalArgumentException if the collection is empty. + */ public static > EnumSet copyOf(Collection other) { if (other instanceof EnumSet) @@ -118,14 +205,31 @@ public abstract class EnumSet> return r; } + /** + * Returns a set which is the inverse of the supplied set. + * If a constant is present in the current set, it will not be + * present in the new set and vice versa. + * + * @param other the set to provide the complement of. + * @return an {@link EnumSet} which is the inverse of the current one. + * @throws NullPointerException if other is null. + */ public static > EnumSet complementOf(EnumSet other) { EnumSet r = other.clone(); - r.store.flip(0, r.store.size()); - r.cardinality = r.store.size() - other.cardinality; + int numConstants = r.enumClass.getEnumConstants().length; + r.store.flip(0, numConstants); + r.cardinality = numConstants - other.cardinality; return r; } + /** + * Creates a new {@link EnumSet} populated with the given element. + * + * @param first the element to use to populate the new set. + * @return an {@link EnumSet} containing the element. + * @throws NullPointerException if first is null. + */ public static > EnumSet of(T first) { EnumSet r = new EnumSet() @@ -286,6 +390,14 @@ public abstract class EnumSet> return r; } + /** + * Creates a new {@link EnumSet} populated with the given two elements. + * + * @param first the first element to use to populate the new set. + * @param second the second element to use. + * @return an {@link EnumSet} containing the elements. + * @throws NullPointerException if any of the parameters are null. + */ public static > EnumSet of(T first, T second) { EnumSet r = of(first); @@ -293,6 +405,15 @@ public abstract class EnumSet> return r; } + /** + * Creates a new {@link EnumSet} populated with the given three elements. + * + * @param first the first element to use to populate the new set. + * @param second the second element to use. + * @param third the third element to use. + * @return an {@link EnumSet} containing the elements. + * @throws NullPointerException if any of the parameters are null. + */ public static > EnumSet of(T first, T second, T third) { EnumSet r = of(first, second); @@ -300,6 +421,16 @@ public abstract class EnumSet> return r; } + /** + * Creates a new {@link EnumSet} populated with the given four elements. + * + * @param first the first element to use to populate the new set. + * @param second the second element to use. + * @param third the third element to use. + * @param fourth the fourth element to use. + * @return an {@link EnumSet} containing the elements. + * @throws NullPointerException if any of the parameters are null. + */ public static > EnumSet of(T first, T second, T third, T fourth) { @@ -308,6 +439,17 @@ public abstract class EnumSet> return r; } + /** + * Creates a new {@link EnumSet} populated with the given five elements. + * + * @param first the first element to use to populate the new set. + * @param second the second element to use. + * @param third the third element to use. + * @param fourth the fourth element to use. + * @param fifth the fifth element to use. + * @return an {@link EnumSet} containing the elements. + * @throws NullPointerException if any of the parameters are null. + */ public static > EnumSet of(T first, T second, T third, T fourth, T fifth) { @@ -316,6 +458,14 @@ public abstract class EnumSet> return r; } + /** + * Creates a new {@link EnumSet} populated with the given elements. + * + * @param first the first element to use to populate the new set. + * @param rest the other elements to use. + * @return an {@link EnumSet} containing the elements. + * @throws NullPointerException if any of the parameters are null. + */ public static > EnumSet of(T first, T... rest) { EnumSet r = noneOf(first.getDeclaringClass()); @@ -325,6 +475,22 @@ public abstract class EnumSet> return r; } + /** + * Creates a new {@link EnumSet} using the enumeration constants + * starting from {@code from} and ending at {@code to} inclusive. + * The two may be the same, but they must be in the correct order. + * So giving the first constant twice would give a set with just that + * constant set, while supplying the first and second constant will give + * a set with those two elements. However, specifying the second as + * the {@code from} element followed by an earlier element as the + * {@code to} element will result in an error. + * + * @param from the element to start from. + * @param to the element to end at (may be the same as {@code from}. + * @return an {@link EnumSet} containing the specified range of elements. + * @throws NullPointerException if any of the parameters are null. + * @throws IllegalArgumentException if {@code first.compareTo(last) > 0}. + */ public static > EnumSet range(T from, T to) { if (from.compareTo(to) > 0) -- cgit v1.1