1 32 package net.sf.retrotranslator.runtime.java.lang; 33 34 import java.io.*; 35 import java.lang.reflect.Method ; 36 import java.security.*; 37 import net.sf.retrotranslator.runtime.impl.WeakIdentityTable; 38 39 42 public abstract class Enum_<E extends Enum_<E>> implements Comparable <E>, Serializable { 43 44 private static final WeakIdentityTable<Class , ConstantContainer> containers = 45 new WeakIdentityTable<Class , ConstantContainer>(); 46 47 private static class ConstantContainer { 48 49 private Enum_[] constants; 50 51 public synchronized Enum_[] getConstants() { 52 return constants; 53 } 54 55 public synchronized void setConstants(Enum_[] constants) { 56 this.constants = constants; 57 } 58 59 } 60 61 private final String name; 62 63 private final int ordinal; 64 65 protected Enum_(String name, int ordinal) { 66 this.name = name; 67 this.ordinal = ordinal; 68 } 69 70 public final String name() { 71 return name; 72 } 73 74 public final int ordinal() { 75 return ordinal; 76 } 77 78 public String toString() { 79 return name; 80 } 81 82 public final boolean equals(Object other) { 83 return this == other; 84 } 85 86 public final int hashCode() { 87 return super.hashCode(); 88 } 89 90 protected final Object clone() throws CloneNotSupportedException { 91 throw new CloneNotSupportedException (); 92 } 93 94 public final int compareTo(E other) { 95 if (this.getClass() != other.getClass() && this.getDeclaringClass() != other.getDeclaringClass()) { 96 throw new ClassCastException (); 97 } 98 return this.ordinal - other.ordinal; 99 } 100 101 public final Class <E> getDeclaringClass() { 102 Class clazz = getClass(); 103 Class zuper = clazz.getSuperclass(); 104 return (zuper == Enum_.class) ? clazz : zuper; 105 } 106 107 public static <T extends Enum_<T>> T valueOf(Class <T> enumType, String name) { 108 if (name == null) throw new NullPointerException ("Name is null"); 109 T[] enums = (T[]) getEnumConstants(enumType); 110 if (enums == null) throw new IllegalArgumentException (enumType.getName() + " is not an enum type"); 111 for (T currentEnum : enums) { 112 if (currentEnum.name.equals(name)) return currentEnum; 113 } 114 throw new IllegalArgumentException ("No enum const " + enumType + "." + name); 115 } 116 117 protected Object readResolve() throws InvalidObjectException { 118 try { 119 return valueOf(getDeclaringClass(), name); 120 } catch (IllegalArgumentException e) { 121 InvalidObjectException exception = new InvalidObjectException(e.getMessage()); 122 exception.initCause(e); 123 throw exception; 124 } 125 } 126 127 protected static Enum_[] getEnumConstants(Class aClass) { 128 ConstantContainer container = containers.lookup(aClass); 129 if (container != null) { 130 return container.getConstants(); 131 } 132 if (aClass.getSuperclass() != Enum_.class) return null; 133 initialize(aClass); 134 container = containers.lookup(aClass); 135 return container == null ? null : container.getConstants(); 136 } 137 138 protected static void setEnumConstants(Class aClass, Enum_[] enumConstants) { 139 ConstantContainer container = new ConstantContainer(); 140 container.setConstants(enumConstants); 141 containers.putIfAbsent(aClass, container); 142 } 143 144 private static void initialize(final Class aClass) { 145 AccessController.doPrivileged(new PrivilegedAction<Object >() { 146 public Object run() { 147 try { 148 Class.forName(aClass.getName(), true, aClass.getClassLoader()); 149 if (containers.lookup(aClass) == null) { 150 Method method = aClass.getMethod("values"); 151 method.setAccessible(true); 152 method.invoke(null); 153 } 154 } catch (Exception e) { 155 } 157 return null; 158 } 159 }); 160 } 161 162 } 163 | Popular Tags |