Question

I am searching for a way to build a wrapper for multiple enums. Say you have

public enum Enum1 {
    A,B,C
}

public enum Enum2 {
    ONE,TWO,THREE
}

I want to have a new enum with the literals

(A,ONE), (A,TWO), (A,THREE), (B,ONE), ...

The whole thing generic so that I don’t have to know Enum1 and Enum2. Is there a way to build that or even extend it to n Enums?

Or should I look to other general ways to model that?

Answer 1

And here’s one that will wrap any number of enums. It comes as an Iterator but combine it with either or both of the other solutions and I think you’ve got all you asked for.

public class Test {
  public static void main(String args[]) {
    new Test().test();
  }

  public static class EnumIterator implements Iterator<Enum[]> {
    // The enums
    private final Enum[][] enums;
    // Where we are in each column.
    private final int[] is;
    // Which column to increment next.
    private int i = 0;

    // Construct from Enum[]s.
    public EnumIterator(Enum[]... enums) {
      // Grab the enums.
      this.enums = enums;
      // Start all ordinals at zero.
      is = new int[enums.length];
      // Next one to increment is the last one.
      i = enums.length - 1;
    }

    // Construct from classes.
    public EnumIterator(Class<? extends Enum>... classes) {
      this(enumsFromClasses(classes));
    }

    // Factory to build the Enum[] array from an array of classes.
    private static Enum[][] enumsFromClasses(Class<? extends Enum>[] classes) {
      Enum[][] theEnums = new Enum[classes.length][];
      for ( int j = 0; j < classes.length; j++ ) {
        theEnums[j] = classes[j].getEnumConstants();
      }
      return theEnums;
    }

    @Override
    public boolean hasNext() {
      // We stop when we are about to increment col 0 and we are at its end.
      return (i > 0 || is[0] < enums[0].length);
    }

    @Override
    public Enum[] next() {
      if (hasNext()) {
        // One from each.
        Enum[] next = new Enum[enums.length];
        for (int j = 0; j < next.length; j++) {
          next[j] = enums[j][is[j]];
        }
        // Step - Kinda like incrementing a number with each digit in a different base.
        // Walk back past '9's setting them to 0.
        for (i = is.length - 1; i > 0 && is[i] == enums[i].length - 1; i--) {
          // Back one.
          is[i] = 0;
        }
        // Step that one up one.
        is[i] += 1;
        return next;
      } else {
        throw new NoSuchElementException();
      }
    }

    @Override
    public void remove() {
      throw new UnsupportedOperationException("Not supported.");
    }
  }

  enum ABC {
    A, B, C;
  }

  enum XY {
    X, Y;
  }

  enum IJ {
    I, J;
  }

  private void test() {
    // Also works - but constructing from classes is cleaner.
    //Iterator<Enum[]> i = new EnumIterator(ABC.values(), XY.values(), IJ.values());
    Iterator<Enum[]> i = new EnumIterator(ABC.class, XY.class, IJ.class);
    for (Enum[] e : Iterables.in(i)) {
      System.out.println(Arrays.toString(e));
    }
  }
}

Prints:

[A, X, I]
[A, X, J]
[A, Y, I]
[A, Y, J]
[B, X, I]
[B, X, J]
[B, Y, I]
[B, Y, J]
[C, X, I]
[C, X, J]
[C, Y, I]
[C, Y, J]

Note that Iterables.in merely wraps an Iterator<E> in an Iterable<E> like this (not my code – I found it here on SO).

public class Iterables {
  /**
   * Adapts an {@link Iterator} to an {@link Iterable} for use in enhanced for loops.
   *
   * If {@link Iterable#iterator()} is invoked more than once, an
   * {@link IllegalStateException} is thrown.
   */
  public static <T> java.lang.Iterable<T> in(final Iterator<T> iterator) {
    assert iterator != null;
    class SingleUseIterable implements java.lang.Iterable<T> {
      private boolean used = false;

      @Override
      public Iterator<T> iterator() {
        if (used) {
          throw new IllegalStateException("SingleUseIterable already invoked");
        }
        used = true;
        return iterator;
      }
    }
    return new SingleUseIterable();
  }
}