EnumBitSetHelper

Type Parameters:: E - The Enum-Type.

All Superinterfaces:: Comparable<E>, Serializable

public interface EnumBitSetHelper<E extends Enum<E> & EnumBitSetHelper<E>>
extends Comparable<E>, Serializable

This extends any enum type with methods for bitwise operations and use in an EnumBitSet. A set of such enum values can be interpreted as an enum bit set, which can be stored to a bit field (i.e. an integer field in a database).

Since this is an interface it does not change the state of the element it is used on or any parameters passed to a method. Instead it always returns a newly created object. I.e. all methods that take an EnumBitSet return a new EnumBitSet. If you wish to alter such a set you can simply use the methods of that set.

Examples for usage:

 User permissions:
 public enum Role { READ, WRITE, EXECUTE }
 
 BigInteger permissions = MyDBAccess.getUserPermissions(currentUser);
 permissions = Role.READ.removedFrom(permissions);
 MyDBAccess.setUserPermissions(currentUser, permissions);

 Planetary composition:
 public enum Planet { MERCURY, VENUS, EARTH, ... }
 public enum Element { H, He, Li, Be, B, C, N, ... }
 
 final Map<Planet, EnumBitSet<Element>> composition = new HashMap>>();
 final EnumBitSet<Element> mercury = Element.O.union(Element.Na, Element.H, Element.He, Element.K);
 composition.put(Planet.MERCURY, mercury);

 Counterexample:
 public enum Status { SUBMITTED, REVIEWED, ACCEPTED, PUBLISHED }
 Each status includes all previous ones (can't be reviewed if not submitted). 
 A regular integer field is enough to store the status 
 (e.g. REVIEWED.ordinal()).

Java 8 Beta has still some bugs. It does not allow assert statements and @SafeVarargs in interfaces.

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default BigInteger`	`bitmask()` Bitmask for `this`.
`default long`	`bitmask64()` 64 bit bitmask for `this`.
`default boolean`	`elementOf(BigInteger bitmask)` Returns whether this value is set in the given bitmask.
`default boolean`	`elementOf(BitSet bitset)` Returns whether this value is set in the given bitset.
`default boolean`	`elementOf(Collection<E> collection)` Returns whether this enum can be found in the given collection.
`default boolean`	`elementOf(Enum<E>... set)` Returns whether this enum constant can be found in the array of constants of the same type.
`default boolean`	`elementOf(long bitmask64)` Returns whether this value is set in the given bitmask.
`default BigInteger`	`intersect(BigInteger mask)` Bit mask with all other bits removed.
`default BitSet`	`intersect(BitSet set)` Bit mask with all other bits removed.
`default EnumBitSet<E>`	`intersect(E... set)` Creates a set with all other elements removed.
`default EnumBitSet<E>`	`intersect(EnumBitSet<E> set)` Creates a set with all other elements removed.
`default EnumSet<E>`	`intersect(EnumSet<E> set)` Bit mask with all other bits removed.
`default long`	`intersect(long mask)` Bit mask with all other bits removed.
`String`	`name()` Returns the name of this enum constant, exactly as declared in its enum declaration.
`int`	`ordinal()`
`default EnumBitSet<E>`	`others()` Returns a set of all elements except `this`.
`default BigInteger`	`removedFrom(BigInteger mask)` Removes this from the given mask.
`default BitSet`	`removedFrom(BitSet set)` Removes this from the BitSet and returns the new BitSet.
`default EnumBitSet<E>`	`removedFrom(E... set)` Creates a new EnumSet with `this` removed.
`default EnumBitSet<E>`	`removedFrom(EnumBitSet<E> set)` Creates a new EnumBitSet with `this` removed.
`default EnumSet<E>`	`removedFrom(EnumSet<E> set)` Creates a new EnumSet with `this` removed.
`default long`	`removedFrom(long mask)` Removes this from the given mask.
`default BigInteger`	`toBigInteger()` Bit mask for `this`.
`default BitSet`	`toBitSet()` Returns a BitSet with all bits set to 0, except the bit representing `this`.
`default EnumBitSet<E>`	`toEnumBitSet()` Returns a set containing nothing but `this`.
`default EnumSet<E>`	`toEnumSet()` Returns a set containing nothing but `this`.
`default long`	`toLong()` Bitmask for `this`.
`default BigInteger`	`union(BigInteger mask)` Takes the bitmasks of `this` and `mask`, then applies logical OR.
`default BitSet`	`union(BitSet set)` Creates a new EnumSet with `this` added.
`default EnumBitSet<E>`	`union(E... set)` Creates an EnumBitSet containing this and all other elements.
`default EnumBitSet<E>`	`union(EnumBitSet<E> set)` Takes the bitmasks of `this` and a clone of `mask`, then applies logical OR.
`default EnumSet<E>`	`union(EnumSet<E> set)` Creates a new EnumSet with `this` added.
`default long`	`union(long mask)` Creates a bit mask with `this` included.
`default BigInteger`	`xor(BigInteger mask)` This can be used to switch one bit in a bit mask.
`default EnumBitSet<E>`	`xor(EnumBitSet<E> set)` Removes or adds `this` to the given set.

Methods inherited from interface java.lang.Comparable
compareTo

- Method Detail
  - bitmask
```
default BigInteger bitmask()
```
    Bitmask for this. The value is based on the ordinal.
    
    Returns:
    
    1<<this.ordinal()
    
    See Also:
    
    toEnumBitSet(), toBitSet(), toEnumSet()
  - bitmask64
```
default long bitmask64()
                throws MoreThan64ElementsException
```
    64 bit bitmask for this. The value is based on the ordinal.
    
    Returns:
    
    1<<this.ordinal()
    
    Throws:
    
    MoreThan64ElementsException - If more than 64 constants are in the enum type then a long is not enough. The exception is only thrown if this element is not one of the first 64 elements.
    
    See Also:
    
    bitmask(), toEnumBitSet(), toBitSet(), toEnumSet()
  - elementOf
```
default boolean elementOf(BigInteger bitmask)
```
    Returns whether this value is set in the given bitmask.
    
    Parameters:
    
    bitmask - A bitmask.
    
    Returns:
    
    (this.bitmask() & bitmask) != 0
  - elementOf
```
default boolean elementOf(BitSet bitset)
```
    Returns whether this value is set in the given bitset.
    
    Parameters:
    
    bitset - A bit set.
    
    Returns:
    
    bitset.get(this.ordinal());
  - elementOf
```
default boolean elementOf(Collection<E> collection)
```
    Returns whether this enum can be found in the given collection.
    This is equivalent to: coll.contains(this);
    
    Parameters:
    
    collection - A collection, not null.
    
    Returns:
    
    true, iff this can be found in collection.
  - elementOf
```
default boolean elementOf(Enum<E>... set)
```
    Returns whether this enum constant can be found in the array of constants of the same type.
    
    Parameters:
    
    set - A set of enum elements, all non-null and of the same enum type.
    
    Returns:
    
    true, if this can be found.
  - elementOf
```
default boolean elementOf(long bitmask64)
                   throws MoreThan64ElementsException
```
    Returns whether this value is set in the given bitmask.
    Note: This does not check if the given mask is valid for the enum type of this element. It may have more bits set than this enum type has constants.
    
    Parameters:
    
    bitmask64 - A bitmask.
    
    Returns:
    
    (this.bitmask64() & bitmask64) != 0;
    
    Throws:
    
    MoreThan64ElementsException - if this element is not one of the first 64 elements.
  - intersect
```
default BigInteger intersect(BigInteger mask)
```
    Bit mask with all other bits removed. The resulting bit mask will have just one or zero bits set to 1.
    
    Parameters:
    
    mask - A bit mask, must be positive.
    
    Returns:
    
    mask.and(this.bitmask())
    
    See Also:
    
    elementOf(BigInteger)
  - intersect
```
default BitSet intersect(BitSet set)
```
    Bit mask with all other bits removed. The resulting BitSet will have just one or zero bits set to true.
    
    Parameters:
    
    set - A bit set.
    
    Returns:
    
    mask & this
    
    See Also:
    
    elementOf(BitSet)
  - intersect
```
default EnumBitSet<E> intersect(E... set)
```
    Creates a set with all other elements removed. The resulting set will contain just this element or nothing at all.
    
    Parameters:
    
    set - A set.
    
    Returns:
    
    set & this.ordinal()
    
    See Also:
    
    elementOf(BitSet)
  - intersect
```
default EnumBitSet<E> intersect(EnumBitSet<E> set)
```
    Creates a set with all other elements removed. The resulting set will contain just this element or nothing at all.
    
    Parameters:
    
    set - A set.
    
    Returns:
    
    set.clone() & this
    
    See Also:
    
    elementOf(BigInteger)
  - intersect
```
default EnumSet<E> intersect(EnumSet<E> set)
```
    Bit mask with all other bits removed. The resulting bit mask will have just one or zero bits set to 1.
    
    Parameters:
    
    set - A set.
    
    Returns:
    
    mask.clone() & this
    
    See Also:
    
    elementOf(BigInteger)
  - intersect
```
default long intersect(long mask)
                throws MoreThan64ElementsException
```
    Bit mask with all other bits removed. The resulting bit mask will have just one or zero bits set to 1.
    Note: This does not check if the given mask is valid for the enum type of this element. It may have more bits set than this enum type has constants.
    
    Parameters:
    
    mask - A bit mask.
    
    Returns:
    
    mask & this.bitmask64()
    
    Throws:
    
    MoreThan64ElementsException - The enum type must not contain more than 64 elements.
    
    See Also:
    
    elementOf(long)
  - name
```
String name()
```
    Returns the name of this enum constant, exactly as declared in its enum declaration.
    
    Returns:
    
    the name of this enumeration constant
    
    See Also:
    
    Enum.name()
  - ordinal
```
int ordinal()
```
    Returns:
    
    the ordinal of this enumeration constant
    
    See Also:
    
    Enum.ordinal()
  - others
```
default EnumBitSet<E> others()
```
    Returns a set of all elements except this.
    This is equivalent to: EnumBitSet.just(this).complement()
    
    Returns:
    
    A new EnumSet with all elements except this.
  - removedFrom
```
default BigInteger removedFrom(BigInteger mask)
```
    Removes this from the given mask.
    
    Parameters:
    
    mask - A bit mask, must be positive.
    
    Returns:
    
    mask.andNot(this.bitmask())
  - removedFrom
```
default BitSet removedFrom(BitSet set)
```
    Removes this from the BitSet and returns the new BitSet.
    
    Parameters:
    
    set - A set that may contain this.
    
    Returns:
    
    set \ this
  - removedFrom
```
default EnumBitSet<E> removedFrom(E... set)
```
    Creates a new EnumSet with this removed.
    
    Parameters:
    
    set - A set that may contain this.
    
    Returns:
    
    A new EnumSet with all given enums, except this. A copy of the set is returned even if this is not present.
  - removedFrom
```
default EnumBitSet<E> removedFrom(EnumBitSet<E> set)
```
    Creates a new EnumBitSet with this removed.
    
    Parameters:
    
    set - A set that may contain this.
    
    Returns:
    
    A new EnumBitSet with all elements of the set, except this. A copy of the set is returned even if this is not present.
  - removedFrom
```
default EnumSet<E> removedFrom(EnumSet<E> set)
```
    Creates a new EnumSet with this removed.
    
    Parameters:
    
    set - A set that may contain this.
    
    Returns:
    
    A new EnumSet with all elements of the set, except this. A copy of the set is returned even if this is not present.
  - removedFrom
```
default long removedFrom(long mask)
                  throws MoreThan64ElementsException
```
    Removes this from the given mask.
    Note: This does not check if the given mask is valid for the enum type of this element. It may have more bits set than this enum type has constants.
    
    Parameters:
    
    mask - A bit mask.
    
    Returns:
    
    mask & ~this.bitmask64()
    
    Throws:
    
    MoreThan64ElementsException - if this element is not one of the first 64 elements.
  - toBigInteger
```
default BigInteger toBigInteger()
```
    Bit mask for this. The value is based on the ordinal. This is actually the same as bitmask().
    
    Returns:
    
    this.bitmask()
  - toBitSet
```
default BitSet toBitSet()
```
    Returns a BitSet with all bits set to 0, except the bit representing this.
    
    Returns:
    
    A new EnumSet containing this.
  - toEnumBitSet
```
default EnumBitSet<E> toEnumBitSet()
```
    Returns a set containing nothing but this.
    Note: EnumBitSet.just(X) is equal to X.asEnumBitSet()
    
    Returns:
    
    A new EnumSet containing this.
  - toEnumSet
```
default EnumSet<E> toEnumSet()
```
    Returns a set containing nothing but this.
    
    Returns:
    
    A new EnumSet containing this.
  - toLong
```
default long toLong()
             throws MoreThan64ElementsException
```
    Bitmask for this. The value is based on the ordinal. This is actually the same as bitmask64() .
    
    Returns:
    
    this.bitmask64()
    
    Throws:
    
    MoreThan64ElementsException - If more than 64 constants are in the enum type then a long is not enough. The exception is only thrown if this element is not one of the first 64 elements.
    
    See Also:
    
    bitmask64()
  - union
```
default BigInteger union(BigInteger mask)
```
    Takes the bitmasks of this and mask, then applies logical OR. This results in a new bit mask that also includes this .
    
    Parameters:
    
    mask - A bit mask, must be positive.
    
    Returns:
    
    mask.or(this.bitmask())
    
    See Also:
    
    union(BigInteger), union(EnumSet), union(Enum...)
  - union
```
default BitSet union(BitSet set)
```
    Creates a new EnumSet with this added.
    
    Parameters:
    
    set - A set of enum elements.
    
    Returns:
    
    A new EnumSet including all elements of the set and also this.
  - union
```
default EnumBitSet<E> union(E... set)
```
    Creates an EnumBitSet containing this and all other elements.
    Note that there are other ways to do this. The following expressions define the same set:
    Planet.EARTH.union(Planet.MARS, Planet.JUPITER) Planet.of(Planet.EARTH, Planet.MARS, Planet.JUPITER)
    
    Parameters:
    
    set - A list of elements to add.
    
    Returns:
    
    Returns a new set containing this and all given elements.
    
    See Also:
    
    EnumSet.of(Enum)
  - union
```
default EnumBitSet<E> union(EnumBitSet<E> set)
```
    Takes the bitmasks of this and a clone of mask, then applies logical OR. This results in a new bit set that also includes this.
    
    Parameters:
    
    set - A set of enum elements.
    
    Returns:
    
    mask.clone() | this
    
    See Also:
    
    union(BigInteger), union(EnumSet), union(Enum...)
  - union
```
default EnumSet<E> union(EnumSet<E> set)
```
    Creates a new EnumSet with this added.
    
    Parameters:
    
    set - A set of enum elements.
    
    Returns:
    
    A new EnumSet including all elements of the set and also this.
  - union
```
default long union(long mask)
            throws MoreThan64ElementsException
```
    Creates a bit mask with this included.
    
    Parameters:
    
    mask - A bit mask.
    
    Returns:
    
    this.bitmask64() | mask;
    
    Throws:
    
    MoreThan64ElementsException - Thrown if the enum type contains more than 64 elements.
  - xor
```
default BigInteger xor(BigInteger mask)
```
    This can be used to switch one bit in a bit mask.
    
    Parameters:
    
    mask - A bit mask, must be positive.
    
    Returns:
    
    mask.xor(this.bitmask())
  - xor
```
default EnumBitSet<E> xor(EnumBitSet<E> set)
```
    Removes or adds this to the given set. The operation is equivalent to switching one bit in a bit mask.
    
    Parameters:
    
    set - A set of enum elements.
    
    Returns:
    
    set.clone() XOR this

Interface EnumBitSetHelper<E extends Enum<E> & EnumBitSetHelper<E>>

Method Summary

Methods inherited from interface java.lang.Comparable

Method Detail

bitmask

bitmask64

elementOf

elementOf

elementOf

elementOf

elementOf

intersect

intersect

intersect

intersect

intersect

intersect

name

ordinal

others

removedFrom

removedFrom

removedFrom

removedFrom

removedFrom

removedFrom

toBigInteger

toBitSet

toEnumBitSet

toEnumSet

toLong

union

union

union

union

union

union

xor

xor