1 files changed, 0 insertions, 518 deletions
diff --git a/libjava/classpath/java/util/EnumSet.java b/libjava/classpath/java/util/EnumSet.java
deleted file mode 100644
index 60d0106..0000000
--- a/libjava/classpath/java/util/EnumSet.java
+++ /dev/null
@@ -1,518 +0,0 @@
-/* EnumSet.java - Set of enum objects
-   Copyright (C) 2004, 2005 Free Software Foundation, Inc.
-
-This file is part of GNU Classpath.
-
-GNU Classpath is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2, or (at your option)
-any later version.
-
-GNU Classpath is distributed in the hope that it will be useful, but
-WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with GNU Classpath; see the file COPYING.  If not, write to the
-Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-02110-1301 USA.
-
-Linking this library statically or dynamically with other modules is
-making a combined work based on this library.  Thus, the terms and
-conditions of the GNU General Public License cover the whole
-combination.
-
-As a special exception, the copyright holders of this library give you
-permission to link this library with independent modules to produce an
-executable, regardless of the license terms of these independent
-modules, and to copy and distribute the resulting executable under
-terms of your choice, provided that you also meet, for each linked
-independent module, the terms and conditions of the license of that
-module.  An independent module is a module which is not derived from
-or based on this library.  If you modify this library, you may extend
-this exception to your version of the library, but you are not
-obligated to do so.  If you do not wish to do so, delete this
-exception statement from your version. */
-
-
-package java.util;
-
-import java.io.Serializable;
-
-/**
- * <p>
- * 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.
- * </p>
- * <p>
- * 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.
- * </p>
- * <p>
- * The {@link Iterator} implementation traverses the values in the natural order
- * of the enumeration provided by each constant's {@link Enum#ordinal()}.  It is
- * <emph>weakly consistent</emph> and will not throw a {@link ConcurrentModificationException}.
- * This means that concurrent changes to the set may or may not be noticeable during
- * traversal.
- * </p>
- * <p>
- * 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}.
- * </p>
- *
- * @author Tom Tromey (tromey@redhat.com)
- * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
- * @author Dalibor Topic (robilad@kaffe.org)
- * @since 1.5
- */
-
-// FIXME: serialization is special, uses SerializationProxy.
-// of(E e) is the 'bottom' method that creates a real EnumSet.
-public abstract class EnumSet<T extends Enum<T>>
-  extends AbstractSet<T>
-  implements Cloneable, Serializable
-{
-  private static final long serialVersionUID = 4782406773684236311L;
-
-  // 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<T> enumClass;
-
-  /**
-   * Empty package-private constructor
-   */
-  EnumSet()
-  {
-  }
-
-  /**
-   * Returns a clone of the set.
-   *
-   * @return a clone of the set.
-   */
-  public EnumSet<T> clone()
-  {
-    EnumSet<T> r;
-
-    try
-      {
-        r = (EnumSet<T>) super.clone();
-      }
-    catch (CloneNotSupportedException _)
-      {
-        /* Can't happen */
-        return null;
-      }
-    r.store = (BitSet) store.clone();
-    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 <code>null</code>.
-   */
-  public static <T extends Enum<T>> EnumSet<T> allOf(Class<T> 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 <code>null</code>.
-   */
-  public static <T extends Enum<T>> EnumSet<T> noneOf(Class<T> 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 <code>other</code> is <code>null</code>.
-   */
-  public static <T extends Enum<T>> EnumSet<T> copyOf(EnumSet<T> 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 <code>other</code> is <code>null</code>.
-   * @throws IllegalArgumentException if the collection is empty.
-   */
-  public static <T extends Enum<T>> EnumSet<T> copyOf(Collection<T> other)
-  {
-    if (other instanceof EnumSet)
-      return copyOf((EnumSet<T>) other);
-    if (other.isEmpty())
-        throw new IllegalArgumentException("Collection is empty");
-
-    EnumSet<T> r = null;
-
-    for (T val : other)
-      {
-        if (r == null)
-          r = of(val);
-        else
-          r.add(val);
-      }
-
-    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 <code>other</code> is <code>null</code>.
-   */
-  public static <T extends Enum<T>> EnumSet<T> complementOf(EnumSet<T> other)
-  {
-    EnumSet<T> r = other.clone();
-    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 <code>first</code> is <code>null</code>.
-   */
-  public static <T extends Enum<T>> EnumSet<T> of(T first)
-  {
-    EnumSet<T> r = new EnumSet<T>()
-    {
-      public boolean add(T val)
-      {
-        if (store.get(val.ordinal()))
-          return false;
-
-        store.set(val.ordinal());
-        ++cardinality;
-        return true;
-      }
-
-      public boolean addAll(Collection<? extends T> c)
-      {
-        boolean result = false;
-        if (c instanceof EnumSet)
-        {
-          EnumSet<T> other = (EnumSet<T>) c;
-          if (enumClass == other.enumClass)
-          {
-            store.or(other.store);
-            int save = cardinality;
-            cardinality = store.cardinality();
-            result = save != cardinality;
-          }
-        }
-        else
-        {
-          for (T val : c)
-          {
-            if (add (val))
-            result = true;
-          }
-        }
-        return result;
-      }
-
-      public void clear()
-      {
-        store.clear();
-        cardinality = 0;
-      }
-
-      public boolean contains(Object o)
-      {
-        if (! (o instanceof Enum))
-          return false;
-
-        Enum<T> e = (Enum<T>) o;
-        if (e.getDeclaringClass() != enumClass)
-          return false;
-
-        return store.get(e.ordinal());
-      }
-
-      public boolean containsAll(Collection<?> c)
-      {
-        if (c instanceof EnumSet)
-        {
-          EnumSet<T> other = (EnumSet<T>) c;
-          if (enumClass == other.enumClass)
-            return store.containsAll(other.store);
-
-          return false;
-        }
-        return super.containsAll(c);
-      }
-
-      public Iterator<T> iterator()
-      {
-        return new Iterator<T>()
-        {
-          int next = -1;
-          int count = 0;
-
-          public boolean hasNext()
-          {
-            return count < cardinality;
-          }
-
-          public T next()
-          {
-            next = store.nextSetBit(next + 1);
-            ++count;
-            return enumClass.getEnumConstants()[next];
-          }
-
-          public void remove()
-          {
-            if (! store.get(next))
-            {
-                store.clear(next);
-                --cardinality;
-            }
-          }
-        };
-      }
-
-      public boolean remove(Object o)
-      {
-        if (! (o instanceof Enum))
-          return false;
-
-        Enum<T> e = (Enum<T>) o;
-        if (e.getDeclaringClass() != enumClass)
-          return false;
-
-        store.clear(e.ordinal());
-        --cardinality;
-        return true;
-      }
-
-      public boolean removeAll(Collection<?> c)
-      {
-        if (c instanceof EnumSet)
-        {
-          EnumSet<T> other = (EnumSet<T>) c;
-          if (enumClass != other.enumClass)
-            return false;
-
-          store.andNot(other.store);
-          int save = cardinality;
-          cardinality = store.cardinality();
-          return save != cardinality;
-        }
-        return super.removeAll(c);
-      }
-
-      public boolean retainAll(Collection<?> c)
-      {
-        if (c instanceof EnumSet)
-        {
-          EnumSet<T> other = (EnumSet<T>) c;
-          if (enumClass != other.enumClass)
-            return false;
-
-          store.and(other.store);
-          int save = cardinality;
-          cardinality = store.cardinality();
-          return save != cardinality;
-        }
-        return super.retainAll(c);
-      }
-
-      public int size()
-      {
-        return cardinality;
-      }
-    };
-
-    // initialize the class
-    r.enumClass = first.getDeclaringClass();
-    r.store = new BitSet(r.enumClass.getEnumConstants().length);
-
-    r.add(first);
-    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 <code>null</code>.
-   */
-  public static <T extends Enum<T>> EnumSet<T> of(T first, T second)
-  {
-    EnumSet<T> r = of(first);
-    r.add(second);
-    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 <code>null</code>.
-   */
-  public static <T extends Enum<T>> EnumSet<T> of(T first, T second, T third)
-  {
-    EnumSet<T> r = of(first, second);
-    r.add(third);
-    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 <code>null</code>.
-   */
-  public static <T extends Enum<T>> EnumSet<T> of(T first, T second, T third,
-                                                  T fourth)
-  {
-    EnumSet<T> r = of(first, second, third);
-    r.add(fourth);
-    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 <code>null</code>.
-   */
-  public static <T extends Enum<T>> EnumSet<T> of(T first, T second, T third,
-                                                  T fourth, T fifth)
-  {
-    EnumSet<T> r = of(first, second, third, fourth);
-    r.add(fifth);
-    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 <code>null</code>.
-   */
-  public static <T extends Enum<T>> EnumSet<T> of(T first, T... rest)
-  {
-    EnumSet<T> r = noneOf(first.getDeclaringClass());
-    r.add(first);
-    for (T val : rest)
-      r.add(val);
-    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 <code>null</code>.
-   * @throws IllegalArgumentException if {@code first.compareTo(last) > 0}.
-   */
-  public static <T extends Enum<T>> EnumSet<T> range(T from, T to)
-  {
-    if (from.compareTo(to) > 0)
-      throw new IllegalArgumentException();
-    Class<T> type = from.getDeclaringClass();
-    EnumSet<T> r = noneOf(type);
-
-    T[] values = type.getEnumConstants();
-    // skip over values until start of range is found
-    int i = 0;
-    while (from != values[i])
-      i++;
-
-    // add values until end of range is found
-    while (to != values[i]) {
-      r.add(values[i]);
-      i++;
-    }
-
-    // add end of range
-    r.add(to);
-
-    return r;
-  }
-}