EnumSet bit vector values

[R Das]

I am on Java 1.5 and the API http://java.sun.com/javase/7/docs/api/java/util/EnumSet.html mentions that "Enum sets are represented internally as bit vectors.". Is it possible to get that bit value?

The following pseudo code fragment shows what I'm trying to achieve as well as my question.

public class ExampleClass {
public Enum ServiceCapability 
{
   CAPABILITY0, // 1 << 0
   CAPABILITY2, // 1 << 1
   CAPABILITY4, // 1 << 2
   CAPABILITY8; // 1 << 3
}

public static void main(String[] args) 
{
  Set<ServiceCapability> serCap = EnumSet.allOf(ServiceCapability.class);
  /* Apparently the EnumSet is recommended to be used instead of bit fields
      however, I am not sure how to use the EnumSet to get the internal bit vector
      representations.
      I can modify the Enum that I have created to have a 'short' value that
      represents the corresponding bit values and that would work just fine.
      I am hoping that the JavaRanch community will have an answer for me.
  */
} 
} 
 

Thanks!

[Ireneusz Kordal]

R Pervasive wrote: Is it possible to get that bit value?

Yes, it is possible using reflection.
Here is an example for enums up to 64 elements (bits):

enum TestEnum {
    A, B, C, D, E, F, G, H
};

public class Test {
    public static void main(String a[]) {
        EnumSet<TestEnum> t = EnumSet.noneOf(TestEnum.class); // empty enumSet
        System.out.println("Empty enum : " + getBinaryVector(t));

        for(TestEnum tt: TestEnum.values() ){
            t.clear();
            t.add(tt);
            System.out.println("Enum = " + tt.name() + " : " + getBinaryVector(t));
        }
        t.clear();
        for(TestEnum tt: TestEnum.values() ){
            t.add(tt);
            System.out.println("Enums : " + getBinaryVector(t));
        }
    }

    static public String getBinaryVector(EnumSet e) {
        Class<?> c = e.getClass();
        try {
            Field elements = c.getDeclaredField("elements");
            elements.setAccessible(true);
            return Long.toBinaryString(elements.getLong(e));
        } catch (NoSuchFieldException ex) {
            throw new RuntimeException("Error while accessing bitVector", ex);
        } catch (SecurityException ex) {
            throw new RuntimeException("Error while accessing bitVector", ex);
        } catch (IllegalAccessException ex) {
            throw new RuntimeException("Error while accessing bitVector", ex);
        }
    }
}

This code accesses a private field of Enum object and is highly implementation dependent,
could run on some versions of JVM/operating systems, could break on others or on future versions of JVM,
so don't use this method unless you really must.

[Rob Spoor]

Except that won't work if you all of a sudden get more than 64 elements. Instead of the RegularEnumSet class that uses a long field you get the JumboEnumSet class that uses a long[].

[Jesper de Jong]

R Pervasive wrote:I am on Java 1.5 and the API http://java.sun.com/javase/7/docs/api/java/util/EnumSet.html mentions that "Enum sets are represented internally as bit vectors.". Is it possible to get that bit value?

Note that the documentation that your link points to is for the pre-release version of Java 7 - not all of it applies to Java 5.

[R Das]

Thanks for the solution and your comments.

[Federico Minarelli]

hello everybody!
I am facing a similar problem to that exposed in this thread..

I want to use an EnumSet instead of bit fields, but my problem is that I need a constructor which has to accept an integer representing the members of the enum which have to be present in the EnumSet..

   
public class Text{

private EnumSet<Style> styles; 
public enum Style {BOLD, ITALIC,UNDERLINE};// 1. 2. 4 in numbers


public Text (int s){
//Has to set styles properly 
//eg, 5 represents BOLD + UNDERLINE
}

public boolean isBold(){
return styles.contains(Style.BOLD);
}
 

Do I have to make an explicit switch (s) in the constructor? Or is there a better solution?

Thanks a lot for your help!
Bye!

[Aj Neufeld]

The reverse of the above works almost as well. Only trick is the EnumSet must be created, such as with the noneOf() call below. Again, this assumes the "RegularEnumSet", with 64 or less bits, but you wanted a bitmask passed in as a 32-bit int, so that seems a safe assumption. Standard disclaimers about subject to changes in implementation details apply.

import java.lang.reflect.Field;
import java.util.EnumSet;

public class Text {  
   
  private EnumSet<Style> styles = EnumSet.noneOf(Style.class);
  public enum Style {BOLD, ITALIC, UNDERLINE};// 1. 2. 4 in numbers  
  
  public Text (int s) throws Exception {
    Field elements = styles.getClass().getDeclaredField("elements");
    elements.setAccessible(true);
    elements.setLong(styles, s);
  }

  public static void main(String[] args) throws Exception {
    Text text = new Text(5);
    for(Style s : text.styles)
    	System.out.println(s);
  }
}

[Aj Neufeld]

On reflection (pun intended), this isn't that difficult to do without using reflection:

  public Text (int s) {
	for(Style style : Style.values())
		if ((s & (1 << style.ordinal())) != 0)
			styles.add(style);
  }