/*
* @(#) $(JCGO)/goclsp/clsp_fix/java/util/BitSet.java --
* Int-based implementation of the standard BitSet class.
**
* Project: JCGO (http://www.ivmaisoft.com/jcgo/)
* Copyright (C) 2001-2007 Ivan Maidanski <ivmai@ivmaisoft.com>
* All rights reserved.
**
* Class specification origin: GNU Classpath v0.93
*/
/*
* This is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
**
* This software is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License (GPL) for more details.
**
* Linking this library statically or dynamically with other modules is
* making a combined work based on this library. Thus, the terms and
* conditions of the GNU General Public License cover the whole
* combination.
**
* As a special exception, the copyright holders of this library give you
* permission to link this library with independent modules to produce an
* executable, regardless of the license terms of these independent
* modules, and to copy and distribute the resulting executable under
* terms of your choice, provided that you also meet, for each linked
* independent module, the terms and conditions of the license of that
* module. An independent module is a module which is not derived from
* or based on this library. If you modify this library, you may extend
* this exception to your version of the library, but you are not
* obligated to do so. If you do not wish to do so, delete this
* exception statement from your version.
*/
package java.util;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class BitSet
implements Cloneable, Serializable
{
private static final long serialVersionUID = 7997698588986878753L;
private static final int INDEX_SHIFT = 5;
private long[] bits;
private transient int unitsInUse;
private transient int[] intBits;
public BitSet()
{
this(64);
}
public BitSet(int nbits)
{
if (nbits < 0)
throw new NegativeArraySizeException("" + nbits);
intBits = new int[(((nbits - 1) >> INDEX_SHIFT) + 2) & ~1];
}
public int length()
{
recalculateUnitsInUse();
int i = unitsInUse;
return i > 0 ? (i << INDEX_SHIFT) -
numberOfLeadingZeros(intBits[i - 1]) : 0;
}
public boolean isEmpty()
{
recalculateUnitsInUse();
return unitsInUse == 0;
}
public void set(int bitIndex)
{
if (bitIndex < 0)
throw new IndexOutOfBoundsException("" + bitIndex);
int i = bitIndex >> INDEX_SHIFT;
if (unitsInUse <= i)
ensureCapacity(i + 1);
intBits[i] |= 1 << bitIndex;
}
public void set(int fromIndex, int toIndex)
{
if (fromIndex < 0 || toIndex < fromIndex)
throw new IndexOutOfBoundsException("" + fromIndex + ", " + toIndex);
if (fromIndex < toIndex)
{
int i = fromIndex >> INDEX_SHIFT;
int j = (toIndex - 1) >> INDEX_SHIFT;
if (unitsInUse <= j)
ensureCapacity(j + 1);
int[] intBits = this.intBits;
if (i < j)
{
intBits[i] |= -1 << fromIndex;
intBits[j] |= (2 << (toIndex - 1)) - 1;
while (++i < j)
intBits[i] = -1;
}
else intBits[i] |= (-1 << fromIndex) & ((2 << (toIndex - 1)) - 1);
}
}
public void set(int bitIndex, boolean value)
{
if (value)
set(bitIndex);
else clear(bitIndex);
}
public void set(int fromIndex, int toIndex, boolean value)
{
if (value)
set(fromIndex, toIndex);
else clear(fromIndex, toIndex);
}
public void clear()
{
int i = unitsInUse;
if (i > 0)
{
int[] intBits = this.intBits;
unitsInUse = 0;
do
{
intBits[--i] = 0;
} while (i > 0);
}
}
public void clear(int bitIndex)
{
if (bitIndex < 0)
throw new IndexOutOfBoundsException("" + bitIndex);
int i = bitIndex >> INDEX_SHIFT;
if (unitsInUse > i)
intBits[i] &= ~(1 << bitIndex);
}
public void clear(int fromIndex, int toIndex)
{
if (fromIndex < 0 || toIndex < fromIndex)
throw new IndexOutOfBoundsException("" + fromIndex + ", " + toIndex);
if (fromIndex < toIndex)
{
int i = fromIndex >> INDEX_SHIFT;
int j = unitsInUse - 1;
if (i <= j)
{
int[] intBits = this.intBits;
int k = (toIndex - 1) >> INDEX_SHIFT;
if (j >= k)
j = k;
if (i < j)
{
intBits[i] &= (1 << fromIndex) - 1;
intBits[j] &= -2 << (toIndex - 1);
while (++i < j)
intBits[i] = 0;
}
else intBits[i] &= ((1 << fromIndex) - 1) | (-2 << (toIndex - 1));
}
}
}
public boolean get(int bitIndex)
{
if (bitIndex < 0)
throw new IndexOutOfBoundsException("" + bitIndex);
int i = bitIndex >> INDEX_SHIFT;
return unitsInUse > i && (intBits[i] & (1 << bitIndex)) != 0;
}
public BitSet get(int fromIndex, int toIndex)
{
if (fromIndex < 0 || toIndex < fromIndex)
throw new IndexOutOfBoundsException("" + fromIndex + ", " + toIndex);
BitSet set = new BitSet(toIndex - fromIndex);
if (fromIndex < toIndex)
{
int i = fromIndex >> INDEX_SHIFT;
int j = unitsInUse;
if (i < j)
{
int[] intBits = this.intBits;
int[] intBits2 = set.intBits;
int k = (toIndex - 1) >> INDEX_SHIFT;
if (j >= k)
j = k;
k = j - i;
set.unitsInUse = k + 1;
if ((fromIndex & ((1 << INDEX_SHIFT) - 1)) != 0)
{
int v = intBits[i];
if (k > 0)
{
int revShift = -fromIndex;
k = 0;
do
{
int w = intBits[++i];
intBits2[k++] = (v >>> fromIndex) | (w << revShift);
v = w;
} while (i < j);
}
intBits2[k] = (((2 << (toIndex - 1)) - 1) & v) >>> fromIndex;
}
else
{
if (k > 0)
System.arraycopy(intBits, i, intBits2, 0, k);
intBits2[k] = intBits[j] & ((2 << (toIndex - 1)) - 1);
}
}
}
return set;
}
public void flip(int bitIndex)
{
if (bitIndex < 0)
throw new IndexOutOfBoundsException("" + bitIndex);
int i = bitIndex >> INDEX_SHIFT;
if (unitsInUse <= i)
ensureCapacity(i + 1);
intBits[i] ^= 1 << bitIndex;
}
public void flip(int fromIndex, int toIndex)
{
if (fromIndex < 0 || toIndex < fromIndex)
throw new IndexOutOfBoundsException("" + fromIndex + ", " + toIndex);
if (fromIndex < toIndex)
{
int i = fromIndex >> INDEX_SHIFT;
int j = (toIndex - 1) >> INDEX_SHIFT;
if (unitsInUse <= j)
ensureCapacity(j + 1);
int[] intBits = this.intBits;
if (i < j)
{
intBits[i] ^= -1 << fromIndex;
intBits[j] ^= (2 << (toIndex - 1)) - 1;
while (++i < j)
intBits[i] ^= -1;
}
else intBits[i] ^= (-1 << fromIndex) & ((2 << (toIndex - 1)) - 1);
}
}
public void and(BitSet set)
{
if (set != this)
{
set.recalculateUnitsInUse();
recalculateUnitsInUse();
int i = unitsInUse;
int j = set.unitsInUse;
int[] intBits = this.intBits;
int[] intBits2 = set.intBits;
if (i > j)
{
unitsInUse = j;
do
{
intBits[--i] = 0;
} while (i > j);
}
while (i-- > 0)
intBits[i] &= intBits2[i];
}
}
public void andNot(BitSet set)
{
if (set != this)
{
set.recalculateUnitsInUse();
recalculateUnitsInUse();
int i = unitsInUse;
int[] intBits = this.intBits;
int[] intBits2 = set.intBits;
int j = set.unitsInUse;
if (i >= j)
i = j;
while (i-- > 0)
intBits[i] &= ~intBits2[i];
}
else clear();
}
public void or(BitSet set)
{
if (set != this)
{
set.recalculateUnitsInUse();
recalculateUnitsInUse();
int i = unitsInUse;
int j = set.unitsInUse;
if (i < j)
ensureCapacity(j);
int[] intBits = this.intBits;
int[] intBits2 = set.intBits;
while (i < j)
{
j--;
intBits[j] = intBits2[j];
}
while (j-- > 0)
intBits[j] |= intBits2[j];
}
}
public void xor(BitSet set)
{
if (set != this)
{
set.recalculateUnitsInUse();
recalculateUnitsInUse();
int i = unitsInUse;
int j = set.unitsInUse;
if (i < j)
ensureCapacity(j);
int[] intBits = this.intBits;
int[] intBits2 = set.intBits;
while (i < j)
{
j--;
intBits[j] = intBits2[j];
}
while (j-- > 0)
intBits[j] ^= intBits2[j];
}
else clear();
}
public boolean intersects(BitSet set)
{
if (set == this)
return true;
set.recalculateUnitsInUse();
recalculateUnitsInUse();
int i = unitsInUse;
int[] intBits = this.intBits;
int[] intBits2 = set.intBits;
int j = set.unitsInUse;
if (i >= j)
i = j;
while (i-- > 0)
if ((bits[i] & intBits2[i]) != 0)
return true;
return false;
}
public int nextClearBit(int bitIndex)
{
if (bitIndex < 0)
throw new IndexOutOfBoundsException("" + bitIndex);
int i = bitIndex >> INDEX_SHIFT;
int j = unitsInUse;
if (i < j)
{
int[] intBits = this.intBits;
int v = intBits[i] | ((1 << bitIndex) - 1);
while (++i < j && v == -1)
v = intBits[i];
bitIndex = numberOfTrailingZeros(~v) + ((i - 1) << INDEX_SHIFT);
}
return bitIndex;
}
public int nextSetBit(int bitIndex)
{
if (bitIndex < 0)
throw new IndexOutOfBoundsException("" + bitIndex);
int i = bitIndex >> INDEX_SHIFT;
int j = unitsInUse;
if (i < j)
{
int[] intBits = this.intBits;
int v = intBits[i] & (-1 << bitIndex);
while (v == 0 && ++i < j)
v = intBits[i];
if (i < j)
return numberOfTrailingZeros(v) + (i << INDEX_SHIFT);
}
return -1;
}
public int size()
{
return intBits.length << INDEX_SHIFT;
}
public int cardinality()
{
recalculateUnitsInUse();
int i = unitsInUse;
int count = 0;
int[] intBits = this.intBits;
while (i-- > 0)
count += bitCount(intBits[i]);
return count;
}
public int hashCode()
{
recalculateUnitsInUse();
int h = 1234;
int[] intBits = this.intBits;
for (int i = (unitsInUse + 1) >> 1; i > 0; i--)
{
int v = intBits[(i - 1) << 1];
h ^= (mulHigh(v, i) + intBits[(i << 1) - 1] * i) ^ (v * i);
}
return h;
}
public boolean equals(Object obj)
{
if (obj != this)
{
if (!(obj instanceof BitSet))
return false;
BitSet set = (BitSet) obj;
recalculateUnitsInUse();
set.recalculateUnitsInUse();
int i = unitsInUse;
if (set.unitsInUse != i)
return false;
int[] intBits = this.intBits;
int[] intBits2 = set.intBits;
while (i-- > 0)
if (intBits[i] != intBits2[i])
return false;
}
return true;
}
public Object clone()
{
BitSet result;
try
{
result = (BitSet) super.clone();
}
catch (CloneNotSupportedException e)
{
throw new InternalError();
}
int[] intBits = this.intBits;
System.arraycopy(intBits, 0, result.intBits = new int[intBits.length], 0,
unitsInUse);
return result;
}
private void writeObject(ObjectOutputStream output)
throws IOException
{
int[] intBits = this.intBits;
long[] bits = new long[intBits.length >> 1];
int i = (unitsInUse + 1) >> 1;
while (i-- > 0)
bits[i] = ((long) intBits[(i << 1) + 1] << 32) |
(long) intBits[i << 1] & 0xffffffffL;
this.bits = bits;
output.defaultWriteObject();
this.bits = null;
}
private void readObject(ObjectInputStream input)
throws IOException, ClassNotFoundException
{
input.defaultReadObject();
long[] bits = this.bits;
int i = bits.length;
this.bits = null;
int[] intBits = new int[i << 1];
unitsInUse = i << 1;
while (i-- > 0)
{
long v = bits[i];
intBits[i << 1] = (int) v;
intBits[(i << 1) + 1] = (int) (v >>> 32);
}
this.intBits = intBits;
recalculateUnitsInUse();
}
public String toString()
{
StringBuilder buffer = new StringBuilder();
buffer.append('{');
int[] intBits = this.intBits;
int len = unitsInUse;
boolean next = false;
for (int i = 0; i < len; i++)
{
int v = intBits[i];
for (int j = 0; v != 0; j++)
{
if ((v & 1) != 0)
{
if (next)
buffer.append(',').append(' ');
buffer.append((i << INDEX_SHIFT) | j);
next = true;
}
v >>>= 1;
}
}
return buffer.append('}').toString();
}
private void ensureCapacity(int unitsRequired)
{
int[] intBits = this.intBits;
if (intBits.length < unitsRequired)
{
int newLen = intBits.length << 1;
if (newLen < 0)
newLen = -1 >>> 1;
if (unitsRequired + 1 > newLen)
newLen = (unitsRequired + 1) & ~1;
int[] newBits = new int[newLen];
System.arraycopy(intBits, 0, newBits, 0, unitsInUse);
this.intBits = newBits;
}
unitsInUse = unitsRequired;
}
private void recalculateUnitsInUse()
{
int i = unitsInUse - 1;
if (i >= 0)
{
int[] intBits = this.intBits;
if (intBits[i] == 0)
{
while (i-- > 0)
if (intBits[i] != 0)
break;
unitsInUse = i + 1;
}
}
}
private static int numberOfLeadingZeros(int value)
{
value |= value >>> 1;
value |= value >>> 2;
value |= value >>> 4;
value |= value >>> 8;
return bitCount(~((value >>> 16) | value));
}
private static int numberOfTrailingZeros(int value)
{
return bitCount((-value & value) - 1);
}
private static int bitCount(int value)
{
if (((value + 1) >> 1) == 0)
return value != 0 ? 32 : 0;
value = ((value >> 1) & 0x55555555) + (value & 0x55555555);
value = ((value >> 2) & 0x33333333) + (value & 0x33333333);
value = ((value >> 4) & 0xf0f0f0f) + (value & 0xf0f0f0f);
value = ((value >> 8) & 0xff00ff) + (value & 0xff00ff);
return ((value >> 16) & 0xffff) + (value & 0xffff);
}
private static int mulHigh(int valueA, int valueB)
{
int highA = valueA >>> 16;
int highB = valueB >>> 16;
valueA &= 0xffff;
int lowB = valueB & 0xffff;
valueA = ((valueA * lowB) >>> 16) + valueA * highB;
lowB *= highA;
valueA += lowB;
highA = highA * highB + (valueA >>> 16);
if ((valueA ^ lowB) >= 0)
lowB = valueA - lowB;
if (lowB < 0)
highA += 0x10000;
return highA;
}
}