FileDocCategorySizeDatePackage
RegularEnumSet.javaAPI DocJava SE 5 API8670Fri Aug 26 14:57:24 BST 2005java.util

RegularEnumSet

public class RegularEnumSet extends EnumSet
Private implementation class for EnumSet, for "regular sized" enum types (i.e., those with 64 or fewer enum constants).
author
Josh Bloch
since
1.5
serial
exclude

Fields Summary
private long
elements
Bit vector representation of this set. The 2^k bit indicates the presence of universe[k] in this set.
Constructors Summary
RegularEnumSet(Class elementType, Enum[] universe)


       
        super(elementType, universe);
    
Methods Summary
public booleanadd(E e)
Adds the specified element to this set if it is not already present.

param
e element to be added to this set
return
true if the set changed as a result of the call
throws
NullPointerException if e is null

        typeCheck(e);

        long oldElements = elements;
        elements |= (1L << ((Enum)e).ordinal());
        return elements != oldElements;
    
public booleanaddAll(java.util.Collection c)
Adds all of the elements in the specified collection to this set.

param
c collection whose elements are to be added to this set
return
true if this set changed as a result of the call
throws
NullPointerException if the specified collection or any of its elements are null

        if (!(c instanceof RegularEnumSet))
            return super.addAll(c);

        RegularEnumSet es = (RegularEnumSet)c;
        if (es.elementType != elementType) {
            if (es.isEmpty())
                return false;
            else
                throw new ClassCastException(
                    es.elementType + " != " + elementType);
        }

        long oldElements = elements;
        elements |= es.elements;
        return elements != oldElements;
    
voidaddAll()

        if (universe.length != 0)
            elements = -1L >>> -universe.length;
    
voidaddRange(E from, E to)

        elements = (-1L >>>  (from.ordinal() - to.ordinal() - 1)) << from.ordinal();
    
public voidclear()
Removes all of the elements from this set.

        elements = 0;
    
voidcomplement()

        if (universe.length != 0) {
            elements = ~elements;
            elements &= -1L >>> -universe.length;  // Mask unused bits
        }
    
public booleancontains(java.lang.Object e)
Returns true if this set contains the specified element.

param
e element to be checked for containment in this collection
return
true if this set contains the specified element

        if (e == null)
            return false;
        Class eClass = e.getClass();
        if (eClass != elementType && eClass.getSuperclass() != elementType)
            return false;

        return (elements & (1L << ((Enum)e).ordinal())) != 0;
    
public booleancontainsAll(java.util.Collection c)
Returns true if this set contains all of the elements in the specified collection.

param
c collection to be checked for containment in this set
return
true if this set contains all of the elements in the specified collection
throws
NullPointerException if the specified collection is null

        if (!(c instanceof RegularEnumSet))
            return super.containsAll(c);

        RegularEnumSet es = (RegularEnumSet)c;
        if (es.elementType != elementType)
            return es.isEmpty();

        return (es.elements & ~elements) == 0;
    
public booleanequals(java.lang.Object o)
Compares the specified object with this set for equality. Returns true if the given object is also a set, the two sets have the same size, and every member of the given set is contained in this set.

param
e object to be compared for equality with this set
return
true if the specified object is equal to this set

        if (!(o instanceof RegularEnumSet))
            return super.equals(o);

        RegularEnumSet es = (RegularEnumSet)o;
        if (es.elementType != elementType)
            return elements == 0 && es.elements == 0;
        return es.elements == elements;
    
public booleanisEmpty()
Returns true if this set contains no elements.

return
true if this set contains no elements

        return elements == 0;
    
public java.util.Iteratoriterator()
Returns an iterator over the elements contained in this set. The iterator traverses the elements in their natural order (which is the order in which the enum constants are declared). The returned Iterator is a "snapshot" iterator that will never throw {@link ConcurrentModificationException}; the elements are traversed as they existed when this call was invoked.

return
an iterator over the elements contained in this set

        return new EnumSetIterator<E>();
    
public booleanremove(java.lang.Object e)
Removes the specified element from this set if it is present.

param
e element to be removed from this set, if present
return
true if the set contained the specified element

        if (e == null)
            return false;
        Class eClass = e.getClass();
        if (eClass != elementType && eClass.getSuperclass() != elementType)
            return false;

        long oldElements = elements;
        elements &= ~(1L << ((Enum)e).ordinal());
        return elements != oldElements;
    
public booleanremoveAll(java.util.Collection c)
Removes from this set all of its elements that are contained in the specified collection.

param
c elements to be removed from this set
return
true if this set changed as a result of the call
throws
NullPointerException if the specified collection is null

        if (!(c instanceof RegularEnumSet))
            return super.removeAll(c);

        RegularEnumSet es = (RegularEnumSet)c;
        if (es.elementType != elementType)
            return false;

        long oldElements = elements;
        elements &= ~es.elements;
        return elements != oldElements;
    
public booleanretainAll(java.util.Collection c)
Retains only the elements in this set that are contained in the specified collection.

param
c elements to be retained in this set
return
true if this set changed as a result of the call
throws
NullPointerException if the specified collection is null

        if (!(c instanceof RegularEnumSet))
            return super.retainAll(c);

        RegularEnumSet es = (RegularEnumSet)c;
        if (es.elementType != elementType) {
            elements = 0;
            return true;
        }

        long oldElements = elements;
        elements &= es.elements;
        return elements != oldElements;
    
public intsize()
Returns the number of elements in this set.

return
the number of elements in this set

        return Long.bitCount(elements);