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 }