LongBitSet (Lucene 10.5.1 core API)
Description: declaration: package: org.apache.lucene.util, class: LongBitSet

Package org.apache.lucene.util

# Class LongBitSet

java.lang.Object
org.apache.lucene.util.LongBitSet

All Implemented Interfaces:
  `Accountable`

public final class LongBitSet extends Object implements Accountable
BitSet of fixed length (numBits), backed by accessible (`getBits()`) long[], accessed with a long index. Use it only if you intend to store more than 2.1B bits, otherwise you should use `FixedBitSet`.

NOTE: This API is for internal purposes only and might change in incompatible ways in the next release.

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `static final long`
  `MAX_NUM_BITS`
  The maximum `numBits` supported.

  ### Fields inherited from interface org.apache.lucene.util.Accountable

  `NULL_ACCOUNTABLE`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `LongBitSet(long numBits)`
  Creates a new LongBitSet.
  `LongBitSet(long[] storedBits, long numBits)`
  Creates a new LongBitSet using the provided long[] array as backing store.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `and(LongBitSet other)`
  this = this AND other
  `void`
  `andNot(LongBitSet other)`
  this = this AND NOT other
  `static int`
  `bits2words(long numBits)`
  Returns the number of 64 bit words it would take to hold numBits
  `long`
  `cardinality()`
  Returns number of set bits.
  `void`
  `clear(long index)`
  `void`
  `clear(long startIndex, long endIndex)`
  Clears a range of bits.
  `LongBitSet`
  `clone()`
  `static LongBitSet`
  `ensureCapacity(LongBitSet bits, long numBits)`
  If the given `LongBitSet` is large enough to hold `numBits+1`, returns the given bits, otherwise returns a new `LongBitSet` which can hold the requested number of bits.
  `boolean`
  `equals(Object o)`
  returns true if both sets have the same bits set
  `void`
  `flip(long index)`
  Flip the bit at the provided index.
  `void`
  `flip(long startIndex, long endIndex)`
  Flips a range of bits
  `boolean`
  `get(long index)`
  `boolean`
  `getAndClear(long index)`
  `boolean`
  `getAndSet(long index)`
  `long[]`
  `getBits()`
  Expert.
  `int`
  `hashCode()`
  `boolean`
  `intersects(LongBitSet other)`
  returns true if the sets have any elements in common
  `long`
  `length()`
  Returns the number of bits stored in this bitset.
  `long`
  `nextSetBit(long index)`
  Returns the index of the first set bit starting at the index specified.
  `void`
  `or(LongBitSet other)`
  this = this OR other
  `long`
  `prevSetBit(long index)`
  Returns the index of the last set bit before or on the index specified.
  `long`
  `ramBytesUsed()`
  Returns an estimate of the JVM heap memory used by this object in bytes.
  `boolean`
  `scanIsEmpty()`
  Scans the backing store to check if all bits are clear.
  `void`
  `set(long index)`
  `void`
  `set(long startIndex, long endIndex)`
  Sets a range of bits
  `void`
  `xor(LongBitSet other)`
  this = this XOR other

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

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

  ### Methods inherited from interface org.apache.lucene.util.Accountable

  `getChildResources`

- ## Field Details

  - ### MAX_NUM_BITS

    public static final long MAX_NUM_BITS
    The maximum `numBits` supported.

- ## Constructor Details

  - ### LongBitSet

    public LongBitSet(long numBits)
    Creates a new LongBitSet. The internally allocated long array will be exactly the size needed to accommodate the numBits specified.
    Parameters:
      `numBits` - the number of bits needed

  - ### LongBitSet

    public LongBitSet(long[] storedBits, long numBits)
    Creates a new LongBitSet using the provided long[] array as backing store. The storedBits array must be large enough to accommodate the numBits specified, but may be larger. In that case the 'extra' or 'ghost' bits must be clear (or they may provoke spurious side-effects)
    Parameters:
      `storedBits` - the array to use as backing store
      `numBits` - the number of bits actually needed

- ## Method Details

  - ### ensureCapacity

    public static LongBitSet ensureCapacity(LongBitSet bits, long numBits)
    If the given `LongBitSet` is large enough to hold `numBits+1`, returns the given bits, otherwise returns a new `LongBitSet` which can hold the requested number of bits.

    NOTE: the returned bitset reuses the underlying `long[]` of the given `bits` if possible. Also, calling `length()` on the returned bits may return a value greater than `numBits`.

  - ### bits2words

    public static int bits2words(long numBits)
    Returns the number of 64 bit words it would take to hold numBits

  - ### length

    public long length()
    Returns the number of bits stored in this bitset.

  - ### getBits

    public long[] getBits()
    Expert.

  - ### cardinality

    public long cardinality()
    Returns number of set bits. NOTE: this visits every long in the backing bits array, and the result is not internally cached!

  - ### get

    public boolean get(long index)

  - ### set

    public void set(long index)

  - ### getAndSet

    public boolean getAndSet(long index)

  - ### clear

    public void clear(long index)

  - ### getAndClear

    public boolean getAndClear(long index)

  - ### nextSetBit

    public long nextSetBit(long index)
    Returns the index of the first set bit starting at the index specified. -1 is returned if there are no more set bits.

  - ### prevSetBit

    public long prevSetBit(long index)
    Returns the index of the last set bit before or on the index specified. -1 is returned if there are no more set bits.

  - ### or

    public void or(LongBitSet other)
    this = this OR other

  - ### xor

    public void xor(LongBitSet other)
    this = this XOR other

  - ### intersects

    public boolean intersects(LongBitSet other)
    returns true if the sets have any elements in common

  - ### and

    public void and(LongBitSet other)
    this = this AND other

  - ### andNot

    public void andNot(LongBitSet other)
    this = this AND NOT other

  - ### scanIsEmpty

    public boolean scanIsEmpty()
    Scans the backing store to check if all bits are clear. The method is deliberately not called "isEmpty" to emphasize it is not low cost (as isEmpty usually is).
    Returns:
      true if all bits are clear.

  - ### flip

    public void flip(long startIndex, long endIndex)
    Flips a range of bits
    Parameters:
      `startIndex` - lower index
      `endIndex` - one-past the last bit to flip

  - ### flip

    public void flip(long index)
    Flip the bit at the provided index.

  - ### set

    public void set(long startIndex, long endIndex)
    Sets a range of bits
    Parameters:
      `startIndex` - lower index
      `endIndex` - one-past the last bit to set

  - ### clear

    public void clear(long startIndex, long endIndex)
    Clears a range of bits.
    Parameters:
      `startIndex` - lower index
      `endIndex` - one-past the last bit to clear

  - ### clone

    public LongBitSet clone()
    Overrides:
      `clone` in class `Object`

  - ### equals

    public boolean equals(Object o)
    returns true if both sets have the same bits set
    Overrides:
      `equals` in class `Object`

  - ### hashCode

    public int hashCode()
    Overrides:
      `hashCode` in class `Object`

  - ### ramBytesUsed

    public long ramBytesUsed()
    Description copied from interface: `Accountable`
    Returns an estimate of the JVM heap memory used by this object in bytes. The method name uses "ram" for historical reasons; only JVM heap memory should be reported. Off-heap resources such as memory-mapped files or native direct buffers should not be included. Negative values are illegal.
    Specified by:
      `ramBytesUsed` in interface `Accountable`