Commons already has an enum facility in commons-lang. It is designed for
pre-JDK 1.5, works reasonably well and provides most of the semantics
you are looking for.
For JDK1.5 onwards, most developers would choose the Sun supported enum
facility. It appears to meet most peoples requirements.
Stephen
John Kaplan wrote:
Hello All,
I've been working on a Java card playing program in my spare time, and I
figured out something about Enumerations that may be of general use.
The issue is if you are working with concepts like card ranks and suits
in a
non-trivial application, you want them to be comparable, serializable, and
have their visual aspects defined in properties, not code. In the classic
Enumeration pattern, you would re-implement the methods needed to do this
stuff for each class, along with iterators and lookup methods.
I figured out a way to code up an Enumeration base class that takes care of
all the excise tasks for properties, serialization, hashing, comparing,
etc.. This class allows you to extend as many subclass enumerations as you
want, and it automatically keeps all of the enumerations in their own name
and number (ordinal) spaces with no runtime penalty.
To extend the current implementation, you have to override 3 one-liner
methods in your subclass (the constructor and methods to look up
enumeration
instances by name and ordinal). I think I can further simplify that with
annotation processing so you only have to indicate if you want the default
overrides or variations. Other possible enhancements include allowing
injection of alternate serialization options or ordinal sizes. (It
currently
uses a byte-sized ordinal because most cases I could think of don't have
hundreds of enumeration constants, but they often have need of conserving
space in databases.)
I also think there's a way with annotation processing to specify default
properties in the class file without having to create/edit a separate
properties file, and that may be generally useful outside of enumerations.
So, any interest in being involved with a commons project for such a thing,
or in using it if delivered? I am not sure of the number of committers
required or the sponsorship/championship needed for such a small thing in
the Commons, so any advice would be appreciated. I am willing to do all the
coding, testing, and documentation if need be, or to share with anyone else
interested in contributing according to Commons guidelines. Below is an
example of a subclass.
Thanks,
- John
public final class Suit extends Enumeration
{
protected static final long serialVersionUID =
Enumeration.serialVersionUID;
public static final Suit noSuit = new Suit( 0, "X" );
public static final Suit clubs = new Suit( 1, "C" );
public static final Suit diamonds = new Suit( 2, "D" );
public static final Suit hearts = new Suit( 3, "H" );
public static final Suit spades = new Suit( 4, "S" );
private Suit( int ordinal, String name )
{
super( ordinal, name );
}
public static final Suit fromOrdinal( int ordinal )
{
return (Suit) noSuit.getFromOrdinal( ordinal );
}
public static final Suit fromName( String name )
{
return (Suit) noSuit.getFromName( name );
}
}
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
