src/java.base/share/classes/java/util/RegularEnumSet.java

@@ -1,7 +1,7 @@
 /*
- * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2018, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this

@@ -37,29 +37,54 @@
     private static final long serialVersionUID = 3411599620347842686L;
     /**
      * Bit vector representation of this set.  The 2^k bit indicates the
      * presence of universe[k] in this set.
      */
-    private long elements = 0L;
+    private byte[] bits = new byte[8];
+
+    private void setBits(long elems) {
+        for (int i=0; i<bits.length; i++)
+            bits[i] = (byte)(elems >> (i<<3));
+    }
+
+    private long elems() {
+        long elems = 0L;
+        for (int i=0; i<bits.length; i++)
+            elems |= (((long)bits[i]) & 0xFFL) << (i<<3);
+
+        return elems;
+    }
+
+    /**
+     * Returns a copy of this set.
+     *
+     * @return a copy of this set
+     */
+    @SuppressWarnings("unchecked")
+    public EnumSet<E> clone() {
+        RegularEnumSet<E> es = (RegularEnumSet<E>) super.clone();
+        es.bits = new byte[8];
+        es.setBits(elems());
+        return es;
+    }
 
     RegularEnumSet(Class<E>elementType, Enum<?>[] universe) {
         super(elementType, universe);
     }
 
     void addRange(E from, E to) {
-        elements = (-1L >>>  (from.ordinal() - to.ordinal() - 1)) << from.ordinal();
+        setBits((-1L >>>  (from.ordinal() - to.ordinal() - 1)) << from.ordinal());
     }
 
     void addAll() {
         if (universe.length != 0)
-            elements = -1L >>> -universe.length;
+            setBits(-1L >>> -universe.length);
     }
 
     void complement() {
         if (universe.length != 0) {
-            elements = ~elements;
-            elements &= -1L >>> -universe.length;  // Mask unused bits
+            setBits(~elems() & (-1L >>> -universe.length));
         }
     }
 
     /**
      * Returns an iterator over the elements contained in this set.  The

@@ -87,11 +112,11 @@
          * but not removed, or zero if no such element exists.
          */
         long lastReturned = 0;
 
         EnumSetIterator() {
-            unseen = elements;
+            unseen = elems();
         }
 
         public boolean hasNext() {
             return unseen != 0;
         }

@@ -106,31 +131,31 @@
         }
 
         public void remove() {
             if (lastReturned == 0)
                 throw new IllegalStateException();
-            elements &= ~lastReturned;
+            setBits(elems() & ~lastReturned);
             lastReturned = 0;
         }
     }
 
     /**
      * Returns the number of elements in this set.
      *
      * @return the number of elements in this set
      */
     public int size() {
-        return Long.bitCount(elements);
+        return Long.bitCount(elems());
     }
 
     /**
      * Returns {@code true} if this set contains no elements.
      *
      * @return {@code true} if this set contains no elements
      */
     public boolean isEmpty() {
-        return elements == 0;
+        return elems() == 0;
     }
 
     /**
      * Returns {@code true} if this set contains the specified element.
      *

@@ -142,11 +167,11 @@
             return false;
         Class<?> eClass = e.getClass();
         if (eClass != elementType && eClass.getSuperclass() != elementType)
             return false;
 
-        return (elements & (1L << ((Enum<?>)e).ordinal())) != 0;
+        return System.isBit(bits, ((Enum<?>)e).ordinal());
     }
 
     // Modification Operations
 
     /**

@@ -157,14 +182,13 @@
      *
      * @throws NullPointerException if {@code e} is null
      */
     public boolean add(E e) {
         typeCheck(e);
-
-        long oldElements = elements;
-        elements |= (1L << ((Enum<?>)e).ordinal());
-        return elements != oldElements;
+        long oldElements = elems();
+        System.setBit(bits, ((Enum<?>)e).ordinal());
+        return elems() != oldElements;
     }
 
     /**
      * Removes the specified element from this set if it is present.
      *

@@ -175,14 +199,13 @@
         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;
+        long oldElements = elems();
+        System.clrBit(bits, ((Enum<?>)e).ordinal());
+        return elems() != oldElements;
     }
 
     // Bulk Operations
 
     /**

@@ -200,11 +223,11 @@
 
         RegularEnumSet<?> es = (RegularEnumSet<?>)c;
         if (es.elementType != elementType)
             return es.isEmpty();
 
-        return (es.elements & ~elements) == 0;
+        return (es.elems() & ~elems()) == 0;
     }
 
     /**
      * Adds all of the elements in the specified collection to this set.
      *

@@ -223,14 +246,13 @@
                 return false;
             else
                 throw new ClassCastException(
                     es.elementType + " != " + elementType);
         }
-
-        long oldElements = elements;
-        elements |= es.elements;
-        return elements != oldElements;
+        long oldElements = elems();
+        setBits(elems() | es.elems());
+        return elems() != oldElements;
     }
 
     /**
      * Removes from this set all of its elements that are contained in
      * the specified collection.

@@ -244,14 +266,13 @@
             return super.removeAll(c);
 
         RegularEnumSet<?> es = (RegularEnumSet<?>)c;
         if (es.elementType != elementType)
             return false;
-
-        long oldElements = elements;
-        elements &= ~es.elements;
-        return elements != oldElements;
+        long oldElements = elems();
+        setBits(elems() & ~es.elems());
+        return elems() != oldElements;
     }
 
     /**
      * Retains only the elements in this set that are contained in the
      * specified collection.

@@ -264,25 +285,24 @@
         if (!(c instanceof RegularEnumSet))
             return super.retainAll(c);
 
         RegularEnumSet<?> es = (RegularEnumSet<?>)c;
         if (es.elementType != elementType) {
-            boolean changed = (elements != 0);
-            elements = 0;
+            boolean changed = (elems() != 0);
+            setBits(0);
             return changed;
         }
-
-        long oldElements = elements;
-        elements &= es.elements;
-        return elements != oldElements;
+        long oldElements = elems();
+        setBits(elems() & es.elems());
+        return elems() != oldElements;
     }
 
     /**
      * Removes all of the elements from this set.
      */
     public void clear() {
-        elements = 0;
+        setBits(0);
     }
 
     /**
      * Compares the specified object with this set for equality.  Returns
      * {@code true} if the given object is also a set, the two sets have

@@ -296,9 +316,9 @@
         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;
+            return elems() == 0 && es.elems() == 0;
+        return es.elems() == elems();
     }
 }