org.apache.cassandra.utils.obs

## Class OpenBitSet

- java.lang.Object
- - org.apache.cassandra.utils.obs.OpenBitSet

- All Implemented Interfaces:
    java.io.Closeable, java.lang.AutoCloseable, IBitSet

      public class OpenBitSet
      extends java.lang.Object
      implements IBitSet

  An "open" BitSet implementation that allows direct access to the arrays of words storing the bits. Derived from Lucene's OpenBitSet, but with a paged backing array (see bits delaration, below).

  Unlike java.util.bitset, the fact that bits are packed into an array of longs is part of the interface. This allows efficient implementation of other algorithms by someone other than the author. It also allows one to efficiently implement alternate serialization or interchange formats.

  `OpenBitSet` is faster than `java.util.BitSet` in most operations and *much* faster at calculating cardinality of sets and results of set operations. It can also handle sets of larger cardinality (up to 64 * 2**32-1)

  The goals of `OpenBitSet` are the fastest implementation possible, and maximum code reuse. Extra safety and encapsulation may always be built on top, but if that's built in, the cost can never be removed (and hence people re-implement their own version in order to get better performance). If you want a "safe", totally encapsulated (and slower and limited) BitSet class, use `java.util.BitSet`.

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `OpenBitSet()`
    `OpenBitSet(long numBits)` Constructs an OpenBitSet large enough to hold numBits.

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addTo(Ref.IdentityCollection identities)`
    `void` | `and(OpenBitSet other)`
    `static long` | `bits2words(long numBits)` returns the number of 64 bit words it would take to hold numBits
    `long` | `capacity()` Returns the current capacity in bits (1 greater than the index of the last bit)
    `long` | `cardinality()`
    `void` | `clear()`
    `void` | `clear(int index)` clears a bit.
    `void` | `clear(int startIndex, int endIndex)` Clears a range of bits.
    `void` | `clear(long index)` clears a bit.
    `void` | `clear(long startIndex, long endIndex)` Clears a range of bits.
    `void` | `close()`
    `static OpenBitSet` | `deserialize(java.io.DataInput in)`
    `boolean` | `equals(java.lang.Object o)` returns true if both sets have the same bits set
    `boolean` | `get(int index)` Returns true or false for the specified bit index.
    `boolean` | `get(long index)` Returns true or false for the specified bit index.
    `int` | `getNumWords()` Expert: gets the number of longs in the array that are in use
    `long[]` | `getPage(int pageIdx)`
    `int` | `getPageCount()`
    `int` | `getPageSize()`
    `int` | `hashCode()`
    `void` | `intersect(OpenBitSet other)` this = this AND other
    `boolean` | `isEmpty()` Returns true if there are no set bits
    `long` | `length()`
    `long` | `offHeapSize()` Returns the amount of memory in bytes used off heap.
    `void` | `serialize(java.io.DataOutput out)`
    `long` | `serializedSize()`
    `void` | `set(int index)` Sets the bit at the specified index.
    `void` | `set(long index)` Sets the bit at the specified index.
    `long` | `size()` Returns the current capacity of this set.
    `void` | `trimTrailingZeros()` Lowers numWords, the number of words in use, by checking for trailing zero words.

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### OpenBitSet

          public OpenBitSet(long numBits)

      Constructs an OpenBitSet large enough to hold numBits.
      Parameters:
        `numBits` -

    - #### OpenBitSet

          public OpenBitSet()

  - ### Method Detail

    - #### getPageSize

          public int getPageSize()

      Returns:
        the pageSize

    - #### getPageCount

          public int getPageCount()

    - #### getPage

          public long[] getPage(int pageIdx)

    - #### capacity

          public long capacity()

      Returns the current capacity in bits (1 greater than the index of the last bit)
      Specified by:
        `capacity` in interface `IBitSet`

    - #### offHeapSize

          public long offHeapSize()

      Description copied from interface: `IBitSet`
      Returns the amount of memory in bytes used off heap.
      Specified by:
        `offHeapSize` in interface `IBitSet`
      Returns:
        the amount of memory in bytes used off heap

    - #### addTo

          public void addTo(Ref.IdentityCollection identities)

      Specified by:
        `addTo` in interface `IBitSet`

    - #### size

          public long size()

      Returns the current capacity of this set. Included for compatibility. This is *not* equal to `cardinality()`

    - #### length

          public long length()

    - #### isEmpty

          public boolean isEmpty()

      Returns true if there are no set bits

    - #### getNumWords

          public int getNumWords()

      Expert: gets the number of longs in the array that are in use

    - #### get

          public boolean get(int index)

      Returns true or false for the specified bit index. The index should be less than the OpenBitSet size

    - #### get

          public boolean get(long index)

      Returns true or false for the specified bit index. The index should be less than the OpenBitSet size.
      Specified by:
        `get` in interface `IBitSet`

    - #### set

          public void set(long index)

      Sets the bit at the specified index. The index should be less than the OpenBitSet size.
      Specified by:
        `set` in interface `IBitSet`

    - #### set

          public void set(int index)

      Sets the bit at the specified index. The index should be less than the OpenBitSet size.

    - #### clear

          public void clear(int index)

      clears a bit. The index should be less than the OpenBitSet size.

    - #### clear

          public void clear(long index)

      clears a bit. The index should be less than the OpenBitSet size.
      Specified by:
        `clear` in interface `IBitSet`

    - #### clear

          public void clear(int startIndex,
                            int endIndex)

      Clears a range of bits. Clearing past the end does not change the size of the set.
      Parameters:
        `startIndex` - lower index
        `endIndex` - one-past the last bit to clear

    - #### clear

          public void clear(long startIndex,
                            long endIndex)

      Clears a range of bits. Clearing past the end does not change the size of the set.
      Parameters:
        `startIndex` - lower index
        `endIndex` - one-past the last bit to clear

    - #### cardinality

          public long cardinality()

      Returns:
        the number of set bits

    - #### intersect

          public void intersect(OpenBitSet other)

      this = this AND other

    - #### and

          public void and(OpenBitSet other)

    - #### trimTrailingZeros

          public void trimTrailingZeros()

      Lowers numWords, the number of words in use, by checking for trailing zero words.

    - #### bits2words

          public static long bits2words(long numBits)

      returns the number of 64 bit words it would take to hold numBits

    - #### equals

          public boolean equals(java.lang.Object o)

      returns true if both sets have the same bits set
      Overrides:
        `equals` in class `java.lang.Object`

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `java.lang.Object`

    - #### close

          public void close()

      Specified by:
        `close` in interface `java.io.Closeable`
      Specified by:
        `close` in interface `java.lang.AutoCloseable`
      Specified by:
        `close` in interface `IBitSet`

    - #### serialize

          public void serialize(java.io.DataOutput out)
                         throws java.io.IOException

      Specified by:
        `serialize` in interface `IBitSet`
      Throws:
        `java.io.IOException`

    - #### serializedSize

          public long serializedSize()

      Specified by:
        `serializedSize` in interface `IBitSet`

    - #### clear

          public void clear()

      Specified by:
        `clear` in interface `IBitSet`

    - #### deserialize

          public static OpenBitSet deserialize(java.io.DataInput in)
                                        throws java.io.IOException

      Throws:
        `java.io.IOException`

Copyright © 2018 The Apache Software Foundation