mirror of
git://gcc.gnu.org/git/gcc.git
synced 2024-12-23 02:19:04 +08:00
389 lines
11 KiB
Java
389 lines
11 KiB
Java
// BitSet - A vector of bits.
|
|
|
|
/* Copyright (C) 1998, 1999, 2000 Free Software Foundation
|
|
|
|
This file is part of GNU Classpath.
|
|
|
|
GNU Classpath 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.
|
|
|
|
GNU Classpath 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 for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GNU Classpath; see the file COPYING. If not, write to the
|
|
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
|
02111-1307 USA.
|
|
|
|
As a special exception, if you link this library with other files to
|
|
produce an executable, this library does not by itself cause the
|
|
resulting executable to be covered by the GNU General Public License.
|
|
This exception does not however invalidate any other reasons why the
|
|
executable file might be covered by the GNU General Public License. */
|
|
|
|
package java.util;
|
|
import java.io.Serializable;
|
|
|
|
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
|
|
* hashCode algorithm taken from JDK 1.2 docs.
|
|
*/
|
|
|
|
/**
|
|
* This class can be thought of in two ways. You can see it as a
|
|
* vector of bits or as a set of non-negative integers. The name
|
|
* <code>BitSet</code> is a bit misleading.
|
|
*
|
|
* It is implemented by a bit vector, but its equally possible to see
|
|
* it as set of non-negative integer; each integer in the set is
|
|
* represented by a set bit at the corresponding index. The size of
|
|
* this structure is determined by the highest integer in the set.
|
|
*
|
|
* You can union, intersect and build (symmetric) remainders, by
|
|
* invoking the logical operations and, or, andNot, resp. xor.
|
|
*
|
|
* This implementation is NOT synchronized against concurrent access from
|
|
* multiple threads. Specifically, if one thread is reading from a bitset
|
|
* while another thread is simultaneously modifying it, the results are
|
|
* undefined.
|
|
*
|
|
* @specnote Historically, there has been some confusion as to whether or not
|
|
* this class should be synchronized. From an efficiency perspective,
|
|
* it is very undesirable to synchronize it because multiple locks
|
|
* and explicit lock ordering are required to safely synchronize some
|
|
* methods. The JCL 1.2 supplement book specifies that as of JDK
|
|
* 1.2, the class is no longer synchronized.
|
|
*
|
|
* @author Jochen Hoenicke
|
|
* @author Tom Tromey <tromey@cygnus.com>
|
|
* @date October 23, 1998.
|
|
* @status API complete to JDK 1.3.
|
|
*/
|
|
public class BitSet implements Cloneable, Serializable
|
|
{
|
|
/**
|
|
* Create a new empty bit set.
|
|
*/
|
|
public BitSet()
|
|
{
|
|
this(64);
|
|
}
|
|
|
|
/**
|
|
* Create a new empty bit set, with a given size. This
|
|
* constructor reserves enough space to represent the integers
|
|
* from <code>0</code> to <code>nbits-1</code>.
|
|
* @param nbits the initial size of the bit set.
|
|
* @throws NegativeArraySizeException if the specified initial
|
|
* size is negative.
|
|
* @require nbits >= 0
|
|
*/
|
|
public BitSet(int nbits)
|
|
{
|
|
if (nbits < 0)
|
|
throw new NegativeArraySizeException();
|
|
int length = nbits / 64;
|
|
if (nbits % 64 != 0)
|
|
++length;
|
|
bits = new long[length];
|
|
}
|
|
|
|
/**
|
|
* Performs the logical AND operation on this bit set and the
|
|
* given <code>set</code>. This means it builds the intersection
|
|
* of the two sets. The result is stored into this bit set.
|
|
* @param set the second bit set.
|
|
* @require set != null
|
|
*/
|
|
public void and(BitSet bs)
|
|
{
|
|
int max = Math.min(bits.length, bs.bits.length);
|
|
int i;
|
|
for (i = 0; i < max; ++i)
|
|
bits[i] &= bs.bits[i];
|
|
for (; i < bits.length; ++i)
|
|
bits[i] = 0;
|
|
}
|
|
|
|
/**
|
|
* Performs the logical AND operation on this bit set and the
|
|
* complement of the given <code>set</code>. This means it
|
|
* selects every element in the first set, that isn't in the
|
|
* second set. The result is stored into this bit set.
|
|
* @param set the second bit set.
|
|
* @require set != null
|
|
* @since JDK1.2
|
|
*/
|
|
public void andNot(BitSet bs)
|
|
{
|
|
int max = Math.min(bits.length, bs.bits.length);
|
|
int i;
|
|
for (i = 0; i < max; ++i)
|
|
bits[i] &= ~bs.bits[i];
|
|
}
|
|
|
|
/**
|
|
* Removes the integer <code>bitIndex</code> from this set. That is
|
|
* the corresponding bit is cleared. If the index is not in the set,
|
|
* this method does nothing.
|
|
* @param bitIndex a non-negative integer.
|
|
* @exception ArrayIndexOutOfBoundsException if the specified bit index
|
|
* is negative.
|
|
* @require bitIndex >= 0
|
|
*/
|
|
public void clear(int pos)
|
|
{
|
|
if (pos < 0)
|
|
throw new IndexOutOfBoundsException();
|
|
int bit = pos % 64;
|
|
int offset = pos / 64;
|
|
ensure(offset);
|
|
bits[offset] &= ~(1L << bit);
|
|
}
|
|
|
|
/**
|
|
* Create a clone of this bit set, that is an instance of the same
|
|
* class and contains the same elements. But it doesn't change when
|
|
* this bit set changes.
|
|
* @return the clone of this object.
|
|
*/
|
|
public Object clone()
|
|
{
|
|
BitSet bs = new BitSet(bits.length * 64);
|
|
System.arraycopy(bits, 0, bs.bits, 0, bits.length);
|
|
return bs;
|
|
}
|
|
|
|
/**
|
|
* Returns true if the <code>obj</code> is a bit set that contains
|
|
* exactly the same elements as this bit set, otherwise false.
|
|
* @return true if obj equals this bit set.
|
|
*/
|
|
public boolean equals(Object obj)
|
|
{
|
|
if (!(obj instanceof BitSet))
|
|
return false;
|
|
BitSet bs = (BitSet) obj;
|
|
int max = Math.min(bits.length, bs.bits.length);
|
|
int i;
|
|
for (i = 0; i < max; ++i)
|
|
if (bits[i] != bs.bits[i])
|
|
return false;
|
|
// If one is larger, check to make sure all extra bits are 0.
|
|
for (int j = i; j < bits.length; ++j)
|
|
if (bits[j] != 0)
|
|
return false;
|
|
for (int j = i; j < bs.bits.length; ++j)
|
|
if (bs.bits[j] != 0)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Returns true if the integer <code>bitIndex</code> is in this bit
|
|
* set, otherwise false.
|
|
* @param bitIndex a non-negative integer
|
|
* @return the value of the bit at the specified index.
|
|
* @exception ArrayIndexOutOfBoundsException if the specified bit index
|
|
* is negative.
|
|
* @require bitIndex >= 0
|
|
*/
|
|
public boolean get(int pos)
|
|
{
|
|
if (pos < 0)
|
|
throw new IndexOutOfBoundsException();
|
|
|
|
int bit = pos % 64;
|
|
int offset = pos / 64;
|
|
|
|
if (offset >= bits.length)
|
|
return false;
|
|
|
|
return (bits[offset] & (1L << bit)) == 0 ? false : true;
|
|
}
|
|
|
|
/**
|
|
* Returns a hash code value for this bit set. The hash code of
|
|
* two bit sets containing the same integers is identical. The algorithm
|
|
* used to compute it is as follows:
|
|
*
|
|
* Suppose the bits in the BitSet were to be stored in an array of
|
|
* long integers called <code>bits</code>, in such a manner that
|
|
* bit <code>k</code> is set in the BitSet (for non-negative values
|
|
* of <code>k</code>) if and only if
|
|
*
|
|
* <pre>
|
|
* ((k/64) < bits.length) && ((bits[k/64] & (1L << (bit % 64))) != 0)
|
|
* </pre>
|
|
*
|
|
* Then the following definition of the hashCode method
|
|
* would be a correct implementation of the actual algorithm:
|
|
*
|
|
* <pre>
|
|
* public int hashCode() {
|
|
* long h = 1234;
|
|
* for (int i = bits.length-1; i>=0; i--) {
|
|
* h ^= bits[i] * (i + 1);
|
|
* }
|
|
* return (int)((h >> 32) ^ h);
|
|
* }
|
|
* </pre>
|
|
*
|
|
* Note that the hash code values changes, if the set is changed.
|
|
* @return the hash code value for this bit set.
|
|
*/
|
|
public int hashCode()
|
|
{
|
|
long h = 1234;
|
|
for (int i = bits.length - 1; i >= 0; --i)
|
|
h ^= bits[i] * (i + 1);
|
|
return (int) ((h >> 32) ^ h);
|
|
}
|
|
|
|
/**
|
|
* Returns the logical number of bits actually used by this bit
|
|
* set. It returns the index of the highest set bit plus one.
|
|
* Note that this method doesn't return the number of set bits.
|
|
* @return the index of the highest set bit plus one.
|
|
*/
|
|
public int length()
|
|
{
|
|
// Set i to highest index that contains a non-zero value.
|
|
int i;
|
|
for (i = bits.length - 1; i >= 0 && bits[i] == 0; --i)
|
|
;
|
|
|
|
// if i < 0 all bits are cleared.
|
|
if (i < 0)
|
|
return 0;
|
|
|
|
// Now determine the exact length.
|
|
long b = bits[i];
|
|
int len = (i + 1) * 64;
|
|
// b >= 0 checks if the highest bit is zero.
|
|
while (b >= 0)
|
|
{
|
|
--len;
|
|
b <<= 1;
|
|
}
|
|
|
|
return len;
|
|
}
|
|
|
|
/**
|
|
* Performs the logical OR operation on this bit set and the
|
|
* given <code>set</code>. This means it builds the union
|
|
* of the two sets. The result is stored into this bit set, which
|
|
* grows as necessary.
|
|
* @param set the second bit set.
|
|
* @exception OutOfMemoryError if the current set can't grow.
|
|
* @require set != null
|
|
*/
|
|
public void or(BitSet bs)
|
|
{
|
|
ensure(bs.bits.length - 1);
|
|
int i;
|
|
for (i = 0; i < bs.bits.length; ++i)
|
|
bits[i] |= bs.bits[i];
|
|
}
|
|
|
|
/**
|
|
* Add the integer <code>bitIndex</code> to this set. That is
|
|
* the corresponding bit is set to true. If the index was already in
|
|
* the set, this method does nothing. The size of this structure
|
|
* is automatically increased as necessary.
|
|
* @param bitIndex a non-negative integer.
|
|
* @exception ArrayIndexOutOfBoundsException if the specified bit index
|
|
* is negative.
|
|
* @require bitIndex >= 0
|
|
*/
|
|
public void set(int pos)
|
|
{
|
|
if (pos < 0)
|
|
throw new IndexOutOfBoundsException();
|
|
int bit = pos % 64;
|
|
int offset = pos / 64;
|
|
ensure(offset);
|
|
bits[offset] |= 1L << bit;
|
|
}
|
|
|
|
/**
|
|
* Returns the number of bits actually used by this bit set. Note
|
|
* that this method doesn't return the number of set bits.
|
|
* @returns the number of bits currently used.
|
|
*/
|
|
public int size()
|
|
{
|
|
return bits.length * 64;
|
|
}
|
|
|
|
/**
|
|
* Returns the string representation of this bit set. This
|
|
* consists of a comma separated list of the integers in this set
|
|
* surrounded by curly braces. There is a space after each comma.
|
|
* @return the string representation.
|
|
*/
|
|
public String toString()
|
|
{
|
|
String r = "{";
|
|
boolean first = true;
|
|
for (int i = 0; i < bits.length; ++i)
|
|
{
|
|
long bit = 1;
|
|
long word = bits[i];
|
|
if (word == 0)
|
|
continue;
|
|
for (int j = 0; j < 64; ++j)
|
|
{
|
|
if ((word & bit) != 0)
|
|
{
|
|
if (!first)
|
|
r += ", ";
|
|
r += Integer.toString(64 * i + j);
|
|
first = false;
|
|
}
|
|
bit <<= 1;
|
|
}
|
|
}
|
|
|
|
return r += "}";
|
|
}
|
|
|
|
/**
|
|
* Performs the logical XOR operation on this bit set and the
|
|
* given <code>set</code>. This means it builds the symmetric
|
|
* remainder of the two sets (the elements that are in one set,
|
|
* but not in the other). The result is stored into this bit set,
|
|
* which grows as necessary.
|
|
* @param set the second bit set.
|
|
* @exception OutOfMemoryError if the current set can't grow.
|
|
* @require set != null
|
|
*/
|
|
public void xor(BitSet bs)
|
|
{
|
|
ensure(bs.bits.length - 1);
|
|
int i;
|
|
for (i = 0; i < bs.bits.length; ++i)
|
|
bits[i] ^= bs.bits[i];
|
|
}
|
|
|
|
// Make sure the vector is big enough.
|
|
private final void ensure(int lastElt)
|
|
{
|
|
if (lastElt + 1 > bits.length)
|
|
{
|
|
long[] nd = new long[lastElt + 1];
|
|
System.arraycopy(bits, 0, nd, 0, bits.length);
|
|
bits = nd;
|
|
}
|
|
}
|
|
|
|
// The actual bits.
|
|
long[] bits;
|
|
|
|
private static final long serialVersionUID = 7997698588986878753L;
|
|
}
|