EnumBitOperations

!!!!! There is now a project with much better code than this !!!!!
http://claude-martin.ch/enumbitset/


















I made this because enums can not easily be stored to bit fields. Set and bitwise operations are equally difficult.
I put this on pastebin because it's just one single interface. I will edit this paste if I change anything. Maybe I'll put in on a repository later.
Note that I didn't really test this!
You can use it for whatever you want. There is no copyright. But it would be nice if you would keep my name in the file.
-----------------
package ch.claude_martin.java8;

import java.math.BigInteger;
import java.util.Arrays;
import java.util.BitSet;
import java.util.EnumSet;
import java.util.Set;

/**
 * This adds support to use bit fields and bit masks for the enym type. The set
 * of enum values is interpreted as a bit set, which can be stored to a bit
 * field.
 *
 * <p>
 * Since this is an interface it does not change the state of the element it is
 * used on or any parameters. Instead it always returns a newly created object.
 * I.e. all methods that take a Set return a new Set. If you wish to alter the
 * set you can simply use the methods of that set.
 *
 * <p>
 * Bit fields are by default of type {@link BigInteger}, but {@link BitSet} and
 * {@link Long long} can be used as well. Bit masks should not be stored into a
 * database unless you can guarantee that no changes are made in the future. The
 * only change that would not break your code is to add new enums at the end of
 * the list of existing enums. Note that {@link EnumSet} and {@link BigInteger}
 * already has many methods to help using sets of enums and large integers.
 *
 * <p>
 * A bit field is always used to store a set of bits. Each bit can represent one
 * enum value. each enum has a distinct {@link #bitmask() bit mask}.
 *
 * <p>
 * Java 8 Beta has still a bug that does not allow assert statements in
 * interfaces: <a
 * href="https://bugs.openjdk.java.net/browse/JDK-8025141">https:/
 * /bugs.openjdk.java.net/browse/JDK-8025141</a>
 *
 * <p>
 * Nomenclature:
 * <dl>
 * <dt>enum type</dt>
 * <dd>Any type that is an enum. I.e. it uses "enum" insteaf of "class" in its
 * declaration. <br/>
 * Example: <code>Planet.class</code></dd>
 * <dt>enum</dt>
 * <dd>A field of an enumy type. This is one single value of any enum type.<br/>
 * Example: Planet.VENUS</dd>
 * </dl>
 * Example:
 *
 * <pre><blockquote>
 * public enum Planet {
 *   MERCURY, VENUS, EARTH, ...
 * }
 * </blockquote></pre>
 * <p>
 * The goal of this interface is to use only existing types. Since all primitive
 * types are limited this uses {@link BigInteger} instead.
 *
 * @author Claude Martin
 *
 * @param <E>
 *          The Enum-Type.
 */
public interface EnumBitOperations<E extends Enum<E>> {
    /**
     * Returns whether this enum can be found in the list of enums of the same
     * type.
     *
     * @returns <code>true</code>, if <code>this</code> can be found.
     */
    public default boolean elementOf(final Enum<?>... set) {
        for (final Enum<?> e : set)
            if (e == this)
                return true;
        return false;
    }

    /**
     * Returns whether this enum can be found in the set of enums of the same
     * type.
     * <p>
     * This is equivalent to: <code>
     * set.contains(this);
     * </code>
     *
     * @returns <code>true</code>, if <code>this</code> can be found.
     */
    public default boolean elementOf(final Set<Enum<?>> set) {
        return set.contains(this);
    }

    /**
     * Creates a new EnumSet with <code>this</code> added.
     *
     * @returns A new {@link EnumSet} including all given elements and also
     *          <code>this</code>.
     */
    @SuppressWarnings("unchecked")
    public default EnumSet<E> addTo(final E... set) {
        final EnumSet<E> result = EnumSet.copyOf(Arrays.asList(set));
        result.add((E) this);
        return result;
    }

    /**
     * Creates a new EnumSet with <code>this</code> added.
     *
     * @returns A new {@link EnumSet} including all elements of the set and also
     *          <code>this</code>.
     */
    @SuppressWarnings("unchecked")
    public default EnumSet<E> addedTo(final EnumSet<E> set) {
        final EnumSet<E> result = EnumSet.copyOf(set);
        result.add((E) this);
        return result;
    }

    /**
     * Creates a new EnumSet with <code>this</code> removed.
     *
     * @returns A new {@link EnumSet} with all given enums, except
     *          <code>this</code>. A copy of the set is returned if
     *          <code>this</code> is not present.
     */
    @SuppressWarnings("unchecked")
    public default EnumSet<E> removedFrom(final E... set) {
        final EnumSet<E> result = EnumSet.copyOf(Arrays.asList(set));
        result.remove(this);
        return result;
    }

    /**
     * Creates a new EnumSet with <code>this</code> removed.
     *
     * @returns A new {@link EnumSet} with all elements of the set, except
     *          <code>this</code>. A copy of the set is returned if
     *          <code>this</code> is not present.
     */
    public default EnumSet<E> removedFrom(final EnumSet<E> set) {
        final EnumSet<E> result = EnumSet.copyOf(set);
        result.remove(this);
        return result;
    }

    /**
     * Returns a set of all enums except <code>this</code>.
     *
     * <p>
     * This is equivalent to: <code>EnumSet.complementOf(this.asSet())</code>
     *
     * @returns A new {@link EnumSet} with all elements except <code>this</code>.
     */
    @SuppressWarnings("unchecked")
    public default EnumSet<E> others() {
        final E e = (E) this;
        final EnumSet<E> result = EnumSet.allOf(e.getClass());
        result.remove(e);
        return result;
    }

    /**
     * Returns a set containing nothing but <code>this</code>.
     *
     * @returns A new {@link EnumSet} containing <code>this</code>.
     */
    @SuppressWarnings("unchecked")
    public default EnumSet<E> asEnumSet() {
        final E e = (E) this;
        final EnumSet<E> result = EnumSet.noneOf(e.getClass());
        result.add(e);
        return result;
    }

    /**
     * Returns a BitSet with all bits set to 0, except the bit representing
     * <code>this</code>.
     *
     * @returns A new {@link EnumSet} containing <code>this</code>.
     */
    @SuppressWarnings("unchecked")
    public default BitSet asBitSet() {
        final E e = (E) this;
        final BitSet result = new BitSet();
        result.set(e.ordinal());
        return result;
    }

    /**
     * Bitmask for <code>this</code>. The value is based on the ordinal.
     *
     * @return <code>1&lt;&lt;this.ordinal()</code>
     * @deprecated This is actually the same as {@link #bitmask()}. This is here
     *             so that programmers will find and use {@link #bitmask()}.
     */
    @Deprecated
    public default BigInteger asBigInteger() {
        return this.bitmask();
    }

    /**
     * 64 bit bitmask for <code>this</code>. The value is based on the ordinal.
     *
     * @return <code>1&lt;&lt;this.ordinal()</code>
     */
    @SuppressWarnings("unchecked")
    public default long bitmask64() {
        final E e = (E) this;
        // assert EnumSet.allOf(e.getClass()).size() <= 64;
        return 1 << e.ordinal();
    }

    /**
     * Bitmask for <code>this</code>. The value is based on the ordinal.
     *
     * @return <code>1&lt;&lt;this.ordinal()</code>
     */
    @SuppressWarnings("unchecked")
    public default BigInteger bitmask() {
        final E e = (E) this;
        return BigInteger.ONE.shiftLeft(e.ordinal());
    }

    /**
     * Returns whether this value is set in the given bitmask.
     *
     * @param bitmask64
     *          A bitmask.
     * @return (this.bitmask64() & bitmask8) != 0;
     */
    public default boolean elementOf(final long bitmask64) {
        return (this.bitmask64() & bitmask64) != 0;
    }

    /**
     * Returns whether this value is set in the given bitmask.
     *
     * @param bitmask
     *          A bitmask.
     * @return (this.bitmask() & bitmask) != 0
     */
    public default boolean elementOf(final BigInteger bitmask) {
        return !this.bitmask().and(bitmask).equals(BigInteger.ZERO);
    }

    /**
     * Returns whether this value is set in the given bitset.
     *
     * @param bitset
     * @return bitset.get(this.ordinal());
     */
    @SuppressWarnings("unchecked")
    public default boolean elementOf(final BitSet bitset) {
        return bitset.get(((E) this).ordinal());
    }

    /** Creates a 64 bit bitmask of a given set of enums. */
    public static <X extends Enum<X> & EnumBitOperations<X>> long toBitmask64(final EnumSet<X> set) {
        long result = 0;
        for (final X e : set)
            result |= e.bitmask64();
        return result;
    }

    /** Creates a 64 bit bitmask of a given set of enums. */
    @SafeVarargs
    public static <X extends Enum<X> & EnumBitOperations<X>> long toBitmask64(final X... set) {
        long result = 0;
        for (final X e : set)
            result |= e.bitmask64();
        return result;
    }

    /** Creates a bitmask of a given set of enums. */
    public static <X extends Enum<X> & EnumBitOperations<X>> BigInteger toBitmask(final EnumSet<X> set) {
        BigInteger result = BigInteger.ZERO;
        for (final X e : set)
            result = result.or(e.bitmask());
        return result;
    }

    /** Creates a bitmask of a given set of enums. */
    @SafeVarargs
    public static <X extends Enum<X> & EnumBitOperations<X>> BigInteger toBitmask(final X... set) {
        BigInteger result = BigInteger.ZERO;
        for (final X e : set)
            result = result.or(e.bitmask());
        return result;
    }

    /**
     * Creates a BitSet of a given set of enums.
     * */
    @SafeVarargs
    public static <X extends Enum<X> & EnumBitOperations<X>> BitSet toBitSet(final X... set) {
        final BitSet result = new BitSet();
        for (final X e : set)
            result.set(e.ordinal());
        return result;
    }

    /**
     * Creates a BitSet of a given set of enums.
     */
    public static <X extends Enum<X> & EnumBitOperations<X>> BitSet toBitSet(final EnumSet<X> set) {
        final BitSet result = new BitSet();
        for (final X e : set)
            result.set(e.ordinal());
        return result;
    }

    /** Creates a BitSet of a given mask. */
    public static BitSet toBitSet(final BigInteger mask) {
        return BitSet.valueOf(mask.toByteArray());
    }

    /** Creates a BigInteger of a given mask. */
    public static BigInteger toBigInteger(final BitSet bitset) {
        return new BigInteger(bitset.toByteArray());
    }

    /** Creates set of enums from a 64 bit bitset. */
    public static <X extends Enum<X> & EnumBitOperations<X>> EnumSet<X> toEnumSet(final long mask, final Class<X> type) {
        final EnumSet<X> result = EnumSet.noneOf(type);
        for (final X e : EnumSet.allOf(type))
            if ((e.bitmask64() & mask) != 0)
                result.add(e);
        return result;
    }

    /** Creates set of enums from a BitSet. */
    public static <X extends Enum<X> & EnumBitOperations<X>> EnumSet<X> toEnumSet(final BitSet bitset, final Class<X> type) {
        long mask = 0L;
        for (int i = 0; i < bitset.length(); ++i)
            mask += bitset.get(i) ? 1L << i : 0L;
        return EnumBitOperations.toEnumSet(mask, type);
    }

    /**
     * Takes the bitmasks of <code>this</code> and all arguments, then applies
     * logical OR to all. This results in a bitmask for all given enums (including
     * <code>this</code>).
     *
     * @see #or(Enum...)
     * @see EnumSet#of(Enum)
     * @return <code>this.bitmask64() | arg0.bitmask64() | ... | argN.bitmask64()</code>
     */
    @SuppressWarnings("unchecked")
    public default <X extends Enum<X> & EnumBitOperations<X>> long or64(final X... set) {
        long result = this.bitmask64();
        for (final X e : set)
            result |= 1 << e.ordinal();
        return result;
    }

    /**
     *
     * Note that there is a much simpler way using {@link EnumSet#of(Enum)
     * of(...)}. The following expressions define the same set: <br>
     * <code>Planet.<b>EARTH</b>.or(Planet.<b>MARS</b>, Planet.<b>JUPITER</b>)<br/>
     * Planet.of(Planet.<b>EARTH</b>, Planet.<b>MARS</b>, Planet.<b>JUPITER</b>)</code>
     * <br/>
     * However, this method returns a bitmask of type BigInteger.
     *
     * @see EnumSet#of(Enum)
     * @see #or(BigInteger)
     * @return <code>this.bitmask() | arg<sub>0</sub>.bitmask() | ... | arg<sub>N</sub>.bitmask()</code>
     */
    @SuppressWarnings("unchecked")
    public default <X extends Enum<X> & EnumBitOperations<X>> BigInteger addedTo(final X... set) {
        BigInteger result = this.bitmask();
        for (final X e : set)
            result = result.or(e.bitmask());
        return result;
    }

    /**
     * Takes the bitmasks of <code>this</code> and <code>mask</code>, then applies
     * logical OR. This results in a new bitmask that also includes
     * <code>this</code>.
     *
     * @see #addedTo(BigInteger)
     * @see #addedTo(EnumSet)
     * @see #addedTo(Enum...)
     * @return <code>mask.or(this.bitmask())</code>
     */
    public default <X extends Enum<X> & EnumBitOperations<X>> BigInteger or(final BigInteger mask) {
        return mask.or(this.bitmask());
    }

    /**
     * @return <code>mask.and(this.bitmask())</code>
     */
    public default <X extends Enum<X> & EnumBitOperations<X>> BigInteger and(final BigInteger mask) {
        return mask.and(this.bitmask());
    }

    /**
     * @return <code>mask.xor(this.bitmask())</code>
     */
    public default <X extends Enum<X> & EnumBitOperations<X>> BigInteger xor(final BigInteger mask) {
        return mask.xor(this.bitmask());
    }

    /**
     * Removes this from mask, but only if its bit is set in the mask.
     *
     * @return <code>mask.andNot(this.bitmask())</code>
     */
    public default <X extends Enum<X> & EnumBitOperations<X>> BigInteger removedFrom(final BigInteger mask) {
        return mask.andNot(this.bitmask());
    }

}