Atif Khan’s Blog

Multi-valued Reversible enum in Java

By Atif Khan ( April 16, 2007 at 6:46 pm) · Filed under Java, Programming, Software

Sometime back I proposed a reversible enum pattern in my post. One thing missing from that implementation was the ability to successfully lookup the enum constants in cases where enum constants can have multiple values. To accomplish this, I utilized another feature introduced in Java 5, namely varargs or variable argument support. This way while building the key for the map, we utilize all the values for a constant and use the varargs in the reverse() method of the enum.

Let’s look at the interface MultiValueReversibleEnum that denotes an enum as reversible and that an enum should implement.

The things to notice in this interface are:

getAllCode() method - It returns an array of all the possible values for an enum constant
reverse( E ... code ) method - You can see the usage of varargs here. You basically give all the possible values for the enum constant you want to lookup in the right order

Next we need to look at the map MultiValueReverseEnumMap that will store the enum constants and their value mappings.

import java.util.HashMap;
import java.util.Map;

/**
 * 
 * A utility class that provides a reverse map of the {@link Enum} that is keyed
 * by the values of the {@link Enum} constant. This map implementation
 * should be used with the enums implementing the
 * {@link MultiValueReversibleEnum} interface.
 * 
 * @author Atif Khan
 * @param <K>
 * The class type of the values of the enum constant
 * @param <V>
 * The Enum for which the map is being created
 * @since Mar 26, 2007
 */
public class MultiValueReverseEnumMap<K, V extends MultiValueReversibleEnum<K, V>>
{
 private final Map<String, V> mReverseMap = new HashMap<String, V>();

/**
 * 
 * Create a new instance of ReverseEnumMap.
 * 
 * @param valueType
 */
 public MultiValueReverseEnumMap( final Class<V> valueType )
 {
 for( final V v : valueType.getEnumConstants() ) {
 mReverseMap.put( buildKey( v.getAllCodes() ), v );
 }
 }

/**
 * 
 * Perform the reverse lookup for the given enum values and return the enum
 * constant.
 * 
 * @param enumValues
 * @return enum constant
 */
 public V get( final K ... enumValues )
 {
 return mReverseMap.get( buildKey( enumValues ) );
 }

/**
 * 
 * Build the key for the entry in the map using the array of values supplied.
 * 
 * @param values
 * @return key for the entry
 */
 private String buildKey( final K[] values )
 {
 final StringBuilder valueBuff = new StringBuilder( values.length * 5 );
 for( final K value : values ) {
 valueBuff.append( value.hashCode() );
 }

return valueBuff.toString();
  }
}

As you can see, the getAllCodes() defined in the interface is used to build the key for the map. Also, the get( final K ... enumValues ) method that looks up the value in map uses varargs.

Now it’s time to glue everything together and see how to use the interface and map to build a multi-valued reversible enum. We will write a test class MultiValuedEnumTest.

import com.ihg.dec.framework.commons.utils.enums.MultiValueReverseEnumMap;
import com.ihg.dec.framework.commons.utils.enums.MultiValueReversibleEnum;

/**
 * 
 * A test class for multi-values enum that implements the
 * <code>MultiValueReversibleEnum</code> interface and uses the
 * <code>MultiValueReverseEnumMap</code>.
 * 
 * @author Atif Khan
 * @since Apr 16, 2007
 */
public class MultiValuedEnumTest
{
 enum TestEnum
 implements MultiValueReversibleEnum<Integer, TestEnum>
 {

ONE(1, 11),
    TWO(2, 22);

private int mCode1;
    private int mCode2;

private static final MultiValueReverseEnumMap<Integer, TestEnum> mMap = new MultiValueReverseEnumMap<Integer, TestEnum>(
 TestEnum.class );

/**
 * Create a new instance of TestEnum. 
 * @param code1
 * @param code2
 */
 private TestEnum( final int code1, final int code2 )
 {
 mCode1 = code1;
 mCode2 = code2;
 }

/**
 * Get the value of <code>code1</code>. 
 * @return Returns the code1.
 */
 public int getCode1()
 {
 return mCode1;
 }

/**
 * Get the value of <code>code2</code>. 
 * @return Returns the code2.
 */
 public int getCode2()
 {
 return mCode2;
 }

/**
     * Get an instance of TestEnum
     * @return TestEnum constant
     */
    public static TestEnum getInstance()
    {
      return TestEnum.ONE;
    }

/**
     * @see com.ihg.dec.framework.commons.utils.enums.MultiValueReversibleEnum#getAllCodes()
     */
    public Integer[] getAllCodes()
    {
      return new Integer[] {
        getCode1(), getCode2()
      };
    }

/**
     * @see com.ihg.dec.framework.commons.utils.enums.MultiValueReversibleEnum#reverse(E[])
     */
    public TestEnum reverse( final Integer ... code )
    {
      return mMap.get( code );
    }
  }

/**
 * 
 * The main method to execute this class.
 * 
 * @param args
 */
 public static void main( final String[] args )
 {
 System.out.println("Reverse for [1, 11]: " + TestMultiValueEnum.getInstance().reverse( 1, 11 ) );
 System.out.println("Reverse for [2, 22]: " + TestMultiValueEnum.getInstance().reverse( 2, 22 ) );
 }

}

If you run this class, you should see following getting printed:

Reverse for [1, 11]: ONE
Reverse for [2, 22]: TWO

It’s all very simple and straightforward. If you have any suggestions or feedback to improve this, please leave me a comment.

Share and Enjoy:

Permalink

1 Comment »

christian heinzer said,

May 10, 2007 @ 4:44 pm

Good work: exactly what I was looking for.

One word of warning though: The buildKey method in MultiValueReverseEnumMap is dangerous: hashCode() doesn’t guarantee uniqueness - as an example try with single String values and use .reverse( “0-42L” ) and .reverse(”0-43-”): they will return the same enum.