java.lang.Object
   net.sf.eBus.util.Enum

All Implemented Interfaces:
    Serializable, Comparable

Direct Known Subclasses:
    OpEnum, PriceType, MessageTypeEnum, ConnectStateEnum, SystemStatusEnum, ReportFrequencyEnum, Participant, DataTypeEnum

Extending Enum

Classes extending Enum should provide the following:

• Have a private constructor which takes a least the enumerated object's name and ordinal as arguments.
• Store the enumerated objects in both an array and a Map. Use the ordinal as the array index and the name as the Map's key. Note: because the ordinal is used as an array index, you should number the enumerated objects sequentially starting from 0.
• Define each enumerated object as a public static final data member.
• Provide two methods to translate an ordinal or name into an enumerated object:

  public static MyEnum valueOf(int ordinal)
  throws ArrayIndexOutOfBoundsException
  {
  return (_OrdinalMap.get(_ordinal));
  }
  
  public static MyEnum valueOf(String name)
  {
  return ((MyEnum) _NameMap.get(name));
  }
  

See net.sf.eBus.util.logging.ReportFrequencyEnum for an Enum example.

Serializing an Enum

Because all enumerated objects are statically instantiated and applications depending on == working for two separate references to the same enumeration object, serialization must reuse those existing enumeration objects and not create new ones. If you are extending Enum and need to serialize your enumeration objects, then do the following:

• Have your enumeration class implement java.io.Serliazable interface.
• Make all member data transient. The Enum base class will serialize only the _ordinal.
• This method translates the deserialized ordinal back into one of the existing references:

  private Object readResolve()
  throws ObjectStreamException
  {
  MyEnum retval = (MyEnum) _ordinalMap.get(_ordinal);
  
  if (retval == null)
  {
  throw (
  new InvalidObjectException(
  "invalid ordinal (" + _ordinal + ")"));
  }
  
  return (retval);
  }
  

author: < - a href="mailto:rapp@acm.org">Charles Rapp

 protected Enum(String name,
    int ordinal) 
{
        _name = name;
        _ordinal = new Integer(ordinal);
}

 public int compareTo(Object obj) 
{
        Class clazz = obj.getClass();
        if (clazz.equals(getClass()) == false)
        {
            throw (
                new ClassCastException());
        }
        return (_ordinal.compareTo(((Enum) obj)._ordinal));
}

 public boolean equals(Object obj) 
{
        boolean retcode = false;
        if (obj == this)
        {
            retcode = true;
        }
        else if (obj != null &&
                 obj.getClass().equals(getClass()) == true)
        {
            try
            {
                Enum enumObj = (Enum) obj;
                retcode = enumObj._ordinal.equals(_ordinal);
            }
            catch (ClassCastException castex)
            {
                // The return code is already set to false.
            }
        }
        return (retcode);
}

 public String getName() 
{
        return (_name);
}

 public int getOrdinal() 
{
        return (_ordinal.intValue());
}

 public int hashCode() 
{
        return (_ordinal.hashCode());
}

 public String toString() 
{
        return (_name);
}