001    /* Enum.java - Base class for all enums
002       Copyright (C) 2004, 2005 Free Software Foundation
003    
004    This file is part of GNU Classpath.
005    
006    GNU Classpath is free software; you can redistribute it and/or modify
007    it under the terms of the GNU General Public License as published by
008    the Free Software Foundation; either version 2, or (at your option)
009    any later version.
010    
011    GNU Classpath is distributed in the hope that it will be useful, but
012    WITHOUT ANY WARRANTY; without even the implied warranty of
013    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
014    General Public License for more details.
015    
016    You should have received a copy of the GNU General Public License
017    along with GNU Classpath; see the file COPYING.  If not, write to the
018    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
019    02110-1301 USA.
020    
021    Linking this library statically or dynamically with other modules is
022    making a combined work based on this library.  Thus, the terms and
023    conditions of the GNU General Public License cover the whole
024    combination.
025    
026    As a special exception, the copyright holders of this library give you
027    permission to link this library with independent modules to produce an
028    executable, regardless of the license terms of these independent
029    modules, and to copy and distribute the resulting executable under
030    terms of your choice, provided that you also meet, for each linked
031    independent module, the terms and conditions of the license of that
032    module.  An independent module is a module which is not derived from
033    or based on this library.  If you modify this library, you may extend
034    this exception to your version of the library, but you are not
035    obligated to do so.  If you do not wish to do so, delete this
036    exception statement from your version. */
037    
038    package java.lang;
039    
040    import java.io.Serializable;
041    import java.lang.reflect.Field;
042    
043    /**
044     * This class represents a Java enumeration.  All enumerations are
045     * subclasses of this class.
046     *
047     * @author Tom Tromey (tromey@redhat.com)
048     * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
049     * @since 1.5
050     */
051    public abstract class Enum<T extends Enum<T>>
052      implements Comparable<T>, Serializable
053    {
054    
055      /**
056       * For compatability with Sun's JDK
057       */
058      private static final long serialVersionUID = -4300926546619394005L;
059    
060      /**
061       * The name of this enum constant.
062       */
063      final String name;
064    
065      /**
066       * The number of this enum constant.  Each constant is given a number
067       * which matches the order in which it was declared, starting with zero.
068       */
069      final int ordinal;
070    
071      /**
072       * This constructor is used by the compiler to create enumeration constants.
073       *
074       * @param name the name of the enumeration constant.
075       * @param ordinal the number of the enumeration constant, based on the
076       *                declaration order of the constants and starting from zero.
077       */
078      protected Enum(String name, int ordinal)
079      {
080        this.name = name;
081        this.ordinal = ordinal;
082      }
083    
084      /**
085       * Returns an Enum for a enum class given a description string of
086       * the enum constant.
087       *
088       * @exception NullPointerException when etype or s are null.
089       * @exception IllegalArgumentException when there is no value s in
090       * the enum etype.
091       */
092      @SuppressWarnings("unchecked")
093      public static <S extends Enum<S>> S valueOf(Class<S> etype, String s)
094      {
095        if (etype == null || s == null)
096          throw new NullPointerException();
097    
098        try
099          {
100            // XXX We should not use getDeclaredField, because it does
101            // an unnecessary security check.
102            Field f = etype.getDeclaredField(s);
103            if (! f.isEnumConstant())
104              throw new IllegalArgumentException(s);
105            Class.setAccessible(f);
106            return (S) f.get(null);
107          }
108        catch (NoSuchFieldException exception)
109          {
110            throw new IllegalArgumentException(s);
111          }
112        catch (IllegalAccessException exception)
113          {
114            throw new Error("Unable to access Enum class");
115          }
116      }
117    
118      /**
119       * Returns true if this enumeration is equivalent to the supplied object,
120       * <code>o</code>.  Only one instance of an enumeration constant exists,
121       * so the comparison is simply done using <code>==</code>.
122       *
123       * @param o the object to compare to this.
124       * @return true if <code>this == o</code>.
125       */
126      public final boolean equals(Object o)
127      {
128        // Enum constants are singular, so we need only compare `=='.
129        return this == o;
130      }
131    
132      /**
133       * Returns the hash code of this constant.  This is simply the ordinal.
134       *
135       * @return the hash code of this enumeration constant.
136       */
137      public final int hashCode()
138      {
139        return ordinal;
140      }
141    
142      /**
143       * Returns a textual representation of this enumeration constant.
144       * By default, this is simply the declared name of the constant, but
145       * specific enumeration types may provide an implementation more suited
146       * to the data being stored.
147       *
148       * @return a textual representation of this constant.
149       */
150      public String toString()
151      {
152        return name;
153      }
154    
155      /**
156       * Returns an integer which represents the relative ordering of this
157       * enumeration constant.  Enumeration constants are ordered by their
158       * ordinals, which represents their declaration order.  So, comparing
159       * two identical constants yields zero, while one declared prior to
160       * this returns a positive integer and one declared after yields a
161       * negative integer.
162       *
163       * @param e the enumeration constant to compare.
164       * @return a negative integer if <code>e.ordinal < this.ordinal</code>,
165       *         zero if <code>e.ordinal == this.ordinal</code> and a positive
166       *         integer if <code>e.ordinal > this.ordinal</code>.
167       * @throws ClassCastException if <code>e</code> is not an enumeration
168       *                            constant of the same class.
169       */ 
170      public final int compareTo(T e)
171      {
172        if (getDeclaringClass() != e.getDeclaringClass())
173          throw new ClassCastException();
174        return ordinal - e.ordinal;
175      }
176    
177      /**
178       * Cloning of enumeration constants is prevented, to maintain their
179       * singleton status.
180       *
181       * @return the cloned object.
182       * @throws CloneNotSupportedException as enumeration constants can't be
183       *         cloned.
184       */
185      protected final Object clone() throws CloneNotSupportedException
186      {
187        throw new CloneNotSupportedException("can't clone an enum constant");
188      }
189    
190      /**
191       * Returns the name of this enumeration constant.
192       *
193       * @return the name of the constant.
194       */
195      public final String name()
196      {
197        return name;
198      }
199    
200      /**
201       * Returns the number of this enumeration constant, which represents
202       * the order in which it was originally declared, starting from zero.
203       * 
204       * @return the number of this constant.
205       */
206      public final int ordinal()
207      {
208        return ordinal;
209      }
210    
211      /**
212       * Returns the type of this enumeration constant.  This is the class
213       * corresponding to the declaration of the enumeration.
214       *
215       * @return the type of this enumeration constant.
216       */
217      public final Class<T> getDeclaringClass()
218      {
219        Class k = getClass();
220        // We might be in an anonymous subclass of the enum class, so go
221        // up one more level.
222        if (k.getSuperclass() != Enum.class)
223          k = k.getSuperclass();
224        return k;
225      }
226    
227      /**
228       * Enumerations can not have finalization methods.
229       *
230       * @since 1.6
231       */
232      protected final void finalize()
233      {
234      }
235    
236    }