adds 32-bit java.util.BitSet extends javajs.util.BS

BobHanson · BobHanson · commit 001b377a41da · 2017-09-05T22:47:54.000-05:00
diff --git a/sources/net.sf.j2s.java.core/src/java/util/BitSet.java b/sources/net.sf.j2s.java.core/src/java/util/BitSet.java
@@ -0,0 +1,129 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one or more
+ *  contributor license agreements.  See the NOTICE file distributed with
+ *  this work for additional information regarding copyright ownership.
+ *  The ASF licenses this file to You under the Apache License, Version 2.0
+ *  (the "License"); you may not use this file except in compliance with
+ *  the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package java.util;
+
+import javajs.util.BS;
+
+public class BitSet extends BS {
+	public BitSet() {
+		super();
+	}
+	
+	public BitSet(int nbits) {
+		super();
+	    init(nbits);
+	}
+	
+    public void flip(int bitIndex) {
+        if (bitIndex < 0)
+            throw new IndexOutOfBoundsException("bitIndex < 0: " + bitIndex);
+          int wordIndex = wordIndex(bitIndex);
+          expandTo(wordIndex);
+          words[wordIndex] ^= (1 << bitIndex); // Restores invariants
+       }
+       public void flip(int fromIndex, int toIndex) {
+    	    if (fromIndex == toIndex)
+    	        return;
+
+    	      // Increase capacity if necessary
+    	      int startWordIndex = wordIndex(fromIndex);
+    	      int endWordIndex = wordIndex(toIndex - 1);
+    	      expandTo(endWordIndex);
+
+    	      int firstWordMask = WORD_MASK << fromIndex;
+    	      int lastWordMask = WORD_MASK >>> -toIndex;
+    	      if (startWordIndex == endWordIndex) {
+    	        // Case 1: One word
+    	        words[startWordIndex] ^= (firstWordMask & lastWordMask);
+    	      } else {
+    	        // Case 2: Multiple words
+    	        // Handle first word
+    	        words[startWordIndex] ^= firstWordMask;
+
+    	        // Handle intermediate words, if any
+    	        for (int i = startWordIndex + 1; i < endWordIndex; i++)
+    	          words[i] ^= WORD_MASK;
+
+    	        // Handle last word (restores invariants)
+    	        words[endWordIndex] ^= lastWordMask;
+    	      }
+       }
+       public void set(int bitIndex, boolean value) {
+         setBitTo(bitIndex, value);
+       }
+       public void set(int fromIndex, int toIndex) {
+         setBits(fromIndex, toIndex);
+       }
+       public void set(int fromIndex, int toIndex, boolean value) {
+           if (value)
+               set(fromIndex, toIndex);
+           else
+               clear(fromIndex, toIndex);
+       }
+       public void clear(int fromIndex, int toIndex) {
+         clearBits(fromIndex, toIndex);
+       }
+       public void clear() { 
+         clearAll();
+       }
+       public BitSet get(int fromIndex, int toIndex) {
+           //checkRange(fromIndex, toIndex);
+
+           //checkInvariants();
+
+           int len = length();
+
+           // If no set bits in range return empty bitset
+           if (len <= fromIndex || fromIndex == toIndex)
+               return new BitSet(0);
+
+           // An optimization
+           if (toIndex > len)
+               toIndex = len;
+
+           BitSet result = new BitSet(toIndex - fromIndex);
+           int targetWords = wordIndex(toIndex - fromIndex - 1) + 1;
+           int sourceIndex = wordIndex(fromIndex);
+           boolean wordAligned = ((fromIndex & BIT_INDEX_MASK) == 0);
+
+           // Process all words but the last word
+           for (int i = 0; i < targetWords - 1; i++, sourceIndex++)
+               result.words[i] = wordAligned ? words[sourceIndex] :
+                   (words[sourceIndex] >>> fromIndex) |
+                   (words[sourceIndex+1] << -fromIndex);
+
+           // Process the last word
+           int lastWordMask = WORD_MASK >>> -toIndex;
+           result.words[targetWords - 1] =
+               ((toIndex-1) & BIT_INDEX_MASK) < (fromIndex & BIT_INDEX_MASK)
+               ? /* straddles source words */
+               ((words[sourceIndex] >>> fromIndex) |
+                (words[sourceIndex+1] & lastWordMask) << -fromIndex)
+               :
+               ((words[sourceIndex] & lastWordMask) >>> fromIndex);
+
+           // Set wordsInUse correctly
+           result.wordsInUse = targetWords;
+           result.recalculateWordsInUse();
+           //result.checkInvariants();
+
+           return result;
+       }
+
+
+}
diff --git a/sources/net.sf.j2s.java.core/src/javajs/util/BS.java b/sources/net.sf.j2s.java.core/src/javajs/util/BS.java
@@ -79,27 +79,28 @@
  */
 public class BS implements Cloneable, JSONEncodable {
   /*
-   * BitSets are packed into arrays of "words."
+   * BitSets are packed into arrays of "wrangeords."
    * 
    * An int, which consists of 32 bits, requiring 5 address bits, is used for
    * the JavaScript port.
    */
   private final static int ADDRESS_BITS_PER_WORD = 5;
   private final static int BITS_PER_WORD = 1 << ADDRESS_BITS_PER_WORD;
+  protected final static int BIT_INDEX_MASK = BITS_PER_WORD - 1;
 
   /* Used to shift left or right for a partial word mask */
-  private static final int WORD_MASK = 0xffffffff;
+  protected static final int WORD_MASK = 0xffffffff;
 
 
   /**
    * The internal field corresponding to the serialField "bits".
    */
-  private int[] words;
+  protected int[] words;
 
   /**
    * The number of words in the logical size of this BitSet.
    */
-  private transient int wordsInUse = 0;
+  protected transient int wordsInUse = 0;
 
   /**
    * Whether the size of "words" is user-specified. If so, we assume the user
@@ -115,7 +116,7 @@ public class BS implements Cloneable, JSONEncodable {
    * @param bitIndex 
    * @return b
    */
-  private static int wordIndex(int bitIndex) {
+  protected static int wordIndex(int bitIndex) {
     return bitIndex >> ADDRESS_BITS_PER_WORD;
   }
 
@@ -124,7 +125,7 @@ private static int wordIndex(int bitIndex) {
    * WARNING:This method assumes that the number of words actually in use is
    * less than or equal to the current value of wordsInUse!
    */
-  private void recalculateWordsInUse() {
+  protected void recalculateWordsInUse() {
     // Traverse the bitset until a used word is found
     int i;
     for (i = wordsInUse - 1; i >= 0; i--)
@@ -159,7 +160,7 @@ public static BS newN(int nbits) {
     return bs;
   }
 
-  private void init(int nbits) {
+  protected void init(int nbits) {
     // nbits can't be negative; size 0 is OK
     if (nbits < 0)
       throw new NegativeArraySizeException("nbits < 0: " + nbits);
@@ -194,7 +195,7 @@ private void ensureCapacity(int wordsRequired) {
    * @param wordIndex
    *          the index to be accommodated.
    */
-  private void expandTo(int wordIndex) {
+  protected void expandTo(int wordIndex) {
     int wordsRequired = wordIndex + 1;
     if (wordsInUse < wordsRequired) {
       ensureCapacity(wordsRequired);
