1 /* Enum.java - Base class for all enums 2 Copyright (C) 2004, 2005 Free Software Foundation 3 4 This file is part of GNU Classpath. 5 6 GNU Classpath is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 2, or (at your option) 9 any later version. 10 11 GNU Classpath is distributed in the hope that it will be useful, but 12 WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with GNU Classpath; see the file COPYING. If not, write to the 18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 19 02110-1301 USA. 20 21 Linking this library statically or dynamically with other modules is 22 making a combined work based on this library. Thus, the terms and 23 conditions of the GNU General Public License cover the whole 24 combination. 25 26 As a special exception, the copyright holders of this library give you 27 permission to link this library with independent modules to produce an 28 executable, regardless of the license terms of these independent 29 modules, and to copy and distribute the resulting executable under 30 terms of your choice, provided that you also meet, for each linked 31 independent module, the terms and conditions of the license of that 32 module. An independent module is a module which is not derived from 33 or based on this library. If you modify this library, you may extend 34 this exception to your version of the library, but you are not 35 obligated to do so. If you do not wish to do so, delete this 36 exception statement from your version. */ 37 38 package java.lang; 39 40 import java.io.Serializable; 41 import java.lang.reflect.Field; 42 43 /** 44 * This class represents a Java enumeration. All enumerations are 45 * subclasses of this class. 46 * 47 * @author Tom Tromey (tromey@redhat.com) 48 * @author Andrew John Hughes (gnu_andrew@member.fsf.org) 49 * @since 1.5 50 */ 51 public abstract class Enum<T extends Enum<T>> 52 implements Comparable<T>, Serializable 53 { 54 55 /** 56 * For compatability with Sun's JDK 57 */ 58 private static final long serialVersionUID = -4300926546619394005L; 59 60 /** 61 * The name of this enum constant. 62 */ 63 final String name; 64 65 /** 66 * The number of this enum constant. Each constant is given a number 67 * which matches the order in which it was declared, starting with zero. 68 */ 69 final int ordinal; 70 71 /** 72 * This constructor is used by the compiler to create enumeration constants. 73 * 74 * @param name the name of the enumeration constant. 75 * @param ordinal the number of the enumeration constant, based on the 76 * declaration order of the constants and starting from zero. 77 */ Enum(String name, int ordinal)78 protected Enum(String name, int ordinal) 79 { 80 this.name = name; 81 this.ordinal = ordinal; 82 } 83 84 /** 85 * Returns an Enum for a enum class given a description string of 86 * the enum constant. 87 * 88 * @exception NullPointerException when etype or s are null. 89 * @exception IllegalArgumentException when there is no value s in 90 * the enum etype. 91 */ valueOf(Class<S> etype, String s)92 public static <S extends Enum<S>> S valueOf(Class<S> etype, String s) 93 { 94 if (etype == null || s == null) 95 throw new NullPointerException(); 96 97 try 98 { 99 // XXX We should not use getDeclaredField, because it does 100 // an unnecessary security check. 101 Field f = etype.getDeclaredField(s); 102 if (! f.isEnumConstant()) 103 throw new IllegalArgumentException(s); 104 Class.setAccessible(f); 105 @SuppressWarnings("unchecked") 106 S val = (S) f.get(null); 107 return val; 108 } 109 catch (NoSuchFieldException exception) 110 { 111 throw new IllegalArgumentException(s); 112 } 113 catch (IllegalAccessException exception) 114 { 115 throw new Error("Unable to access Enum class"); 116 } 117 } 118 119 /** 120 * Returns true if this enumeration is equivalent to the supplied object, 121 * <code>o</code>. Only one instance of an enumeration constant exists, 122 * so the comparison is simply done using <code>==</code>. 123 * 124 * @param o the object to compare to this. 125 * @return true if <code>this == o</code>. 126 */ equals(Object o)127 public final boolean equals(Object o) 128 { 129 // Enum constants are singular, so we need only compare `=='. 130 return this == o; 131 } 132 133 /** 134 * Returns the hash code of this constant. This is simply the ordinal. 135 * 136 * @return the hash code of this enumeration constant. 137 */ hashCode()138 public final int hashCode() 139 { 140 return ordinal; 141 } 142 143 /** 144 * Returns a textual representation of this enumeration constant. 145 * By default, this is simply the declared name of the constant, but 146 * specific enumeration types may provide an implementation more suited 147 * to the data being stored. 148 * 149 * @return a textual representation of this constant. 150 */ toString()151 public String toString() 152 { 153 return name; 154 } 155 156 /** 157 * Returns an integer which represents the relative ordering of this 158 * enumeration constant. Enumeration constants are ordered by their 159 * ordinals, which represents their declaration order. So, comparing 160 * two identical constants yields zero, while one declared prior to 161 * this returns a positive integer and one declared after yields a 162 * negative integer. 163 * 164 * @param e the enumeration constant to compare. 165 * @return a negative integer if <code>e.ordinal < this.ordinal</code>, 166 * zero if <code>e.ordinal == this.ordinal</code> and a positive 167 * integer if <code>e.ordinal > this.ordinal</code>. 168 * @throws ClassCastException if <code>e</code> is not an enumeration 169 * constant of the same class. 170 */ compareTo(T e)171 public final int compareTo(T e) 172 { 173 if (getDeclaringClass() != e.getDeclaringClass()) 174 throw new ClassCastException(); 175 return ordinal - e.ordinal; 176 } 177 178 /** 179 * Cloning of enumeration constants is prevented, to maintain their 180 * singleton status. 181 * 182 * @return the cloned object. 183 * @throws CloneNotSupportedException as enumeration constants can't be 184 * cloned. 185 */ clone()186 protected final Object clone() throws CloneNotSupportedException 187 { 188 throw new CloneNotSupportedException("can't clone an enum constant"); 189 } 190 191 /** 192 * Returns the name of this enumeration constant. 193 * 194 * @return the name of the constant. 195 */ name()196 public final String name() 197 { 198 return name; 199 } 200 201 /** 202 * Returns the number of this enumeration constant, which represents 203 * the order in which it was originally declared, starting from zero. 204 * 205 * @return the number of this constant. 206 */ ordinal()207 public final int ordinal() 208 { 209 return ordinal; 210 } 211 212 /** 213 * Returns the type of this enumeration constant. This is the class 214 * corresponding to the declaration of the enumeration. 215 * 216 * @return the type of this enumeration constant. 217 */ getDeclaringClass()218 public final Class<T> getDeclaringClass() 219 { 220 Class k = getClass(); 221 // We might be in an anonymous subclass of the enum class, so go 222 // up one more level. 223 if (k.getSuperclass() != Enum.class) 224 k = k.getSuperclass(); 225 return k; 226 } 227 228 /** 229 * Enumerations can not have finalization methods. 230 * 231 * @since 1.6 232 */ finalize()233 protected final void finalize() 234 { 235 } 236 237 } 238