Class RegularBitSet

src/main/java/pascal/taie/util/collection/RegularBitSet.java:33–681

Regular bit set implementation. This implementation is very similar to java.util.Set which uses a long[] to store all the set bits.

 * a {@code long[]} to store all the set bits.
 */
public class RegularBitSet extends AbstractBitSet
        implements Serializable {

    /* Used to shift left or right for a partial word mask */
    private static final long WORD_MASK = 0xffffffffffffffffL;

    /**
     * The internal field corresponding to the serialField "bits".
     */
    private long[] words;

    /**
     * The number of words in the logical size of this BitSet.
     */
    private int wordsInUse = 0;

    /**
     * Creates a new bit set. All bits are initially {@code false}.
     */
    public RegularBitSet() {
        initWords(BITS_PER_WORD);
    }

    /**
     * Creates a bit set whose initial size is large enough to explicitly
     * represent bits with indices in the range {@code 0} through
     * {@code nbits-1}. All bits are initially {@code false}.
     *
     * @param nbits the initial size of the bit set
     * @throws NegativeArraySizeException if the specified initial size
     *                                    is negative
     */
    public RegularBitSet(int nbits) {
        // nbits can't be negative; size 0 is OK
        if (nbits < 0) {
            throw new NegativeArraySizeException("nbits < 0: " + nbits);
        }

        initWords(nbits);
    }

    private void initWords(int nbits) {
        words = new long[wordIndex(nbits - 1) + 1];
    }

    /**
     * Every public method must preserve these invariants.
     */
    private void checkInvariants() {
        assert (wordsInUse == 0 || words[wordsInUse - 1] != 0);
        assert (wordsInUse >= 0 && wordsInUse <= words.length);
        assert (wordsInUse == words.length || words[wordsInUse] == 0);
    }

    /**
     * Sets the field wordsInUse to the logical size in words of the bit set.
     * WARNING:This method assumes that the number of words actually in use is
     * less than or equal to the current value of wordsInUse!