| /* Enum.java - Base class for all enums |
| Copyright (C) 2004, 2005 Free Software Foundation |
| |
| 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.lang; |
| |
| import java.io.Serializable; |
| import java.lang.reflect.Field; |
| |
| /** |
| * This class represents a Java enumeration. All enumerations are |
| * subclasses of this class. |
| * |
| * @author Tom Tromey (tromey@redhat.com) |
| * @author Andrew John Hughes (gnu_andrew@member.fsf.org) |
| * @since 1.5 |
| */ |
| /* FIXME[GENERICS]: Should be Enum<T extends Enum<T>> |
| and Comparable<T> */ |
| public abstract class Enum |
| implements Comparable, Serializable |
| { |
| |
| /** |
| * For compatability with Sun's JDK |
| */ |
| private static final long serialVersionUID = -4300926546619394005L; |
| |
| /** |
| * The name of this enum constant. |
| */ |
| String name; |
| |
| /** |
| * The number of this enum constant. Each constant is given a number |
| * which matches the order in which it was declared, starting with zero. |
| */ |
| int ordinal; |
| |
| /** |
| * This constructor is used by the compiler to create enumeration constants. |
| * |
| * @param name the name of the enumeration constant. |
| * @param ordinal the number of the enumeration constant, based on the |
| * declaration order of the constants and starting from zero. |
| */ |
| protected Enum(String name, int ordinal) |
| { |
| this.name = name; |
| this.ordinal = ordinal; |
| } |
| |
| /** |
| * Returns an Enum for a enum class given a description string of |
| * the enum constant. |
| * |
| * @exception NullPointerException when etype or s are null. |
| * @exception IllegalArgumentException when there is no value s in |
| * the enum etype. |
| */ |
| /* FIXME[GENERICS]: Should be <S extends Enum<S>> S valueOf(Class<S>) */ |
| public static Enum valueOf(Class etype, String s) |
| { |
| if (etype == null || s == null) |
| throw new NullPointerException(); |
| |
| try |
| { |
| Field f = etype.getDeclaredField(s); |
| if (! f.isEnumConstant()) |
| throw new IllegalArgumentException(s); |
| /* FIXME[GENERICS]: Should cast to S */ |
| return (Enum) f.get(null); |
| } |
| catch (NoSuchFieldException exception) |
| { |
| throw new IllegalArgumentException(s); |
| } |
| catch (IllegalAccessException exception) |
| { |
| throw new Error("Unable to access Enum class"); |
| } |
| } |
| |
| /** |
| * Returns true if this enumeration is equivalent to the supplied object, |
| * <code>o</code>. Only one instance of an enumeration constant exists, |
| * so the comparison is simply done using <code>==</code>. |
| * |
| * @param o the object to compare to this. |
| * @return true if <code>this == o</code>. |
| */ |
| public final boolean equals(Object o) |
| { |
| // Enum constants are singular, so we need only compare `=='. |
| return this == o; |
| } |
| |
| /** |
| * Returns the hash code of this constant. This is simply the ordinal. |
| * |
| * @return the hash code of this enumeration constant. |
| */ |
| public final int hashCode() |
| { |
| return ordinal; |
| } |
| |
| /** |
| * Returns a textual representation of this enumeration constant. |
| * By default, this is simply the declared name of the constant, but |
| * specific enumeration types may provide an implementation more suited |
| * to the data being stored. |
| * |
| * @return a textual representation of this constant. |
| */ |
| public String toString() |
| { |
| return name; |
| } |
| |
| /** |
| * Returns an integer which represents the relative ordering of this |
| * enumeration constant. Enumeration constants are ordered by their |
| * ordinals, which represents their declaration order. So, comparing |
| * two identical constants yields zero, while one declared prior to |
| * this returns a positive integer and one declared after yields a |
| * negative integer. |
| * |
| * @param e the enumeration constant to compare. |
| * @return a negative integer if <code>e.ordinal < this.ordinal</code>, |
| * zero if <code>e.ordinal == this.ordinal</code> and a positive |
| * integer if <code>e.ordinal > this.ordinal</code>. |
| * @throws ClassCastException if <code>e</code> is not an enumeration |
| * constant of the same class. |
| */ |
| public final int compareTo(Enum e) |
| { |
| if (getDeclaringClass() != e.getDeclaringClass()) |
| throw new ClassCastException(); |
| return ordinal - e.ordinal; |
| } |
| |
| /** |
| * Returns an integer which represents the relative ordering of this |
| * enumeration constant. Enumeration constants are ordered by their |
| * ordinals, which represents their declaration order. So, comparing |
| * two identical constants yields zero, while one declared prior to |
| * this returns a positive integer and one declared after yields a |
| * negative integer. |
| * |
| * @param o the enumeration constant to compare. |
| * @return a negative integer if <code>e.ordinal < this.ordinal</code>, |
| * zero if <code>e.ordinal == this.ordinal</code> and a positive |
| * integer if <code>e.ordinal > this.ordinal</code>. |
| * @throws ClassCastException if <code>e</code> is not an enumeration |
| * constant of the same class. |
| */ |
| /* FIXME[GENERICS]: Remove this method */ |
| public final int compareTo(Object o) |
| { |
| return compareTo((Enum)o); |
| } |
| |
| /** |
| * Cloning of enumeration constants is prevented, to maintain their |
| * singleton status. |
| * |
| * @return the cloned object. |
| * @throws CloneNotSupportedException as enumeration constants can't be |
| * cloned. |
| */ |
| protected final Object clone() throws CloneNotSupportedException |
| { |
| throw new CloneNotSupportedException("can't clone an enum constant"); |
| } |
| |
| /** |
| * Returns the name of this enumeration constant. |
| * |
| * @return the name of the constant. |
| */ |
| public final String name() |
| { |
| return name; |
| } |
| |
| /** |
| * Returns the number of this enumeration constant, which represents |
| * the order in which it was originally declared, starting from zero. |
| * |
| * @return the number of this constant. |
| */ |
| public final int ordinal() |
| { |
| return ordinal; |
| } |
| |
| /** |
| * Returns the type of this enumeration constant. This is the class |
| * corresponding to the declaration of the enumeration. |
| * |
| * @return the type of this enumeration constant. |
| */ |
| /* FIXME[GENERICS]: Should return Class<T> */ |
| public final Class getDeclaringClass() |
| { |
| Class k = getClass(); |
| // We might be in an anonymous subclass of the enum class, so go |
| // up one more level. |
| if (k.getSuperclass() != Enum.class) |
| k = k.getSuperclass(); |
| return k; |
| } |
| } |