jdk/src/java.base/share/classes/java/util/JumboEnumSet.java
author mchung
Fri, 22 May 2015 16:43:39 -0700
changeset 30789 9eca83469588
parent 25859 3317bb8137f4
child 32108 aa5490a167ee
permissions -rw-r--r--
8074431: Remove native2ascii tool Reviewed-by: erikj, alanb, okutsu, mfang, naoto
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     1
/*
13795
73850c397272 7193406: Clean-up JDK Build Warnings in java.util, java.io
dxu
parents: 12448
diff changeset
     2
 * Copyright (c) 2003, 2012, Oracle and/or its affiliates. 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
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 715
diff changeset
     7
 * published by the Free Software Foundation.  Oracle designates this
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     8
 * particular file as subject to the "Classpath" exception as provided
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 715
diff changeset
     9
 * by Oracle in the LICENSE file that accompanied this code.
2
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
 *
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 715
diff changeset
    21
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 715
diff changeset
    22
 * or visit www.oracle.com if you need additional information or have any
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 715
diff changeset
    23
 * questions.
2
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> {
8800
e658ae923d53 7028133: Specify serialVersionUID for RegularEnumSet and JumboEnumSet
mduigou
parents: 8787
diff changeset
    37
    private static final long serialVersionUID = 334349849919042784L;
e658ae923d53 7028133: Specify serialVersionUID for RegularEnumSet and JumboEnumSet
mduigou
parents: 8787
diff changeset
    38
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    39
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    40
     * Bit vector representation of this set.  The ith bit of the jth
90ce3da70b43 Initial load
duke
parents:
diff changeset
    41
     * element of this array represents the  presence of universe[64*j +i]
90ce3da70b43 Initial load
duke
parents:
diff changeset
    42
     * in this set.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    43
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    44
    private long elements[];
90ce3da70b43 Initial load
duke
parents:
diff changeset
    45
90ce3da70b43 Initial load
duke
parents:
diff changeset
    46
    // Redundant - maintained for performance
90ce3da70b43 Initial load
duke
parents:
diff changeset
    47
    private int size = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    48
12448
b95438b17098 7157893: Warnings Cleanup in java.util.*
khazra
parents: 9035
diff changeset
    49
    JumboEnumSet(Class<E>elementType, Enum<?>[] universe) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    50
        super(elementType, universe);
90ce3da70b43 Initial load
duke
parents:
diff changeset
    51
        elements = new long[(universe.length + 63) >>> 6];
90ce3da70b43 Initial load
duke
parents:
diff changeset
    52
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
    53
90ce3da70b43 Initial load
duke
parents:
diff changeset
    54
    void addRange(E from, E to) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    55
        int fromIndex = from.ordinal() >>> 6;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    56
        int toIndex = to.ordinal() >>> 6;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    57
90ce3da70b43 Initial load
duke
parents:
diff changeset
    58
        if (fromIndex == toIndex) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    59
            elements[fromIndex] = (-1L >>>  (from.ordinal() - to.ordinal() - 1))
90ce3da70b43 Initial load
duke
parents:
diff changeset
    60
                            << from.ordinal();
90ce3da70b43 Initial load
duke
parents:
diff changeset
    61
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    62
            elements[fromIndex] = (-1L << from.ordinal());
90ce3da70b43 Initial load
duke
parents:
diff changeset
    63
            for (int i = fromIndex + 1; i < toIndex; i++)
90ce3da70b43 Initial load
duke
parents:
diff changeset
    64
                elements[i] = -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    65
            elements[toIndex] = -1L >>> (63 - to.ordinal());
90ce3da70b43 Initial load
duke
parents:
diff changeset
    66
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
    67
        size = to.ordinal() - from.ordinal() + 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    68
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
    69
90ce3da70b43 Initial load
duke
parents:
diff changeset
    70
    void addAll() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    71
        for (int i = 0; i < elements.length; i++)
90ce3da70b43 Initial load
duke
parents:
diff changeset
    72
            elements[i] = -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    73
        elements[elements.length - 1] >>>= -universe.length;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    74
        size = universe.length;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    75
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
    76
90ce3da70b43 Initial load
duke
parents:
diff changeset
    77
    void complement() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    78
        for (int i = 0; i < elements.length; i++)
90ce3da70b43 Initial load
duke
parents:
diff changeset
    79
            elements[i] = ~elements[i];
90ce3da70b43 Initial load
duke
parents:
diff changeset
    80
        elements[elements.length - 1] &= (-1L >>> -universe.length);
90ce3da70b43 Initial load
duke
parents:
diff changeset
    81
        size = universe.length - size;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    82
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
    83
90ce3da70b43 Initial load
duke
parents:
diff changeset
    84
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    85
     * Returns an iterator over the elements contained in this set.  The
90ce3da70b43 Initial load
duke
parents:
diff changeset
    86
     * iterator traverses the elements in their <i>natural order</i> (which is
90ce3da70b43 Initial load
duke
parents:
diff changeset
    87
     * the order in which the enum constants are declared). The returned
90ce3da70b43 Initial load
duke
parents:
diff changeset
    88
     * Iterator is a "weakly consistent" iterator that will never throw {@link
90ce3da70b43 Initial load
duke
parents:
diff changeset
    89
     * ConcurrentModificationException}.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    90
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    91
     * @return an iterator over the elements contained in this set
90ce3da70b43 Initial load
duke
parents:
diff changeset
    92
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    93
    public Iterator<E> iterator() {
7803
56bc97d69d93 6880112: Project Coin: Port JDK core library code to use diamond operator
smarks
parents: 5506
diff changeset
    94
        return new EnumSetIterator<>();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    95
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
    96
90ce3da70b43 Initial load
duke
parents:
diff changeset
    97
    private class EnumSetIterator<E extends Enum<E>> implements Iterator<E> {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    98
        /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    99
         * A bit vector representing the elements in the current "word"
90ce3da70b43 Initial load
duke
parents:
diff changeset
   100
         * of the set not yet returned by this iterator.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   101
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   102
        long unseen;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   103
90ce3da70b43 Initial load
duke
parents:
diff changeset
   104
        /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   105
         * The index corresponding to unseen in the elements array.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   106
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   107
        int unseenIndex = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   108
90ce3da70b43 Initial load
duke
parents:
diff changeset
   109
        /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   110
         * The bit representing the last element returned by this iterator
90ce3da70b43 Initial load
duke
parents:
diff changeset
   111
         * but not removed, or zero if no such element exists.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   112
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   113
        long lastReturned = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   114
90ce3da70b43 Initial load
duke
parents:
diff changeset
   115
        /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   116
         * The index corresponding to lastReturned in the elements array.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   117
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   118
        int lastReturnedIndex = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   119
90ce3da70b43 Initial load
duke
parents:
diff changeset
   120
        EnumSetIterator() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   121
            unseen = elements[0];
90ce3da70b43 Initial load
duke
parents:
diff changeset
   122
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   123
13795
73850c397272 7193406: Clean-up JDK Build Warnings in java.util, java.io
dxu
parents: 12448
diff changeset
   124
        @Override
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   125
        public boolean hasNext() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   126
            while (unseen == 0 && unseenIndex < elements.length - 1)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   127
                unseen = elements[++unseenIndex];
90ce3da70b43 Initial load
duke
parents:
diff changeset
   128
            return unseen != 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   129
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   130
12448
b95438b17098 7157893: Warnings Cleanup in java.util.*
khazra
parents: 9035
diff changeset
   131
        @Override
13795
73850c397272 7193406: Clean-up JDK Build Warnings in java.util, java.io
dxu
parents: 12448
diff changeset
   132
        @SuppressWarnings("unchecked")
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   133
        public E next() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   134
            if (!hasNext())
90ce3da70b43 Initial load
duke
parents:
diff changeset
   135
                throw new NoSuchElementException();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   136
            lastReturned = unseen & -unseen;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   137
            lastReturnedIndex = unseenIndex;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   138
            unseen -= lastReturned;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   139
            return (E) universe[(lastReturnedIndex << 6)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   140
                                + Long.numberOfTrailingZeros(lastReturned)];
90ce3da70b43 Initial load
duke
parents:
diff changeset
   141
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   142
13795
73850c397272 7193406: Clean-up JDK Build Warnings in java.util, java.io
dxu
parents: 12448
diff changeset
   143
        @Override
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   144
        public void remove() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   145
            if (lastReturned == 0)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   146
                throw new IllegalStateException();
8787
4b055daf8dd0 7014637: Improve behavior of EnumSet Iterator.remove()
mduigou
parents: 7803
diff changeset
   147
            final long oldElements = elements[lastReturnedIndex];
4b055daf8dd0 7014637: Improve behavior of EnumSet Iterator.remove()
mduigou
parents: 7803
diff changeset
   148
            elements[lastReturnedIndex] &= ~lastReturned;
4b055daf8dd0 7014637: Improve behavior of EnumSet Iterator.remove()
mduigou
parents: 7803
diff changeset
   149
            if (oldElements != elements[lastReturnedIndex]) {
4b055daf8dd0 7014637: Improve behavior of EnumSet Iterator.remove()
mduigou
parents: 7803
diff changeset
   150
                size--;
4b055daf8dd0 7014637: Improve behavior of EnumSet Iterator.remove()
mduigou
parents: 7803
diff changeset
   151
            }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   152
            lastReturned = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   153
        }
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 the number of elements in this set.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   158
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   159
     * @return the number of elements in this set
90ce3da70b43 Initial load
duke
parents:
diff changeset
   160
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   161
    public int size() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   162
        return size;
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 no elements.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   167
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   168
     * @return <tt>true</tt> if this set contains no elements
90ce3da70b43 Initial load
duke
parents:
diff changeset
   169
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   170
    public boolean isEmpty() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   171
        return size == 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   172
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   173
90ce3da70b43 Initial load
duke
parents:
diff changeset
   174
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   175
     * Returns <tt>true</tt> if this set contains the specified element.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   176
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   177
     * @param e element to be checked for containment in this collection
90ce3da70b43 Initial load
duke
parents:
diff changeset
   178
     * @return <tt>true</tt> if this set contains the specified element
90ce3da70b43 Initial load
duke
parents:
diff changeset
   179
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   180
    public boolean contains(Object e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   181
        if (e == null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   182
            return false;
12448
b95438b17098 7157893: Warnings Cleanup in java.util.*
khazra
parents: 9035
diff changeset
   183
        Class<?> eClass = e.getClass();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   184
        if (eClass != elementType && eClass.getSuperclass() != elementType)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   185
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   186
12448
b95438b17098 7157893: Warnings Cleanup in java.util.*
khazra
parents: 9035
diff changeset
   187
        int eOrdinal = ((Enum<?>)e).ordinal();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   188
        return (elements[eOrdinal >>> 6] & (1L << eOrdinal)) != 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   189
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   190
90ce3da70b43 Initial load
duke
parents:
diff changeset
   191
    // Modification Operations
90ce3da70b43 Initial load
duke
parents:
diff changeset
   192
90ce3da70b43 Initial load
duke
parents:
diff changeset
   193
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   194
     * Adds the specified element to this set if it is not already present.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   195
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   196
     * @param e element to be added to this set
90ce3da70b43 Initial load
duke
parents:
diff changeset
   197
     * @return <tt>true</tt> if the set changed as a result of the call
90ce3da70b43 Initial load
duke
parents:
diff changeset
   198
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   199
     * @throws NullPointerException if <tt>e</tt> is null
90ce3da70b43 Initial load
duke
parents:
diff changeset
   200
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   201
    public boolean add(E e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   202
        typeCheck(e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   203
90ce3da70b43 Initial load
duke
parents:
diff changeset
   204
        int eOrdinal = e.ordinal();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   205
        int eWordNum = eOrdinal >>> 6;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   206
90ce3da70b43 Initial load
duke
parents:
diff changeset
   207
        long oldElements = elements[eWordNum];
90ce3da70b43 Initial load
duke
parents:
diff changeset
   208
        elements[eWordNum] |= (1L << eOrdinal);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   209
        boolean result = (elements[eWordNum] != oldElements);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   210
        if (result)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   211
            size++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   212
        return result;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   213
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   214
90ce3da70b43 Initial load
duke
parents:
diff changeset
   215
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   216
     * Removes the specified element from this set if it is present.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   217
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   218
     * @param e element to be removed from this set, if present
90ce3da70b43 Initial load
duke
parents:
diff changeset
   219
     * @return <tt>true</tt> if the set contained the specified element
90ce3da70b43 Initial load
duke
parents:
diff changeset
   220
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   221
    public boolean remove(Object e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   222
        if (e == null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   223
            return false;
12448
b95438b17098 7157893: Warnings Cleanup in java.util.*
khazra
parents: 9035
diff changeset
   224
        Class<?> eClass = e.getClass();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   225
        if (eClass != elementType && eClass.getSuperclass() != elementType)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   226
            return false;
12448
b95438b17098 7157893: Warnings Cleanup in java.util.*
khazra
parents: 9035
diff changeset
   227
        int eOrdinal = ((Enum<?>)e).ordinal();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   228
        int eWordNum = eOrdinal >>> 6;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   229
90ce3da70b43 Initial load
duke
parents:
diff changeset
   230
        long oldElements = elements[eWordNum];
90ce3da70b43 Initial load
duke
parents:
diff changeset
   231
        elements[eWordNum] &= ~(1L << eOrdinal);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   232
        boolean result = (elements[eWordNum] != oldElements);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   233
        if (result)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   234
            size--;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   235
        return result;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   236
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   237
90ce3da70b43 Initial load
duke
parents:
diff changeset
   238
    // Bulk Operations
90ce3da70b43 Initial load
duke
parents:
diff changeset
   239
90ce3da70b43 Initial load
duke
parents:
diff changeset
   240
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   241
     * Returns <tt>true</tt> if this set contains all of the elements
90ce3da70b43 Initial load
duke
parents:
diff changeset
   242
     * in the specified collection.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   243
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   244
     * @param c collection to be checked for containment in this set
90ce3da70b43 Initial load
duke
parents:
diff changeset
   245
     * @return <tt>true</tt> if this set contains all of the elements
90ce3da70b43 Initial load
duke
parents:
diff changeset
   246
     *        in the specified collection
90ce3da70b43 Initial load
duke
parents:
diff changeset
   247
     * @throws NullPointerException if the specified collection is null
90ce3da70b43 Initial load
duke
parents:
diff changeset
   248
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   249
    public boolean containsAll(Collection<?> c) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   250
        if (!(c instanceof JumboEnumSet))
90ce3da70b43 Initial load
duke
parents:
diff changeset
   251
            return super.containsAll(c);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   252
12448
b95438b17098 7157893: Warnings Cleanup in java.util.*
khazra
parents: 9035
diff changeset
   253
        JumboEnumSet<?> es = (JumboEnumSet<?>)c;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   254
        if (es.elementType != elementType)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   255
            return es.isEmpty();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   256
90ce3da70b43 Initial load
duke
parents:
diff changeset
   257
        for (int i = 0; i < elements.length; i++)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   258
            if ((es.elements[i] & ~elements[i]) != 0)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   259
                return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   260
        return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   261
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   262
90ce3da70b43 Initial load
duke
parents:
diff changeset
   263
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   264
     * Adds all of the elements in the specified collection to this set.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   265
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   266
     * @param c collection whose elements are to be added to this set
90ce3da70b43 Initial load
duke
parents:
diff changeset
   267
     * @return <tt>true</tt> if this set changed as a result of the call
90ce3da70b43 Initial load
duke
parents:
diff changeset
   268
     * @throws NullPointerException if the specified collection or any of
90ce3da70b43 Initial load
duke
parents:
diff changeset
   269
     *     its elements are null
90ce3da70b43 Initial load
duke
parents:
diff changeset
   270
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   271
    public boolean addAll(Collection<? extends E> c) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   272
        if (!(c instanceof JumboEnumSet))
90ce3da70b43 Initial load
duke
parents:
diff changeset
   273
            return super.addAll(c);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   274
12448
b95438b17098 7157893: Warnings Cleanup in java.util.*
khazra
parents: 9035
diff changeset
   275
        JumboEnumSet<?> es = (JumboEnumSet<?>)c;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   276
        if (es.elementType != elementType) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   277
            if (es.isEmpty())
90ce3da70b43 Initial load
duke
parents:
diff changeset
   278
                return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   279
            else
90ce3da70b43 Initial load
duke
parents:
diff changeset
   280
                throw new ClassCastException(
90ce3da70b43 Initial load
duke
parents:
diff changeset
   281
                    es.elementType + " != " + elementType);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   282
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   283
90ce3da70b43 Initial load
duke
parents:
diff changeset
   284
        for (int i = 0; i < elements.length; i++)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   285
            elements[i] |= es.elements[i];
90ce3da70b43 Initial load
duke
parents:
diff changeset
   286
        return recalculateSize();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   287
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   288
90ce3da70b43 Initial load
duke
parents:
diff changeset
   289
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   290
     * Removes from this set all of its elements that are contained in
90ce3da70b43 Initial load
duke
parents:
diff changeset
   291
     * the specified collection.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   292
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   293
     * @param c elements to be removed from this set
90ce3da70b43 Initial load
duke
parents:
diff changeset
   294
     * @return <tt>true</tt> if this set changed as a result of the call
90ce3da70b43 Initial load
duke
parents:
diff changeset
   295
     * @throws NullPointerException if the specified collection is null
90ce3da70b43 Initial load
duke
parents:
diff changeset
   296
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   297
    public boolean removeAll(Collection<?> c) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   298
        if (!(c instanceof JumboEnumSet))
90ce3da70b43 Initial load
duke
parents:
diff changeset
   299
            return super.removeAll(c);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   300
12448
b95438b17098 7157893: Warnings Cleanup in java.util.*
khazra
parents: 9035
diff changeset
   301
        JumboEnumSet<?> es = (JumboEnumSet<?>)c;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   302
        if (es.elementType != elementType)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   303
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   304
90ce3da70b43 Initial load
duke
parents:
diff changeset
   305
        for (int i = 0; i < elements.length; i++)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   306
            elements[i] &= ~es.elements[i];
90ce3da70b43 Initial load
duke
parents:
diff changeset
   307
        return recalculateSize();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   308
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   309
90ce3da70b43 Initial load
duke
parents:
diff changeset
   310
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   311
     * Retains only the elements in this set that are contained in the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   312
     * specified collection.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   313
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   314
     * @param c elements to be retained in this set
90ce3da70b43 Initial load
duke
parents:
diff changeset
   315
     * @return <tt>true</tt> if this set changed as a result of the call
90ce3da70b43 Initial load
duke
parents:
diff changeset
   316
     * @throws NullPointerException if the specified collection is null
90ce3da70b43 Initial load
duke
parents:
diff changeset
   317
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   318
    public boolean retainAll(Collection<?> c) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   319
        if (!(c instanceof JumboEnumSet))
90ce3da70b43 Initial load
duke
parents:
diff changeset
   320
            return super.retainAll(c);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   321
90ce3da70b43 Initial load
duke
parents:
diff changeset
   322
        JumboEnumSet<?> es = (JumboEnumSet<?>)c;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   323
        if (es.elementType != elementType) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   324
            boolean changed = (size != 0);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   325
            clear();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   326
            return changed;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   327
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   328
90ce3da70b43 Initial load
duke
parents:
diff changeset
   329
        for (int i = 0; i < elements.length; i++)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   330
            elements[i] &= es.elements[i];
90ce3da70b43 Initial load
duke
parents:
diff changeset
   331
        return recalculateSize();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   332
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   333
90ce3da70b43 Initial load
duke
parents:
diff changeset
   334
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   335
     * Removes all of the elements from this set.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   336
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   337
    public void clear() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   338
        Arrays.fill(elements, 0);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   339
        size = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   340
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   341
90ce3da70b43 Initial load
duke
parents:
diff changeset
   342
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   343
     * Compares the specified object with this set for equality.  Returns
90ce3da70b43 Initial load
duke
parents:
diff changeset
   344
     * <tt>true</tt> if the given object is also a set, the two sets have
90ce3da70b43 Initial load
duke
parents:
diff changeset
   345
     * the same size, and every member of the given set is contained in
90ce3da70b43 Initial load
duke
parents:
diff changeset
   346
     * this set.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   347
     *
14014
da3648e13e67 8000269: Cleanup javadoc warnings
alanb
parents: 13795
diff changeset
   348
     * @param o object to be compared for equality with this set
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   349
     * @return <tt>true</tt> if the specified object is equal to this set
90ce3da70b43 Initial load
duke
parents:
diff changeset
   350
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   351
    public boolean equals(Object o) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   352
        if (!(o instanceof JumboEnumSet))
90ce3da70b43 Initial load
duke
parents:
diff changeset
   353
            return super.equals(o);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   354
12448
b95438b17098 7157893: Warnings Cleanup in java.util.*
khazra
parents: 9035
diff changeset
   355
        JumboEnumSet<?> es = (JumboEnumSet<?>)o;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   356
        if (es.elementType != elementType)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   357
            return size == 0 && es.size == 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   358
90ce3da70b43 Initial load
duke
parents:
diff changeset
   359
        return Arrays.equals(es.elements, elements);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   360
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   361
90ce3da70b43 Initial load
duke
parents:
diff changeset
   362
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   363
     * Recalculates the size of the set.  Returns true if it's changed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   364
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   365
    private boolean recalculateSize() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   366
        int oldSize = size;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   367
        size = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   368
        for (long elt : elements)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   369
            size += Long.bitCount(elt);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   370
90ce3da70b43 Initial load
duke
parents:
diff changeset
   371
        return size != oldSize;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   372
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   373
90ce3da70b43 Initial load
duke
parents:
diff changeset
   374
    public EnumSet<E> clone() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   375
        JumboEnumSet<E> result = (JumboEnumSet<E>) super.clone();
51
6fe31bc95bbc 6600143: Remove another 450 unnecessary casts
martin
parents: 2
diff changeset
   376
        result.elements = result.elements.clone();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   377
        return result;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   378
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   379
}