jdk/src/share/classes/java/util/JumboEnumSet.java
author xdono
Wed, 02 Jul 2008 12:55:45 -0700
changeset 715 f16baef3a20e
parent 51 6fe31bc95bbc
child 5506 202f599c92aa
permissions -rw-r--r--
6719955: Update copyright year Summary: Update copyright year for files that have been modified in 2008 Reviewed-by: ohair, tbell
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     1
/*
715
f16baef3a20e 6719955: Update copyright year
xdono
parents: 51
diff changeset
     2
 * Copyright 2003-2008 Sun Microsystems, Inc.  All Rights Reserved.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
90ce3da70b43 Initial load
duke
parents:
diff changeset
     4
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
90ce3da70b43 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
90ce3da70b43 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.  Sun designates this
90ce3da70b43 Initial load
duke
parents:
diff changeset
     8
 * particular file as subject to the "Classpath" exception as provided
90ce3da70b43 Initial load
duke
parents:
diff changeset
     9
 * by Sun in the LICENSE file that accompanied this code.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    10
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    11
 * This code is distributed in the hope that it will be useful, but WITHOUT
90ce3da70b43 Initial load
duke
parents:
diff changeset
    12
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
90ce3da70b43 Initial load
duke
parents:
diff changeset
    13
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
90ce3da70b43 Initial load
duke
parents:
diff changeset
    14
 * version 2 for more details (a copy is included in the LICENSE file that
90ce3da70b43 Initial load
duke
parents:
diff changeset
    15
 * accompanied this code).
90ce3da70b43 Initial load
duke
parents:
diff changeset
    16
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    17
 * You should have received a copy of the GNU General Public License version
90ce3da70b43 Initial load
duke
parents:
diff changeset
    18
 * 2 along with this work; if not, write to the Free Software Foundation,
90ce3da70b43 Initial load
duke
parents:
diff changeset
    19
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    20
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    21
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
90ce3da70b43 Initial load
duke
parents:
diff changeset
    22
 * CA 95054 USA or visit www.sun.com if you need additional information or
90ce3da70b43 Initial load
duke
parents:
diff changeset
    23
 * have any questions.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    24
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    25
90ce3da70b43 Initial load
duke
parents:
diff changeset
    26
package java.util;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    27
90ce3da70b43 Initial load
duke
parents:
diff changeset
    28
/**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    29
 * Private implementation class for EnumSet, for "jumbo" enum types
90ce3da70b43 Initial load
duke
parents:
diff changeset
    30
 * (i.e., those with more than 64 elements).
90ce3da70b43 Initial load
duke
parents:
diff changeset
    31
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    32
 * @author Josh Bloch
90ce3da70b43 Initial load
duke
parents:
diff changeset
    33
 * @since 1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
    34
 * @serial exclude
90ce3da70b43 Initial load
duke
parents:
diff changeset
    35
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    36
class JumboEnumSet<E extends Enum<E>> extends EnumSet<E> {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    37
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    38
     * Bit vector representation of this set.  The ith bit of the jth
90ce3da70b43 Initial load
duke
parents:
diff changeset
    39
     * element of this array represents the  presence of universe[64*j +i]
90ce3da70b43 Initial load
duke
parents:
diff changeset
    40
     * in this set.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    41
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    42
    private long elements[];
90ce3da70b43 Initial load
duke
parents:
diff changeset
    43
90ce3da70b43 Initial load
duke
parents:
diff changeset
    44
    // Redundant - maintained for performance
90ce3da70b43 Initial load
duke
parents:
diff changeset
    45
    private int size = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    46
90ce3da70b43 Initial load
duke
parents:
diff changeset
    47
    JumboEnumSet(Class<E>elementType, Enum[] universe) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    48
        super(elementType, universe);
90ce3da70b43 Initial load
duke
parents:
diff changeset
    49
        elements = new long[(universe.length + 63) >>> 6];
90ce3da70b43 Initial load
duke
parents:
diff changeset
    50
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
    51
90ce3da70b43 Initial load
duke
parents:
diff changeset
    52
    void addRange(E from, E to) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    53
        int fromIndex = from.ordinal() >>> 6;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    54
        int toIndex = to.ordinal() >>> 6;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    55
90ce3da70b43 Initial load
duke
parents:
diff changeset
    56
        if (fromIndex == toIndex) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    57
            elements[fromIndex] = (-1L >>>  (from.ordinal() - to.ordinal() - 1))
90ce3da70b43 Initial load
duke
parents:
diff changeset
    58
                            << from.ordinal();
90ce3da70b43 Initial load
duke
parents:
diff changeset
    59
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    60
            elements[fromIndex] = (-1L << from.ordinal());
90ce3da70b43 Initial load
duke
parents:
diff changeset
    61
            for (int i = fromIndex + 1; i < toIndex; i++)
90ce3da70b43 Initial load
duke
parents:
diff changeset
    62
                elements[i] = -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    63
            elements[toIndex] = -1L >>> (63 - to.ordinal());
90ce3da70b43 Initial load
duke
parents:
diff changeset
    64
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
    65
        size = to.ordinal() - from.ordinal() + 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    66
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
    67
90ce3da70b43 Initial load
duke
parents:
diff changeset
    68
    void addAll() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    69
        for (int i = 0; i < elements.length; i++)
90ce3da70b43 Initial load
duke
parents:
diff changeset
    70
            elements[i] = -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    71
        elements[elements.length - 1] >>>= -universe.length;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    72
        size = universe.length;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    73
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
    74
90ce3da70b43 Initial load
duke
parents:
diff changeset
    75
    void complement() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    76
        for (int i = 0; i < elements.length; i++)
90ce3da70b43 Initial load
duke
parents:
diff changeset
    77
            elements[i] = ~elements[i];
90ce3da70b43 Initial load
duke
parents:
diff changeset
    78
        elements[elements.length - 1] &= (-1L >>> -universe.length);
90ce3da70b43 Initial load
duke
parents:
diff changeset
    79
        size = universe.length - size;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    80
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
    81
90ce3da70b43 Initial load
duke
parents:
diff changeset
    82
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    83
     * Returns an iterator over the elements contained in this set.  The
90ce3da70b43 Initial load
duke
parents:
diff changeset
    84
     * iterator traverses the elements in their <i>natural order</i> (which is
90ce3da70b43 Initial load
duke
parents:
diff changeset
    85
     * the order in which the enum constants are declared). The returned
90ce3da70b43 Initial load
duke
parents:
diff changeset
    86
     * Iterator is a "weakly consistent" iterator that will never throw {@link
90ce3da70b43 Initial load
duke
parents:
diff changeset
    87
     * ConcurrentModificationException}.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    88
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    89
     * @return an iterator over the elements contained in this set
90ce3da70b43 Initial load
duke
parents:
diff changeset
    90
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    91
    public Iterator<E> iterator() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    92
        return new EnumSetIterator<E>();
90ce3da70b43 Initial load
duke
parents:
diff changeset
    93
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
    94
90ce3da70b43 Initial load
duke
parents:
diff changeset
    95
    private class EnumSetIterator<E extends Enum<E>> implements Iterator<E> {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    96
        /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    97
         * A bit vector representing the elements in the current "word"
90ce3da70b43 Initial load
duke
parents:
diff changeset
    98
         * of the set not yet returned by this iterator.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    99
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   100
        long unseen;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   101
90ce3da70b43 Initial load
duke
parents:
diff changeset
   102
        /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   103
         * The index corresponding to unseen in the elements array.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   104
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   105
        int unseenIndex = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   106
90ce3da70b43 Initial load
duke
parents:
diff changeset
   107
        /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   108
         * The bit representing the last element returned by this iterator
90ce3da70b43 Initial load
duke
parents:
diff changeset
   109
         * but not removed, or zero if no such element exists.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   110
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   111
        long lastReturned = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   112
90ce3da70b43 Initial load
duke
parents:
diff changeset
   113
        /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   114
         * The index corresponding to lastReturned in the elements array.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   115
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   116
        int lastReturnedIndex = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   117
90ce3da70b43 Initial load
duke
parents:
diff changeset
   118
        EnumSetIterator() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   119
            unseen = elements[0];
90ce3da70b43 Initial load
duke
parents:
diff changeset
   120
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   121
90ce3da70b43 Initial load
duke
parents:
diff changeset
   122
        public boolean hasNext() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   123
            while (unseen == 0 && unseenIndex < elements.length - 1)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   124
                unseen = elements[++unseenIndex];
90ce3da70b43 Initial load
duke
parents:
diff changeset
   125
            return unseen != 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   126
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   127
90ce3da70b43 Initial load
duke
parents:
diff changeset
   128
        public E next() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   129
            if (!hasNext())
90ce3da70b43 Initial load
duke
parents:
diff changeset
   130
                throw new NoSuchElementException();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   131
            lastReturned = unseen & -unseen;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   132
            lastReturnedIndex = unseenIndex;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   133
            unseen -= lastReturned;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   134
            return (E) universe[(lastReturnedIndex << 6)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   135
                                + Long.numberOfTrailingZeros(lastReturned)];
90ce3da70b43 Initial load
duke
parents:
diff changeset
   136
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   137
90ce3da70b43 Initial load
duke
parents:
diff changeset
   138
        public void remove() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   139
            if (lastReturned == 0)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   140
                throw new IllegalStateException();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   141
            elements[lastReturnedIndex] -= lastReturned;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   142
            size--;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   143
            lastReturned = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   144
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   145
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   146
90ce3da70b43 Initial load
duke
parents:
diff changeset
   147
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   148
     * Returns the number of elements in this set.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   149
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   150
     * @return the number of elements in this set
90ce3da70b43 Initial load
duke
parents:
diff changeset
   151
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   152
    public int size() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   153
        return size;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   154
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   155
90ce3da70b43 Initial load
duke
parents:
diff changeset
   156
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   157
     * Returns <tt>true</tt> if this set contains no elements.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   158
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   159
     * @return <tt>true</tt> if this set contains no elements
90ce3da70b43 Initial load
duke
parents:
diff changeset
   160
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   161
    public boolean isEmpty() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   162
        return size == 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   163
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   164
90ce3da70b43 Initial load
duke
parents:
diff changeset
   165
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   166
     * Returns <tt>true</tt> if this set contains the specified element.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   167
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   168
     * @param e element to be checked for containment in this collection
90ce3da70b43 Initial load
duke
parents:
diff changeset
   169
     * @return <tt>true</tt> if this set contains the specified element
90ce3da70b43 Initial load
duke
parents:
diff changeset
   170
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   171
    public boolean contains(Object e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   172
        if (e == null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   173
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   174
        Class eClass = e.getClass();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   175
        if (eClass != elementType && eClass.getSuperclass() != elementType)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   176
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   177
90ce3da70b43 Initial load
duke
parents:
diff changeset
   178
        int eOrdinal = ((Enum)e).ordinal();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   179
        return (elements[eOrdinal >>> 6] & (1L << eOrdinal)) != 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   180
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   181
90ce3da70b43 Initial load
duke
parents:
diff changeset
   182
    // Modification Operations
90ce3da70b43 Initial load
duke
parents:
diff changeset
   183
90ce3da70b43 Initial load
duke
parents:
diff changeset
   184
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   185
     * Adds the specified element to this set if it is not already present.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   186
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   187
     * @param e element to be added to this set
90ce3da70b43 Initial load
duke
parents:
diff changeset
   188
     * @return <tt>true</tt> if the set changed as a result of the call
90ce3da70b43 Initial load
duke
parents:
diff changeset
   189
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   190
     * @throws NullPointerException if <tt>e</tt> is null
90ce3da70b43 Initial load
duke
parents:
diff changeset
   191
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   192
    public boolean add(E e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   193
        typeCheck(e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   194
90ce3da70b43 Initial load
duke
parents:
diff changeset
   195
        int eOrdinal = e.ordinal();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   196
        int eWordNum = eOrdinal >>> 6;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   197
90ce3da70b43 Initial load
duke
parents:
diff changeset
   198
        long oldElements = elements[eWordNum];
90ce3da70b43 Initial load
duke
parents:
diff changeset
   199
        elements[eWordNum] |= (1L << eOrdinal);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   200
        boolean result = (elements[eWordNum] != oldElements);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   201
        if (result)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   202
            size++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   203
        return result;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   204
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   205
90ce3da70b43 Initial load
duke
parents:
diff changeset
   206
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   207
     * Removes the specified element from this set if it is present.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   208
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   209
     * @param e element to be removed from this set, if present
90ce3da70b43 Initial load
duke
parents:
diff changeset
   210
     * @return <tt>true</tt> if the set contained the specified element
90ce3da70b43 Initial load
duke
parents:
diff changeset
   211
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   212
    public boolean remove(Object e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   213
        if (e == null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   214
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   215
        Class eClass = e.getClass();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   216
        if (eClass != elementType && eClass.getSuperclass() != elementType)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   217
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   218
        int eOrdinal = ((Enum)e).ordinal();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   219
        int eWordNum = eOrdinal >>> 6;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   220
90ce3da70b43 Initial load
duke
parents:
diff changeset
   221
        long oldElements = elements[eWordNum];
90ce3da70b43 Initial load
duke
parents:
diff changeset
   222
        elements[eWordNum] &= ~(1L << eOrdinal);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   223
        boolean result = (elements[eWordNum] != oldElements);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   224
        if (result)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   225
            size--;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   226
        return result;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   227
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   228
90ce3da70b43 Initial load
duke
parents:
diff changeset
   229
    // Bulk Operations
90ce3da70b43 Initial load
duke
parents:
diff changeset
   230
90ce3da70b43 Initial load
duke
parents:
diff changeset
   231
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   232
     * Returns <tt>true</tt> if this set contains all of the elements
90ce3da70b43 Initial load
duke
parents:
diff changeset
   233
     * in the specified collection.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   234
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   235
     * @param c collection to be checked for containment in this set
90ce3da70b43 Initial load
duke
parents:
diff changeset
   236
     * @return <tt>true</tt> if this set contains all of the elements
90ce3da70b43 Initial load
duke
parents:
diff changeset
   237
     *        in the specified collection
90ce3da70b43 Initial load
duke
parents:
diff changeset
   238
     * @throws NullPointerException if the specified collection is null
90ce3da70b43 Initial load
duke
parents:
diff changeset
   239
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   240
    public boolean containsAll(Collection<?> c) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   241
        if (!(c instanceof JumboEnumSet))
90ce3da70b43 Initial load
duke
parents:
diff changeset
   242
            return super.containsAll(c);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   243
90ce3da70b43 Initial load
duke
parents:
diff changeset
   244
        JumboEnumSet es = (JumboEnumSet)c;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   245
        if (es.elementType != elementType)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   246
            return es.isEmpty();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   247
90ce3da70b43 Initial load
duke
parents:
diff changeset
   248
        for (int i = 0; i < elements.length; i++)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   249
            if ((es.elements[i] & ~elements[i]) != 0)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   250
                return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   251
        return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   252
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   253
90ce3da70b43 Initial load
duke
parents:
diff changeset
   254
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   255
     * Adds all of the elements in the specified collection to this set.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   256
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   257
     * @param c collection whose elements are to be added to this set
90ce3da70b43 Initial load
duke
parents:
diff changeset
   258
     * @return <tt>true</tt> if this set changed as a result of the call
90ce3da70b43 Initial load
duke
parents:
diff changeset
   259
     * @throws NullPointerException if the specified collection or any of
90ce3da70b43 Initial load
duke
parents:
diff changeset
   260
     *     its elements are null
90ce3da70b43 Initial load
duke
parents:
diff changeset
   261
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   262
    public boolean addAll(Collection<? extends E> c) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   263
        if (!(c instanceof JumboEnumSet))
90ce3da70b43 Initial load
duke
parents:
diff changeset
   264
            return super.addAll(c);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   265
90ce3da70b43 Initial load
duke
parents:
diff changeset
   266
        JumboEnumSet es = (JumboEnumSet)c;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   267
        if (es.elementType != elementType) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   268
            if (es.isEmpty())
90ce3da70b43 Initial load
duke
parents:
diff changeset
   269
                return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   270
            else
90ce3da70b43 Initial load
duke
parents:
diff changeset
   271
                throw new ClassCastException(
90ce3da70b43 Initial load
duke
parents:
diff changeset
   272
                    es.elementType + " != " + elementType);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   273
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   274
90ce3da70b43 Initial load
duke
parents:
diff changeset
   275
        for (int i = 0; i < elements.length; i++)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   276
            elements[i] |= es.elements[i];
90ce3da70b43 Initial load
duke
parents:
diff changeset
   277
        return recalculateSize();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   278
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   279
90ce3da70b43 Initial load
duke
parents:
diff changeset
   280
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   281
     * Removes from this set all of its elements that are contained in
90ce3da70b43 Initial load
duke
parents:
diff changeset
   282
     * the specified collection.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   283
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   284
     * @param c elements to be removed from this set
90ce3da70b43 Initial load
duke
parents:
diff changeset
   285
     * @return <tt>true</tt> if this set changed as a result of the call
90ce3da70b43 Initial load
duke
parents:
diff changeset
   286
     * @throws NullPointerException if the specified collection is null
90ce3da70b43 Initial load
duke
parents:
diff changeset
   287
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   288
    public boolean removeAll(Collection<?> c) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   289
        if (!(c instanceof JumboEnumSet))
90ce3da70b43 Initial load
duke
parents:
diff changeset
   290
            return super.removeAll(c);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   291
90ce3da70b43 Initial load
duke
parents:
diff changeset
   292
        JumboEnumSet es = (JumboEnumSet)c;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   293
        if (es.elementType != elementType)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   294
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   295
90ce3da70b43 Initial load
duke
parents:
diff changeset
   296
        for (int i = 0; i < elements.length; i++)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   297
            elements[i] &= ~es.elements[i];
90ce3da70b43 Initial load
duke
parents:
diff changeset
   298
        return recalculateSize();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   299
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   300
90ce3da70b43 Initial load
duke
parents:
diff changeset
   301
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   302
     * Retains only the elements in this set that are contained in the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   303
     * specified collection.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   304
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   305
     * @param c elements to be retained in this set
90ce3da70b43 Initial load
duke
parents:
diff changeset
   306
     * @return <tt>true</tt> if this set changed as a result of the call
90ce3da70b43 Initial load
duke
parents:
diff changeset
   307
     * @throws NullPointerException if the specified collection is null
90ce3da70b43 Initial load
duke
parents:
diff changeset
   308
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   309
    public boolean retainAll(Collection<?> c) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   310
        if (!(c instanceof JumboEnumSet))
90ce3da70b43 Initial load
duke
parents:
diff changeset
   311
            return super.retainAll(c);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   312
90ce3da70b43 Initial load
duke
parents:
diff changeset
   313
        JumboEnumSet<?> es = (JumboEnumSet<?>)c;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   314
        if (es.elementType != elementType) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   315
            boolean changed = (size != 0);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   316
            clear();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   317
            return changed;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   318
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   319
90ce3da70b43 Initial load
duke
parents:
diff changeset
   320
        for (int i = 0; i < elements.length; i++)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   321
            elements[i] &= es.elements[i];
90ce3da70b43 Initial load
duke
parents:
diff changeset
   322
        return recalculateSize();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   323
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   324
90ce3da70b43 Initial load
duke
parents:
diff changeset
   325
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   326
     * Removes all of the elements from this set.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   327
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   328
    public void clear() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   329
        Arrays.fill(elements, 0);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   330
        size = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   331
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   332
90ce3da70b43 Initial load
duke
parents:
diff changeset
   333
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   334
     * Compares the specified object with this set for equality.  Returns
90ce3da70b43 Initial load
duke
parents:
diff changeset
   335
     * <tt>true</tt> if the given object is also a set, the two sets have
90ce3da70b43 Initial load
duke
parents:
diff changeset
   336
     * the same size, and every member of the given set is contained in
90ce3da70b43 Initial load
duke
parents:
diff changeset
   337
     * this set.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   338
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   339
     * @param e object to be compared for equality with this set
90ce3da70b43 Initial load
duke
parents:
diff changeset
   340
     * @return <tt>true</tt> if the specified object is equal to this set
90ce3da70b43 Initial load
duke
parents:
diff changeset
   341
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   342
    public boolean equals(Object o) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   343
        if (!(o instanceof JumboEnumSet))
90ce3da70b43 Initial load
duke
parents:
diff changeset
   344
            return super.equals(o);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   345
90ce3da70b43 Initial load
duke
parents:
diff changeset
   346
        JumboEnumSet es = (JumboEnumSet)o;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   347
        if (es.elementType != elementType)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   348
            return size == 0 && es.size == 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   349
90ce3da70b43 Initial load
duke
parents:
diff changeset
   350
        return Arrays.equals(es.elements, elements);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   351
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   352
90ce3da70b43 Initial load
duke
parents:
diff changeset
   353
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   354
     * Recalculates the size of the set.  Returns true if it's changed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   355
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   356
    private boolean recalculateSize() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   357
        int oldSize = size;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   358
        size = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   359
        for (long elt : elements)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   360
            size += Long.bitCount(elt);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   361
90ce3da70b43 Initial load
duke
parents:
diff changeset
   362
        return size != oldSize;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   363
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   364
90ce3da70b43 Initial load
duke
parents:
diff changeset
   365
    public EnumSet<E> clone() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   366
        JumboEnumSet<E> result = (JumboEnumSet<E>) super.clone();
51
6fe31bc95bbc 6600143: Remove another 450 unnecessary casts
martin
parents: 2
diff changeset
   367
        result.elements = result.elements.clone();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   368
        return result;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   369
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   370
}